$estr = function() { return js.Boot.__string_rec(this,''); }
js = {}
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;
            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) === o) && isFinite(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 && o.__enum__ == cl) return true;
            return false;
        }break;
        }
    }
}
js.Boot.__init = function() {
    {
        js.Lib.isIE = (document.all != null && window.opera == null);
        js.Lib.isOpera = (window.opera != null);
        Array.prototype.copy = Array.prototype.slice;
        Array.prototype.insert = function(i,x) {
            this.splice(i,0,x);
        }
        Array.prototype.remove = 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++];
            }}
        }
        String.prototype.__class__ = String;
        String.__name__ = ["String"];
        Array.prototype.__class__ = Array;
        Array.__name__ = ["Array"];
        var cca = String.prototype.charCodeAt;
        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]);
        }
        Int = new Object();
        Dynamic = new Object();
        Float = Number;
        Bool = new Object();
        Bool["true"] = true;
        Bool["false"] = false;
        $closure = js.Boot.__closure;
    }
}
js.Boot.prototype.__class__ = js.Boot;
js.Lib = function() { }
js.Lib.__name__ = ["js","Lib"];
js.Lib.isIE = null;
js.Lib.isOpera = 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;
haxe = {}
haxe.Http = function(url) { if( url === $_ ) return; {
    this.url = url;
    this.headers = new Hash();
    this.params = new Hash();
    this.async = true;
}}
haxe.Http.__name__ = ["haxe","Http"];
haxe.Http.request = function(url) {
    var h = new haxe.Http(url);
    h.async = false;
    var r = null;
    h.onData = function(d) {
        r = d;
    }
    h.onError = function(e) {
        throw e;
    }
    h.request(false);
    return r;
}
haxe.Http.prototype.async = null;
haxe.Http.prototype.headers = null;
haxe.Http.prototype.onData = function(data) {
    null;
}
haxe.Http.prototype.onError = function(msg) {
    null;
}
haxe.Http.prototype.onStatus = function(status) {
    null;
}
haxe.Http.prototype.params = null;
haxe.Http.prototype.postData = null;
haxe.Http.prototype.request = function(post) {
    var me = this;
    var r = new js.XMLHttpRequest();
    var onreadystatechange = function() {
        if(r.readyState != 4) return;
        var s = function($this) {
            var $r;
            try {
                $r = r.status;
            }
            catch( $e2 ) {
                {
                    var e = $e2;
                    $r = null;
                }
            }
            return $r;
        }(this);
        if(s == undefined) s = null;
        if(s != null) me.onStatus(s);
        if(s != null && s >= 200 && s < 400) me.onData(r.responseText);
        else switch(s) {
        case null:{
//            me.onError("Failed to connect or resolve host");
        }break;
        case 12029:{
//            me.onError("Failed to connect to host");
        }break;
        case 12007:{
//            me.onError("Unknown host");
        }break;
        default:{
            me.onError("Http Error #" + r.status);
        }break;
        }
    }
    r.onreadystatechange = onreadystatechange;
    var uri = this.postData;
    if(uri != null) post = true;
    else { var $it3 = this.params.keys();
    while( $it3.hasNext() ) { var p = $it3.next();
    {
        if(uri == null) uri = "";
        else uri += "&";
        uri += StringTools.urlDecode(p) + "=" + StringTools.urlEncode(this.params.get(p));
    }
    }}
    try {
        if(post) r.open("POST",this.url,this.async);
        else if(uri != null) {
            var question = this.url.split("?").length <= 1;
            r.open("GET",this.url + ((question?"?":"&")) + uri,this.async);
            uri = null;
        }
        else r.open("GET",this.url,this.async);
    }
    catch( $e4 ) {
        {
            var e = $e4;
            {
                this.onError(e.toString());
                return;
            }
        }
    }
    if(this.headers.get("Content-Type") == null && post && this.postData == null) r.setRequestHeader("Content-Type","application/x-www-form-urlencoded");
    { var $it5 = this.headers.keys();
    while( $it5.hasNext() ) { var h = $it5.next();
    r.setRequestHeader(h,this.headers.get(h));
    }}
    r.send(uri);
    if(!this.async) onreadystatechange();
}
haxe.Http.prototype.setHeader = function(header,value) {
    this.headers.set(header,value);
}
haxe.Http.prototype.setParameter = function(param,value) {
    this.params.set(param,value);
}
haxe.Http.prototype.setPostData = function(data) {
    this.postData = data;
}
haxe.Http.prototype.url = null;
haxe.Http.prototype.__class__ = haxe.Http;

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.bool = function(x) {
    return (x !== 0 && x != null && x !== false);
}
Std.parseInt = function(x) {
    {
        var v = parseInt(x);
        if(Math.isNaN(v)) return null;
        return v;
    }
}
Std.parseFloat = function(x) {
    return parseFloat(x);
}
Std.chr = function(x) {
    return String.fromCharCode(x);
}
Std.ord = function(x) {
    if(x == "") return null;
    else return x.charCodeAt(0);
}
Std.random = function(x) {
    return Math.floor(Math.random() * x);
}
Std.resource = function(name) {
    return js.Boot.__res[name];
}
Std.prototype.__class__ = Std;
StringTools = function() { }
StringTools.__name__ = ["StringTools"];
StringTools.urlEncode = function(s) {
    return encodeURIComponent(s);
}
StringTools.urlDecode = function(s) {
    return decodeURIComponent(s.split("+").join(" "));
}
StringTools.htmlEscape = function(s) {
    return s.split("&").join("&amp;").split("<").join("&lt;").split(">").join("&gt;");
}
StringTools.htmlUnescape = function(s) {
    return s.split("&gt;").join(">").split("&lt;").join("<").split("&amp;").join("&");
}
StringTools.startsWith = function(s,start) {
    return (s.length >= start.length && s.substr(0,start.length) == start);
}
StringTools.endsWith = function(s,end) {
    var elen = end.length;
    var slen = s.length;
    return (slen >= elen && s.substr(slen - elen,elen) == end);
}
StringTools.isSpace = function(s,pos) {
    var c = s.charCodeAt(pos);
    return (c >= 9 && c <= 13) || c == 32;
}
StringTools.ltrim = function(s) {
    var l = s.length;
    var r = 0;
    while(r < l && StringTools.isSpace(s,r)) {
        r++;
    }
    if(r > 0) return s.substr(r,l - r);
    else return s;
}
StringTools.rtrim = function(s) {
    var l = s.length;
    var r = 0;
    while(r < l && StringTools.isSpace(s,l - r - 1)) {
        r++;
    }
    if(r > 0) {
        return s.substr(0,l - r);
    }
    else {
        return s;
    }
}
StringTools.trim = function(s) {
    return StringTools.ltrim(StringTools.rtrim(s));
}
StringTools.rpad = function(s,c,l) {
    var sl = s.length;
    var cl = c.length;
    while(sl < l) {
        if(l - sl < cl) {
            s += c.substr(0,l - sl);
            sl = l;
        }
        else {
            s += c;
            sl += cl;
        }
    }
    return s;
}
StringTools.lpad = function(s,c,l) {
    var ns = "";
    var sl = s.length;
    if(sl >= l) return s;
    var cl = c.length;
    while(sl < l) {
        if(l - sl < cl) {
            ns += c.substr(0,l - sl);
            sl = l;
        }
        else {
            ns += c;
            sl += cl;
        }
    }
    return ns + s;
}
StringTools.replace = function(s,sub,by) {
    return s.split(sub).join(by);
}
StringTools.baseEncode = function(s,base) {
    var len = base.length;
    var nbits = 1;
    while(len > 1 << nbits) nbits++;
    if(nbits > 8 || len != 1 << nbits) throw "baseEncode: base must be a power of two.";
    var size = Std["int"]((s.length * 8 + nbits - 1) / nbits);
    var out = new StringBuf();
    var buf = 0;
    var curbits = 0;
    var mask = ((1 << nbits) - 1);
    var pin = 0;
    while(size-- > 0) {
        while(curbits < nbits) {
            curbits += 8;
            buf <<= 8;
            var t = s.charCodeAt(pin++);
            if(t > 255) throw "baseEncode: bad chars";
            buf |= t;
        }
        curbits -= nbits;
        out.addChar(base.charCodeAt((buf >> curbits) & mask));
    }
    return out.toString();
}
StringTools.baseDecode = function(s,base) {
    var len = base.length;
    var nbits = 1;
    while(len > 1 << nbits) nbits++;
    if(nbits > 8 || len != 1 << nbits) throw "baseDecode: base must be a power of two.";
    var size = (s.length * 8 + nbits - 1) / nbits;
    var tbl = new Array();
    {
        var _g = 0;
        while(_g < 256) {
            var i = _g++;
            tbl[i] = -1;
        }
    }
    {
        var _g = 0;
        while(_g < len) {
            var i = _g++;
            tbl[base.charCodeAt(i)] = i;
        }
    }
    var size1 = (s.length * nbits) / 8;
    var out = new StringBuf();
    var buf = 0;
    var curbits = 0;
    var pin = 0;
    while(size1-- > 0) {
        while(curbits < 8) {
            curbits += nbits;
            buf <<= nbits;
            var i = tbl[s.charCodeAt(pin++)];
            if(i == -1) throw "baseDecode: bad chars";
            buf |= i;
        }
        curbits -= 8;
        out.addChar((buf >> curbits) & 255);
    }
    return out.toString();
}
StringTools.hex = function(n,digits) {
    var neg = false;
    if(n < 0) {
        neg = true;
        n = -n;
    }
    var s = n.toString(16);
    s = s.toUpperCase();
    if(digits != null) while(s.length < digits) s = "0" + s;
    if(neg) s = "-" + s;
    return s;
}
StringTools.prototype.__class__ = StringTools;
Hash = function(p) { if( p === $_ ) return; {
    {
        this.h = {}
        if(this.h.__proto__ != null) {
            this.h.__proto__ = null;
            delete(this.h.__proto__);
        }
        else null;
    }
}}
Hash.__name__ = ["Hash"];
Hash.prototype.exists = function(key) {
    try {
        key = "$" + key;
        return this.hasOwnProperty.call(this.h,key);
    }
    catch( $e6 ) {
        {
            var e = $e6;
            {

                for(var i in this.h)
                    if( i == key ) return true;
            ;
                return false;
            }
        }
    }
}
Hash.prototype.get = function(key) {
    return this.h["$" + key];
}
Hash.prototype.h = null;
Hash.prototype.iterator = function() {
    return { ref : this.h, it : this.keys(), hasNext : function() {
        return this.it.hasNext();
    }, next : function() {
        var i = this.it.next();
        return this.ref["$" + i];
    }}
}
Hash.prototype.keys = function() {
    var a = new Array();

            for(var i in this.h)
                a.push(i.substr(1));
        ;
    return a.iterator();
}
Hash.prototype.remove = function(key) {
    if(!this.exists(key)) return false;
    delete(this.h["$" + key]);
    return true;
}
Hash.prototype.set = function(key,value) {
    this.h["$" + key] = value;
}
Hash.prototype.toString = function() {
    var s = new StringBuf();
    s.add("{");
    var it = this.keys();
    { var $it7 = it;
    while( $it7.hasNext() ) { var i = $it7.next();
    {
        s.add(i);
        s.add(" => ");
        s.add(Std.string(this.get(i)));
        if(it.hasNext()) s.add(", ");
    }
    }}
    s.add("}");
    return s.toString();
}
Hash.prototype.__class__ = Hash;
EReg = function(r,opt) { if( r === $_ ) return; {
    opt = opt.split("u").join("");
    this.r = new RegExp(r,opt);
}}
EReg.__name__ = ["EReg"];
EReg.prototype.match = function(s) {
    {
        this.r.m = this.r.exec(s);
        this.r.s = s;
        this.r.l = RegExp.leftContext;
        this.r.r = RegExp.rightContext;
        return (this.r.m != null);
    }
}
EReg.prototype.matched = function(n) {
    return (this.r.m != null && n >= 0 && n < this.r.m.length?this.r.m[n]:function($this) {
        var $r;
        throw "EReg::matched";
        return $r;
    }(this));
}
EReg.prototype.matchedLeft = function() {
    {
        if(this.r.m == null) throw "EReg::matchedLeft";
        if(this.r.l == null) return this.r.s.substr(0,this.r.m.index);
        return this.r.l;
    }
}
EReg.prototype.matchedPos = function() {
    if(this.r.m == null) throw "EReg::matchedPos";
    return { pos : this.r.m.index, len : this.r.m[0].length}
}
EReg.prototype.matchedRight = function() {
    {
        if(this.r.m == null) throw "EReg::matchedRight";
        if(this.r.r == null) {
            var sz = this.r.m.index + this.r.m[0].length;
            return this.r.s.substr(sz,this.r.s.length - sz);
        }
        return this.r.r;
    }
}
EReg.prototype.r = null;
EReg.prototype.replace = function(s,by) {
    return s.replace(this.r,by);
}
EReg.prototype.split = function(s) {
    var d = "#__delim__#";
    return s.replace(this.r,d).split(d);
}
EReg.prototype.__class__ = EReg;
StringBuf = function(p) { if( p === $_ ) return; {
    this.b = "";
}}
StringBuf.__name__ = ["StringBuf"];
StringBuf.prototype.add = function(x) {
    this.b += x;
}
StringBuf.prototype.addChar = function(c) {
    this.b += String.fromCharCode(c);
}
StringBuf.prototype.addSub = function(s,pos,len) {
    this.b += s.substr(pos,len);
}
StringBuf.prototype.b = null;
StringBuf.prototype.toString = function() {
    return this.b;
}
StringBuf.prototype.__class__ = StringBuf;
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;
$Main = function() { }
$Main.__name__ = ["@Main"];
$Main.prototype.__class__ = $Main;
$_ = {}
js.Boot.__res = {}
js.Boot.__init();
{

            onerror = function(msg,url,line) {
                var f = js.Lib.onerror;
                if( f == null )
                    return false;
                return f(msg,[url+":"+line]);
            }
        ;
}
{
    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);
    }
}
{
    js["XMLHttpRequest"] = (window.XMLHttpRequest?XMLHttpRequest:(window.ActiveXObject?function() {
        try {
            return new ActiveXObject("Msxml2.XMLHTTP");
        }
        catch( $e8 ) {
            {
                var e = $e8;
                {
                    try {
                        return new ActiveXObject("Microsoft.XMLHTTP");
                    }
                    catch( $e9 ) {
                        {
                            var e1 = $e9;
                            {
                                throw "Unable to create XMLHttpRequest object.";
                            }
                        }
                    }
                }
            }
        }
    }:function($this) {
        var $r;
        throw "Unable to create XMLHttpRequest object.";
        return $r;
    }(this)));
}
js.Lib.document = document;
js.Lib.window = window;
js.Lib.onerror = null;