$estr = function() { return js.Boot.__string_rec(this,''); }
Std = function() { }
Std.__name__ = ["Std"];
Std["is"] = function(v,t) {
	return js.Boot.__instanceof(v,t);
}
Std.string = function(s) {
	return js.Boot.__string_rec(s,"");
}
Std["int"] = function(x) {
	if(x < 0) return Math.ceil(x);
	return Math.floor(x);
}
Std.parseInt = function(x) {
	var v = parseInt(x);
	if(Math.isNaN(v)) return null;
	return v;
}
Std.parseFloat = function(x) {
	return parseFloat(x);
}
Std.random = function(x) {
	return Math.floor(Math.random() * x);
}
Std.prototype.__class__ = Std;
IntIter = function(min,max) { if( min === $_ ) return; {
	this.min = min;
	this.max = max;
}}
IntIter.__name__ = ["IntIter"];
IntIter.prototype.hasNext = function() {
	return this.min < this.max;
}
IntIter.prototype.max = null;
IntIter.prototype.min = null;
IntIter.prototype.next = function() {
	return this.min++;
}
IntIter.prototype.__class__ = IntIter;
if(typeof js=='undefined') js = {}
js.Lib = function() { }
js.Lib.__name__ = ["js","Lib"];
js.Lib.isIE = null;
js.Lib.isOpera = null;
js.Lib.document = null;
js.Lib.window = null;
js.Lib.alert = function(v) {
	alert(js.Boot.__string_rec(v,""));
}
js.Lib.eval = function(code) {
	return eval(code);
}
js.Lib.setErrorHandler = function(f) {
	js.Lib.onerror = f;
}
js.Lib.prototype.__class__ = js.Lib;
HXCS = function() { }
HXCS.__name__ = ["HXCS"];
HXCS.main = function() {
	null;
}
HXCS.sh_isEmailAddress = function(url) {
	if (/^mailto:/.test(url)) {
        return false;
      }
      return url.indexOf('@') !== -1;;
}
HXCS.sh_setHref = function(tags,numTags,inputString) {
	var url = inputString.substring(tags[numTags - 2].pos, tags[numTags - 1].pos);
      if (url.length >= 2 && url.charAt(0) === '<' && url.charAt(url.length - 1) === '>') {
        url = url.substr(1, url.length - 2);
      }
      if (HXCS.sh_isEmailAddress(url)) {
        url = 'mailto:' + url;
      }
      tags[numTags - 2].node.href = url;;
}
HXCS.sh_konquerorExec = function(s) {
	var result = [''];
      result.index = s.length;
      result.input = s;
      return result;;
}
HXCS.sh_highlightString = function(inputString,language) {
	if (/Konqueror/.test(navigator.userAgent)) {
        if (! language.konquered) {
          for (var s = 0; s < language.length; s++) {
            for (var p = 0; p < language[s].length; p++) {
              var r = language[s][p][0];
              if (r.source === '$') {
                r.exec = HXCS.sh_konquerorExec;
              }
            }
          }
          language.konquered = true;
        }
      }

      var a = document.createElement('a');
      var span = document.createElement('span');
 
      var tags = [];
      var numTags = 0;
 
      var patternStack = [];
 
      var pos = 0;
 
      var currentStyle = null;

      var output = function(s, style) {
        var length = s.length; 
        if (length === 0) {
          return;
        }
        if (! style) {
          var stackLength = patternStack.length;
          if (stackLength !== 0) {
            var pattern = patternStack[stackLength - 1];
            // check whether this is a state or an environment
            if (! pattern[3]) {
              style = pattern[1];
            }
          }
        }
        if (currentStyle !== style) {
          if (currentStyle) {
            tags[numTags++] = {pos: pos};
            if (currentStyle === 'sh_url') {
              HXCS.sh_setHref(tags, numTags, inputString);
            }
          }
          if (style) {
            var clone;
            if (style == 'sh_url') {
              clone = a.cloneNode(false);
            }
            else {
              clone = span.cloneNode(false);
            }
            clone.className = style;
            tags[numTags++] = {node: clone, pos: pos};
          }
        }
        pos += length;
        currentStyle = style;
      };

      var endOfLinePattern = /\r\n|\r|\n/g;
      endOfLinePattern.lastIndex = 0;
      var inputStringLength = inputString.length;
      while (pos < inputStringLength) {
        var start = pos;
        var end;
        var startOfNextLine;
        var endOfLineMatch = endOfLinePattern.exec(inputString);
        if (endOfLineMatch === null) {
          end = inputStringLength;
          startOfNextLine = inputStringLength;
        }
        else {
          end = endOfLineMatch.index;
          startOfNextLine = endOfLinePattern.lastIndex;
        }

        var line = inputString.substring(start, end);

        var matchCache = [];
        for (;;) {
          var posWithinLine = pos - start;

          var stateIndex;
          var stackLength = patternStack.length;
          if (stackLength === 0) {
            stateIndex = 0;
          }
          else {
            // get the next state
            stateIndex = patternStack[stackLength - 1][2];
          }

          var state = language[stateIndex];
          var numPatterns = state.length;
          var mc = matchCache[stateIndex];
          if (! mc) {
            mc = matchCache[stateIndex] = [];
          }
          var bestMatch = null;
          var bestPatternIndex = -1;
          for (var i = 0; i < numPatterns; i++) {
            var match;
            if (i < mc.length && (mc[i] === null || posWithinLine <= mc[i].index)) {
              match = mc[i];
            }
            else {
              var regex = state[i][0];
              regex.lastIndex = posWithinLine;
              match = regex.exec(line);
              mc[i] = match;
            }
            if (match !== null && (bestMatch === null || match.index < bestMatch.index)) {
              bestMatch = match;
              bestPatternIndex = i;
              if (match.index === posWithinLine) {
                break;
              }
            }
          }

          if (bestMatch === null) {
            output(line.substring(posWithinLine), null);
            break;
          }
          else {
            // got a match
            if (bestMatch.index > posWithinLine) {
              output(line.substring(posWithinLine, bestMatch.index), null);
            }

            var pattern = state[bestPatternIndex];

            var newStyle = pattern[1];
            var matchedString;
            if (newStyle instanceof Array) {
              for (var subexpression = 0; subexpression < newStyle.length; subexpression++) {
                matchedString = bestMatch[subexpression + 1];
                output(matchedString, newStyle[subexpression]);
              }
            }
            else {
              matchedString = bestMatch[0];
              output(matchedString, newStyle);
            }

            switch (pattern[2]) {
            case -1:
              // do nothing
              break;
            case -2:
              // exit
              patternStack.pop();
              break;
            case -3:
              // exitall
              patternStack.length = 0;
              break;
            default:
              // this was the start of a delimited pattern or a state/environment
              patternStack.push(pattern);
              break;
            }
          }
        }

        // end of the line
        if (currentStyle) {
          tags[numTags++] = {pos: pos};
          if (currentStyle === 'sh_url') {
            HXCS.sh_setHref(tags, numTags, inputString);
          }
          currentStyle = null;
        }
        pos = startOfNextLine;
      }

      return tags;;
}
HXCS.sh_getClasses = function(element) {
	var result = [];
      var htmlClass = element.className;
      if (htmlClass && htmlClass.length > 0) {
        var htmlClasses = htmlClass.split(' ');
        for (var i = 0; i < htmlClasses.length; i++) {
          if (htmlClasses[i].length > 0) {
            result.push(htmlClasses[i]);
          }
        }
      }
      return result;;
}
HXCS.sh_addClass = function(element,name) {
	var htmlClasses = HXCS.sh_getClasses(element);
      for (var i = 0; i < htmlClasses.length; i++) {
        if (name.toLowerCase() === htmlClasses[i].toLowerCase()) {
          return;
        }
      }
      htmlClasses.push(name);
      element.className = htmlClasses.join(' ');;
}
HXCS.sh_extractTagsFromNodeList = function(nodeList,result) {
	var length = nodeList.length;
      for (var i = 0; i < length; i++) {
        var node = nodeList.item(i);
        switch (node.nodeType) {
        case 1:
          if (node.nodeName.toLowerCase() === 'br') {
            var terminator;
            if (/MSIE/.test(navigator.userAgent)) {
              terminator = '\r';
            }
            else {
              terminator = '\n';
            }
            result.text.push(terminator);
            result.pos++;
          }
          else {
            result.tags.push({node: node.cloneNode(false), pos: result.pos});
            HXCS.sh_extractTagsFromNodeList(node.childNodes, result);
            result.tags.push({pos: result.pos});
          }
          break;
        case 3:
        case 4:
          result.text.push(node.data);
          result.pos += node.length;
          break;
        }
      }
}
HXCS.sh_extractTags = function(element,tags) {
	var result = {};
      result.text = [];
      result.tags = tags;
      result.pos = 0;
      HXCS.sh_extractTagsFromNodeList(element.childNodes, result);
      return result.text.join('');;
}
HXCS.sh_mergeTags = function(originalTags,highlightTags) {
	var numOriginalTags = originalTags.length;
      if (numOriginalTags === 0) {
        return highlightTags;
      }

      var numHighlightTags = highlightTags.length;
      if (numHighlightTags === 0) {
        return originalTags;
      }

      var result = [];
      var originalIndex = 0;
      var highlightIndex = 0;

      while (originalIndex < numOriginalTags && highlightIndex < numHighlightTags) {
        var originalTag = originalTags[originalIndex];
        var highlightTag = highlightTags[highlightIndex];

        if (originalTag.pos <= highlightTag.pos) {
          result.push(originalTag);
          originalIndex++;
        }
        else {
          result.push(highlightTag);
          if (highlightTags[highlightIndex + 1].pos <= originalTag.pos) {
            highlightIndex++;
            result.push(highlightTags[highlightIndex]);
            highlightIndex++;
          }
          else {
            // new end tag
            result.push({pos: originalTag.pos});

            // new start tag
            highlightTags[highlightIndex] = {node: highlightTag.node.cloneNode(false), pos: originalTag.pos};
          }
        }
      }

      while (originalIndex < numOriginalTags) {
        result.push(originalTags[originalIndex]);
        originalIndex++;
      }

      while (highlightIndex < numHighlightTags) {
        result.push(highlightTags[highlightIndex]);
        highlightIndex++;
      }

      return result;;
}
HXCS.sh_insertTags = function(tags,text) {
	var doc = document;

      var result = document.createDocumentFragment();
      var tagIndex = 0;
      var numTags = tags.length;
      var textPos = 0;
      var textLength = text.length;
      var currentNode = result;

      // output one tag or text node every iteration
      while (textPos < textLength || tagIndex < numTags) {
        var tag;
        var tagPos;
        if (tagIndex < numTags) {
          tag = tags[tagIndex];
          tagPos = tag.pos;
        }
        else {
          tagPos = textLength;
        }

        if (tagPos <= textPos) {
          // output the tag
          if (tag.node) {
            // start tag
            var newNode = tag.node;
            currentNode.appendChild(newNode);
            currentNode = newNode;
          }
          else {
            // end tag
            currentNode = currentNode.parentNode;
          }
          tagIndex++;
        }
        else {
          // output text
          currentNode.appendChild(doc.createTextNode(text.substring(textPos, tagPos)));
          textPos = tagPos;
        }
      }

      return result;;
}
HXCS.sh_highlightElement = function(element,language) {
	HXCS.sh_addClass(element, 'sh_sourceCode');
      var originalTags = [];
      var inputString = HXCS.sh_extractTags(element, originalTags);
      var highlightTags = HXCS.sh_highlightString(inputString, language);
      var tags = HXCS.sh_mergeTags(originalTags, highlightTags);
      var documentFragment = HXCS.sh_insertTags(tags, inputString);
      while (element.hasChildNodes()) {
        element.removeChild(element.firstChild);
      }
      element.appendChild(documentFragment);;
}
HXCS.sh_getXMLHttpRequest = function() {
	if (window.ActiveXObject) {
        return new ActiveXObject('Msxml2.XMLHTTP');
      }
      else if (window.XMLHttpRequest) {
        return new XMLHttpRequest();
      }
      throw 'No XMLHttpRequest implementation available';;
}
HXCS.sh_load = function(language,element,prefix,suffix) {
	if (language in sh_requests) {
        sh_requests[language].push(element);
        return;
      }
      sh_requests[language] = [element];
      var request = HXCS.sh_getXMLHttpRequest();
      var url = prefix + 'sh_' + language + suffix;
      request.open('GET', url, true);
      request.onreadystatechange = function () {
        if (request.readyState === 4) {
          try {
            if (! request.status || request.status === 200) {
              eval(request.responseText);
              var elements = sh_requests[language];
              for (var i = 0; i < elements.length; i++) {
                HXCS.sh_highlightElement(elements[i], sh_languages[language]);
              }
            }
            else {
              throw 'HTTP error: status ' + request.status;
            }
          }
          finally {
            request = null;
          }
        }
      };
      request.send(null);;
}
HXCS.sh_highlightDocument = function(prefix,suffix) {
	var nodeList = document.getElementsByTagName('pre');
      for (var i = 0; i < nodeList.length; i++) {
        var element = nodeList.item(i);
        var htmlClasses = HXCS.sh_getClasses(element);
        for (var j = 0; j < htmlClasses.length; j++) {
          var htmlClass = htmlClasses[j].toLowerCase();
          if (htmlClass === 'sh_sourcecode') {
            continue;
          }
          if (htmlClass.substr(0, 3) === 'sh_') {
            var language = htmlClass.substring(3);
            if (language in sh_languages) {
              HXCS.sh_highlightElement(element, sh_languages[language]);
            }
            else if (typeof(prefix) === 'string' && typeof(suffix) === 'string') {
              HXCS.sh_load(language, element, prefix, suffix);
            }
            else {
              throw 'Found <pre> element with class="' + htmlClass + '", but no such language exists';
            }
            break;
          }
        }
      }
}
HXCS.prototype.__class__ = HXCS;
js.Boot = function() { }
js.Boot.__name__ = ["js","Boot"];
js.Boot.__unhtml = function(s) {
	return s.split("&").join("&amp;").split("<").join("&lt;").split(">").join("&gt;");
}
js.Boot.__trace = function(v,i) {
	var msg = (i != null?((i.fileName + ":") + i.lineNumber) + ": ":"");
	msg += js.Boot.__unhtml(js.Boot.__string_rec(v,"")) + "<br/>";
	var d = document.getElementById("haxe:trace");
	if(d == null) alert("No haxe:trace element defined\n" + msg);
	else d.innerHTML += msg;
}
js.Boot.__clear_trace = function() {
	var d = document.getElementById("haxe:trace");
	if(d != null) d.innerHTML = "";
	else null;
}
js.Boot.__closure = function(o,f) {
	var m = o[f];
	if(m == null) return null;
	var f1 = function() {
		return m.apply(o,arguments);
	}
	f1.scope = o;
	f1.method = m;
	return f1;
}
js.Boot.__string_rec = function(o,s) {
	if(o == null) return "null";
	if(s.length >= 5) return "<...>";
	var t = typeof(o);
	if(t == "function" && (o.__name__ != null || o.__ename__ != null)) t = "object";
	switch(t) {
	case "object":{
		if(o instanceof Array) {
			if(o.__enum__ != null) {
				if(o.length == 2) return o[0];
				var str = o[0] + "(";
				s += "\t";
				{
					var _g1 = 2, _g = o.length;
					while(_g1 < _g) {
						var i = _g1++;
						if(i != 2) str += "," + js.Boot.__string_rec(o[i],s);
						else str += js.Boot.__string_rec(o[i],s);
					}
				}
				return str + ")";
			}
			var l = o.length;
			var i;
			var str = "[";
			s += "\t";
			{
				var _g = 0;
				while(_g < l) {
					var i1 = _g++;
					str += ((i1 > 0?",":"")) + js.Boot.__string_rec(o[i1],s);
				}
			}
			str += "]";
			return str;
		}
		var tostr;
		try {
			tostr = o.toString;
		}
		catch( $e0 ) {
			{
				var e = $e0;
				{
					return "???";
				}
			}
		}
		if(tostr != null && tostr != Object.toString) {
			var s2 = o.toString();
			if(s2 != "[object Object]") return s2;
		}
		var k = null;
		var str = "{\n";
		s += "\t";
		var hasp = (o.hasOwnProperty != null);
		for( var k in o ) { ;
		if(hasp && !o.hasOwnProperty(k)) continue;
		if(k == "prototype" || k == "__class__" || k == "__super__" || k == "__interfaces__") continue;
		if(str.length != 2) str += ", \n";
		str += ((s + k) + " : ") + js.Boot.__string_rec(o[k],s);
		}
		s = s.substring(1);
		str += ("\n" + s) + "}";
		return str;
	}break;
	case "function":{
		return "<function>";
	}break;
	case "string":{
		return o;
	}break;
	default:{
		return String(o);
	}break;
	}
}
js.Boot.__interfLoop = function(cc,cl) {
	if(cc == null) return false;
	if(cc == cl) return true;
	var intf = cc.__interfaces__;
	if(intf != null) {
		var _g1 = 0, _g = intf.length;
		while(_g1 < _g) {
			var i = _g1++;
			var i1 = intf[i];
			if(i1 == cl || js.Boot.__interfLoop(i1,cl)) return true;
		}
	}
	return js.Boot.__interfLoop(cc.__super__,cl);
}
js.Boot.__instanceof = function(o,cl) {
	try {
		if(o instanceof cl) {
			if(cl == Array) return (o.__enum__ == null);
			return true;
		}
		if(js.Boot.__interfLoop(o.__class__,cl)) return true;
	}
	catch( $e1 ) {
		{
			var e = $e1;
			{
				if(cl == null) return false;
			}
		}
	}
	switch(cl) {
	case Int:{
		return Math.ceil(o%2147483648.0) === o;
	}break;
	case Float:{
		return typeof(o) == "number";
	}break;
	case Bool:{
		return o === true || o === false;
	}break;
	case String:{
		return typeof(o) == "string";
	}break;
	case Dynamic:{
		return true;
	}break;
	default:{
		if(o == null) return false;
		return o.__enum__ == cl || (cl == Class && o.__name__ != null) || (cl == Enum && o.__ename__ != null);
	}break;
	}
}
js.Boot.__init = function() {
	js.Lib.isIE = (typeof document!='undefined' && document.all != null && typeof window!='undefined' && window.opera == null);
	js.Lib.isOpera = (typeof window!='undefined' && window.opera != null);
	Array.prototype.copy = Array.prototype.slice;
	Array.prototype.insert = function(i,x) {
		this.splice(i,0,x);
	}
	Array.prototype.remove = (Array.prototype.indexOf?function(obj) {
		var idx = this.indexOf(obj);
		if(idx == -1) return false;
		this.splice(idx,1);
		return true;
	}:function(obj) {
		var i = 0;
		var l = this.length;
		while(i < l) {
			if(this[i] == obj) {
				this.splice(i,1);
				return true;
			}
			i++;
		}
		return false;
	});
	Array.prototype.iterator = function() {
		return { cur : 0, arr : this, hasNext : function() {
			return this.cur < this.arr.length;
		}, next : function() {
			return this.arr[this.cur++];
		}}
	}
	var cca = String.prototype.charCodeAt;
	String.prototype.cca = cca;
	String.prototype.charCodeAt = function(i) {
		var x = cca.call(this,i);
		if(isNaN(x)) return null;
		return x;
	}
	var oldsub = String.prototype.substr;
	String.prototype.substr = function(pos,len) {
		if(pos != null && pos != 0 && len != null && len < 0) return "";
		if(len == null) len = this.length;
		if(pos < 0) {
			pos = this.length + pos;
			if(pos < 0) pos = 0;
		}
		else if(len < 0) {
			len = (this.length + len) - pos;
		}
		return oldsub.apply(this,[pos,len]);
	}
	$closure = js.Boot.__closure;
}
js.Boot.prototype.__class__ = js.Boot;
$Main = function() { }
$Main.__name__ = ["@Main"];
$Main.prototype.__class__ = $Main;
$_ = {}
js.Boot.__res = {}
js.Boot.__init();
{
	String.prototype.__class__ = String;
	String.__name__ = ["String"];
	Array.prototype.__class__ = Array;
	Array.__name__ = ["Array"];
	Int = { __name__ : ["Int"]}
	Dynamic = { __name__ : ["Dynamic"]}
	Float = Number;
	Float.__name__ = ["Float"];
	Bool = { __ename__ : ["Bool"]}
	Class = { __name__ : ["Class"]}
	Enum = { }
	Void = { __ename__ : ["Void"]}
}
{
	Math.NaN = Number["NaN"];
	Math.NEGATIVE_INFINITY = Number["NEGATIVE_INFINITY"];
	Math.POSITIVE_INFINITY = Number["POSITIVE_INFINITY"];
	Math.isFinite = function(i) {
		return isFinite(i);
	}
	Math.isNaN = function(i) {
		return isNaN(i);
	}
	Math.__name__ = ["Math"];
}
{
	js.Lib.document = document;
	js.Lib.window = window;
	onerror = function(msg,url,line) {
		var f = js.Lib.onerror;
		if( f == null )
			return false;
		return f(msg,[url+":"+line]);
	}
}
js.Lib.onerror = null;
HXCS.sh_requests = { }
$Main.init = HXCS.main();