$estr = function() { return js.Boot.__string_rec(this,''); }
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( $e0 ) {
				{
					var e = $e0;
					$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 $it1 = this.params.keys();
	while( $it1.hasNext() ) { var p = $it1.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( $e2 ) {
		{
			var e = $e2;
			{
				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 $it3 = this.headers.keys();
	while( $it3.hasNext() ) { var h = $it3.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;
org = {}
org.omixed = {}
org.omixed.client = {}
org.omixed.client.OmixedClientHttpRequest = function(url) { if( url === $_ ) return; {
	haxe.Http.apply(this,[url]);
}}
org.omixed.client.OmixedClientHttpRequest.__name__ = ["org","omixed","client","OmixedClientHttpRequest"];
org.omixed.client.OmixedClientHttpRequest.__super__ = haxe.Http;
for(var k in haxe.Http.prototype ) org.omixed.client.OmixedClientHttpRequest.prototype[k] = haxe.Http.prototype[k];
org.omixed.client.OmixedClientHttpRequest.prototype.getParams = function() {
	return this.params;
}
org.omixed.client.OmixedClientHttpRequest.prototype.__class__ = org.omixed.client.OmixedClientHttpRequest;
haxe.io = {}
haxe.io.BytesBuffer = function(p) { if( p === $_ ) return; {
	this.b = new Array();
}}
haxe.io.BytesBuffer.__name__ = ["haxe","io","BytesBuffer"];
haxe.io.BytesBuffer.prototype.add = function(src) {
	var b1 = this.b;
	var b2 = src.b;
	{
		var _g1 = 0, _g = src.length;
		while(_g1 < _g) {
			var i = _g1++;
			this.b.push(b2[i]);
		}
	}
}
haxe.io.BytesBuffer.prototype.addByte = function($byte) {
	this.b.push($byte);
}
haxe.io.BytesBuffer.prototype.addBytes = function(src,pos,len) {
	if(pos < 0 || len < 0 || pos + len > src.length) throw haxe.io.Error.OutsideBounds;
	var b1 = this.b;
	var b2 = src.b;
	{
		var _g1 = pos, _g = pos + len;
		while(_g1 < _g) {
			var i = _g1++;
			this.b.push(b2[i]);
		}
	}
}
haxe.io.BytesBuffer.prototype.b = null;
haxe.io.BytesBuffer.prototype.getBytes = function() {
	var bytes = new haxe.io.Bytes(this.b.length,this.b);
	this.b = null;
	return bytes;
}
haxe.io.BytesBuffer.prototype.__class__ = haxe.io.BytesBuffer;
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.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;
EReg = function(r,opt) { if( r === $_ ) return; {
	opt = opt.split("u").join("");
	this.r = new RegExp(r,opt);
}}
EReg.__name__ = ["EReg"];
EReg.prototype.customReplace = function(s,f) {
	var buf = new StringBuf();
	while(true) {
		if(!this.match(s)) break;
		buf.b += this.matchedLeft();
		buf.b += f(this);
		s = this.matchedRight();
	}
	buf.b += s;
	return buf.b;
}
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 "No string matched";
	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 "No string matched";
	return { pos : this.r.m.index, len : this.r.m[0].length}
}
EReg.prototype.matchedRight = function() {
	if(this.r.m == null) throw "No string matched";
	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;
js = {}
js.JsXml__ = function(p) { if( p === $_ ) return; {
	null;
}}
js.JsXml__.__name__ = ["js","JsXml__"];
js.JsXml__.parse = function(str) {
	var rules = [js.JsXml__.enode,js.JsXml__.epcdata,js.JsXml__.eend,js.JsXml__.ecdata,js.JsXml__.edoctype,js.JsXml__.ecomment,js.JsXml__.eprolog];
	var nrules = rules.length;
	var current = Xml.createDocument();
	var stack = new List();
	while(str.length > 0) {
		var i = 0;
		try {
			while(i < nrules) {
				var r = rules[i];
				if(r.match(str)) {
					switch(i) {
					case 0:{
						var x = Xml.createElement(r.matched(1));
						current.addChild(x);
						str = r.matchedRight();
						while(js.JsXml__.eattribute.match(str)) {
							x.set(js.JsXml__.eattribute.matched(1),js.JsXml__.eattribute.matched(3));
							str = js.JsXml__.eattribute.matchedRight();
						}
						if(!js.JsXml__.eclose.match(str)) {
							i = nrules;
							throw "__break__";
						}
						if(js.JsXml__.eclose.matched(1) == ">") {
							stack.push(current);
							current = x;
						}
						str = js.JsXml__.eclose.matchedRight();
					}break;
					case 1:{
						var x = Xml.createPCData(r.matched(0));
						current.addChild(x);
						str = r.matchedRight();
					}break;
					case 2:{
						if(current._children != null && current._children.length == 0) {
							var e = Xml.createPCData("");
							current.addChild(e);
						}
						else null;
						if(r.matched(1) != current._nodeName || stack.isEmpty()) {
							i = nrules;
							throw "__break__";
						}
						else null;
						current = stack.pop();
						str = r.matchedRight();
					}break;
					case 3:{
						str = r.matchedRight();
						if(!js.JsXml__.ecdata_end.match(str)) throw "End of CDATA section not found";
						var x = Xml.createCData(js.JsXml__.ecdata_end.matchedLeft());
						current.addChild(x);
						str = js.JsXml__.ecdata_end.matchedRight();
					}break;
					case 4:{
						var pos = 0;
						var count = 0;
						var old = str;
						try {
							while(true) {
								if(!js.JsXml__.edoctype_elt.match(str)) throw "End of DOCTYPE section not found";
								var p = js.JsXml__.edoctype_elt.matchedPos();
								pos += p.pos + p.len;
								str = js.JsXml__.edoctype_elt.matchedRight();
								switch(js.JsXml__.edoctype_elt.matched(0)) {
								case "[":{
									count++;
								}break;
								case "]":{
									count--;
									if(count < 0) throw "Invalid ] found in DOCTYPE declaration";
								}break;
								default:{
									if(count == 0) throw "__break__";
								}break;
								}
							}
						} catch( e ) { if( e != "__break__" ) throw e; }
						var x = Xml.createDocType(old.substr(0,pos));
						current.addChild(x);
					}break;
					case 5:{
						if(!js.JsXml__.ecomment_end.match(str)) throw "Unclosed Comment";
						var p = js.JsXml__.ecomment_end.matchedPos();
						var x = Xml.createComment(str.substr(0,p.pos + p.len));
						current.addChild(x);
						str = js.JsXml__.ecomment_end.matchedRight();
					}break;
					case 6:{
						var x = Xml.createProlog(r.matched(0));
						current.addChild(x);
						str = r.matchedRight();
					}break;
					}
					throw "__break__";
				}
				i += 1;
			}
		} catch( e ) { if( e != "__break__" ) throw e; }
		if(i == nrules) {
			if(str.length > 10) throw ("Xml parse error : Unexpected " + str.substr(0,10) + "...");
			else throw ("Xml parse error : Unexpected " + str);
		}
	}
	return current;
}
js.JsXml__.createElement = function(name) {
	var r = new js.JsXml__();
	r.nodeType = Xml.Element;
	r._children = new Array();
	r._attributes = new Hash();
	r.setNodeName(name);
	return r;
}
js.JsXml__.createPCData = function(data) {
	var r = new js.JsXml__();
	r.nodeType = Xml.PCData;
	r.setNodeValue(data);
	return r;
}
js.JsXml__.createCData = function(data) {
	var r = new js.JsXml__();
	r.nodeType = Xml.CData;
	r.setNodeValue(data);
	return r;
}
js.JsXml__.createComment = function(data) {
	var r = new js.JsXml__();
	r.nodeType = Xml.Comment;
	r.setNodeValue(data);
	return r;
}
js.JsXml__.createDocType = function(data) {
	var r = new js.JsXml__();
	r.nodeType = Xml.DocType;
	r.setNodeValue(data);
	return r;
}
js.JsXml__.createProlog = function(data) {
	var r = new js.JsXml__();
	r.nodeType = Xml.Prolog;
	r.setNodeValue(data);
	return r;
}
js.JsXml__.createDocument = function() {
	var r = new js.JsXml__();
	r.nodeType = Xml.Document;
	r._children = new Array();
	return r;
}
js.JsXml__.prototype._attributes = null;
js.JsXml__.prototype._children = null;
js.JsXml__.prototype._nodeName = null;
js.JsXml__.prototype._nodeValue = null;
js.JsXml__.prototype._parent = null;
js.JsXml__.prototype.addChild = function(x) {
	if(this._children == null) throw "bad nodetype";
	if(x._parent != null) x._parent._children.remove(x);
	x._parent = this;
	this._children.push(x);
}
js.JsXml__.prototype.attributes = function() {
	if(this.nodeType != Xml.Element) throw "bad nodeType";
	return this._attributes.keys();
}
js.JsXml__.prototype.elements = function() {
	if(this._children == null) throw "bad nodetype";
	return { cur : 0, x : this._children, hasNext : function() {
		var k = this.cur;
		var l = this.x.length;
		while(k < l) {
			if(this.x[k].nodeType == Xml.Element) break;
			k += 1;
		}
		this.cur = k;
		return k < l;
	}, next : function() {
		var k = this.cur;
		var l = this.x.length;
		while(k < l) {
			var n = this.x[k];
			k += 1;
			if(n.nodeType == Xml.Element) {
				this.cur = k;
				return n;
			}
		}
		return null;
	}}
}
js.JsXml__.prototype.elementsNamed = function(name) {
	if(this._children == null) throw "bad nodetype";
	return { cur : 0, x : this._children, hasNext : function() {
		var k = this.cur;
		var l = this.x.length;
		while(k < l) {
			var n = this.x[k];
			if(n.nodeType == Xml.Element && n._nodeName == name) break;
			k++;
		}
		this.cur = k;
		return k < l;
	}, next : function() {
		var k = this.cur;
		var l = this.x.length;
		while(k < l) {
			var n = this.x[k];
			k++;
			if(n.nodeType == Xml.Element && n._nodeName == name) {
				this.cur = k;
				return n;
			}
		}
		return null;
	}}
}
js.JsXml__.prototype.exists = function(att) {
	if(this.nodeType != Xml.Element) throw "bad nodeType";
	return this._attributes.exists(att);
}
js.JsXml__.prototype.firstChild = function() {
	if(this._children == null) throw "bad nodetype";
	return this._children[0];
}
js.JsXml__.prototype.firstElement = function() {
	if(this._children == null) throw "bad nodetype";
	var cur = 0;
	var l = this._children.length;
	while(cur < l) {
		var n = this._children[cur];
		if(n.nodeType == Xml.Element) return n;
		cur++;
	}
	return null;
}
js.JsXml__.prototype.get = function(att) {
	if(this.nodeType != Xml.Element) throw "bad nodeType";
	return this._attributes.get(att);
}
js.JsXml__.prototype.getNodeName = function() {
	if(this.nodeType != Xml.Element) throw "bad nodeType";
	return this._nodeName;
}
js.JsXml__.prototype.getNodeValue = function() {
	if(this.nodeType == Xml.Element || this.nodeType == Xml.Document) throw "bad nodeType";
	return this._nodeValue;
}
js.JsXml__.prototype.getParent = function() {
	return this._parent;
}
js.JsXml__.prototype.insertChild = function(x,pos) {
	if(this._children == null) throw "bad nodetype";
	if(x._parent != null) x._parent._children.remove(x);
	x._parent = this;
	this._children.insert(pos,x);
}
js.JsXml__.prototype.iterator = function() {
	if(this._children == null) throw "bad nodetype";
	return { cur : 0, x : this._children, hasNext : function() {
		return this.cur < this.x.length;
	}, next : function() {
		return this.x[this.cur++];
	}}
}
js.JsXml__.prototype.nodeName = null;
js.JsXml__.prototype.nodeType = null;
js.JsXml__.prototype.nodeValue = null;
js.JsXml__.prototype.parent = null;
js.JsXml__.prototype.remove = function(att) {
	if(this.nodeType != Xml.Element) throw "bad nodeType";
	this._attributes.remove(att);
}
js.JsXml__.prototype.removeChild = function(x) {
	if(this._children == null) throw "bad nodetype";
	var b = this._children.remove(x);
	if(b) x._parent = null;
	return b;
}
js.JsXml__.prototype.set = function(att,value) {
	if(this.nodeType != Xml.Element) throw "bad nodeType";
	this._attributes.set(att,value);
}
js.JsXml__.prototype.setNodeName = function(n) {
	if(this.nodeType != Xml.Element) throw "bad nodeType";
	return this._nodeName = n;
}
js.JsXml__.prototype.setNodeValue = function(v) {
	if(this.nodeType == Xml.Element || this.nodeType == Xml.Document) throw "bad nodeType";
	return this._nodeValue = v;
}
js.JsXml__.prototype.toString = function() {
	if(this.nodeType == Xml.PCData) return this._nodeValue;
	if(this.nodeType == Xml.CData) return "<![CDATA[" + this._nodeValue + "]]>";
	if(this.nodeType == Xml.Comment || this.nodeType == Xml.DocType || this.nodeType == Xml.Prolog) return this._nodeValue;
	var s = new StringBuf();
	if(this.nodeType == Xml.Element) {
		s.b += "<";
		s.b += this._nodeName;
		{ var $it4 = this._attributes.keys();
		while( $it4.hasNext() ) { var k = $it4.next();
		{
			s.b += " ";
			s.b += k;
			s.b += "=\"";
			s.b += this._attributes.get(k);
			s.b += "\"";
		}
		}}
		if(this._children.length == 0) {
			s.b += "/>";
			return s.b;
		}
		s.b += ">";
	}
	{ var $it5 = this.iterator();
	while( $it5.hasNext() ) { var x = $it5.next();
	s.b += x.toString();
	}}
	if(this.nodeType == Xml.Element) {
		s.b += "</";
		s.b += this._nodeName;
		s.b += ">";
	}
	return s.b;
}
js.JsXml__.prototype.__class__ = js.JsXml__;
Reflect = function() { }
Reflect.__name__ = ["Reflect"];
Reflect.hasField = function(o,field) {
	if(o.hasOwnProperty != null) return o.hasOwnProperty(field);
	var arr = Reflect.fields(o);
	{ var $it6 = arr.iterator();
	while( $it6.hasNext() ) { var t = $it6.next();
	if(t == field) return true;
	}}
	return false;
}
Reflect.field = function(o,field) {
	var v = null;
	try {
		v = o[field];
	}
	catch( $e7 ) {
		{
			var e = $e7;
			null;
		}
	}
	return v;
}
Reflect.setField = function(o,field,value) {
	o[field] = value;
}
Reflect.callMethod = function(o,func,args) {
	return func.apply(o,args);
}
Reflect.fields = function(o) {
	if(o == null) return new Array();
	var a = new Array();
	if(o.hasOwnProperty) {
		
					for(var i in o)
						if( o.hasOwnProperty(i) )
							a.push(i);
				;
	}
	else {
		var t;
		try {
			t = o.__proto__;
		}
		catch( $e8 ) {
			{
				var e = $e8;
				{
					t = null;
				}
			}
		}
		if(t != null) o.__proto__ = null;
		
					for(var i in o)
						if( i != "__proto__" )
							a.push(i);
				;
		if(t != null) o.__proto__ = t;
	}
	return a;
}
Reflect.isFunction = function(f) {
	return typeof(f) == "function" && f.__name__ == null;
}
Reflect.compare = function(a,b) {
	return ((a == b)?0:((((a) > (b))?1:-1)));
}
Reflect.compareMethods = function(f1,f2) {
	if(f1 == f2) return true;
	if(!Reflect.isFunction(f1) || !Reflect.isFunction(f2)) return false;
	return f1.scope == f2.scope && f1.method == f2.method && f1.method != null;
}
Reflect.isObject = function(v) {
	if(v == null) return false;
	var t = typeof(v);
	return (t == "string" || (t == "object" && !v.__enum__) || (t == "function" && v.__name__ != null));
}
Reflect.deleteField = function(o,f) {
	if(!Reflect.hasField(o,f)) return false;
	delete(o[f]);
	return true;
}
Reflect.copy = function(o) {
	var o2 = { }
	{
		var _g = 0, _g1 = Reflect.fields(o);
		while(_g < _g1.length) {
			var f = _g1[_g];
			++_g;
			o2[f] = Reflect.field(o,f);
		}
	}
	return o2;
}
Reflect.makeVarArgs = function(f) {
	return function() {
		var a = new Array();
		{
			var _g1 = 0, _g = arguments.length;
			while(_g1 < _g) {
				var i = _g1++;
				a.push(arguments[i]);
			}
		}
		return f(a);
	}
}
Reflect.prototype.__class__ = Reflect;
org.omixed.client.RequestSequence = function(client,onSequenceComplete) { if( client === $_ ) return; {
	this.requests = new Array();
	this.currentRequestID = 0;
	this.client = client;
	if(onSequenceComplete != null) {
		this.onSequenceComplete = onSequenceComplete;
	}
}}
org.omixed.client.RequestSequence.__name__ = ["org","omixed","client","RequestSequence"];
org.omixed.client.RequestSequence.prototype.addRequest = function(parameters,methodName,onResult,onFault) {
	this.requests.push({ parameters : parameters, methodName : methodName, onResult : onResult, onFault : onFault});
}
org.omixed.client.RequestSequence.prototype.callCurrent = function() {
	var requestor = this.requests[this.currentRequestID];
	this.client.newHandler().send(requestor.methodName,requestor.parameters,$closure(this,"onComplete"),$closure(this,"onError"));
}
org.omixed.client.RequestSequence.prototype.callNext = function() {
	this.currentRequestID++;
	this.callCurrent();
}
org.omixed.client.RequestSequence.prototype.client = null;
org.omixed.client.RequestSequence.prototype.currentRequestID = null;
org.omixed.client.RequestSequence.prototype.onComplete = function(event,handler) {
	var requestor = this.requests[this.currentRequestID];
	requestor.onResult(event,handler);
	var maxIndex = this.requests.length - 1;
	if(maxIndex > this.currentRequestID) {
		this.callNext();
	}
	else {
		if(this.onSequenceComplete != null) {
			this.onSequenceComplete();
		}
	}
}
org.omixed.client.RequestSequence.prototype.onError = function(event,handler) {
	var requestor = this.requests[this.currentRequestID];
	haxe.Log.trace("sequence error" + event,{ fileName : "RequestSequence.hx", lineNumber : 97, className : "org.omixed.client.RequestSequence", methodName : "onError", customParams : [Logger.error]});
	requestor.onFault(event,handler);
}
org.omixed.client.RequestSequence.prototype.onSequenceComplete = null;
org.omixed.client.RequestSequence.prototype.requests = null;
org.omixed.client.RequestSequence.prototype.start = function() {
	this.callCurrent();
}
org.omixed.client.RequestSequence.prototype.__class__ = org.omixed.client.RequestSequence;
haxe.Log = function() { }
haxe.Log.__name__ = ["haxe","Log"];
haxe.Log.trace = function(v,infos) {
	js.Boot.__trace(v,infos);
}
haxe.Log.clear = function() {
	js.Boot.__clear_trace();
}
haxe.Log.prototype.__class__ = haxe.Log;
org.omixed.client.QueryOptions = function(acceptedValues) { if( acceptedValues === $_ ) return; {
	this.options = new org.omixed.client.OrderedHash();
	this.acceptedValues = acceptedValues;
}}
org.omixed.client.QueryOptions.__name__ = ["org","omixed","client","QueryOptions"];
org.omixed.client.QueryOptions.prototype.acceptedValues = null;
org.omixed.client.QueryOptions.prototype.addOption = function(key,val) {
	if(this.acceptedValues.exists(key)) {
		var vals = this.acceptedValues.get(key);
		if((Lambda.has(vals,val)) || (vals.length < 1)) {
			this.options.set(key,val);
		}
		else {
			throw new org.omixed.client.ClientError("WRONG_VALUE","Sorry, but " + val + " is not a valid value. Valid values are " + vals.toString());
		}
	}
	else {
		var keys = new Array();
		{ var $it9 = this.acceptedValues.keys();
		while( $it9.hasNext() ) { var k = $it9.next();
		{
			keys.push(k);
		}
		}}
		throw new org.omixed.client.ClientError("WRONG_KEY","Sorry, but " + key + " is not a valid key. Valid keys are " + keys.toString());
	}
}
org.omixed.client.QueryOptions.prototype.addOptions = function(newOptions) {
	var _g = 0, _g1 = Reflect.fields(newOptions);
	while(_g < _g1.length) {
		var fieldName = _g1[_g];
		++_g;
		var fieldValue = Reflect.field(newOptions,fieldName);
		this.addOption(fieldName,fieldValue);
	}
}
org.omixed.client.QueryOptions.prototype.getOption = function(key) {
	if(this.options.exists(key)) {
		return this.options.get(key);
	}
	return null;
}
org.omixed.client.QueryOptions.prototype.options = null;
org.omixed.client.QueryOptions.prototype.toString = function() {
	var s = "";
	{ var $it10 = this.options.keys();
	while( $it10.hasNext() ) { var key = $it10.next();
	{
		s += key + "=" + this.options.get(key) + "\n";
	}
	}}
	return s;
}
org.omixed.client.QueryOptions.prototype.__class__ = org.omixed.client.QueryOptions;
org.omixed.client.OrderedHash = function(p) { if( p === $_ ) return; {
	this.my_keys = new Array();
	this.my_values = new Array();
}}
org.omixed.client.OrderedHash.__name__ = ["org","omixed","client","OrderedHash"];
org.omixed.client.OrderedHash.prototype.exists = function(key) {
	{
		var _g = 0, _g1 = this.my_keys;
		while(_g < _g1.length) {
			var k = _g1[_g];
			++_g;
			if(k == key) {
				return true;
			}
		}
	}
	return false;
}
org.omixed.client.OrderedHash.prototype.get = function(key) {
	var i = 0;
	{
		var _g = 0, _g1 = this.my_keys;
		while(_g < _g1.length) {
			var k = _g1[_g];
			++_g;
			if(k == key) {
				return this.my_values[i];
			}
			i++;
		}
	}
	return null;
}
org.omixed.client.OrderedHash.prototype.iterator = function() {
	return new org.omixed.client.OrderedHashArrayIterator(this.my_values);
}
org.omixed.client.OrderedHash.prototype.keys = function() {
	return new org.omixed.client.OrderedHashArrayIterator(this.my_keys);
}
org.omixed.client.OrderedHash.prototype.my_keys = null;
org.omixed.client.OrderedHash.prototype.my_values = null;
org.omixed.client.OrderedHash.prototype.remove = function(key) {
	var removed = false;
	var new_keys = new Array();
	var new_values = new Array();
	var i = 0;
	{
		var _g = 0, _g1 = this.my_keys;
		while(_g < _g1.length) {
			var k = _g1[_g];
			++_g;
			if(k == key) {
				removed = true;
			}
			else {
				new_keys.push(k);
				new_values.push(this.my_values[i]);
			}
			i++;
		}
	}
	if(removed == true) {
		this.my_keys = new_keys;
		this.my_values = new_values;
	}
	return removed;
}
org.omixed.client.OrderedHash.prototype.set = function(key,value) {
	if(this.exists(key)) {
		var i = 0;
		{
			var _g = 0, _g1 = this.my_keys;
			while(_g < _g1.length) {
				var k = _g1[_g];
				++_g;
				if(k == key) {
					this.my_values[i] = value;
				}
				i++;
			}
		}
	}
	else {
		this.my_keys.push(key);
		this.my_values.push(value);
	}
}
org.omixed.client.OrderedHash.prototype.toString = function() {
	var s = "[ ";
	var sep = "";
	var i = 0;
	{
		var _g = 0, _g1 = this.my_keys;
		while(_g < _g1.length) {
			var k = _g1[_g];
			++_g;
			s += sep + k + ":" + this.my_values[i];
			sep = " , ";
			i++;
		}
	}
	s += " ]";
	return s;
}
org.omixed.client.OrderedHash.prototype.__class__ = org.omixed.client.OrderedHash;
org.omixed.client.OrderedHashArrayIterator = function(array_store) { if( array_store === $_ ) return; {
	this.array_store = array_store;
	this.index = 0;
}}
org.omixed.client.OrderedHashArrayIterator.__name__ = ["org","omixed","client","OrderedHashArrayIterator"];
org.omixed.client.OrderedHashArrayIterator.prototype.array_store = null;
org.omixed.client.OrderedHashArrayIterator.prototype.hasNext = function() {
	return (this.index < this.array_store.length);
}
org.omixed.client.OrderedHashArrayIterator.prototype.index = null;
org.omixed.client.OrderedHashArrayIterator.prototype.next = function() {
	var old_index = this.index;
	this.index++;
	return this.array_store[old_index];
}
org.omixed.client.OrderedHashArrayIterator.prototype.toString = function() {
	return this.array_store.toString();
}
org.omixed.client.OrderedHashArrayIterator.prototype.__class__ = org.omixed.client.OrderedHashArrayIterator;
org.omixed.client.graphviz = {}
org.omixed.client.graphviz.GraphVizQueryOptions = function(p) { if( p === $_ ) return; {
	var keys = new Hash();
	keys.set("maxOutboundDepth",["1","2","3","4","5","6","7","8"]);
	keys.set("maxInboundDepth",["1","2","3","4","5","6","7","8"]);
	org.omixed.client.QueryOptions.apply(this,[keys]);
}}
org.omixed.client.graphviz.GraphVizQueryOptions.__name__ = ["org","omixed","client","graphviz","GraphVizQueryOptions"];
org.omixed.client.graphviz.GraphVizQueryOptions.__super__ = org.omixed.client.QueryOptions;
for(var k in org.omixed.client.QueryOptions.prototype ) org.omixed.client.graphviz.GraphVizQueryOptions.prototype[k] = org.omixed.client.QueryOptions.prototype[k];
org.omixed.client.graphviz.GraphVizQueryOptions.prototype.__class__ = org.omixed.client.graphviz.GraphVizQueryOptions;
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;
haxe.remoting = {}
haxe.remoting.Connection = function() { }
haxe.remoting.Connection.__name__ = ["haxe","remoting","Connection"];
haxe.remoting.Connection.prototype.call = null;
haxe.remoting.Connection.prototype.resolve = null;
haxe.remoting.Connection.prototype.__class__ = haxe.remoting.Connection;
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( $e11 ) {
		{
			var e = $e11;
			{
				
				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.b += "{";
	var it = this.keys();
	{ var $it12 = it;
	while( $it12.hasNext() ) { var i = $it12.next();
	{
		s.b += i;
		s.b += " => ";
		s.b += Std.string(this.get(i));
		if(it.hasNext()) s.b += ", ";
	}
	}}
	s.b += "}";
	return s.b;
}
Hash.prototype.__class__ = Hash;
haxe.remoting.ExternalConnection = function(data,path) { if( data === $_ ) return; {
	this.__data = data;
	this.__path = path;
}}
haxe.remoting.ExternalConnection.__name__ = ["haxe","remoting","ExternalConnection"];
haxe.remoting.ExternalConnection.escapeString = function(s) {
	return s;
}
haxe.remoting.ExternalConnection.doCall = function(name,path,params) {
	try {
		var cnx = haxe.remoting.ExternalConnection.connections.get(name);
		if(cnx == null) throw "Unknown connection : " + name;
		if(cnx.__data.ctx == null) throw "No context shared for the connection " + name;
		var params1 = new haxe.Unserializer(params).unserialize();
		var ret = cnx.__data.ctx.call(path.split("."),params1);
		var s = new haxe.Serializer();
		s.serialize(ret);
		return s.toString() + "#";
	}
	catch( $e13 ) {
		{
			var e = $e13;
			{
				var s = new haxe.Serializer();
				s.serializeException(e);
				return s.toString();
			}
		}
	}
}
haxe.remoting.ExternalConnection.flashConnect = function(name,flashObjectID,ctx) {
	var cnx = new haxe.remoting.ExternalConnection({ ctx : ctx, name : name, flash : flashObjectID},[]);
	haxe.remoting.ExternalConnection.connections.set(name,cnx);
	return cnx;
}
haxe.remoting.ExternalConnection.prototype.__data = null;
haxe.remoting.ExternalConnection.prototype.__path = null;
haxe.remoting.ExternalConnection.prototype.call = function(params) {
	var s = new haxe.Serializer();
	s.serialize(params);
	var params1 = s.toString();
	var data = null;
	var fobj = window.document[this.__data.flash];
	if(fobj == null) fobj = window.document.getElementById[this.__data.flash];
	if(fobj == null) throw "Could not find flash object '" + this.__data.flash + "'";
	try {
		data = fobj.externalRemotingCall(this.__data.name,this.__path.join("."),params1);
	}
	catch( $e14 ) {
		{
			var e = $e14;
			null;
		}
	}
	if(data == null) throw "Call failure : ExternalConnection is not " + "initialized in Flash";
	return new haxe.Unserializer(data).unserialize();
}
haxe.remoting.ExternalConnection.prototype.close = function() {
	haxe.remoting.ExternalConnection.connections.remove(this.__data.name);
}
haxe.remoting.ExternalConnection.prototype.resolve = function(field) {
	var e = new haxe.remoting.ExternalConnection(this.__data,this.__path.copy());
	e.__path.push(field);
	return e;
}
haxe.remoting.ExternalConnection.prototype.__class__ = haxe.remoting.ExternalConnection;
haxe.remoting.ExternalConnection.__interfaces__ = [haxe.remoting.Connection];
org.omixed.main = {}
org.omixed.main.GraphVizAppletJS = function() { }
org.omixed.main.GraphVizAppletJS.__name__ = ["org","omixed","main","GraphVizAppletJS"];
org.omixed.main.GraphVizAppletJS.cnx = null;
org.omixed.main.GraphVizAppletJS.main = function() {
	Logger.setup();
	org.omixed.main.GraphVizAppletJS.getConnection();
	org.omixed.main.GraphVizAppletJS.addMouseListeners();
}
org.omixed.main.GraphVizAppletJS.addMouseListeners = function() {
	var window = js.Lib.window;
	var document = js.Lib.document;
	var browser = BrowserDetect.browser;
	if(browser == "Opera") {
		window.attachEvent("mousewheel",$closure(org.omixed.main.GraphVizAppletJS,"deltaDispatcher"));
	}
	else if(browser == "Firefox") {
		window.addEventListener("DOMMouseScroll",$closure(org.omixed.main.GraphVizAppletJS,"deltaDispatcher"),false);
	}
	else if(browser == "Safari") {
		window.onmousewheel = document.onmousewheel = $closure(org.omixed.main.GraphVizAppletJS,"deltaDispatcher");
	}
	else if(browser == "Explorer") {
		window.onmousewheel = document.onmousewheel = $closure(org.omixed.main.GraphVizAppletJS,"deltaDispatcher");
	}
}
org.omixed.main.GraphVizAppletJS.deltaFilter = function(event) {
	var delta = 0.0;
	var browser = BrowserDetect.browser;
	try {
		if(event.wheelDelta != null) {
			delta = event.wheelDelta / 120;
		}
		else if(event.detail != null) {
			delta = -event.detail;
		}
	}
	catch( $e15 ) {
		{
			var e = $e15;
			{
				haxe.Log.trace(e,{ fileName : "GraphVizAppletJS.hx", lineNumber : 121, className : "org.omixed.main.GraphVizAppletJS", methodName : "deltaFilter"});
			}
		}
	}
	return delta;
}
org.omixed.main.GraphVizAppletJS.cancelEvent = function(event) {
	var browser = BrowserDetect.browser;
	if(browser == "Explorer") {
		event.cancelBubble = true;
		event.cancel = true;
		event.returnValue = false;
	}
	else {
		event.stopPropagation();
		event.preventDefault();
		event.cancel = true;
		event.returnValue = false;
		event.cancelBubble = true;
		if(browser == "Safari") {
			event.stop();
		}
	}
	return false;
}
org.omixed.main.GraphVizAppletJS.deltaDispatcher = function(event) {
	var browser = BrowserDetect.browser;
	if(browser == "Explorer") {
		var window = js.Lib.window;
		event = window.event;
	}
	if((org.omixed.main.GraphVizAppletJS.cnx != null) && (event != null)) {
		var browser1 = BrowserDetect.browser;
		var target = Std.string(event.target);
		var appletIsTarget = false;
		var expectedID = "myFlashObject";
		if(browser1 == "Explorer") {
			var srcElementNodeName = Std.string(event.srcElement.nodeName);
			if((srcElementNodeName == "OBJECT") && (event.srcElement.id == "myFlashObject")) {
				appletIsTarget = true;
			}
		}
		else if(target == "[object HTMLEmbedElement]") {
			appletIsTarget = true;
		}
		else if(target == "<function>") {
			appletIsTarget = true;
		}
		if(appletIsTarget) {
			org.omixed.main.GraphVizAppletJS.cancelEvent(event);
			var mouseWheel = org.omixed.main.GraphVizAppletJS.deltaFilter(event);
			org.omixed.main.GraphVizAppletJS.cnx.resolve("GraphVizAppletFlash").resolve("mouseWheel").call([mouseWheel,browser1]);
		}
	}
}
org.omixed.main.GraphVizAppletJS.getConnection = function() {
	if(org.omixed.main.GraphVizAppletJS.cnx == null) {
		var ctx = new haxe.remoting.Context();
		ctx.addObject("GraphVizAppletJS",org.omixed.main.GraphVizAppletJS);
		org.omixed.main.GraphVizAppletJS.cnx = haxe.remoting.ExternalConnection.flashConnect("default","myFlashObject",ctx);
	}
	return org.omixed.main.GraphVizAppletJS.cnx;
}
org.omixed.main.GraphVizAppletJS.foo = function(x,y) {
	return x + y;
}
org.omixed.main.GraphVizAppletJS.setDisplayProperty = function(propertyName,value) {
	org.omixed.main.GraphVizAppletJS.cnx.resolve("GraphVizAppletFlash").resolve("setDisplayProperty").call([propertyName,value]);
}
org.omixed.main.GraphVizAppletJS.setDisplayProperties = function(props) {
	org.omixed.main.GraphVizAppletJS.cnx.resolve("GraphVizAppletFlash").resolve("setDisplayProperties").call([props]);
}
org.omixed.main.GraphVizAppletJS.setXML = function(xmlString) {
	haxe.Log.trace("setting XML",{ fileName : "GraphVizAppletJS.hx", lineNumber : 244, className : "org.omixed.main.GraphVizAppletJS", methodName : "setXML"});
	haxe.Log.trace(xmlString.substr(1,20),{ fileName : "GraphVizAppletJS.hx", lineNumber : 245, className : "org.omixed.main.GraphVizAppletJS", methodName : "setXML"});
	haxe.Log.trace(org.omixed.main.GraphVizAppletJS.cnx.resolve("GraphVizAppletFlash").resolve("setXML").call([xmlString]),{ fileName : "GraphVizAppletJS.hx", lineNumber : 249, className : "org.omixed.main.GraphVizAppletJS", methodName : "setXML"});
}
org.omixed.main.GraphVizAppletJS.setDot = function(dotString) {
	haxe.Log.trace("setting dot",{ fileName : "GraphVizAppletJS.hx", lineNumber : 258, className : "org.omixed.main.GraphVizAppletJS", methodName : "setDot"});
	haxe.Log.trace(dotString.substr(1,20),{ fileName : "GraphVizAppletJS.hx", lineNumber : 259, className : "org.omixed.main.GraphVizAppletJS", methodName : "setDot"});
	haxe.Log.trace(org.omixed.main.GraphVizAppletJS.cnx.resolve("GraphVizAppletFlash").resolve("setDot").call([dotString]),{ fileName : "GraphVizAppletJS.hx", lineNumber : 263, className : "org.omixed.main.GraphVizAppletJS", methodName : "setDot"});
}
org.omixed.main.GraphVizAppletJS.locationURL = null;
org.omixed.main.GraphVizAppletJS.setLocationURL = function(locationURL) {
	org.omixed.main.GraphVizAppletJS.locationURL = locationURL;
}
org.omixed.main.GraphVizAppletJS.setupClient = function(sessionID,resourceName,userName) {
	haxe.Log.trace("setting up client",{ fileName : "GraphVizAppletJS.hx", lineNumber : 278, className : "org.omixed.main.GraphVizAppletJS", methodName : "setupClient"});
	var location = js.Lib.window.location;
	var url = location.protocol + "//" + location.hostname + ":" + location.port;
	if(org.omixed.main.GraphVizAppletJS.locationURL != null) {
		url = org.omixed.main.GraphVizAppletJS.locationURL;
	}
	org.omixed.main.GraphVizAppletJS.cnx.resolve("GraphVizAppletFlash").resolve("setupClient").call([url,sessionID,resourceName,userName]);
}
org.omixed.main.GraphVizAppletJS.drawSchema = function(sessionID,layoutOptions) {
	org.omixed.main.GraphVizAppletJS.cnx.resolve("GraphVizAppletFlash").resolve("drawSchema").call([sessionID,layoutOptions]);
}
org.omixed.main.GraphVizAppletJS.drawItemGraph = function(sessionID,itemID,layoutOptions,queryOptions) {
	org.omixed.main.GraphVizAppletJS.cnx.resolve("GraphVizAppletFlash").resolve("drawItemGraph").call([sessionID,itemID,layoutOptions,queryOptions]);
}
org.omixed.main.GraphVizAppletJS.appletConnected = function(message) {
	haxe.Log.trace("message:" + message,{ fileName : "GraphVizAppletJS.hx", lineNumber : 339, className : "org.omixed.main.GraphVizAppletJS", methodName : "appletConnected"});
	{
		var _g = 0, _g1 = org.omixed.main.GraphVizAppletJS.appletConnectedListeners;
		while(_g < _g1.length) {
			var listener = _g1[_g];
			++_g;
			listener(message);
		}
	}
}
org.omixed.main.GraphVizAppletJS.onNodeClick = function(message) {
	haxe.Log.trace("message:" + message,{ fileName : "GraphVizAppletJS.hx", lineNumber : 351, className : "org.omixed.main.GraphVizAppletJS", methodName : "onNodeClick"});
	{
		var _g = 0, _g1 = org.omixed.main.GraphVizAppletJS.nodeClickListeners;
		while(_g < _g1.length) {
			var listener = _g1[_g];
			++_g;
			listener(message);
		}
	}
}
org.omixed.main.GraphVizAppletJS.onComplete = function(message) {
	var _g = 0, _g1 = org.omixed.main.GraphVizAppletJS.onCompleteListeners;
	while(_g < _g1.length) {
		var l = _g1[_g];
		++_g;
		l(message);
	}
}
org.omixed.main.GraphVizAppletJS.addAppletConnectedListener = function(listener) {
	org.omixed.main.GraphVizAppletJS.appletConnectedListeners.push(listener);
}
org.omixed.main.GraphVizAppletJS.addNodeClickListener = function(listener) {
	org.omixed.main.GraphVizAppletJS.nodeClickListeners.push(listener);
}
org.omixed.main.GraphVizAppletJS.addOnCompleteListener = function(listener) {
	org.omixed.main.GraphVizAppletJS.onCompleteListeners.push(listener);
}
org.omixed.main.GraphVizAppletJS.onServerException = function(message) {
	js.Lib.alert(message);
}
org.omixed.main.GraphVizAppletJS.getDimensions = function() {
	var object_element = js.Lib.document.getElementById("myFlashObject");
	return { width : object_element.width, height : object_element.height}
}
org.omixed.main.GraphVizAppletJS.setDimensions = function(x,y,width,height) {
	org.omixed.main.GraphVizAppletJS.cnx.resolve("GraphVizAppletFlash").resolve("setDimensions").call([x,y,width,height]);
}
org.omixed.main.GraphVizAppletJS.setSchemaCentre = function(schemaCentre) {
	org.omixed.main.GraphVizAppletJS.cnx.resolve("GraphVizAppletFlash").resolve("setSchemaCentre").call([schemaCentre]);
}
org.omixed.main.GraphVizAppletJS.getCenterTitle = function() {
	var t = org.omixed.main.GraphVizAppletJS.cnx.resolve("GraphVizAppletFlash").resolve("getCenterTitle").call([]);
	return t;
}
org.omixed.main.GraphVizAppletJS.getNewClient = function(url) {
	return new org.omixed.client.OmixedClient(url);
}
org.omixed.main.GraphVizAppletJS.prototype.__class__ = org.omixed.main.GraphVizAppletJS;
haxe.io.Bytes = function(length,b) { if( length === $_ ) return; {
	this.length = length;
	this.b = b;
}}
haxe.io.Bytes.__name__ = ["haxe","io","Bytes"];
haxe.io.Bytes.alloc = function(length) {
	var a = new Array();
	{
		var _g = 0;
		while(_g < length) {
			var i = _g++;
			a.push(0);
		}
	}
	return new haxe.io.Bytes(length,a);
}
haxe.io.Bytes.ofString = function(s) {
	var a = new Array();
	{
		var _g1 = 0, _g = s.length;
		while(_g1 < _g) {
			var i = _g1++;
			var c = s["cca"](i);
			if(c <= 127) a.push(c);
			else if(c <= 2047) {
				a.push(192 | (c >> 6));
				a.push(128 | (c & 63));
			}
			else if(c <= 65535) {
				a.push(224 | (c >> 12));
				a.push(128 | ((c >> 6) & 63));
				a.push(128 | (c & 63));
			}
			else {
				a.push(240 | (c >> 18));
				a.push(128 | ((c >> 12) & 63));
				a.push(128 | ((c >> 6) & 63));
				a.push(128 | (c & 63));
			}
		}
	}
	return new haxe.io.Bytes(a.length,a);
}
haxe.io.Bytes.ofData = function(b) {
	return new haxe.io.Bytes(b.length,b);
}
haxe.io.Bytes.prototype.b = null;
haxe.io.Bytes.prototype.blit = function(pos,src,srcpos,len) {
	if(pos < 0 || srcpos < 0 || len < 0 || pos + len > this.length || srcpos + len > src.length) throw haxe.io.Error.OutsideBounds;
	var b1 = this.b;
	var b2 = src.b;
	if(b1 == b2 && pos > srcpos) {
		var i = len;
		while(i > 0) {
			i--;
			b1[i + pos] = b2[i + srcpos];
		}
		return;
	}
	{
		var _g = 0;
		while(_g < len) {
			var i = _g++;
			b1[i + pos] = b2[i + srcpos];
		}
	}
}
haxe.io.Bytes.prototype.compare = function(other) {
	var b1 = this.b;
	var b2 = other.b;
	var len = ((this.length < other.length)?this.length:other.length);
	{
		var _g = 0;
		while(_g < len) {
			var i = _g++;
			if(b1[i] != b2[i]) return b1[i] - b2[i];
		}
	}
	return this.length - other.length;
}
haxe.io.Bytes.prototype.get = function(pos) {
	return this.b[pos];
}
haxe.io.Bytes.prototype.getData = function() {
	return this.b;
}
haxe.io.Bytes.prototype.length = null;
haxe.io.Bytes.prototype.readString = function(pos,len) {
	if(pos < 0 || len < 0 || pos + len > this.length) throw haxe.io.Error.OutsideBounds;
	var s = "";
	var b = this.b;
	var fcc = $closure(String,"fromCharCode");
	var i = pos;
	var max = pos + len;
	while(i < max) {
		var c = b[i++];
		if(c < 128) {
			if(c == 0) break;
			s += fcc(c);
		}
		else if(c < 224) s += fcc(((c & 63) << 6) | (b[i++] & 127));
		else if(c < 240) {
			var c2 = b[i++];
			s += fcc((((c & 31) << 12) | ((c2 & 127) << 6)) | (b[i++] & 127));
		}
		else {
			var c2 = b[i++];
			var c3 = b[i++];
			s += fcc(((((c & 15) << 18) | ((c2 & 127) << 12)) | ((c3 << 6) & 127)) | (b[i++] & 127));
		}
	}
	return s;
}
haxe.io.Bytes.prototype.set = function(pos,v) {
	this.b[pos] = v;
}
haxe.io.Bytes.prototype.sub = function(pos,len) {
	if(pos < 0 || len < 0 || pos + len > this.length) throw haxe.io.Error.OutsideBounds;
	return new haxe.io.Bytes(len,this.b.slice(pos,pos + len));
}
haxe.io.Bytes.prototype.toString = function() {
	return this.readString(0,this.length);
}
haxe.io.Bytes.prototype.__class__ = haxe.io.Bytes;
haxe.Firebug = function() { }
haxe.Firebug.__name__ = ["haxe","Firebug"];
haxe.Firebug.detect = function() {
	try {
		return console != null && console.error != null;
	}
	catch( $e16 ) {
		{
			var e = $e16;
			{
				return false;
			}
		}
	}
}
haxe.Firebug.redirectTraces = function() {
	haxe.Log.trace = $closure(haxe.Firebug,"trace");
	js.Lib.setErrorHandler($closure(haxe.Firebug,"onError"));
}
haxe.Firebug.onError = function(err,stack) {
	var buf = err + "\n";
	{
		var _g = 0;
		while(_g < stack.length) {
			var s = stack[_g];
			++_g;
			buf += "Called from " + s + "\n";
		}
	}
	haxe.Firebug.trace(buf,null);
	return true;
}
haxe.Firebug.trace = function(v,inf) {
	var type = (inf != null && inf.customParams != null?inf.customParams[0]:null);
	if(type != "warn" && type != "info" && type != "debug" && type != "error") type = (inf == null?"error":"log");
	console[type](((inf == null?"":inf.fileName + ":" + inf.lineNumber + " : ")) + Std.string(v));
}
haxe.Firebug.prototype.__class__ = haxe.Firebug;
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;
haxe.io.Error = { __ename__ : ["haxe","io","Error"], __constructs__ : ["Blocked","Overflow","OutsideBounds","Custom"] }
haxe.io.Error.Blocked = ["Blocked",0];
haxe.io.Error.Blocked.toString = $estr;
haxe.io.Error.Blocked.__enum__ = haxe.io.Error;
haxe.io.Error.Custom = function(e) { var $x = ["Custom",3,e]; $x.__enum__ = haxe.io.Error; $x.toString = $estr; return $x; }
haxe.io.Error.OutsideBounds = ["OutsideBounds",2];
haxe.io.Error.OutsideBounds.toString = $estr;
haxe.io.Error.OutsideBounds.__enum__ = haxe.io.Error;
haxe.io.Error.Overflow = ["Overflow",1];
haxe.io.Error.Overflow.toString = $estr;
haxe.io.Error.Overflow.__enum__ = haxe.io.Error;
Logger = function() { }
Logger.__name__ = ["Logger"];
Logger.thresholdLevel = null;
Logger.instance = null;
Logger.setup = function(thresholdLevel) {
	Logger.thresholdLevel = ((thresholdLevel == null)?0:thresholdLevel);
	haxe.Log.trace = $closure(Logger,"log");
	if(haxe.Firebug.detect()) {
		haxe.Firebug.redirectTraces();
	}
}
Logger.log = function(msg,pos) {
	var levelNum = Logger.levels.length - 1;
	if(pos.customParams != null) {
		if(pos.customParams[0] != null) {
			levelNum = pos.customParams[0];
		}
	}
	if(Logger.thresholdLevel <= levelNum) {
		var level = Logger.levels[levelNum];
		var toTrace = "[" + level + "] " + pos.fileName + " " + pos.lineNumber + " " + pos.methodName + "() " + msg;
		var id = "haxe:trace";
		var sep = "\n<br>";
		var d = js.Lib.document.getElementById(id);
		if(d == null) js.Lib.alert("Unknown element : " + id);
		d.innerHTML += toTrace + sep;
	}
}
Logger.prototype.__class__ = Logger;
Type = function() { }
Type.__name__ = ["Type"];
Type.getClass = function(o) {
	if(o == null) return null;
	if(o.__enum__ != null) return null;
	return o.__class__;
}
Type.getEnum = function(o) {
	if(o == null) return null;
	return o.__enum__;
}
Type.getSuperClass = function(c) {
	return c.__super__;
}
Type.getClassName = function(c) {
	if(c == null) return null;
	var a = c.__name__;
	return a.join(".");
}
Type.getEnumName = function(e) {
	var a = e.__ename__;
	return a.join(".");
}
Type.resolveClass = function(name) {
	var cl;
	try {
		cl = eval(name);
	}
	catch( $e17 ) {
		{
			var e = $e17;
			{
				cl = null;
			}
		}
	}
	if(cl == null || cl.__name__ == null) return null;
	return cl;
}
Type.resolveEnum = function(name) {
	var e;
	try {
		e = eval(name);
	}
	catch( $e18 ) {
		{
			var err = $e18;
			{
				e = null;
			}
		}
	}
	if(e == null || e.__ename__ == null) return null;
	return e;
}
Type.createInstance = function(cl,args) {
	if(args.length <= 3) return new cl(args[0],args[1],args[2]);
	if(args.length > 8) throw "Too many arguments";
	return new cl(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7]);
}
Type.createEmptyInstance = function(cl) {
	return new cl($_);
}
Type.createEnum = function(e,constr,params) {
	var f = Reflect.field(e,constr);
	if(f == null) throw "No such constructor " + constr;
	if(Reflect.isFunction(f)) {
		if(params == null) throw "Constructor " + constr + " need parameters";
		return f.apply(e,params);
	}
	if(params != null && params.length != 0) throw "Constructor " + constr + " does not need parameters";
	return f;
}
Type.getInstanceFields = function(c) {
	var a = Reflect.fields(c.prototype);
	a.remove("__class__");
	return a;
}
Type.getClassFields = function(c) {
	var a = Reflect.fields(c);
	a.remove("__name__");
	a.remove("__interfaces__");
	a.remove("__super__");
	a.remove("prototype");
	return a;
}
Type.getEnumConstructs = function(e) {
	return e.__constructs__;
}
Type["typeof"] = function(v) {
	switch(typeof(v)) {
	case "boolean":{
		return ValueType.TBool;
	}break;
	case "string":{
		return ValueType.TClass(String);
	}break;
	case "number":{
		if(Math.ceil(v) == v % 2147483648.0) return ValueType.TInt;
		return ValueType.TFloat;
	}break;
	case "object":{
		if(v == null) return ValueType.TNull;
		var e = v.__enum__;
		if(e != null) return ValueType.TEnum(e);
		var c = v.__class__;
		if(c != null) return ValueType.TClass(c);
		return ValueType.TObject;
	}break;
	case "function":{
		if(v.__name__ != null) return ValueType.TObject;
		return ValueType.TFunction;
	}break;
	case "undefined":{
		return ValueType.TNull;
	}break;
	default:{
		return ValueType.TUnknown;
	}break;
	}
}
Type.enumEq = function(a,b) {
	if(a == b) return true;
	if(a[0] != b[0]) return false;
	{
		var _g1 = 2, _g = a.length;
		while(_g1 < _g) {
			var i = _g1++;
			if(!Type.enumEq(a[i],b[i])) return false;
		}
	}
	var e = a.__enum__;
	if(e != b.__enum__ || e == null) return false;
	return true;
}
Type.enumConstructor = function(e) {
	return e[0];
}
Type.enumParameters = function(e) {
	return e.slice(2);
}
Type.enumIndex = function(e) {
	return e[1];
}
Type.prototype.__class__ = Type;
haxe.Unserializer = function(buf) { if( buf === $_ ) return; {
	this.buf = buf;
	this.length = buf.length;
	this.pos = 0;
	this.scache = new Array();
	this.cache = new Array();
	this.setResolver(haxe.Unserializer.DEFAULT_RESOLVER);
}}
haxe.Unserializer.__name__ = ["haxe","Unserializer"];
haxe.Unserializer.initCodes = function() {
	var codes = new Array();
	{
		var _g1 = 0, _g = haxe.Unserializer.BASE64.length;
		while(_g1 < _g) {
			var i = _g1++;
			codes[haxe.Unserializer.BASE64.cca(i)] = i;
		}
	}
	return codes;
}
haxe.Unserializer.run = function(v) {
	return new haxe.Unserializer(v).unserialize();
}
haxe.Unserializer.prototype.buf = null;
haxe.Unserializer.prototype.cache = null;
haxe.Unserializer.prototype.get = function(p) {
	return this.buf.cca(p);
}
haxe.Unserializer.prototype.length = null;
haxe.Unserializer.prototype.pos = null;
haxe.Unserializer.prototype.readDigits = function() {
	var k = 0;
	var s = false;
	var fpos = this.pos;
	while(true) {
		var c = this.buf.cca(this.pos);
		if(Math.isNaN(c)) break;
		if(c == 45) {
			if(this.pos != fpos) break;
			s = true;
			this.pos++;
			continue;
		}
		c -= 48;
		if(c < 0 || c > 9) break;
		k = k * 10 + c;
		this.pos++;
	}
	if(s) k *= -1;
	return k;
}
haxe.Unserializer.prototype.resolver = null;
haxe.Unserializer.prototype.scache = null;
haxe.Unserializer.prototype.setResolver = function(r) {
	if(r == null) this.resolver = { resolveClass : function(_) {
		return null;
	}, resolveEnum : function(_) {
		return null;
	}}
	else this.resolver = r;
}
haxe.Unserializer.prototype.unserialize = function() {
	switch(this.buf.cca(this.pos++)) {
	case 110:{
		return null;
	}break;
	case 116:{
		return true;
	}break;
	case 102:{
		return false;
	}break;
	case 122:{
		return 0;
	}break;
	case 105:{
		return this.readDigits();
	}break;
	case 100:{
		var p1 = this.pos;
		while(true) {
			var c = this.buf.cca(this.pos);
			if((c >= 43 && c < 58) || c == 101 || c == 69) this.pos++;
			else break;
		}
		return Std.parseFloat(this.buf.substr(p1,this.pos - p1));
	}break;
	case 121:{
		var len = this.readDigits();
		if(this.buf.charAt(this.pos++) != ":" || this.length - this.pos < len) throw "Invalid string length";
		var s = this.buf.substr(this.pos,len);
		this.pos += len;
		s = StringTools.urlDecode(s);
		this.scache.push(s);
		return s;
	}break;
	case 107:{
		return Math.NaN;
	}break;
	case 109:{
		return Math.NEGATIVE_INFINITY;
	}break;
	case 112:{
		return Math.POSITIVE_INFINITY;
	}break;
	case 97:{
		var buf = this.buf;
		var a = new Array();
		this.cache.push(a);
		while(true) {
			var c = this.buf.cca(this.pos);
			if(c == 104) {
				this.pos++;
				break;
			}
			if(c == 117) {
				this.pos++;
				var n = this.readDigits();
				a[a.length + n - 1] = null;
			}
			else a.push(this.unserialize());
		}
		return a;
	}break;
	case 111:{
		var o = { }
		this.cache.push(o);
		this.unserializeObject(o);
		return o;
	}break;
	case 114:{
		var n = this.readDigits();
		if(n < 0 || n >= this.cache.length) throw "Invalid reference";
		return this.cache[n];
	}break;
	case 82:{
		var n = this.readDigits();
		if(n < 0 || n >= this.scache.length) throw "Invalid string reference";
		return this.scache[n];
	}break;
	case 120:{
		throw this.unserialize();
	}break;
	case 99:{
		var name = this.unserialize();
		var cl = this.resolver.resolveClass(name);
		if(cl == null) throw "Class not found " + name;
		var o = Type.createEmptyInstance(cl);
		this.cache.push(o);
		this.unserializeObject(o);
		return o;
	}break;
	case 119:{
		var name = this.unserialize();
		var edecl = this.resolver.resolveEnum(name);
		if(edecl == null) throw "Enum not found " + name;
		return this.unserializeEnum(edecl,this.unserialize());
	}break;
	case 106:{
		var name = this.unserialize();
		var edecl = this.resolver.resolveEnum(name);
		if(edecl == null) throw "Enum not found " + name;
		this.pos++;
		var index = this.readDigits();
		var tag = Type.getEnumConstructs(edecl)[index];
		if(tag == null) throw "Unknown enum index " + name + "@" + index;
		return this.unserializeEnum(edecl,tag);
	}break;
	case 108:{
		var l = new List();
		var buf = this.buf;
		while(this.buf.cca(this.pos) != 104) l.add(this.unserialize());
		this.pos++;
		return l;
	}break;
	case 98:{
		var h = new Hash();
		var buf = this.buf;
		while(this.buf.cca(this.pos) != 104) {
			var s = this.unserialize();
			h.set(s,this.unserialize());
		}
		this.pos++;
		return h;
	}break;
	case 113:{
		var h = new IntHash();
		var buf = this.buf;
		var c = this.buf.cca(this.pos++);
		while(c == 58) {
			var i = this.readDigits();
			h.set(i,this.unserialize());
			c = this.buf.cca(this.pos++);
		}
		if(c != 104) throw "Invalid IntHash format";
		return h;
	}break;
	case 118:{
		var d = Date.fromString(this.buf.substr(this.pos,19));
		this.pos += 19;
		return d;
	}break;
	case 115:{
		var len = this.readDigits();
		var buf = this.buf;
		if(buf.charAt(this.pos++) != ":" || this.length - this.pos < len) throw "Invalid bytes length";
		var codes = haxe.Unserializer.CODES;
		if(codes == null) {
			codes = haxe.Unserializer.initCodes();
			haxe.Unserializer.CODES = codes;
		}
		var b = new haxe.io.BytesBuffer();
		var i = this.pos;
		var rest = len & 3;
		var max = i + (len - rest);
		while(i < max) {
			var c1 = codes[buf.cca(i++)];
			var c2 = codes[buf.cca(i++)];
			b.b.push((c1 << 2) | (c2 >> 4));
			var c3 = codes[buf.cca(i++)];
			b.b.push(((c2 << 4) | (c3 >> 2)) & 255);
			var c4 = codes[buf.cca(i++)];
			b.b.push(((c3 << 6) | c4) & 255);
		}
		if(rest >= 2) {
			var c1 = codes[buf.cca(i++)];
			var c2 = codes[buf.cca(i++)];
			b.b.push((c1 << 2) | (c2 >> 4));
			if(rest == 3) {
				var c3 = codes[buf.cca(i++)];
				b.b.push(((c2 << 4) | (c3 >> 2)) & 255);
			}
		}
		var bytes = b.getBytes();
		this.pos += len;
		this.cache.push(bytes);
		return bytes;
	}break;
	default:{
		null;
	}break;
	}
	this.pos--;
	throw ("Invalid char " + this.buf.charAt(this.pos) + " at position " + this.pos);
}
haxe.Unserializer.prototype.unserializeEnum = function(edecl,tag) {
	var constr = Reflect.field(edecl,tag);
	if(constr == null) throw "Unknown enum tag " + Type.getEnumName(edecl) + "." + tag;
	if(this.buf.cca(this.pos++) != 58) throw "Invalid enum format";
	var nargs = this.readDigits();
	if(nargs == 0) {
		this.cache.push(constr);
		return constr;
	}
	var args = new Array();
	while(nargs > 0) {
		args.push(this.unserialize());
		nargs -= 1;
	}
	var e = constr.apply(edecl,args);
	this.cache.push(e);
	return e;
}
haxe.Unserializer.prototype.unserializeObject = function(o) {
	while(true) {
		if(this.pos >= this.length) throw "Invalid object";
		if(this.buf.cca(this.pos) == 103) break;
		var k = this.unserialize();
		if(!Std["is"](k,String)) throw "Invalid object key";
		var v = this.unserialize();
		o[k] = v;
	}
	this.pos++;
}
haxe.Unserializer.prototype.__class__ = haxe.Unserializer;
org.omixed.client.RequestParser = function(p) { if( p === $_ ) return; {
	null;
}}
org.omixed.client.RequestParser.__name__ = ["org","omixed","client","RequestParser"];
org.omixed.client.RequestParser.prototype.getOkString = function(xmlString) {
	var ok = this.getString(xmlString);
	if(ok != "OK") {
		throw new org.omixed.client.ClientError("connection_failed","Connection should be ok");
	}
	return ok;
}
org.omixed.client.RequestParser.prototype.getString = function(xmlString) {
	var x = Xml.parse(xmlString);
	var root = x.firstElement();
	var xString = "";
	{ var $it19 = root.elements();
	while( $it19.hasNext() ) { var elt = $it19.next();
	{
		if(elt.nodeType == Xml.Element) {
			if(elt.getNodeName() == "ns:return") {
				{ var $it20 = elt.iterator();
				while( $it20.hasNext() ) { var c = $it20.next();
				{
					if(c.nodeType == Xml.PCData) {
						xString += c.getNodeValue();
					}
				}
				}}
			}
		}
	}
	}}
	return xString;
}
org.omixed.client.RequestParser.prototype.getStringArray = function(xmlString) {
	var x = Xml.parse(xmlString);
	var root = x.firstElement();
	var xArray = new Array();
	{ var $it21 = root.elements();
	while( $it21.hasNext() ) { var elt = $it21.next();
	{
		if(elt.nodeType == Xml.Element) {
			if(elt.getNodeName() == "ns:return") {
				xArray.push(elt.firstChild().getNodeValue());
			}
		}
	}
	}}
	return xArray;
}
org.omixed.client.RequestParser.prototype.getStringLargeArray = function(xmlString,rootNodeName) {
	var xArray = new Array();
	var strip1 = "<" + rootNodeName + " xmlns:ns=\"http://endpoint.omixedserver.omixed.org\"><ns:return>";
	var strip2 = "</ns:return></" + rootNodeName + ">";
	var xString = StringTools.replace(xmlString,strip1,"");
	xString = StringTools.replace(xString,strip2,"");
	if(StringTools.startsWith(xString,"<" + rootNodeName + "")) {
		return [];
	}
	xArray = this.splitString(xString,"</ns:return><ns:return>");
	return xArray;
}
org.omixed.client.RequestParser.prototype.getXML = function(xmlString) {
	var x = Xml.parse(xmlString);
	var root = x.firstElement();
	var xString = "";
	{ var $it22 = root.elements();
	while( $it22.hasNext() ) { var elt = $it22.next();
	{
		if(elt.nodeType == Xml.Element) {
			if(elt.getNodeName() == "ns:return") {
				return elt.firstChild();
			}
		}
	}
	}}
	return null;
}
org.omixed.client.RequestParser.prototype.parse = function(eventType,resultXMLString,returnType) {
	switch(eventType) {
	case org.omixed.client.OmixedClientEventType.connected:{
		return this.getXML(resultXMLString);
	}break;
	case org.omixed.client.OmixedClientEventType.disconnected:{
		return this.getOkString(resultXMLString);
	}break;
	case org.omixed.client.OmixedClientEventType.get_schema_with_layout:{
		return resultXMLString;
	}break;
	case org.omixed.client.OmixedClientEventType.get_item_graph_with_layout:{
		return resultXMLString;
	}break;
	case org.omixed.client.OmixedClientEventType.get_item_types:{
		return this.getStringArray(resultXMLString);
	}break;
	case org.omixed.client.OmixedClientEventType.describe_schema_item_type:{
		return this.getXML(resultXMLString);
	}break;
	case org.omixed.client.OmixedClientEventType.item_find:{
		return this.parseItemFind(resultXMLString,returnType);
	}break;
	}
	return null;
}
org.omixed.client.RequestParser.prototype.parseItemFind = function(resultXMLString,returnType) {
	var resultXML = this.getXML(resultXMLString);
	switch(returnType) {
	case org.omixed.client.ReturnType.ITEM_ID:{
		var itemIDs = resultXML.firstChild().getNodeValue();
		if(itemIDs.length < 1) {
			return new Array();
		}
		haxe.Log.trace(itemIDs,{ fileName : "RequestParser.hx", lineNumber : 55, className : "org.omixed.client.RequestParser", methodName : "parseItemFind"});
		return itemIDs.split("\n");
	}break;
	default:{
		return resultXML;
	}break;
	}
}
org.omixed.client.RequestParser.prototype.splitString = function(stringToSplit,splitWith) {
	var splitted = new Array();
	var startPos = 0;
	var nextPos = 0;
	var splitLength = splitWith.length;
	if(stringToSplit.indexOf(splitWith,startPos) == -1) {
		haxe.Log.trace(stringToSplit.length,{ fileName : "RequestParser.hx", lineNumber : 191, className : "org.omixed.client.RequestParser", methodName : "splitString"});
		haxe.Log.trace(stringToSplit,{ fileName : "RequestParser.hx", lineNumber : 192, className : "org.omixed.client.RequestParser", methodName : "splitString"});
		return [StringTools.rtrim(stringToSplit)];
	}
	while(startPos >= 0) {
		nextPos = stringToSplit.indexOf(splitWith,startPos);
		if(nextPos <= startPos) {
			startPos = -1;
		}
		else {
			var len = nextPos - startPos;
			var contents = stringToSplit.substr(startPos,len);
			splitted.push(contents);
			startPos = nextPos + splitWith.length;
		}
	}
	return splitted;
}
org.omixed.client.RequestParser.prototype.__class__ = org.omixed.client.RequestParser;
haxe.remoting.Context = function(p) { if( p === $_ ) return; {
	this.objects = new Hash();
}}
haxe.remoting.Context.__name__ = ["haxe","remoting","Context"];
haxe.remoting.Context.share = function(name,obj) {
	var ctx = new haxe.remoting.Context();
	ctx.addObject(name,obj);
	return ctx;
}
haxe.remoting.Context.prototype.addObject = function(name,obj,recursive) {
	this.objects.set(name,{ obj : obj, rec : recursive});
}
haxe.remoting.Context.prototype.call = function(path,params) {
	if(path.length < 2) throw "Invalid path '" + path.join(".") + "'";
	var inf = this.objects.get(path[0]);
	if(inf == null) throw "No such object " + path[0];
	var o = inf.obj;
	var m = Reflect.field(o,path[1]);
	if(path.length > 2) {
		if(!inf.rec) throw "Can't access " + path.join(".");
		{
			var _g1 = 2, _g = path.length;
			while(_g1 < _g) {
				var i = _g1++;
				o = m;
				m = Reflect.field(o,path[i]);
			}
		}
	}
	if(!Reflect.isFunction(m)) throw "No such method " + path.join(".");
	return m.apply(o,params);
}
haxe.remoting.Context.prototype.objects = null;
haxe.remoting.Context.prototype.__class__ = haxe.remoting.Context;
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;
org.omixed.client.ClientEventStore = function(p) { if( p === $_ ) return; {
	this.events = new Array();
	this.dispatchers = new Array();
}}
org.omixed.client.ClientEventStore.__name__ = ["org","omixed","client","ClientEventStore"];
org.omixed.client.ClientEventStore.prototype.dispatchers = null;
org.omixed.client.ClientEventStore.prototype.events = null;
org.omixed.client.ClientEventStore.prototype.exists = function(event) {
	return this.isPresent(event);
}
org.omixed.client.ClientEventStore.prototype.get = function(event) {
	var i = 0;
	{
		var _g = 0, _g1 = this.events;
		while(_g < _g1.length) {
			var ev = _g1[_g];
			++_g;
			if(ev == event) {
				return this.dispatchers[i];
			}
			i++;
		}
	}
	return null;
}
org.omixed.client.ClientEventStore.prototype.isPresent = function(event) {
	var present = false;
	{
		var _g = 0, _g1 = this.events;
		while(_g < _g1.length) {
			var ev = _g1[_g];
			++_g;
			if(ev == event) {
				present = false;
			}
		}
	}
	return present;
}
org.omixed.client.ClientEventStore.prototype.set = function(event,dispatcher) {
	if(this.isPresent(event) == false) {
		this.events.push(event);
		this.dispatchers.push(dispatcher);
	}
}
org.omixed.client.ClientEventStore.prototype.__class__ = org.omixed.client.ClientEventStore;
Lambda = function() { }
Lambda.__name__ = ["Lambda"];
Lambda.array = function(it) {
	var a = new Array();
	{ var $it23 = it.iterator();
	while( $it23.hasNext() ) { var i = $it23.next();
	a.push(i);
	}}
	return a;
}
Lambda.list = function(it) {
	var l = new List();
	{ var $it24 = it.iterator();
	while( $it24.hasNext() ) { var i = $it24.next();
	l.add(i);
	}}
	return l;
}
Lambda.map = function(it,f) {
	var l = new List();
	{ var $it25 = it.iterator();
	while( $it25.hasNext() ) { var x = $it25.next();
	l.add(f(x));
	}}
	return l;
}
Lambda.mapi = function(it,f) {
	var l = new List();
	var i = 0;
	{ var $it26 = it.iterator();
	while( $it26.hasNext() ) { var x = $it26.next();
	l.add(f(i++,x));
	}}
	return l;
}
Lambda.has = function(it,elt,cmp) {
	if(cmp == null) {
		{ var $it27 = it.iterator();
		while( $it27.hasNext() ) { var x = $it27.next();
		if(x == elt) return true;
		}}
	}
	else {
		{ var $it28 = it.iterator();
		while( $it28.hasNext() ) { var x = $it28.next();
		if(cmp(x,elt)) return true;
		}}
	}
	return false;
}
Lambda.exists = function(it,f) {
	{ var $it29 = it.iterator();
	while( $it29.hasNext() ) { var x = $it29.next();
	if(f(x)) return true;
	}}
	return false;
}
Lambda.foreach = function(it,f) {
	{ var $it30 = it.iterator();
	while( $it30.hasNext() ) { var x = $it30.next();
	if(!f(x)) return false;
	}}
	return true;
}
Lambda.iter = function(it,f) {
	{ var $it31 = it.iterator();
	while( $it31.hasNext() ) { var x = $it31.next();
	f(x);
	}}
}
Lambda.filter = function(it,f) {
	var l = new List();
	{ var $it32 = it.iterator();
	while( $it32.hasNext() ) { var x = $it32.next();
	if(f(x)) l.add(x);
	}}
	return l;
}
Lambda.fold = function(it,f,first) {
	{ var $it33 = it.iterator();
	while( $it33.hasNext() ) { var x = $it33.next();
	first = f(x,first);
	}}
	return first;
}
Lambda.count = function(it) {
	var n = 0;
	{ var $it34 = it.iterator();
	while( $it34.hasNext() ) { var _ = $it34.next();
	++n;
	}}
	return n;
}
Lambda.empty = function(it) {
	return !it.iterator().hasNext();
}
Lambda.prototype.__class__ = Lambda;
haxe.Serializer = function(p) { if( p === $_ ) return; {
	this.buf = new StringBuf();
	this.cache = new Array();
	this.useCache = haxe.Serializer.USE_CACHE;
	this.useEnumIndex = haxe.Serializer.USE_ENUM_INDEX;
	this.shash = new Hash();
	this.scount = 0;
}}
haxe.Serializer.__name__ = ["haxe","Serializer"];
haxe.Serializer.run = function(v) {
	var s = new haxe.Serializer();
	s.serialize(v);
	return s.toString();
}
haxe.Serializer.prototype.buf = null;
haxe.Serializer.prototype.cache = null;
haxe.Serializer.prototype.scount = null;
haxe.Serializer.prototype.serialize = function(v) {
	var $e = (Type["typeof"](v));
	switch( $e[1] ) {
	case 0:
	{
		this.buf.b += "n";
	}break;
	case 1:
	{
		if(v == 0) {
			this.buf.b += "z";
			return;
		}
		this.buf.b += "i";
		this.buf.b += v;
	}break;
	case 2:
	{
		if(Math.isNaN(v)) this.buf.b += "k";
		else if(!Math.isFinite(v)) this.buf.b += (v < 0?"m":"p");
		else {
			this.buf.b += "d";
			this.buf.b += v;
		}
	}break;
	case 3:
	{
		this.buf.b += (v?"t":"f");
	}break;
	case 6:
	var c = $e[2];
	{
		if(c == String) {
			this.serializeString(v);
			return;
		}
		if(this.useCache && this.serializeRef(v)) return;
		switch(c) {
		case Array:{
			var ucount = 0;
			this.buf.b += "a";
			var l = v["length"];
			{
				var _g = 0;
				while(_g < l) {
					var i = _g++;
					if(v[i] == null) ucount++;
					else {
						if(ucount > 0) {
							if(ucount == 1) this.buf.b += "n";
							else {
								this.buf.b += "u";
								this.buf.b += ucount;
							}
							ucount = 0;
						}
						this.serialize(v[i]);
					}
				}
			}
			if(ucount > 0) {
				if(ucount == 1) this.buf.b += "n";
				else {
					this.buf.b += "u";
					this.buf.b += ucount;
				}
			}
			this.buf.b += "h";
		}break;
		case List:{
			this.buf.b += "l";
			var v1 = v;
			{ var $it35 = v1.iterator();
			while( $it35.hasNext() ) { var i = $it35.next();
			this.serialize(i);
			}}
			this.buf.b += "h";
		}break;
		case Date:{
			var d = v;
			this.buf.b += "v";
			this.buf.b += d.toString();
		}break;
		case Hash:{
			this.buf.b += "b";
			var v1 = v;
			{ var $it36 = v1.keys();
			while( $it36.hasNext() ) { var k = $it36.next();
			{
				this.serializeString(k);
				this.serialize(v1.get(k));
			}
			}}
			this.buf.b += "h";
		}break;
		case IntHash:{
			this.buf.b += "q";
			var v1 = v;
			{ var $it37 = v1.keys();
			while( $it37.hasNext() ) { var k = $it37.next();
			{
				this.buf.b += ":";
				this.buf.b += k;
				this.serialize(v1.get(k));
			}
			}}
			this.buf.b += "h";
		}break;
		case haxe.io.Bytes:{
			var v1 = v;
			var i = 0;
			var max = v1.length - 2;
			var chars = "";
			var b64 = haxe.Serializer.BASE64;
			while(i < max) {
				var b1 = v1.b[i++];
				var b2 = v1.b[i++];
				var b3 = v1.b[i++];
				chars += b64.charAt(b1 >> 2) + b64.charAt(((b1 << 4) | (b2 >> 4)) & 63) + b64.charAt(((b2 << 2) | (b3 >> 6)) & 63) + b64.charAt(b3 & 63);
			}
			if(i == max) {
				var b1 = v1.b[i++];
				var b2 = v1.b[i++];
				chars += b64.charAt(b1 >> 2) + b64.charAt(((b1 << 4) | (b2 >> 4)) & 63) + b64.charAt((b2 << 2) & 63);
			}
			else if(i == max + 1) {
				var b1 = v1.b[i++];
				chars += b64.charAt(b1 >> 2) + b64.charAt((b1 << 4) & 63);
			}
			this.buf.b += "s";
			this.buf.b += chars.length;
			this.buf.b += ":";
			this.buf.b += chars;
		}break;
		default:{
			this.cache.pop();
			this.buf.b += "c";
			this.serializeString(Type.getClassName(c));
			this.cache.push(v);
			this.serializeFields(v);
		}break;
		}
	}break;
	case 4:
	{
		if(this.useCache && this.serializeRef(v)) return;
		this.buf.b += "o";
		this.serializeFields(v);
	}break;
	case 7:
	var e = $e[2];
	{
		if(this.useCache && this.serializeRef(v)) return;
		this.cache.pop();
		this.buf.b += (this.useEnumIndex?"j":"w");
		this.serializeString(Type.getEnumName(e));
		if(this.useEnumIndex) {
			this.buf.b += ":";
			this.buf.b += v[1];
		}
		else this.serializeString(v[0]);
		this.buf.b += ":";
		var l = v["length"];
		this.buf.b += l - 2;
		{
			var _g = 2;
			while(_g < l) {
				var i = _g++;
				this.serialize(v[i]);
			}
		}
		this.cache.push(v);
	}break;
	case 5:
	{
		throw "Cannot serialize function";
	}break;
	default:{
		throw "Cannot serialize " + Std.string(v);
	}break;
	}
}
haxe.Serializer.prototype.serializeException = function(e) {
	this.buf.b += "x";
	this.serialize(e);
}
haxe.Serializer.prototype.serializeFields = function(v) {
	{
		var _g = 0, _g1 = Reflect.fields(v);
		while(_g < _g1.length) {
			var f = _g1[_g];
			++_g;
			this.serializeString(f);
			this.serialize(Reflect.field(v,f));
		}
	}
	this.buf.b += "g";
}
haxe.Serializer.prototype.serializeRef = function(v) {
	var vt = typeof(v);
	{
		var _g1 = 0, _g = this.cache.length;
		while(_g1 < _g) {
			var i = _g1++;
			var ci = this.cache[i];
			if(typeof(ci) == vt && ci == v) {
				this.buf.b += "r";
				this.buf.b += i;
				return true;
			}
		}
	}
	this.cache.push(v);
	return false;
}
haxe.Serializer.prototype.serializeString = function(s) {
	var x = this.shash.get(s);
	if(x != null) {
		this.buf.b += "R";
		this.buf.b += x;
		return;
	}
	this.shash.set(s,this.scount++);
	this.buf.b += "y";
	s = StringTools.urlEncode(s);
	this.buf.b += s.length;
	this.buf.b += ":";
	this.buf.b += s;
}
haxe.Serializer.prototype.shash = null;
haxe.Serializer.prototype.toString = function() {
	return this.buf.b;
}
haxe.Serializer.prototype.useCache = null;
haxe.Serializer.prototype.useEnumIndex = null;
haxe.Serializer.prototype.__class__ = haxe.Serializer;
List = function(p) { if( p === $_ ) return; {
	this.length = 0;
}}
List.__name__ = ["List"];
List.prototype.add = function(item) {
	var x = [item];
	if(this.h == null) this.h = x;
	else this.q[1] = x;
	this.q = x;
	this.length++;
}
List.prototype.clear = function() {
	this.h = null;
	this.q = null;
	this.length = 0;
}
List.prototype.filter = function(f) {
	var l2 = new List();
	var l = this.h;
	while(l != null) {
		var v = l[0];
		l = l[1];
		if(f(v)) l2.add(v);
	}
	return l2;
}
List.prototype.first = function() {
	return (this.h == null?null:this.h[0]);
}
List.prototype.h = null;
List.prototype.isEmpty = function() {
	return (this.h == null);
}
List.prototype.iterator = function() {
	return { h : this.h, hasNext : function() {
		return (this.h != null);
	}, next : function() {
		if(this.h == null) return null;
		var x = this.h[0];
		this.h = this.h[1];
		return x;
	}}
}
List.prototype.join = function(sep) {
	var s = new StringBuf();
	var first = true;
	var l = this.h;
	while(l != null) {
		if(first) first = false;
		else s.b += sep;
		s.b += l[0];
		l = l[1];
	}
	return s.b;
}
List.prototype.last = function() {
	return (this.q == null?null:this.q[0]);
}
List.prototype.length = null;
List.prototype.map = function(f) {
	var b = new List();
	var l = this.h;
	while(l != null) {
		var v = l[0];
		l = l[1];
		b.add(f(v));
	}
	return b;
}
List.prototype.pop = function() {
	if(this.h == null) return null;
	var x = this.h[0];
	this.h = this.h[1];
	if(this.h == null) this.q = null;
	this.length--;
	return x;
}
List.prototype.push = function(item) {
	var x = [item,this.h];
	this.h = x;
	if(this.q == null) this.q = x;
	this.length++;
}
List.prototype.q = null;
List.prototype.remove = function(v) {
	var prev = null;
	var l = this.h;
	while(l != null) {
		if(l[0] == v) {
			if(prev == null) this.h = l[1];
			else prev[1] = l[1];
			if(this.q == l) this.q = prev;
			this.length--;
			return true;
		}
		prev = l;
		l = l[1];
	}
	return false;
}
List.prototype.toString = function() {
	var s = new StringBuf();
	var first = true;
	var l = this.h;
	s.b += "{";
	while(l != null) {
		if(first) first = false;
		else s.b += ", ";
		s.b += l[0];
		l = l[1];
	}
	s.b += "}";
	return s.b;
}
List.prototype.__class__ = List;
haxe.event = {}
haxe.event._Dispatcher = {}
haxe.event._Dispatcher.EventException = { __ename__ : ["haxe","event","_Dispatcher","EventException"], __constructs__ : ["StopPropagation"] }
haxe.event._Dispatcher.EventException.StopPropagation = ["StopPropagation",0];
haxe.event._Dispatcher.EventException.StopPropagation.toString = $estr;
haxe.event._Dispatcher.EventException.StopPropagation.__enum__ = haxe.event._Dispatcher.EventException;
haxe.event.Dispatcher = function(p) { if( p === $_ ) return; {
	this.listeners = new List();
}}
haxe.event.Dispatcher.__name__ = ["haxe","event","Dispatcher"];
haxe.event.Dispatcher.stop = function() {
	throw haxe.event._Dispatcher.EventException.StopPropagation;
}
haxe.event.Dispatcher.prototype.addHandler = function(f) {
	var l = { handleEvent : f}
	this.listeners.push(l);
	return l;
}
haxe.event.Dispatcher.prototype.addListener = function(l) {
	this.listeners.push(l);
}
haxe.event.Dispatcher.prototype.dispatchEvent = function(e) {
	try {
		{ var $it38 = this.listeners.iterator();
		while( $it38.hasNext() ) { var l = $it38.next();
		l.handleEvent(e);
		}}
		return true;
	}
	catch( $e39 ) {
		if( js.Boot.__instanceof($e39,haxe.event._Dispatcher.EventException) ) {
			var exc = $e39;
			{
				return false;
			}
		} else throw($e39);
	}
}
haxe.event.Dispatcher.prototype.listeners = null;
haxe.event.Dispatcher.prototype.removeListener = function(l) {
	return this.listeners.remove(l);
}
haxe.event.Dispatcher.prototype.__class__ = haxe.event.Dispatcher;
ValueType = { __ename__ : ["ValueType"], __constructs__ : ["TNull","TInt","TFloat","TBool","TObject","TFunction","TClass","TEnum","TUnknown"] }
ValueType.TBool = ["TBool",3];
ValueType.TBool.toString = $estr;
ValueType.TBool.__enum__ = ValueType;
ValueType.TClass = function(c) { var $x = ["TClass",6,c]; $x.__enum__ = ValueType; $x.toString = $estr; return $x; }
ValueType.TEnum = function(e) { var $x = ["TEnum",7,e]; $x.__enum__ = ValueType; $x.toString = $estr; return $x; }
ValueType.TFloat = ["TFloat",2];
ValueType.TFloat.toString = $estr;
ValueType.TFloat.__enum__ = ValueType;
ValueType.TFunction = ["TFunction",5];
ValueType.TFunction.toString = $estr;
ValueType.TFunction.__enum__ = ValueType;
ValueType.TInt = ["TInt",1];
ValueType.TInt.toString = $estr;
ValueType.TInt.__enum__ = ValueType;
ValueType.TNull = ["TNull",0];
ValueType.TNull.toString = $estr;
ValueType.TNull.__enum__ = ValueType;
ValueType.TObject = ["TObject",4];
ValueType.TObject.toString = $estr;
ValueType.TObject.__enum__ = ValueType;
ValueType.TUnknown = ["TUnknown",8];
ValueType.TUnknown.toString = $estr;
ValueType.TUnknown.__enum__ = ValueType;
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;
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( $e40 ) {
			{
				var e = $e40;
				{
					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( $e41 ) {
		{
			var e = $e41;
			{
				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 = (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++];
		}}
	}
	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;
org.omixed.client.RequestHandler = function(url,clientCaller,usePost) { if( url === $_ ) return; {
	this.url = url;
	this.clientCaller = clientCaller;
	this.usePost = usePost;
}}
org.omixed.client.RequestHandler.__name__ = ["org","omixed","client","RequestHandler"];
org.omixed.client.RequestHandler.prototype.addOptions = function(newOptionsName,newOptions) {
	if(this.options == null) {
		this.options = new Hash();
	}
	this.options.set(newOptionsName,newOptions);
}
org.omixed.client.RequestHandler.prototype.checkForErrors = function(xmlString) {
	haxe.Log.trace(xmlString,{ fileName : "RequestHandler.hx", lineNumber : 181, className : "org.omixed.client.RequestHandler", methodName : "checkForErrors"});
	try {
		var x = Xml.parse(xmlString);
		var root = x.firstElement();
		var rootName = root.getNodeName();
		haxe.Log.trace(rootName,{ fileName : "RequestHandler.hx", lineNumber : 188, className : "org.omixed.client.RequestHandler", methodName : "checkForErrors"});
		if(rootName == "soapenv:Fault") {
			var faultstring = "";
			var faultcode = "";
			var ErrorCode = "";
			var ErrorClass = "";
			{ var $it42 = root.elementsNamed("faultstring");
			while( $it42.hasNext() ) { var f = $it42.next();
			{
				faultstring += f.firstChild().getNodeValue();
			}
			}}
			{ var $it43 = root.elementsNamed("faultcode");
			while( $it43.hasNext() ) { var f = $it43.next();
			{
				faultcode += f.firstChild().getNodeValue();
			}
			}}
			{ var $it44 = root.elementsNamed("omixed:ErrorCode");
			while( $it44.hasNext() ) { var f = $it44.next();
			{
				ErrorCode += f.firstChild().getNodeValue();
			}
			}}
			{ var $it45 = root.elementsNamed("omixed:ErrorClass");
			while( $it45.hasNext() ) { var f = $it45.next();
			{
				ErrorClass += f.firstChild().getNodeValue();
			}
			}}
			haxe.Log.trace([faultstring,faultcode,ErrorCode,ErrorClass],{ fileName : "RequestHandler.hx", lineNumber : 218, className : "org.omixed.client.RequestHandler", methodName : "checkForErrors"});
			haxe.Log.trace("done parsing",{ fileName : "RequestHandler.hx", lineNumber : 257, className : "org.omixed.client.RequestHandler", methodName : "checkForErrors"});
			var message = "The omixed server has reported a problem. " + faultstring;
			var ev = new org.omixed.client.ServerFaultEvent({ target : this.clientCaller, message : message, url : this.serviceURL, data : null, parameters : this.parameters, faultstring : faultstring, faultcode : faultcode, ErrorCode : ErrorCode, ErrorClass : ErrorClass});
			this.clientCaller.doDispatchFault(ev,this,org.omixed.client.OmixedClientEventType.fault,$closure(this,"userOnFault"));
			if(this.onUnSuccessFulResult != null) {
				this.onUnSuccessFulResult(message,this);
			}
			return true;
		}
	}
	catch( $e46 ) {
		{
			var e = $e46;
			{
				haxe.Log.trace(e + ". Probably not an xml, so can't check for errors.",{ fileName : "RequestHandler.hx", lineNumber : 290, className : "org.omixed.client.RequestHandler", methodName : "checkForErrors", customParams : [Logger.error]});
			}
		}
	}
	return false;
}
org.omixed.client.RequestHandler.prototype.clientCaller = null;
org.omixed.client.RequestHandler.prototype.onError = function(msg) {
	haxe.Log.trace("onError",{ fileName : "RequestHandler.hx", lineNumber : 134, className : "org.omixed.client.RequestHandler", methodName : "onError"});
	haxe.Log.trace(msg,{ fileName : "RequestHandler.hx", lineNumber : 135, className : "org.omixed.client.RequestHandler", methodName : "onError"});
	var ev = new org.omixed.client.FaultEvent({ target : this.clientCaller, message : msg, url : this.serviceURL, parameters : this.parameters});
	this.clientCaller.doDispatchFault(ev,this,org.omixed.client.OmixedClientEventType.fault,$closure(this,"userOnFault"));
	if(this.onUnSuccessFulResult != null) {
		this.onUnSuccessFulResult(msg,this);
	}
}
org.omixed.client.RequestHandler.prototype.onResult = function(msg) {
	haxe.Log.trace(msg.substr(0,10),{ fileName : "RequestHandler.hx", lineNumber : 112, className : "org.omixed.client.RequestHandler", methodName : "onResult"});
	if(this.checkForErrors(msg) == false) {
		this.onSuccessFulResult(msg,this);
	}
}
org.omixed.client.RequestHandler.prototype.onStatus = function(code) {
	haxe.Log.trace("onStatus",{ fileName : "RequestHandler.hx", lineNumber : 161, className : "org.omixed.client.RequestHandler", methodName : "onStatus"});
	haxe.Log.trace("Status:" + code,{ fileName : "RequestHandler.hx", lineNumber : 162, className : "org.omixed.client.RequestHandler", methodName : "onStatus"});
}
org.omixed.client.RequestHandler.prototype.onSuccessFulResult = null;
org.omixed.client.RequestHandler.prototype.onUnSuccessFulResult = null;
org.omixed.client.RequestHandler.prototype.options = null;
org.omixed.client.RequestHandler.prototype.parameters = null;
org.omixed.client.RequestHandler.prototype.returnType = null;
org.omixed.client.RequestHandler.prototype.send = function(serviceName,parameters,onSuccessFulResult,onUnSuccessFulResult) {
	this.serviceURL = this.url + serviceName;
	this.parameters = parameters;
	this.onSuccessFulResult = onSuccessFulResult;
	this.serviceRequest = new org.omixed.client.OmixedClientHttpRequest(this.serviceURL);
	if(onUnSuccessFulResult != null) {
		this.onUnSuccessFulResult = onUnSuccessFulResult;
	}
	this.serviceRequest.setHeader("x-no-code-500-pages","true");
	{ var $it47 = this.parameters.keys();
	while( $it47.hasNext() ) { var key = $it47.next();
	{
		this.serviceRequest.setParameter(key,this.parameters.get(key));
	}
	}}
	this.serviceRequest.onData = $closure(this,"onResult");
	this.serviceRequest.onError = $closure(this,"onError");
	this.serviceRequest.onStatus = $closure(this,"onStatus");
	haxe.Log.trace(this.serviceURL,{ fileName : "RequestHandler.hx", lineNumber : 95, className : "org.omixed.client.RequestHandler", methodName : "send"});
	haxe.Log.trace(parameters,{ fileName : "RequestHandler.hx", lineNumber : 96, className : "org.omixed.client.RequestHandler", methodName : "send"});
	haxe.Log.trace(this.usePost,{ fileName : "RequestHandler.hx", lineNumber : 97, className : "org.omixed.client.RequestHandler", methodName : "send"});
	this.serviceRequest.request(this.usePost);
}
org.omixed.client.RequestHandler.prototype.serviceRequest = null;
org.omixed.client.RequestHandler.prototype.serviceURL = null;
org.omixed.client.RequestHandler.prototype.url = null;
org.omixed.client.RequestHandler.prototype.usePost = null;
org.omixed.client.RequestHandler.prototype.userOnFault = null;
org.omixed.client.RequestHandler.prototype.userOnResult = null;
org.omixed.client.RequestHandler.prototype.__class__ = org.omixed.client.RequestHandler;
IntHash = function(p) { if( p === $_ ) return; {
	this.h = {}
	if(this.h.__proto__ != null) {
		this.h.__proto__ = null;
		delete(this.h.__proto__);
	}
	else null;
}}
IntHash.__name__ = ["IntHash"];
IntHash.prototype.exists = function(key) {
	return this.h[key] != null;
}
IntHash.prototype.get = function(key) {
	return this.h[key];
}
IntHash.prototype.h = null;
IntHash.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];
	}}
}
IntHash.prototype.keys = function() {
	var a = new Array();
	
			for( x in this.h )
				a.push(x);
		;
	return a.iterator();
}
IntHash.prototype.remove = function(key) {
	if(this.h[key] == null) return false;
	delete(this.h[key]);
	return true;
}
IntHash.prototype.set = function(key,value) {
	this.h[key] = value;
}
IntHash.prototype.toString = function() {
	var s = new StringBuf();
	s.b += "{";
	var it = this.keys();
	{ var $it48 = it;
	while( $it48.hasNext() ) { var i = $it48.next();
	{
		s.b += i;
		s.b += " => ";
		s.b += Std.string(this.get(i));
		if(it.hasNext()) s.b += ", ";
	}
	}}
	s.b += "}";
	return s.b;
}
IntHash.prototype.__class__ = IntHash;
org.omixed.client.ItemFindQueryOptions = function(p) { if( p === $_ ) return; {
	var keys = new Hash();
	keys.set("paginationStartIndex",[]);
	keys.set("maxInboundDepth",[]);
	keys.set("linkExpansionDepth",[]);
	org.omixed.client.QueryOptions.apply(this,[keys]);
}}
org.omixed.client.ItemFindQueryOptions.__name__ = ["org","omixed","client","ItemFindQueryOptions"];
org.omixed.client.ItemFindQueryOptions.__super__ = org.omixed.client.QueryOptions;
for(var k in org.omixed.client.QueryOptions.prototype ) org.omixed.client.ItemFindQueryOptions.prototype[k] = org.omixed.client.QueryOptions.prototype[k];
org.omixed.client.ItemFindQueryOptions.prototype.__class__ = org.omixed.client.ItemFindQueryOptions;
org.omixed.client.ResultEvent = function(obj) { if( obj === $_ ) return; {
	var _g = 0, _g1 = Reflect.fields(obj);
	while(_g < _g1.length) {
		var fieldName = _g1[_g];
		++_g;
		var objField = Reflect.field(obj,fieldName);
		this[fieldName] = objField;
	}
}}
org.omixed.client.ResultEvent.__name__ = ["org","omixed","client","ResultEvent"];
org.omixed.client.ResultEvent.prototype.data = null;
org.omixed.client.ResultEvent.prototype.handler = null;
org.omixed.client.ResultEvent.prototype.parameters = null;
org.omixed.client.ResultEvent.prototype.target = null;
org.omixed.client.ResultEvent.prototype.toString = function() {
	var s = "";
	{
		var _g = 0, _g1 = Reflect.fields(this);
		while(_g < _g1.length) {
			var fieldName = _g1[_g];
			++_g;
			var objField = Reflect.field(this,fieldName);
			s += "\n " + fieldName + " : " + objField;
		}
	}
	return s;
}
org.omixed.client.ResultEvent.prototype.__class__ = org.omixed.client.ResultEvent;
org.omixed.client.FaultEvent = function(obj) { if( obj === $_ ) return; {
	org.omixed.client.ResultEvent.apply(this,[obj]);
}}
org.omixed.client.FaultEvent.__name__ = ["org","omixed","client","FaultEvent"];
org.omixed.client.FaultEvent.__super__ = org.omixed.client.ResultEvent;
for(var k in org.omixed.client.ResultEvent.prototype ) org.omixed.client.FaultEvent.prototype[k] = org.omixed.client.ResultEvent.prototype[k];
org.omixed.client.FaultEvent.prototype.message = null;
org.omixed.client.FaultEvent.prototype.url = null;
org.omixed.client.FaultEvent.prototype.__class__ = org.omixed.client.FaultEvent;
org.omixed.client.ServerFaultEvent = function(obj) { if( obj === $_ ) return; {
	org.omixed.client.FaultEvent.apply(this,[obj]);
}}
org.omixed.client.ServerFaultEvent.__name__ = ["org","omixed","client","ServerFaultEvent"];
org.omixed.client.ServerFaultEvent.__super__ = org.omixed.client.FaultEvent;
for(var k in org.omixed.client.FaultEvent.prototype ) org.omixed.client.ServerFaultEvent.prototype[k] = org.omixed.client.FaultEvent.prototype[k];
org.omixed.client.ServerFaultEvent.prototype.ErrorClass = null;
org.omixed.client.ServerFaultEvent.prototype.ErrorCode = null;
org.omixed.client.ServerFaultEvent.prototype.faultcode = null;
org.omixed.client.ServerFaultEvent.prototype.faultstring = null;
org.omixed.client.ServerFaultEvent.prototype.__class__ = org.omixed.client.ServerFaultEvent;
org.omixed.client.OmixedClient = function(baseURL,usePost) { if( baseURL === $_ ) return; {
	if(usePost == null) usePost = true;
	if(!StringTools.endsWith(baseURL,"/")) {
		baseURL += "/";
	}
	this.url = baseURL + "omixed/server/";
	this.usePost = usePost;
	this.dispatchers = new org.omixed.client.ClientEventStore();
	this.itemTypeGraphsWithLayout = new Hash();
	this.itemTypeSchemata = new Hash();
	this.itemIDs = new Hash();
	this.itemDetails = new Hash();
}}
org.omixed.client.OmixedClient.__name__ = ["org","omixed","client","OmixedClient"];
org.omixed.client.OmixedClient.prototype.addHaxeEventListener = function(event,listener) {
	this.getDispatcher(event).addHandler(listener);
}
org.omixed.client.OmixedClient.prototype.connect = function(resourceName,userName,password,userOnResult,userOnFault) {
	this.resourceName = resourceName;
	this.userName = userName;
	var parameters = new Hash();
	parameters.set("resourceName",resourceName);
	parameters.set("userName",userName);
	parameters.set("password",password);
	haxe.Log.trace(parameters,{ fileName : "OmixedClient.hx", lineNumber : 262, className : "org.omixed.client.OmixedClient", methodName : "connect"});
	this.newHandler(userOnResult,userOnFault).send("connect",parameters,$closure(this,"onConnect"));
}
org.omixed.client.OmixedClient.prototype.disconnect = function(userOnResult,userOnFault) {
	var parameters = new Hash();
	parameters.set("sessionID",this.sessionID);
	haxe.Log.trace(this.sessionID,{ fileName : "OmixedClient.hx", lineNumber : 316, className : "org.omixed.client.OmixedClient", methodName : "disconnect"});
	this.newHandler(userOnResult,userOnFault).send("disconnect",parameters,$closure(this,"onDisconnect"));
}
org.omixed.client.OmixedClient.prototype.dispatchers = null;
org.omixed.client.OmixedClient.prototype.doDispatch = function(ev,rh,eventType,userCallBack) {
	if(userCallBack != null) {
		userCallBack(ev);
	}
	this.getDispatcher(eventType).dispatchEvent(ev);
}
org.omixed.client.OmixedClient.prototype.doDispatchFault = function(ev,rh,eventType,userCallBack) {
	if(userCallBack != null) {
		userCallBack(ev);
	}
	this.getDispatcher(eventType).dispatchEvent(ev);
}
org.omixed.client.OmixedClient.prototype.domainName = null;
org.omixed.client.OmixedClient.prototype.getDispatcher = function(event) {
	if(!this.dispatchers.exists(event)) {
		this.dispatchers.set(event,new haxe.event.Dispatcher());
	}
	return this.dispatchers.get(event);
}
org.omixed.client.OmixedClient.prototype.getTypeFromID = function(itemID) {
	var split = itemID.split("/");
	return split[2];
}
org.omixed.client.OmixedClient.prototype.initialiseClientStart = function() {
	haxe.Log.trace("Initialising client",{ fileName : "OmixedClient.hx", lineNumber : 170, className : "org.omixed.client.OmixedClient", methodName : "initialiseClientStart"});
	var sequence = new org.omixed.client.RequestSequence(this,$closure(this,"initialiseSchemata"));
	var parameters = new Hash();
	parameters.set("sessionID",this.sessionID);
	sequence.addRequest(parameters,"schemaEnumerateItemTypes",$closure(this,"onSchemaEnumerateItemTypes"));
	sequence.start();
}
org.omixed.client.OmixedClient.prototype.initialiseSchemata = function() {
	haxe.Log.trace("Initialising schemas",{ fileName : "OmixedClient.hx", lineNumber : 189, className : "org.omixed.client.OmixedClient", methodName : "initialiseSchemata"});
	var schemaSequence = new org.omixed.client.RequestSequence(this,$closure(this,"onInitialiseSchemataComplete"));
	{
		var _g = 0, _g1 = this.itemTypes;
		while(_g < _g1.length) {
			var itemType = _g1[_g];
			++_g;
			var parameters = new Hash();
			parameters.set("sessionID",this.sessionID);
			parameters.set("itemType",itemType);
			schemaSequence.addRequest(parameters,"schemaDescribeItemType",$closure(this,"onSchemaDescribeItemType"));
		}
	}
	schemaSequence.start();
}
org.omixed.client.OmixedClient.prototype.itemDetails = null;
org.omixed.client.OmixedClient.prototype.itemFind = function(returnType,queryXML,queryOptions,userOnResult,userOnFault) {
	var parameters = new Hash();
	parameters.set("sessionID",this.sessionID);
	parameters.set("returnType",Std.string(returnType));
	parameters.set("queryXML",queryXML.toString());
	if(queryOptions != null) {
		parameters.set("queryOptions",queryOptions.toString());
	}
	else {
		parameters.set("queryOptions","");
	}
	var handler = this.newHandler(userOnResult,userOnFault);
	handler.returnType = returnType;
	handler.addOptions("queryOptions",queryOptions);
	handler.send("itemFind",parameters,$closure(this,"onItemFind"));
}
org.omixed.client.OmixedClient.prototype.itemFindLayout = function(queryXML,queryOptions,layoutOptions,userOnResult,userOnFault) {
	var parameters = new Hash();
	parameters.set("sessionID",this.sessionID);
	parameters.set("queryXML",queryXML.toString());
	parameters.set("queryOptions",queryOptions.toString());
	parameters.set("layoutOptions",layoutOptions.toString());
	var handler = this.newHandler(userOnResult,userOnFault);
	handler.addOptions("layoutOptions",layoutOptions);
	handler.addOptions("queryOptions",queryOptions);
	handler.send("itemFindLayout",parameters,$closure(this,"onItemFindLayout"));
}
org.omixed.client.OmixedClient.prototype.itemIDs = null;
org.omixed.client.OmixedClient.prototype.itemTypeGraphsWithLayout = null;
org.omixed.client.OmixedClient.prototype.itemTypeSchemata = null;
org.omixed.client.OmixedClient.prototype.itemTypeToItemID = function(itemType) {
	var sep = "/";
	var itemID = this.domainName + sep + this.resourceName + sep + itemType;
	return itemID;
}
org.omixed.client.OmixedClient.prototype.itemTypes = null;
org.omixed.client.OmixedClient.prototype.newHandler = function(userOnResult,userOnFault) {
	var handler = new org.omixed.client.RequestHandler(this.url,this,this.usePost);
	handler.userOnResult = userOnResult;
	handler.userOnFault = userOnFault;
	return handler;
}
org.omixed.client.OmixedClient.prototype.onConnect = function(returnedXML,handler) {
	haxe.Log.trace(returnedXML,{ fileName : "OmixedClient.hx", lineNumber : 269, className : "org.omixed.client.OmixedClient", methodName : "onConnect"});
	var connectionDetails = new org.omixed.client.RequestParser().parse(org.omixed.client.OmixedClientEventType.connected,returnedXML);
	{ var $it49 = connectionDetails.elements();
	while( $it49.hasNext() ) { var node = $it49.next();
	{
		haxe.Log.trace([node.getNodeName(),node.firstChild().getNodeValue()],{ fileName : "OmixedClient.hx", lineNumber : 275, className : "org.omixed.client.OmixedClient", methodName : "onConnect"});
		switch(node.getNodeName()) {
		case "SessionID":{
			this.sessionID = node.firstChild().getNodeValue();
		}break;
		case "ServerDomainName":{
			this.domainName = node.firstChild().getNodeValue();
		}break;
		case "ServerAPIVersion":{
			this.serverAPIVersion = node.firstChild().getNodeValue();
		}break;
		case "UserClass":{
			this.userClass = node.firstChild().getNodeValue();
		}break;
		}
	}
	}}
	haxe.Log.trace("connected + " + this.sessionID,{ fileName : "OmixedClient.hx", lineNumber : 289, className : "org.omixed.client.OmixedClient", methodName : "onConnect"});
	var ev = new org.omixed.client.ResultEvent({ target : this, parameters : handler.parameters, data : this.sessionID, handler : handler});
	this.doDispatch(ev,handler,org.omixed.client.OmixedClientEventType.connected,$closure(handler,"userOnResult"));
}
org.omixed.client.OmixedClient.prototype.onDisconnect = function(returnedXML,handler) {
	this.sessionID = "";
	this.resourceName = "";
	this.userName = "";
	this.domainName = "";
	this.serverAPIVersion = "";
	this.userClass = "";
	var is_disconnected = new org.omixed.client.RequestParser().parse(org.omixed.client.OmixedClientEventType.disconnected,returnedXML);
	haxe.Log.trace(is_disconnected,{ fileName : "OmixedClient.hx", lineNumber : 331, className : "org.omixed.client.OmixedClient", methodName : "onDisconnect"});
	var ev = new org.omixed.client.ResultEvent({ target : this, parameters : handler.parameters, data : is_disconnected, handler : handler});
	haxe.Log.trace("disconnected",{ fileName : "OmixedClient.hx", lineNumber : 340, className : "org.omixed.client.OmixedClient", methodName : "onDisconnect"});
	this.doDispatch(ev,handler,org.omixed.client.OmixedClientEventType.disconnected,$closure(handler,"userOnResult"));
}
org.omixed.client.OmixedClient.prototype.onInitialiseSchemataComplete = function() {
	var ev = new org.omixed.client.ResultEvent({ target : this, parameters : new Hash()});
	this.getDispatcher(org.omixed.client.OmixedClientEventType.initialised).dispatchEvent(ev);
}
org.omixed.client.OmixedClient.prototype.onItemFind = function(returnedXML,handler) {
	var result = new org.omixed.client.RequestParser().parse(org.omixed.client.OmixedClientEventType.item_find,returnedXML,handler.returnType);
	if(handler.returnType == org.omixed.client.ReturnType.ITEM_ID) {
		var ids = result;
		this.itemIDs.set(handler.parameters.get("queryXML"),ids);
	}
	var ev = new org.omixed.client.ResultEvent({ target : this, parameters : handler.parameters, data : result, handler : handler});
	this.doDispatch(ev,handler,org.omixed.client.OmixedClientEventType.item_find,$closure(handler,"userOnResult"));
}
org.omixed.client.OmixedClient.prototype.onItemFindLayout = function(returnedXML,handler) {
	var queryXML = handler.parameters.get("queryXML");
	var itemXML = new org.omixed.client.RequestParser().parse(org.omixed.client.OmixedClientEventType.get_item_graph_with_layout,returnedXML);
	this.itemTypeGraphsWithLayout.set(queryXML,itemXML);
	var ev = new org.omixed.client.ResultEvent({ target : this, parameters : handler.parameters, data : itemXML, handler : handler});
	this.doDispatch(ev,handler,org.omixed.client.OmixedClientEventType.get_item_graph_with_layout,$closure(handler,"userOnResult"));
}
org.omixed.client.OmixedClient.prototype.onSchemaDescribeItemType = function(returnedXML,handler) {
	var itemType = handler.parameters.get("itemType");
	var schemaXML = new org.omixed.client.RequestParser().parse(org.omixed.client.OmixedClientEventType.describe_schema_item_type,returnedXML);
	this.itemTypeSchemata.set(itemType,schemaXML);
	var ev = new org.omixed.client.ResultEvent({ target : this, parameters : handler.parameters, data : schemaXML, handler : handler});
	this.doDispatch(ev,handler,org.omixed.client.OmixedClientEventType.describe_schema_item_type,$closure(handler,"userOnResult"));
}
org.omixed.client.OmixedClient.prototype.onSchemaEnumerateItemTypes = function(returnedXML,handler) {
	this.itemTypes = new org.omixed.client.RequestParser().parse(org.omixed.client.OmixedClientEventType.get_item_types,returnedXML);
	var ev = new org.omixed.client.ResultEvent({ target : this, parameters : handler.parameters, data : this.itemTypes, handler : handler});
	this.doDispatch(ev,handler,org.omixed.client.OmixedClientEventType.get_item_types,$closure(handler,"userOnResult"));
}
org.omixed.client.OmixedClient.prototype.onSchemaGetLayout = function(returnedXML,handler) {
	haxe.Log.trace(returnedXML,{ fileName : "OmixedClient.hx", lineNumber : 416, className : "org.omixed.client.OmixedClient", methodName : "onSchemaGetLayout"});
	this.schemaWithLayout = new org.omixed.client.RequestParser().parse(org.omixed.client.OmixedClientEventType.get_schema_with_layout,returnedXML);
	var ev = new org.omixed.client.ResultEvent({ target : this, parameters : handler.parameters, data : this.schemaWithLayout, handler : handler});
	this.doDispatch(ev,handler,org.omixed.client.OmixedClientEventType.get_schema_with_layout,$closure(handler,"userOnResult"));
}
org.omixed.client.OmixedClient.prototype.resourceName = null;
org.omixed.client.OmixedClient.prototype.schemaDescribeItemType = function(itemType,userOnResult,userOnFault) {
	var parameters = new Hash();
	parameters.set("sessionID",this.sessionID);
	parameters.set("itemType",itemType);
	this.newHandler(userOnResult,userOnFault).send("schemaDescribeItemType",parameters,$closure(this,"onSchemaDescribeItemType"));
}
org.omixed.client.OmixedClient.prototype.schemaEnumerateItemTypes = function(userOnResult,userOnFault) {
	var parameters = new Hash();
	parameters.set("sessionID",this.sessionID);
	this.newHandler(userOnResult,userOnFault).send("schemaEnumerateItemTypes",parameters,$closure(this,"onSchemaEnumerateItemTypes"));
}
org.omixed.client.OmixedClient.prototype.schemaGetLayout = function(layoutOptions,userOnResult,userOnFault) {
	var parameters = new Hash();
	parameters.set("sessionID",this.sessionID);
	parameters.set("layoutOptions",layoutOptions.toString());
	var handler = this.newHandler(userOnResult,userOnFault);
	handler.addOptions("layoutOptions",layoutOptions);
	handler.send("schemaGetLayout",parameters,$closure(this,"onSchemaGetLayout"));
}
org.omixed.client.OmixedClient.prototype.schemaWithLayout = null;
org.omixed.client.OmixedClient.prototype.serverAPIVersion = null;
org.omixed.client.OmixedClient.prototype.sessionID = null;
org.omixed.client.OmixedClient.prototype.setExistingSession = function(sessionID,resourceName,userName) {
	this.sessionID = sessionID;
	this.resourceName = resourceName;
	this.userName = userName;
}
org.omixed.client.OmixedClient.prototype.url = null;
org.omixed.client.OmixedClient.prototype.usePost = null;
org.omixed.client.OmixedClient.prototype.userClass = null;
org.omixed.client.OmixedClient.prototype.userName = null;
org.omixed.client.OmixedClient.prototype.__class__ = org.omixed.client.OmixedClient;
org.omixed.client.ClientError = function(errorType,errorMessage) { if( errorType === $_ ) return; {
	this.errorType = errorType;
	this.errorMessage = errorMessage;
}}
org.omixed.client.ClientError.__name__ = ["org","omixed","client","ClientError"];
org.omixed.client.ClientError.prototype.errorMessage = null;
org.omixed.client.ClientError.prototype.errorType = null;
org.omixed.client.ClientError.prototype.getErrorMessage = function() {
	return this.errorMessage;
}
org.omixed.client.ClientError.prototype.geterrorType = function() {
	return this.errorType;
}
org.omixed.client.ClientError.prototype.__class__ = org.omixed.client.ClientError;
org.omixed.client.ReturnType = { __ename__ : ["org","omixed","client","ReturnType"], __constructs__ : ["ITEM_ID","ITEM_WITH_TAGS","SHORT_ITEM_DETAILS","FULL_ITEM_DETAILS","ITEM_GRAPH"] }
org.omixed.client.ReturnType.FULL_ITEM_DETAILS = ["FULL_ITEM_DETAILS",3];
org.omixed.client.ReturnType.FULL_ITEM_DETAILS.toString = $estr;
org.omixed.client.ReturnType.FULL_ITEM_DETAILS.__enum__ = org.omixed.client.ReturnType;
org.omixed.client.ReturnType.ITEM_GRAPH = ["ITEM_GRAPH",4];
org.omixed.client.ReturnType.ITEM_GRAPH.toString = $estr;
org.omixed.client.ReturnType.ITEM_GRAPH.__enum__ = org.omixed.client.ReturnType;
org.omixed.client.ReturnType.ITEM_ID = ["ITEM_ID",0];
org.omixed.client.ReturnType.ITEM_ID.toString = $estr;
org.omixed.client.ReturnType.ITEM_ID.__enum__ = org.omixed.client.ReturnType;
org.omixed.client.ReturnType.ITEM_WITH_TAGS = ["ITEM_WITH_TAGS",1];
org.omixed.client.ReturnType.ITEM_WITH_TAGS.toString = $estr;
org.omixed.client.ReturnType.ITEM_WITH_TAGS.__enum__ = org.omixed.client.ReturnType;
org.omixed.client.ReturnType.SHORT_ITEM_DETAILS = ["SHORT_ITEM_DETAILS",2];
org.omixed.client.ReturnType.SHORT_ITEM_DETAILS.toString = $estr;
org.omixed.client.ReturnType.SHORT_ITEM_DETAILS.__enum__ = org.omixed.client.ReturnType;
org.omixed.client.graphviz.GraphVizLayoutOptions = function(p) { if( p === $_ ) return; {
	var keys = new Hash();
	keys.set("layoutMethod",["dot","neato","fdp","twopi","circo"]);
	keys.set("Grankdir",["LR","TB"]);
	keys.set("Goverlap",["scalexy","true","false","scale","compress"]);
	keys.set("outputFormat",["svg","xdot"]);
	org.omixed.client.QueryOptions.apply(this,[keys]);
	this.addOption("outputFormat","xdot");
	this.addOption("layoutMethod","dot");
}}
org.omixed.client.graphviz.GraphVizLayoutOptions.__name__ = ["org","omixed","client","graphviz","GraphVizLayoutOptions"];
org.omixed.client.graphviz.GraphVizLayoutOptions.__super__ = org.omixed.client.QueryOptions;
for(var k in org.omixed.client.QueryOptions.prototype ) org.omixed.client.graphviz.GraphVizLayoutOptions.prototype[k] = org.omixed.client.QueryOptions.prototype[k];
org.omixed.client.graphviz.GraphVizLayoutOptions.prototype.toString = function() {
	var s = "";
	var layouts = "layoutArguments = ";
	{ var $it50 = this.options.keys();
	while( $it50.hasNext() ) { var key = $it50.next();
	{
		if(Lambda.has(org.omixed.client.graphviz.GraphVizLayoutOptions.nonLayoutArguments,key)) {
			s += key + "=" + this.options.get(key) + "\n";
		}
		else {
			layouts += "-" + key + "=" + this.options.get(key) + " ";
		}
	}
	}}
	s += layouts;
	return s;
}
org.omixed.client.graphviz.GraphVizLayoutOptions.prototype.__class__ = org.omixed.client.graphviz.GraphVizLayoutOptions;
org.omixed.client.OmixedClientEventType = { __ename__ : ["org","omixed","client","OmixedClientEventType"], __constructs__ : ["fault","status","initialised","connected","disconnected","get_schema_with_layout","get_item_graph_with_layout","get_item_types","describe_schema_item_type","item_find"] }
org.omixed.client.OmixedClientEventType.connected = ["connected",3];
org.omixed.client.OmixedClientEventType.connected.toString = $estr;
org.omixed.client.OmixedClientEventType.connected.__enum__ = org.omixed.client.OmixedClientEventType;
org.omixed.client.OmixedClientEventType.describe_schema_item_type = ["describe_schema_item_type",8];
org.omixed.client.OmixedClientEventType.describe_schema_item_type.toString = $estr;
org.omixed.client.OmixedClientEventType.describe_schema_item_type.__enum__ = org.omixed.client.OmixedClientEventType;
org.omixed.client.OmixedClientEventType.disconnected = ["disconnected",4];
org.omixed.client.OmixedClientEventType.disconnected.toString = $estr;
org.omixed.client.OmixedClientEventType.disconnected.__enum__ = org.omixed.client.OmixedClientEventType;
org.omixed.client.OmixedClientEventType.fault = ["fault",0];
org.omixed.client.OmixedClientEventType.fault.toString = $estr;
org.omixed.client.OmixedClientEventType.fault.__enum__ = org.omixed.client.OmixedClientEventType;
org.omixed.client.OmixedClientEventType.get_item_graph_with_layout = ["get_item_graph_with_layout",6];
org.omixed.client.OmixedClientEventType.get_item_graph_with_layout.toString = $estr;
org.omixed.client.OmixedClientEventType.get_item_graph_with_layout.__enum__ = org.omixed.client.OmixedClientEventType;
org.omixed.client.OmixedClientEventType.get_item_types = ["get_item_types",7];
org.omixed.client.OmixedClientEventType.get_item_types.toString = $estr;
org.omixed.client.OmixedClientEventType.get_item_types.__enum__ = org.omixed.client.OmixedClientEventType;
org.omixed.client.OmixedClientEventType.get_schema_with_layout = ["get_schema_with_layout",5];
org.omixed.client.OmixedClientEventType.get_schema_with_layout.toString = $estr;
org.omixed.client.OmixedClientEventType.get_schema_with_layout.__enum__ = org.omixed.client.OmixedClientEventType;
org.omixed.client.OmixedClientEventType.initialised = ["initialised",2];
org.omixed.client.OmixedClientEventType.initialised.toString = $estr;
org.omixed.client.OmixedClientEventType.initialised.__enum__ = org.omixed.client.OmixedClientEventType;
org.omixed.client.OmixedClientEventType.item_find = ["item_find",9];
org.omixed.client.OmixedClientEventType.item_find.toString = $estr;
org.omixed.client.OmixedClientEventType.item_find.__enum__ = org.omixed.client.OmixedClientEventType;
org.omixed.client.OmixedClientEventType.status = ["status",1];
org.omixed.client.OmixedClientEventType.status.toString = $estr;
org.omixed.client.OmixedClientEventType.status.__enum__ = org.omixed.client.OmixedClientEventType;
$Main = function() { }
$Main.__name__ = ["@Main"];
$Main.prototype.__class__ = $Main;
$_ = {}
js.Boot.__res = {}
js.Boot.__init();
{
	Xml = js.JsXml__;
	Xml.__name__ = ["Xml"];
	Xml.Element = "element";
	Xml.PCData = "pcdata";
	Xml.CData = "cdata";
	Xml.Comment = "comment";
	Xml.DocType = "doctype";
	Xml.Prolog = "prolog";
	Xml.Document = "document";
}
{
	Date.now = function() {
		return new Date();
	}
	Date.fromTime = function(t) {
		var d = new Date();
		d["setTime"](t);
		return d;
	}
	Date.fromString = function(s) {
		switch(s.length) {
		case 8:{
			var k = s.split(":");
			var d = new Date();
			d["setTime"](0);
			d["setUTCHours"](k[0]);
			d["setUTCMinutes"](k[1]);
			d["setUTCSeconds"](k[2]);
			return d;
		}break;
		case 10:{
			var k = s.split("-");
			return new Date(k[0],k[1] - 1,k[2],0,0,0);
		}break;
		case 19:{
			var k = s.split(" ");
			var y = k[0].split("-");
			var t = k[1].split(":");
			return new Date(y[0],y[1] - 1,y[2],t[0],t[1],t[2]);
		}break;
		default:{
			throw "Invalid date format : " + s;
		}break;
		}
	}
	Date.prototype["toString"] = function() {
		var date = this;
		var m = date.getMonth() + 1;
		var d = date.getDate();
		var h = date.getHours();
		var mi = date.getMinutes();
		var s = date.getSeconds();
		return date.getFullYear() + "-" + ((m < 10?"0" + m:"" + m)) + "-" + ((d < 10?"0" + d:"" + d)) + " " + ((h < 10?"0" + h:"" + h)) + ":" + ((mi < 10?"0" + mi:"" + mi)) + ":" + ((s < 10?"0" + s:"" + s));
	}
	Date.prototype.__class__ = Date;
	Date.__name__ = ["Date"];
}
{
	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["XMLHttpRequest"] = (window.XMLHttpRequest?XMLHttpRequest:(window.ActiveXObject?function() {
		try {
			return new ActiveXObject("Msxml2.XMLHTTP");
		}
		catch( $e51 ) {
			{
				var e = $e51;
				{
					try {
						return new ActiveXObject("Microsoft.XMLHTTP");
					}
					catch( $e52 ) {
						{
							var e1 = $e52;
							{
								throw "Unable to create XMLHttpRequest object.";
							}
						}
					}
				}
			}
		}
	}:function($this) {
		var $r;
		throw "Unable to create XMLHttpRequest object.";
		return $r;
	}(this)));
}
js.JsXml__.enode = new EReg("^<([a-zA-Z0-9:_-]+)","");
js.JsXml__.ecdata = new EReg("^<!\\[CDATA\\[","i");
js.JsXml__.edoctype = new EReg("^<!DOCTYPE","i");
js.JsXml__.eend = new EReg("^</([a-zA-Z0-9:_-]+)>","");
js.JsXml__.epcdata = new EReg("^[^<]+","");
js.JsXml__.ecomment = new EReg("^<!--","");
js.JsXml__.eprolog = new EReg("^<\\?[^\\?]+\\?>","");
js.JsXml__.eattribute = new EReg("^\\s*([a-zA-Z0-9:_-]+)\\s*=\\s*([\"'])([^\\2]*?)\\2","");
js.JsXml__.eclose = new EReg("^[ \\r\\n\\t]*(>|(/>))","");
js.JsXml__.ecdata_end = new EReg("\\]\\]>","");
js.JsXml__.edoctype_elt = new EReg("[\\[|\\]>]","");
js.JsXml__.ecomment_end = new EReg("-->","");
haxe.remoting.ExternalConnection.connections = new Hash();
org.omixed.main.GraphVizAppletJS.appletConnectedListeners = new Array();
org.omixed.main.GraphVizAppletJS.nodeClickListeners = new Array();
org.omixed.main.GraphVizAppletJS.onCompleteListeners = new Array();
Logger.FATAL = 0;
Logger.ERROR = 1;
Logger.WARN = 2;
Logger.DEBUG = 3;
Logger.INFO = 4;
Logger.levels = ["FATAL","ERROR","WARN","DEBUG","INFO"];
haxe.Unserializer.DEFAULT_RESOLVER = Type;
haxe.Unserializer.BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789%:";
haxe.Unserializer.CODES = null;
haxe.Serializer.USE_CACHE = false;
haxe.Serializer.USE_ENUM_INDEX = false;
haxe.Serializer.BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789%:";
js.Lib.onerror = null;
org.omixed.client.graphviz.GraphVizLayoutOptions.nonLayoutArguments = ["layoutMethod","outputFormat"];
$Main.init = org.omixed.main.GraphVizAppletJS.main();