$estr = function() { return js.Boot.__string_rec(this,''); }
twitterface = {}
twitterface.views = {}
twitterface.views.Observer = function() { }
twitterface.views.Observer.__name__ = ["twitterface","views","Observer"];
twitterface.views.Observer.prototype.update = null;
twitterface.views.Observer.prototype.__class__ = twitterface.views.Observer;
twitterface.views.InlineListView = function(containerElement,elementId,entries,title) { if( containerElement === $_ ) return; {
	$s.push("twitterface.views.InlineListView::new");
	var $spos = $s.length;
	this.containerElement = containerElement;
	this.htmlId = elementId;
	this.entries = entries;
	this.title = title;
	this.rootElement = js.Lib.document.createElement("div");
	this.rootElement.id = this.htmlId;
	this.rootElement.className = twitterface.views.InlineListView.HTML_CLASSNAME;
	this.titleElement = js.Lib.document.createElement("h3");
	this.titleElement.appendChild(js.Lib.document.createTextNode(this.title));
	this.titleElement.className = twitterface.views.InlineListView.HTML_TITLE_CLASSNAME;
	this.rootElement.appendChild(this.titleElement);
	this.listElement = js.Lib.document.createElement("ul");
	var li;
	{
		var _g = 0;
		while(_g < 5) {
			var entry = entries[_g];
			++_g;
			li = js.Lib.document.createElement("li");
			li.appendChild(entry.toHTML());
			this.listElement.appendChild(li);
		}
	}
	this.listElement.className = twitterface.views.InlineListView.HTML_LIST_CLASSNAME;
	this.rootElement.appendChild(this.listElement);
	this.isInDom = false;
	$s.pop();
}}
twitterface.views.InlineListView.__name__ = ["twitterface","views","InlineListView"];
twitterface.views.InlineListView.prototype.containerElement = null;
twitterface.views.InlineListView.prototype.entries = null;
twitterface.views.InlineListView.prototype.htmlId = null;
twitterface.views.InlineListView.prototype.isInDom = null;
twitterface.views.InlineListView.prototype.listElement = null;
twitterface.views.InlineListView.prototype.putIntoDom = function() {
	$s.push("twitterface.views.InlineListView::putIntoDom");
	var $spos = $s.length;
	var element = this.rootElement;
	this.containerElement.appendChild(this.rootElement);
	this.isInDom = true;
	$s.pop();
}
twitterface.views.InlineListView.prototype.removeFromDom = function() {
	$s.push("twitterface.views.InlineListView::removeFromDom");
	var $spos = $s.length;
	this.rootElement.removeChild(this.rootElement);
	$s.pop();
}
twitterface.views.InlineListView.prototype.rootElement = null;
twitterface.views.InlineListView.prototype.title = null;
twitterface.views.InlineListView.prototype.titleElement = null;
twitterface.views.InlineListView.prototype.update = function(observer) {
	$s.push("twitterface.views.InlineListView::update");
	var $spos = $s.length;
	if(this.isInDom) {
		this.removeFromDom();
		this.putIntoDom();
	}
	$s.pop();
}
twitterface.views.InlineListView.prototype.__class__ = twitterface.views.InlineListView;
twitterface.views.InlineListView.__interfaces__ = [twitterface.views.Observer];
StringTools = function() { }
StringTools.__name__ = ["StringTools"];
StringTools.urlEncode = function(s) {
	$s.push("StringTools::urlEncode");
	var $spos = $s.length;
	{
		var $tmp = encodeURIComponent(s);
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
StringTools.urlDecode = function(s) {
	$s.push("StringTools::urlDecode");
	var $spos = $s.length;
	{
		var $tmp = decodeURIComponent(s.split("+").join(" "));
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
StringTools.htmlEscape = function(s) {
	$s.push("StringTools::htmlEscape");
	var $spos = $s.length;
	{
		var $tmp = s.split("&").join("&amp;").split("<").join("&lt;").split(">").join("&gt;");
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
StringTools.htmlUnescape = function(s) {
	$s.push("StringTools::htmlUnescape");
	var $spos = $s.length;
	{
		var $tmp = s.split("&gt;").join(">").split("&lt;").join("<").split("&amp;").join("&");
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
StringTools.startsWith = function(s,start) {
	$s.push("StringTools::startsWith");
	var $spos = $s.length;
	{
		var $tmp = (s.length >= start.length && s.substr(0,start.length) == start);
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
StringTools.endsWith = function(s,end) {
	$s.push("StringTools::endsWith");
	var $spos = $s.length;
	var elen = end.length;
	var slen = s.length;
	{
		var $tmp = (slen >= elen && s.substr(slen - elen,elen) == end);
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
StringTools.isSpace = function(s,pos) {
	$s.push("StringTools::isSpace");
	var $spos = $s.length;
	var c = s.charCodeAt(pos);
	{
		var $tmp = (c >= 9 && c <= 13) || c == 32;
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
StringTools.ltrim = function(s) {
	$s.push("StringTools::ltrim");
	var $spos = $s.length;
	var l = s.length;
	var r = 0;
	while(r < l && StringTools.isSpace(s,r)) {
		r++;
	}
	if(r > 0) {
		var $tmp = s.substr(r,l - r);
		$s.pop();
		return $tmp;
	}
	else {
		$s.pop();
		return s;
	}
	$s.pop();
}
StringTools.rtrim = function(s) {
	$s.push("StringTools::rtrim");
	var $spos = $s.length;
	var l = s.length;
	var r = 0;
	while(r < l && StringTools.isSpace(s,l - r - 1)) {
		r++;
	}
	if(r > 0) {
		{
			var $tmp = s.substr(0,l - r);
			$s.pop();
			return $tmp;
		}
	}
	else {
		{
			$s.pop();
			return s;
		}
	}
	$s.pop();
}
StringTools.trim = function(s) {
	$s.push("StringTools::trim");
	var $spos = $s.length;
	{
		var $tmp = StringTools.ltrim(StringTools.rtrim(s));
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
StringTools.rpad = function(s,c,l) {
	$s.push("StringTools::rpad");
	var $spos = $s.length;
	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;
		}
	}
	{
		$s.pop();
		return s;
	}
	$s.pop();
}
StringTools.lpad = function(s,c,l) {
	$s.push("StringTools::lpad");
	var $spos = $s.length;
	var ns = "";
	var sl = s.length;
	if(sl >= l) {
		$s.pop();
		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;
		}
	}
	{
		var $tmp = ns + s;
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
StringTools.replace = function(s,sub,by) {
	$s.push("StringTools::replace");
	var $spos = $s.length;
	{
		var $tmp = s.split(sub).join(by);
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
StringTools.hex = function(n,digits) {
	$s.push("StringTools::hex");
	var $spos = $s.length;
	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;
	{
		$s.pop();
		return s;
	}
	$s.pop();
}
StringTools.prototype.__class__ = StringTools;
hxjson2 = {}
hxjson2.JSONEncoder = function(value) { if( value === $_ ) return; {
	$s.push("hxjson2.JSONEncoder::new");
	var $spos = $s.length;
	this.jsonString = this.convertToString(value);
	$s.pop();
}}
hxjson2.JSONEncoder.__name__ = ["hxjson2","JSONEncoder"];
hxjson2.JSONEncoder.prototype.arrayToString = function(a) {
	$s.push("hxjson2.JSONEncoder::arrayToString");
	var $spos = $s.length;
	var s = "";
	{
		var _g1 = 0, _g = a.length;
		while(_g1 < _g) {
			var i = _g1++;
			if(s.length > 0) {
				s += ",";
			}
			s += this.convertToString(a[i]);
		}
	}
	{
		var $tmp = "[" + s + "]";
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
hxjson2.JSONEncoder.prototype.convertToString = function(value) {
	$s.push("hxjson2.JSONEncoder::convertToString");
	var $spos = $s.length;
	if(Std["is"](value,List) || Std["is"](value,IntHash)) value = Lambda.array(value);
	if(Std["is"](value,Hash)) value = this.mapHash(value);
	if(Std["is"](value,String)) {
		{
			var $tmp = this.escapeString(function($this) {
				var $r;
				var tmp = value;
				$r = (Std["is"](tmp,String)?tmp:function($this) {
					var $r;
					throw "Class cast error";
					return $r;
				}($this));
				return $r;
			}(this));
			$s.pop();
			return $tmp;
		}
	}
	else if(Std["is"](value,Float)) {
		{
			var $tmp = (Math.isFinite(function($this) {
				var $r;
				var tmp = value;
				$r = (Std["is"](tmp,Float)?tmp:function($this) {
					var $r;
					throw "Class cast error";
					return $r;
				}($this));
				return $r;
			}(this))?value + "":"null");
			$s.pop();
			return $tmp;
		}
	}
	else if(Std["is"](value,Bool)) {
		{
			var $tmp = (value?"true":"false");
			$s.pop();
			return $tmp;
		}
	}
	else if(Std["is"](value,Array)) {
		{
			var $tmp = this.arrayToString(function($this) {
				var $r;
				var tmp = value;
				$r = (Std["is"](tmp,Array)?tmp:function($this) {
					var $r;
					throw "Class cast error";
					return $r;
				}($this));
				return $r;
			}(this));
			$s.pop();
			return $tmp;
		}
	}
	else if(Std["is"](value,Dynamic) && value != null) {
		{
			var $tmp = this.objectToString(value);
			$s.pop();
			return $tmp;
		}
	}
	{
		$s.pop();
		return "null";
	}
	$s.pop();
}
hxjson2.JSONEncoder.prototype.escapeString = function(str) {
	$s.push("hxjson2.JSONEncoder::escapeString");
	var $spos = $s.length;
	var s = "";
	var ch;
	var len = str.length;
	{
		var _g = 0;
		while(_g < len) {
			var i = _g++;
			ch = str.charAt(i);
			switch(ch) {
			case "\"":{
				s += "\\\"";
			}break;
			case "\\":{
				s += "\\\\";
			}break;
			case "\n":{
				s += "\\n";
			}break;
			case "\r":{
				s += "\\r";
			}break;
			case "\t":{
				s += "\\t";
			}break;
			default:{
				var code = ch.charCodeAt(0);
				if(ch < " " || code > 127) {
					var hexCode = StringTools.hex(ch.charCodeAt(0));
					var zeroPad = "";
					{
						var _g2 = 0, _g1 = 4 - hexCode.length;
						while(_g2 < _g1) {
							var j = _g2++;
							zeroPad += "0";
						}
					}
					s += "\\u" + zeroPad + hexCode;
				}
				else {
					s += ch;
				}
			}break;
			}
		}
	}
	{
		var $tmp = "\"" + s + "\"";
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
hxjson2.JSONEncoder.prototype.getString = function() {
	$s.push("hxjson2.JSONEncoder::getString");
	var $spos = $s.length;
	{
		var $tmp = this.jsonString;
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
hxjson2.JSONEncoder.prototype.jsonString = null;
hxjson2.JSONEncoder.prototype.mapHash = function(value) {
	$s.push("hxjson2.JSONEncoder::mapHash");
	var $spos = $s.length;
	var ret = { }
	{ var $it0 = value.keys();
	while( $it0.hasNext() ) { var i = $it0.next();
	ret[i] = value.get(i);
	}}
	{
		$s.pop();
		return ret;
	}
	$s.pop();
}
hxjson2.JSONEncoder.prototype.objectToString = function(o) {
	$s.push("hxjson2.JSONEncoder::objectToString");
	var $spos = $s.length;
	var s = "";
	var value;
	{
		var _g = 0, _g1 = Reflect.fields(o);
		while(_g < _g1.length) {
			var key = _g1[_g];
			++_g;
			value = Reflect.field(o,key);
			if(!Reflect.isFunction(value)) {
				if(s.length > 0) {
					s += ",";
				}
				s += this.escapeString(key) + ":" + this.convertToString(value);
			}
		}
	}
	{
		var $tmp = "{" + s + "}";
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
hxjson2.JSONEncoder.prototype.__class__ = hxjson2.JSONEncoder;
Reflect = function() { }
Reflect.__name__ = ["Reflect"];
Reflect.hasField = function(o,field) {
	$s.push("Reflect::hasField");
	var $spos = $s.length;
	if(o.hasOwnProperty != null) {
		var $tmp = o.hasOwnProperty(field);
		$s.pop();
		return $tmp;
	}
	var arr = Reflect.fields(o);
	{ var $it1 = arr.iterator();
	while( $it1.hasNext() ) { var t = $it1.next();
	if(t == field) {
		$s.pop();
		return true;
	}
	}}
	{
		$s.pop();
		return false;
	}
	$s.pop();
}
Reflect.field = function(o,field) {
	$s.push("Reflect::field");
	var $spos = $s.length;
	var v = null;
	try {
		v = o[field];
	}
	catch( $e2 ) {
		{
			var e = $e2;
			{
				$e = [];
				while($s.length >= $spos) $e.unshift($s.pop());
				$s.push($e[0]);
				null;
			}
		}
	}
	{
		$s.pop();
		return v;
	}
	$s.pop();
}
Reflect.setField = function(o,field,value) {
	$s.push("Reflect::setField");
	var $spos = $s.length;
	o[field] = value;
	$s.pop();
}
Reflect.callMethod = function(o,func,args) {
	$s.push("Reflect::callMethod");
	var $spos = $s.length;
	{
		var $tmp = func.apply(o,args);
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
Reflect.fields = function(o) {
	$s.push("Reflect::fields");
	var $spos = $s.length;
	if(o == null) {
		var $tmp = new Array();
		$s.pop();
		return $tmp;
	}
	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( $e3 ) {
			{
				var e = $e3;
				{
					$e = [];
					while($s.length >= $spos) $e.unshift($s.pop());
					$s.push($e[0]);
					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;
	}
	{
		$s.pop();
		return a;
	}
	$s.pop();
}
Reflect.isFunction = function(f) {
	$s.push("Reflect::isFunction");
	var $spos = $s.length;
	{
		var $tmp = typeof(f) == "function" && f.__name__ == null;
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
Reflect.compare = function(a,b) {
	$s.push("Reflect::compare");
	var $spos = $s.length;
	{
		var $tmp = ((a == b)?0:((((a) > (b))?1:-1)));
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
Reflect.compareMethods = function(f1,f2) {
	$s.push("Reflect::compareMethods");
	var $spos = $s.length;
	if(f1 == f2) {
		$s.pop();
		return true;
	}
	if(!Reflect.isFunction(f1) || !Reflect.isFunction(f2)) {
		$s.pop();
		return false;
	}
	{
		var $tmp = f1.scope == f2.scope && f1.method == f2.method && f1.method != null;
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
Reflect.isObject = function(v) {
	$s.push("Reflect::isObject");
	var $spos = $s.length;
	if(v == null) {
		$s.pop();
		return false;
	}
	var t = typeof(v);
	{
		var $tmp = (t == "string" || (t == "object" && !v.__enum__) || (t == "function" && v.__name__ != null));
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
Reflect.deleteField = function(o,f) {
	$s.push("Reflect::deleteField");
	var $spos = $s.length;
	if(!Reflect.hasField(o,f)) {
		$s.pop();
		return false;
	}
	delete(o[f]);
	{
		$s.pop();
		return true;
	}
	$s.pop();
}
Reflect.copy = function(o) {
	$s.push("Reflect::copy");
	var $spos = $s.length;
	var o2 = { }
	{
		var _g = 0, _g1 = Reflect.fields(o);
		while(_g < _g1.length) {
			var f = _g1[_g];
			++_g;
			o2[f] = Reflect.field(o,f);
		}
	}
	{
		$s.pop();
		return o2;
	}
	$s.pop();
}
Reflect.makeVarArgs = function(f) {
	$s.push("Reflect::makeVarArgs");
	var $spos = $s.length;
	{
		var $tmp = function() {
			$s.push("Reflect::makeVarArgs@345");
			var $spos = $s.length;
			var a = new Array();
			{
				var _g1 = 0, _g = arguments.length;
				while(_g1 < _g) {
					var i = _g1++;
					a.push(arguments[i]);
				}
			}
			{
				var $tmp = f(a);
				$s.pop();
				return $tmp;
			}
			$s.pop();
		}
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
Reflect.prototype.__class__ = Reflect;
twitterface.Twitterface = function(p) { if( p === $_ ) return; {
	$s.push("twitterface.Twitterface::new");
	var $spos = $s.length;
	var myInstance = this;
	this.userUpdatesRequest = new twitterface.controllers.UserUpdatesRequest("twitter.php");
	this.userUpdatesRequest.onData = function(data) {
		$s.push("twitterface.Twitterface::new@42");
		var $spos = $s.length;
		myInstance.init(hxjson2.JSON.decode(data,true));
		$s.pop();
	}
	this.userUpdatesRequest.onError = function(error) {
		$s.push("twitterface.Twitterface::new@46");
		var $spos = $s.length;
		null;
		$s.pop();
	}
	this.userUpdatesRequest.request(false);
	$s.pop();
}}
twitterface.Twitterface.__name__ = ["twitterface","Twitterface"];
twitterface.Twitterface.INSTANCE = null;
twitterface.Twitterface.getInstance = function() {
	$s.push("twitterface.Twitterface::getInstance");
	var $spos = $s.length;
	if(twitterface.Twitterface.INSTANCE == null) {
		twitterface.Twitterface.INSTANCE = new twitterface.Twitterface();
	}
	{
		var $tmp = twitterface.Twitterface.INSTANCE;
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
twitterface.Twitterface.prototype.entries = null;
twitterface.Twitterface.prototype.init = function(data) {
	$s.push("twitterface.Twitterface::init");
	var $spos = $s.length;
	this.entries = new Array();
	var entry;
	var user;
	{
		var _g = 0;
		while(_g < data.length) {
			var jsonString = data[_g];
			++_g;
			user = new twitterface.models.TwitterUser(jsonString.user.screen_name);
			entry = new twitterface.models.TwitterEntry(jsonString.text,jsonString.created_at,user);
			this.entries.push(entry);
		}
	}
	this.inlineListView = new twitterface.views.InlineListView(js.Lib.document.getElementById("twittercourse"),"twitterface",this.entries.copy(),"Racing Twitter");
	this.inlineListView.putIntoDom();
	$s.pop();
}
twitterface.Twitterface.prototype.inlineListView = null;
twitterface.Twitterface.prototype.userUpdatesRequest = null;
twitterface.Twitterface.prototype.__class__ = twitterface.Twitterface;
hxjson2.JSONTokenizer = function(s,strict) { if( s === $_ ) return; {
	$s.push("hxjson2.JSONTokenizer::new");
	var $spos = $s.length;
	this.jsonString = s;
	this.strict = strict;
	this.loc = 0;
	this.nextChar();
	$s.pop();
}}
hxjson2.JSONTokenizer.__name__ = ["hxjson2","JSONTokenizer"];
hxjson2.JSONTokenizer.prototype.ch = null;
hxjson2.JSONTokenizer.prototype.getNextToken = function() {
	$s.push("hxjson2.JSONTokenizer::getNextToken");
	var $spos = $s.length;
	var token = new hxjson2.JSONToken();
	this.skipIgnored();
	switch(this.ch) {
	case "{":{
		token.type = hxjson2.JSONTokenType.LEFT_BRACE;
		token.value = "{";
		this.nextChar();
	}break;
	case "}":{
		token.type = hxjson2.JSONTokenType.RIGHT_BRACE;
		token.value = "}";
		this.nextChar();
	}break;
	case "[":{
		token.type = hxjson2.JSONTokenType.LEFT_BRACKET;
		token.value = "[";
		this.nextChar();
	}break;
	case "]":{
		token.type = hxjson2.JSONTokenType.RIGHT_BRACKET;
		token.value = "]";
		this.nextChar();
	}break;
	case ",":{
		token.type = hxjson2.JSONTokenType.COMMA;
		token.value = ",";
		this.nextChar();
	}break;
	case ":":{
		token.type = hxjson2.JSONTokenType.COLON;
		token.value = ":";
		this.nextChar();
	}break;
	case "t":{
		var possibleTrue = "t" + this.nextChar() + this.nextChar() + this.nextChar();
		if(possibleTrue == "true") {
			token.type = hxjson2.JSONTokenType.TRUE;
			token.value = true;
			this.nextChar();
		}
		else {
			this.parseError("Expecting 'true' but found " + possibleTrue);
		}
	}break;
	case "f":{
		var possibleFalse = "f" + this.nextChar() + this.nextChar() + this.nextChar() + this.nextChar();
		if(possibleFalse == "false") {
			token.type = hxjson2.JSONTokenType.FALSE;
			token.value = false;
			this.nextChar();
		}
		else {
			this.parseError("Expecting 'false' but found " + possibleFalse);
		}
	}break;
	case "n":{
		var possibleNull = "n" + this.nextChar() + this.nextChar() + this.nextChar();
		if(possibleNull == "null") {
			token.type = hxjson2.JSONTokenType.NULL;
			token.value = null;
			this.nextChar();
		}
		else {
			this.parseError("Expecting 'null' but found " + possibleNull);
		}
	}break;
	case "N":{
		var possibleNAN = "N" + this.nextChar() + this.nextChar();
		if(possibleNAN == "NAN" || possibleNAN == "NaN") {
			token.type = hxjson2.JSONTokenType.NAN;
			token.value = Math.NaN;
			this.nextChar();
		}
		else {
			this.parseError("Expecting 'nan' but found " + possibleNAN);
		}
	}break;
	case "\"":{
		token = this.readString();
	}break;
	default:{
		if(this.isDigit(this.ch) || this.ch == "-") {
			token = this.readNumber();
		}
		else if(this.ch == "") {
			{
				$s.pop();
				return null;
			}
		}
		else {
			this.parseError("Unexpected " + this.ch + " encountered");
		}
	}break;
	}
	{
		$s.pop();
		return token;
	}
	$s.pop();
}
hxjson2.JSONTokenizer.prototype.hexValToInt = function(hexVal) {
	$s.push("hxjson2.JSONTokenizer::hexValToInt");
	var $spos = $s.length;
	var ret = 0;
	{
		var _g1 = 0, _g = hexVal.length;
		while(_g1 < _g) {
			var i = _g1++;
			ret = ret << 4;
			switch(hexVal.charAt(i).toUpperCase()) {
			case "1":{
				ret += 1;
			}break;
			case "2":{
				ret += 2;
			}break;
			case "3":{
				ret += 3;
			}break;
			case "4":{
				ret += 4;
			}break;
			case "5":{
				ret += 5;
			}break;
			case "6":{
				ret += 6;
			}break;
			case "7":{
				ret += 7;
			}break;
			case "8":{
				ret += 8;
			}break;
			case "9":{
				ret += 9;
			}break;
			case "A":{
				ret += 10;
			}break;
			case "B":{
				ret += 11;
			}break;
			case "C":{
				ret += 12;
			}break;
			case "D":{
				ret += 13;
			}break;
			case "E":{
				ret += 14;
			}break;
			case "F":{
				ret += 15;
			}break;
			}
		}
	}
	{
		$s.pop();
		return ret;
	}
	$s.pop();
}
hxjson2.JSONTokenizer.prototype.isDigit = function(ch) {
	$s.push("hxjson2.JSONTokenizer::isDigit");
	var $spos = $s.length;
	{
		var $tmp = (ch >= "0" && ch <= "9");
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
hxjson2.JSONTokenizer.prototype.isHexDigit = function(ch) {
	$s.push("hxjson2.JSONTokenizer::isHexDigit");
	var $spos = $s.length;
	var uc = ch.toUpperCase();
	{
		var $tmp = (this.isDigit(ch) || (uc >= "A" && uc <= "F"));
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
hxjson2.JSONTokenizer.prototype.isWhiteSpace = function(ch) {
	$s.push("hxjson2.JSONTokenizer::isWhiteSpace");
	var $spos = $s.length;
	{
		var $tmp = (ch == " " || ch == "\t" || ch == "\n" || ch == "\r");
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
hxjson2.JSONTokenizer.prototype.jsonString = null;
hxjson2.JSONTokenizer.prototype.loc = null;
hxjson2.JSONTokenizer.prototype.nextChar = function() {
	$s.push("hxjson2.JSONTokenizer::nextChar");
	var $spos = $s.length;
	{
		var $tmp = this.ch = this.jsonString.charAt(this.loc++);
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
hxjson2.JSONTokenizer.prototype.obj = null;
hxjson2.JSONTokenizer.prototype.parseError = function(message) {
	$s.push("hxjson2.JSONTokenizer::parseError");
	var $spos = $s.length;
	throw new hxjson2.JSONParseError(message,this.loc,this.jsonString);
	$s.pop();
}
hxjson2.JSONTokenizer.prototype.readNumber = function() {
	$s.push("hxjson2.JSONTokenizer::readNumber");
	var $spos = $s.length;
	var input = "";
	if(this.ch == "-") {
		input += "-";
		this.nextChar();
	}
	if(!this.isDigit(this.ch)) {
		this.parseError("Expecting a digit");
	}
	if(this.ch == "0") {
		input += this.ch;
		this.nextChar();
		if(this.isDigit(this.ch)) {
			this.parseError("A digit cannot immediately follow 0");
		}
		else {
			if(!this.strict && this.ch == "x") {
				input += this.ch;
				this.nextChar();
				if(this.isHexDigit(this.ch)) {
					input += this.ch;
					this.nextChar();
				}
				else {
					this.parseError("Number in hex format require at least one hex digit after \"0x\"");
				}
				while(this.isHexDigit(this.ch)) {
					input += this.ch;
					this.nextChar();
				}
				input = Std.string(this.hexValToInt(input));
			}
		}
	}
	else {
		while(this.isDigit(this.ch)) {
			input += this.ch;
			this.nextChar();
		}
	}
	if(this.ch == ".") {
		input += ".";
		this.nextChar();
		if(!this.isDigit(this.ch)) {
			this.parseError("Expecting a digit");
		}
		while(this.isDigit(this.ch)) {
			input += this.ch;
			this.nextChar();
		}
	}
	if(this.ch == "e" || this.ch == "E") {
		input += "e";
		this.nextChar();
		if(this.ch == "+" || this.ch == "-") {
			input += this.ch;
			this.nextChar();
		}
		if(!this.isDigit(this.ch)) {
			this.parseError("Scientific notation number needs exponent value");
		}
		while(this.isDigit(this.ch)) {
			input += this.ch;
			this.nextChar();
		}
	}
	var num = Std.parseFloat(input);
	if(Math.isFinite(num) && !Math.isNaN(num)) {
		var token = new hxjson2.JSONToken();
		token.type = hxjson2.JSONTokenType.NUMBER;
		token.value = num;
		{
			$s.pop();
			return token;
		}
	}
	else {
		this.parseError("Number " + num + " is not valid!");
	}
	{
		$s.pop();
		return null;
	}
	$s.pop();
}
hxjson2.JSONTokenizer.prototype.readString = function() {
	$s.push("hxjson2.JSONTokenizer::readString");
	var $spos = $s.length;
	var string = "";
	this.nextChar();
	while(this.ch != "\"" && this.ch != "") {
		if(this.ch == "\\") {
			this.nextChar();
			switch(this.ch) {
			case "\"":{
				string += "\"";
			}break;
			case "/":{
				string += "/";
			}break;
			case "\\":{
				string += "\\";
			}break;
			case "n":{
				string += "\n";
			}break;
			case "r":{
				string += "\r";
			}break;
			case "t":{
				string += "\t";
			}break;
			case "u":{
				var hexValue = "";
				{
					var _g = 0;
					while(_g < 4) {
						var i = _g++;
						if(!this.isHexDigit(this.nextChar())) {
							this.parseError(" Excepted a hex digit, but found: " + this.ch);
						}
						hexValue += this.ch;
					}
				}
				string += String.fromCharCode(this.hexValToInt(hexValue));
			}break;
			default:{
				string += "\\" + this.ch;
			}break;
			}
		}
		else {
			string += this.ch;
		}
		this.nextChar();
	}
	if(this.ch == "") {
		this.parseError("Unterminated string literal");
	}
	this.nextChar();
	var token = new hxjson2.JSONToken();
	token.type = hxjson2.JSONTokenType.STRING;
	token.value = string;
	{
		$s.pop();
		return token;
	}
	$s.pop();
}
hxjson2.JSONTokenizer.prototype.skipComments = function() {
	$s.push("hxjson2.JSONTokenizer::skipComments");
	var $spos = $s.length;
	if(this.ch == "/") {
		this.nextChar();
		switch(this.ch) {
		case "/":{
			do {
				this.nextChar();
			} while(this.ch != "\n" && this.ch != "");
			this.nextChar();
		}break;
		case "*":{
			this.nextChar();
			while(true) {
				if(this.ch == "*") {
					this.nextChar();
					if(this.ch == "/") {
						this.nextChar();
						break;
					}
				}
				else {
					this.nextChar();
				}
				if(this.ch == "") {
					this.parseError("Multi-line comment not closed");
				}
			}
		}break;
		default:{
			this.parseError("Unexpected " + this.ch + " encountered (expecting '/' or '*' )");
		}break;
		}
	}
	$s.pop();
}
hxjson2.JSONTokenizer.prototype.skipIgnored = function() {
	$s.push("hxjson2.JSONTokenizer::skipIgnored");
	var $spos = $s.length;
	var originalLoc;
	do {
		originalLoc = this.loc;
		this.skipWhite();
		this.skipComments();
	} while(originalLoc != this.loc);
	$s.pop();
}
hxjson2.JSONTokenizer.prototype.skipWhite = function() {
	$s.push("hxjson2.JSONTokenizer::skipWhite");
	var $spos = $s.length;
	while(this.isWhiteSpace(this.ch)) {
		this.nextChar();
	}
	$s.pop();
}
hxjson2.JSONTokenizer.prototype.strict = null;
hxjson2.JSONTokenizer.prototype.__class__ = hxjson2.JSONTokenizer;
StringBuf = function(p) { if( p === $_ ) return; {
	$s.push("StringBuf::new");
	var $spos = $s.length;
	this.b = new Array();
	$s.pop();
}}
StringBuf.__name__ = ["StringBuf"];
StringBuf.prototype.add = function(x) {
	$s.push("StringBuf::add");
	var $spos = $s.length;
	this.b[this.b.length] = x;
	$s.pop();
}
StringBuf.prototype.addChar = function(c) {
	$s.push("StringBuf::addChar");
	var $spos = $s.length;
	this.b[this.b.length] = String.fromCharCode(c);
	$s.pop();
}
StringBuf.prototype.addSub = function(s,pos,len) {
	$s.push("StringBuf::addSub");
	var $spos = $s.length;
	this.b[this.b.length] = s.substr(pos,len);
	$s.pop();
}
StringBuf.prototype.b = null;
StringBuf.prototype.toString = function() {
	$s.push("StringBuf::toString");
	var $spos = $s.length;
	{
		var $tmp = this.b.join("");
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
StringBuf.prototype.__class__ = StringBuf;
hxjson2.JSONParseError = function(message,location,text) { if( message === $_ ) return; {
	$s.push("hxjson2.JSONParseError::new");
	var $spos = $s.length;
	if(text == null) text = "";
	if(location == null) location = 0;
	if(message == null) message = "";
	this.name = "JSONParseError";
	this._location = location;
	this._text = text;
	this.message = message;
	$s.pop();
}}
hxjson2.JSONParseError.__name__ = ["hxjson2","JSONParseError"];
hxjson2.JSONParseError.prototype._location = null;
hxjson2.JSONParseError.prototype._text = null;
hxjson2.JSONParseError.prototype.getlocation = function() {
	$s.push("hxjson2.JSONParseError::getlocation");
	var $spos = $s.length;
	{
		var $tmp = this._location;
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
hxjson2.JSONParseError.prototype.gettext = function() {
	$s.push("hxjson2.JSONParseError::gettext");
	var $spos = $s.length;
	{
		var $tmp = this._text;
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
hxjson2.JSONParseError.prototype.location = null;
hxjson2.JSONParseError.prototype.message = null;
hxjson2.JSONParseError.prototype.name = null;
hxjson2.JSONParseError.prototype.text = null;
hxjson2.JSONParseError.prototype.toString = function() {
	$s.push("hxjson2.JSONParseError::toString");
	var $spos = $s.length;
	{
		var $tmp = this.name + ": " + this.message + " at position: " + this._location + " near \"" + this._text + "\"";
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
hxjson2.JSONParseError.prototype.__class__ = hxjson2.JSONParseError;
hxjson2.JSONToken = function(type,value) { if( type === $_ ) return; {
	$s.push("hxjson2.JSONToken::new");
	var $spos = $s.length;
	this.type = (type == null?hxjson2.JSONTokenType.UNKNOWN:type);
	this.value = value;
	$s.pop();
}}
hxjson2.JSONToken.__name__ = ["hxjson2","JSONToken"];
hxjson2.JSONToken.prototype.type = null;
hxjson2.JSONToken.prototype.value = null;
hxjson2.JSONToken.prototype.__class__ = hxjson2.JSONToken;
twitterface.models = {}
twitterface.models.Observable = function(p) { if( p === $_ ) return; {
	$s.push("twitterface.models.Observable::new");
	var $spos = $s.length;
	this.observers = new Array();
	$s.pop();
}}
twitterface.models.Observable.__name__ = ["twitterface","models","Observable"];
twitterface.models.Observable.prototype.addObserver = function(observer) {
	$s.push("twitterface.models.Observable::addObserver");
	var $spos = $s.length;
	var canAdd = true;
	var cpt = 0;
	while(canAdd && cpt < this.observers.length) {
		if(this.observers[cpt] == observer) {
			canAdd = false;
		}
		cpt++;
	}
	if(canAdd) {
		this.observers.push(observer);
	}
	$s.pop();
}
twitterface.models.Observable.prototype.notifyObservers = function() {
	$s.push("twitterface.models.Observable::notifyObservers");
	var $spos = $s.length;
	var _g = 0, _g1 = this.observers;
	while(_g < _g1.length) {
		var observer = _g1[_g];
		++_g;
		observer.update(this);
	}
	$s.pop();
}
twitterface.models.Observable.prototype.observers = null;
twitterface.models.Observable.prototype.__class__ = twitterface.models.Observable;
EReg = function(r,opt) { if( r === $_ ) return; {
	$s.push("EReg::new");
	var $spos = $s.length;
	opt = opt.split("u").join("");
	this.r = new RegExp(r,opt);
	$s.pop();
}}
EReg.__name__ = ["EReg"];
EReg.prototype.customReplace = function(s,f) {
	$s.push("EReg::customReplace");
	var $spos = $s.length;
	var buf = new StringBuf();
	while(true) {
		if(!this.match(s)) break;
		buf.b[buf.b.length] = this.matchedLeft();
		buf.b[buf.b.length] = f(this);
		s = this.matchedRight();
	}
	buf.b[buf.b.length] = s;
	{
		var $tmp = buf.b.join("");
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
EReg.prototype.match = function(s) {
	$s.push("EReg::match");
	var $spos = $s.length;
	this.r.m = this.r.exec(s);
	this.r.s = s;
	this.r.l = RegExp.leftContext;
	this.r.r = RegExp.rightContext;
	{
		var $tmp = (this.r.m != null);
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
EReg.prototype.matched = function(n) {
	$s.push("EReg::matched");
	var $spos = $s.length;
	{
		var $tmp = (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));
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
EReg.prototype.matchedLeft = function() {
	$s.push("EReg::matchedLeft");
	var $spos = $s.length;
	if(this.r.m == null) throw "No string matched";
	if(this.r.l == null) {
		var $tmp = this.r.s.substr(0,this.r.m.index);
		$s.pop();
		return $tmp;
	}
	{
		var $tmp = this.r.l;
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
EReg.prototype.matchedPos = function() {
	$s.push("EReg::matchedPos");
	var $spos = $s.length;
	if(this.r.m == null) throw "No string matched";
	{
		var $tmp = { pos : this.r.m.index, len : this.r.m[0].length}
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
EReg.prototype.matchedRight = function() {
	$s.push("EReg::matchedRight");
	var $spos = $s.length;
	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;
		{
			var $tmp = this.r.s.substr(sz,this.r.s.length - sz);
			$s.pop();
			return $tmp;
		}
	}
	{
		var $tmp = this.r.r;
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
EReg.prototype.r = null;
EReg.prototype.replace = function(s,by) {
	$s.push("EReg::replace");
	var $spos = $s.length;
	{
		var $tmp = s.replace(this.r,by);
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
EReg.prototype.split = function(s) {
	$s.push("EReg::split");
	var $spos = $s.length;
	var d = "#__delim__#";
	{
		var $tmp = s.replace(this.r,d).split(d);
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
EReg.prototype.__class__ = EReg;
twitterface.models.TwitterEntry = function(text,creationDate,user) { if( text === $_ ) return; {
	$s.push("twitterface.models.TwitterEntry::new");
	var $spos = $s.length;
	twitterface.models.Observable.apply(this,[]);
	this.text = text;
	this.creationDate = this.parseDate(creationDate);
	this.user = user;
	$s.pop();
}}
twitterface.models.TwitterEntry.__name__ = ["twitterface","models","TwitterEntry"];
twitterface.models.TwitterEntry.__super__ = twitterface.models.Observable;
for(var k in twitterface.models.Observable.prototype ) twitterface.models.TwitterEntry.prototype[k] = twitterface.models.Observable.prototype[k];
twitterface.models.TwitterEntry.prototype.creationDate = null;
twitterface.models.TwitterEntry.prototype.getCreationDate = function() {
	$s.push("twitterface.models.TwitterEntry::getCreationDate");
	var $spos = $s.length;
	{
		var $tmp = this.creationDate;
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
twitterface.models.TwitterEntry.prototype.getText = function() {
	$s.push("twitterface.models.TwitterEntry::getText");
	var $spos = $s.length;
	{
		var $tmp = this.text;
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
twitterface.models.TwitterEntry.prototype.getUser = function() {
	$s.push("twitterface.models.TwitterEntry::getUser");
	var $spos = $s.length;
	{
		var $tmp = this.user;
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
twitterface.models.TwitterEntry.prototype.parseDate = function(creationDate) {
	$s.push("twitterface.models.TwitterEntry::parseDate");
	var $spos = $s.length;
	var cpt = 1;
	var found = false;
	var date;
	twitterface.models.TwitterEntry.DATE_REG.match(creationDate);
	var monthS = twitterface.models.TwitterEntry.DATE_REG.matched(1);
	var month = 0;
	var day = Std.parseInt(twitterface.models.TwitterEntry.DATE_REG.matched(2));
	var hour = Std.parseInt(twitterface.models.TwitterEntry.DATE_REG.matched(3));
	var minutes = Std.parseInt(twitterface.models.TwitterEntry.DATE_REG.matched(4));
	var seconds = Std.parseInt(twitterface.models.TwitterEntry.DATE_REG.matched(5));
	var year = Std.parseInt(twitterface.models.TwitterEntry.DATE_REG.matched(6));
	while(!found && cpt <= twitterface.models.TwitterEntry.MONTHS.length) {
		if(twitterface.models.TwitterEntry.MONTHS[cpt - 1] == monthS) {
			month = cpt;
		}
		cpt++;
	}
	date = new Date(year,month,day,hour,minutes,seconds);
	{
		$s.pop();
		return date;
	}
	$s.pop();
}
twitterface.models.TwitterEntry.prototype.text = null;
twitterface.models.TwitterEntry.prototype.toHTML = function() {
	$s.push("twitterface.models.TwitterEntry::toHTML");
	var $spos = $s.length;
	var rootElement = js.Lib.document.createElement("span");
	var dateSpan = js.Lib.document.createElement("span");
	var textSpan = js.Lib.document.createElement("span");
	var dateText = js.Lib.document.createTextNode(this.creationDate);
	var contentText = js.Lib.document.createTextNode(this.text);
	dateSpan.appendChild(dateText);
	textSpan.appendChild(contentText);
	rootElement.className = twitterface.models.TwitterEntry.HTML_CLASSNAME;
	dateSpan.className = twitterface.models.TwitterEntry.DATE_HTML_CLASSNAME;
	textSpan.className = twitterface.models.TwitterEntry.CONTENT_HTML_CLASSNAME;
	rootElement.appendChild(dateSpan);
	rootElement.appendChild(textSpan);
	{
		$s.pop();
		return rootElement;
	}
	$s.pop();
}
twitterface.models.TwitterEntry.prototype.user = null;
twitterface.models.TwitterEntry.prototype.__class__ = twitterface.models.TwitterEntry;
IntIter = function(min,max) { if( min === $_ ) return; {
	$s.push("IntIter::new");
	var $spos = $s.length;
	this.min = min;
	this.max = max;
	$s.pop();
}}
IntIter.__name__ = ["IntIter"];
IntIter.prototype.hasNext = function() {
	$s.push("IntIter::hasNext");
	var $spos = $s.length;
	{
		var $tmp = this.min < this.max;
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
IntIter.prototype.max = null;
IntIter.prototype.min = null;
IntIter.prototype.next = function() {
	$s.push("IntIter::next");
	var $spos = $s.length;
	{
		var $tmp = this.min++;
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
IntIter.prototype.__class__ = IntIter;
Std = function() { }
Std.__name__ = ["Std"];
Std["is"] = function(v,t) {
	$s.push("Std::is");
	var $spos = $s.length;
	{
		var $tmp = js.Boot.__instanceof(v,t);
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
Std.string = function(s) {
	$s.push("Std::string");
	var $spos = $s.length;
	{
		var $tmp = js.Boot.__string_rec(s,"");
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
Std["int"] = function(x) {
	$s.push("Std::int");
	var $spos = $s.length;
	if(x < 0) {
		var $tmp = Math.ceil(x);
		$s.pop();
		return $tmp;
	}
	{
		var $tmp = Math.floor(x);
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
Std.parseInt = function(x) {
	$s.push("Std::parseInt");
	var $spos = $s.length;
	var v = parseInt(x);
	if(Math.isNaN(v)) {
		$s.pop();
		return null;
	}
	{
		$s.pop();
		return v;
	}
	$s.pop();
}
Std.parseFloat = function(x) {
	$s.push("Std::parseFloat");
	var $spos = $s.length;
	{
		var $tmp = parseFloat(x);
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
Std.random = function(x) {
	$s.push("Std::random");
	var $spos = $s.length;
	{
		var $tmp = Math.floor(Math.random() * x);
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
Std.prototype.__class__ = Std;
twitterface.models.TwitterUser = function(name) { if( name === $_ ) return; {
	$s.push("twitterface.models.TwitterUser::new");
	var $spos = $s.length;
	this.name = name;
	this.url = twitterface.models.TwitterUser.TWITTER_URL + this.name;
	$s.pop();
}}
twitterface.models.TwitterUser.__name__ = ["twitterface","models","TwitterUser"];
twitterface.models.TwitterUser.prototype.getName = function() {
	$s.push("twitterface.models.TwitterUser::getName");
	var $spos = $s.length;
	{
		var $tmp = this.name;
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
twitterface.models.TwitterUser.prototype.name = null;
twitterface.models.TwitterUser.prototype.url = null;
twitterface.models.TwitterUser.prototype.__class__ = twitterface.models.TwitterUser;
Lambda = function() { }
Lambda.__name__ = ["Lambda"];
Lambda.array = function(it) {
	$s.push("Lambda::array");
	var $spos = $s.length;
	var a = new Array();
	{ var $it4 = it.iterator();
	while( $it4.hasNext() ) { var i = $it4.next();
	a.push(i);
	}}
	{
		$s.pop();
		return a;
	}
	$s.pop();
}
Lambda.list = function(it) {
	$s.push("Lambda::list");
	var $spos = $s.length;
	var l = new List();
	{ var $it5 = it.iterator();
	while( $it5.hasNext() ) { var i = $it5.next();
	l.add(i);
	}}
	{
		$s.pop();
		return l;
	}
	$s.pop();
}
Lambda.map = function(it,f) {
	$s.push("Lambda::map");
	var $spos = $s.length;
	var l = new List();
	{ var $it6 = it.iterator();
	while( $it6.hasNext() ) { var x = $it6.next();
	l.add(f(x));
	}}
	{
		$s.pop();
		return l;
	}
	$s.pop();
}
Lambda.mapi = function(it,f) {
	$s.push("Lambda::mapi");
	var $spos = $s.length;
	var l = new List();
	var i = 0;
	{ var $it7 = it.iterator();
	while( $it7.hasNext() ) { var x = $it7.next();
	l.add(f(i++,x));
	}}
	{
		$s.pop();
		return l;
	}
	$s.pop();
}
Lambda.has = function(it,elt,cmp) {
	$s.push("Lambda::has");
	var $spos = $s.length;
	if(cmp == null) {
		{ var $it8 = it.iterator();
		while( $it8.hasNext() ) { var x = $it8.next();
		if(x == elt) {
			$s.pop();
			return true;
		}
		}}
	}
	else {
		{ var $it9 = it.iterator();
		while( $it9.hasNext() ) { var x = $it9.next();
		if(cmp(x,elt)) {
			$s.pop();
			return true;
		}
		}}
	}
	{
		$s.pop();
		return false;
	}
	$s.pop();
}
Lambda.exists = function(it,f) {
	$s.push("Lambda::exists");
	var $spos = $s.length;
	{ var $it10 = it.iterator();
	while( $it10.hasNext() ) { var x = $it10.next();
	if(f(x)) {
		$s.pop();
		return true;
	}
	}}
	{
		$s.pop();
		return false;
	}
	$s.pop();
}
Lambda.foreach = function(it,f) {
	$s.push("Lambda::foreach");
	var $spos = $s.length;
	{ var $it11 = it.iterator();
	while( $it11.hasNext() ) { var x = $it11.next();
	if(!f(x)) {
		$s.pop();
		return false;
	}
	}}
	{
		$s.pop();
		return true;
	}
	$s.pop();
}
Lambda.iter = function(it,f) {
	$s.push("Lambda::iter");
	var $spos = $s.length;
	{ var $it12 = it.iterator();
	while( $it12.hasNext() ) { var x = $it12.next();
	f(x);
	}}
	$s.pop();
}
Lambda.filter = function(it,f) {
	$s.push("Lambda::filter");
	var $spos = $s.length;
	var l = new List();
	{ var $it13 = it.iterator();
	while( $it13.hasNext() ) { var x = $it13.next();
	if(f(x)) l.add(x);
	}}
	{
		$s.pop();
		return l;
	}
	$s.pop();
}
Lambda.fold = function(it,f,first) {
	$s.push("Lambda::fold");
	var $spos = $s.length;
	{ var $it14 = it.iterator();
	while( $it14.hasNext() ) { var x = $it14.next();
	first = f(x,first);
	}}
	{
		$s.pop();
		return first;
	}
	$s.pop();
}
Lambda.count = function(it) {
	$s.push("Lambda::count");
	var $spos = $s.length;
	var n = 0;
	{ var $it15 = it.iterator();
	while( $it15.hasNext() ) { var _ = $it15.next();
	++n;
	}}
	{
		$s.pop();
		return n;
	}
	$s.pop();
}
Lambda.empty = function(it) {
	$s.push("Lambda::empty");
	var $spos = $s.length;
	{
		var $tmp = !it.iterator().hasNext();
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
Lambda.prototype.__class__ = Lambda;
List = function(p) { if( p === $_ ) return; {
	$s.push("List::new");
	var $spos = $s.length;
	this.length = 0;
	$s.pop();
}}
List.__name__ = ["List"];
List.prototype.add = function(item) {
	$s.push("List::add");
	var $spos = $s.length;
	var x = [item];
	if(this.h == null) this.h = x;
	else this.q[1] = x;
	this.q = x;
	this.length++;
	$s.pop();
}
List.prototype.clear = function() {
	$s.push("List::clear");
	var $spos = $s.length;
	this.h = null;
	this.q = null;
	this.length = 0;
	$s.pop();
}
List.prototype.filter = function(f) {
	$s.push("List::filter");
	var $spos = $s.length;
	var l2 = new List();
	var l = this.h;
	while(l != null) {
		var v = l[0];
		l = l[1];
		if(f(v)) l2.add(v);
	}
	{
		$s.pop();
		return l2;
	}
	$s.pop();
}
List.prototype.first = function() {
	$s.push("List::first");
	var $spos = $s.length;
	{
		var $tmp = (this.h == null?null:this.h[0]);
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
List.prototype.h = null;
List.prototype.isEmpty = function() {
	$s.push("List::isEmpty");
	var $spos = $s.length;
	{
		var $tmp = (this.h == null);
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
List.prototype.iterator = function() {
	$s.push("List::iterator");
	var $spos = $s.length;
	{
		var $tmp = { h : this.h, hasNext : function() {
			$s.push("List::iterator@210");
			var $spos = $s.length;
			{
				var $tmp = (this.h != null);
				$s.pop();
				return $tmp;
			}
			$s.pop();
		}, next : function() {
			$s.push("List::iterator@213");
			var $spos = $s.length;
			if(this.h == null) {
				$s.pop();
				return null;
			}
			var x = this.h[0];
			this.h = this.h[1];
			{
				$s.pop();
				return x;
			}
			$s.pop();
		}}
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
List.prototype.join = function(sep) {
	$s.push("List::join");
	var $spos = $s.length;
	var s = new StringBuf();
	var first = true;
	var l = this.h;
	while(l != null) {
		if(first) first = false;
		else s.b[s.b.length] = sep;
		s.b[s.b.length] = l[0];
		l = l[1];
	}
	{
		var $tmp = s.b.join("");
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
List.prototype.last = function() {
	$s.push("List::last");
	var $spos = $s.length;
	{
		var $tmp = (this.q == null?null:this.q[0]);
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
List.prototype.length = null;
List.prototype.map = function(f) {
	$s.push("List::map");
	var $spos = $s.length;
	var b = new List();
	var l = this.h;
	while(l != null) {
		var v = l[0];
		l = l[1];
		b.add(f(v));
	}
	{
		$s.pop();
		return b;
	}
	$s.pop();
}
List.prototype.pop = function() {
	$s.push("List::pop");
	var $spos = $s.length;
	if(this.h == null) {
		$s.pop();
		return null;
	}
	var x = this.h[0];
	this.h = this.h[1];
	if(this.h == null) this.q = null;
	this.length--;
	{
		$s.pop();
		return x;
	}
	$s.pop();
}
List.prototype.push = function(item) {
	$s.push("List::push");
	var $spos = $s.length;
	var x = [item,this.h];
	this.h = x;
	if(this.q == null) this.q = x;
	this.length++;
	$s.pop();
}
List.prototype.q = null;
List.prototype.remove = function(v) {
	$s.push("List::remove");
	var $spos = $s.length;
	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--;
			{
				$s.pop();
				return true;
			}
		}
		prev = l;
		l = l[1];
	}
	{
		$s.pop();
		return false;
	}
	$s.pop();
}
List.prototype.toString = function() {
	$s.push("List::toString");
	var $spos = $s.length;
	var s = new StringBuf();
	var first = true;
	var l = this.h;
	s.b[s.b.length] = "{";
	while(l != null) {
		if(first) first = false;
		else s.b[s.b.length] = ", ";
		s.b[s.b.length] = l[0];
		l = l[1];
	}
	s.b[s.b.length] = "}";
	{
		var $tmp = s.b.join("");
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
List.prototype.__class__ = List;
haxe = {}
haxe.Http = function(url) { if( url === $_ ) return; {
	$s.push("haxe.Http::new");
	var $spos = $s.length;
	this.url = url;
	this.headers = new Hash();
	this.params = new Hash();
	this.async = true;
	$s.pop();
}}
haxe.Http.__name__ = ["haxe","Http"];
haxe.Http.request = function(url) {
	$s.push("haxe.Http::request");
	var $spos = $s.length;
	var h = new haxe.Http(url);
	h.async = false;
	var r = null;
	h.onData = function(d) {
		$s.push("haxe.Http::request@620");
		var $spos = $s.length;
		r = d;
		$s.pop();
	}
	h.onError = function(e) {
		$s.push("haxe.Http::request@623");
		var $spos = $s.length;
		throw e;
		$s.pop();
	}
	h.request(false);
	{
		$s.pop();
		return r;
	}
	$s.pop();
}
haxe.Http.prototype.async = null;
haxe.Http.prototype.headers = null;
haxe.Http.prototype.onData = function(data) {
	$s.push("haxe.Http::onData");
	var $spos = $s.length;
	null;
	$s.pop();
}
haxe.Http.prototype.onError = function(msg) {
	$s.push("haxe.Http::onError");
	var $spos = $s.length;
	null;
	$s.pop();
}
haxe.Http.prototype.onStatus = function(status) {
	$s.push("haxe.Http::onStatus");
	var $spos = $s.length;
	null;
	$s.pop();
}
haxe.Http.prototype.params = null;
haxe.Http.prototype.postData = null;
haxe.Http.prototype.request = function(post) {
	$s.push("haxe.Http::request");
	var $spos = $s.length;
	var me = this;
	var r = new js.XMLHttpRequest();
	var onreadystatechange = function() {
		$s.push("haxe.Http::request@101");
		var $spos = $s.length;
		if(r.readyState != 4) {
			$s.pop();
			return;
		}
		var s = function($this) {
			var $r;
			try {
				$r = r.status;
			}
			catch( $e16 ) {
				{
					var e = $e16;
					$r = function($this) {
						var $r;
						$e = [];
						while($s.length >= $spos) $e.unshift($s.pop());
						$s.push($e[0]);
						$r = null;
						return $r;
					}($this);
				}
			}
			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;
		}
		$s.pop();
	}
	r.onreadystatechange = onreadystatechange;
	var uri = this.postData;
	if(uri != null) post = true;
	else { var $it17 = this.params.keys();
	while( $it17.hasNext() ) { var p = $it17.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( $e18 ) {
		{
			var e = $e18;
			{
				$e = [];
				while($s.length >= $spos) $e.unshift($s.pop());
				$s.push($e[0]);
				this.onError(e.toString());
				{
					$s.pop();
					return;
				}
			}
		}
	}
	if(this.headers.get("Content-Type") == null && post && this.postData == null) r.setRequestHeader("Content-Type","application/x-www-form-urlencoded");
	{ var $it19 = this.headers.keys();
	while( $it19.hasNext() ) { var h = $it19.next();
	r.setRequestHeader(h,this.headers.get(h));
	}}
	r.send(uri);
	if(!this.async) onreadystatechange();
	$s.pop();
}
haxe.Http.prototype.setHeader = function(header,value) {
	$s.push("haxe.Http::setHeader");
	var $spos = $s.length;
	this.headers.set(header,value);
	$s.pop();
}
haxe.Http.prototype.setParameter = function(param,value) {
	$s.push("haxe.Http::setParameter");
	var $spos = $s.length;
	this.params.set(param,value);
	$s.pop();
}
haxe.Http.prototype.setPostData = function(data) {
	$s.push("haxe.Http::setPostData");
	var $spos = $s.length;
	this.postData = data;
	$s.pop();
}
haxe.Http.prototype.url = null;
haxe.Http.prototype.__class__ = haxe.Http;
js = {}
js.Lib = function() { }
js.Lib.__name__ = ["js","Lib"];
js.Lib.isIE = null;
js.Lib.isOpera = null;
js.Lib.document = null;
js.Lib.window = null;
js.Lib.alert = function(v) {
	$s.push("js.Lib::alert");
	var $spos = $s.length;
	alert(js.Boot.__string_rec(v,""));
	$s.pop();
}
js.Lib.eval = function(code) {
	$s.push("js.Lib::eval");
	var $spos = $s.length;
	{
		var $tmp = eval(code);
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
js.Lib.setErrorHandler = function(f) {
	$s.push("js.Lib::setErrorHandler");
	var $spos = $s.length;
	js.Lib.onerror = f;
	$s.pop();
}
js.Lib.prototype.__class__ = js.Lib;
js.Boot = function() { }
js.Boot.__name__ = ["js","Boot"];
js.Boot.__unhtml = function(s) {
	$s.push("js.Boot::__unhtml");
	var $spos = $s.length;
	{
		var $tmp = s.split("&").join("&amp;").split("<").join("&lt;").split(">").join("&gt;");
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
js.Boot.__trace = function(v,i) {
	$s.push("js.Boot::__trace");
	var $spos = $s.length;
	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;
	$s.pop();
}
js.Boot.__clear_trace = function() {
	$s.push("js.Boot::__clear_trace");
	var $spos = $s.length;
	var d = document.getElementById("haxe:trace");
	if(d != null) d.innerHTML = "";
	else null;
	$s.pop();
}
js.Boot.__closure = function(o,f) {
	$s.push("js.Boot::__closure");
	var $spos = $s.length;
	var m = o[f];
	if(m == null) {
		$s.pop();
		return null;
	}
	var f1 = function() {
		$s.push("js.Boot::__closure@67");
		var $spos = $s.length;
		{
			var $tmp = m.apply(o,arguments);
			$s.pop();
			return $tmp;
		}
		$s.pop();
	}
	f1.scope = o;
	f1.method = m;
	{
		$s.pop();
		return f1;
	}
	$s.pop();
}
js.Boot.__string_rec = function(o,s) {
	$s.push("js.Boot::__string_rec");
	var $spos = $s.length;
	if(o == null) {
		$s.pop();
		return "null";
	}
	if(s.length >= 5) {
		$s.pop();
		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) {
					var $tmp = o[0];
					$s.pop();
					return $tmp;
				}
				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);
					}
				}
				{
					var $tmp = str + ")";
					$s.pop();
					return $tmp;
				}
			}
			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 += "]";
			{
				$s.pop();
				return str;
			}
		}
		var tostr;
		try {
			tostr = o.toString;
		}
		catch( $e20 ) {
			{
				var e = $e20;
				{
					$e = [];
					while($s.length >= $spos) $e.unshift($s.pop());
					$s.push($e[0]);
					{
						$s.pop();
						return "???";
					}
				}
			}
		}
		if(tostr != null && tostr != Object.toString) {
			var s2 = o.toString();
			if(s2 != "[object Object]") {
				$s.pop();
				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 + "}";
		{
			$s.pop();
			return str;
		}
	}break;
	case "function":{
		{
			$s.pop();
			return "<function>";
		}
	}break;
	case "string":{
		{
			$s.pop();
			return o;
		}
	}break;
	default:{
		{
			var $tmp = String(o);
			$s.pop();
			return $tmp;
		}
	}break;
	}
	$s.pop();
}
js.Boot.__interfLoop = function(cc,cl) {
	$s.push("js.Boot::__interfLoop");
	var $spos = $s.length;
	if(cc == null) {
		$s.pop();
		return false;
	}
	if(cc == cl) {
		$s.pop();
		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)) {
				$s.pop();
				return true;
			}
		}
	}
	{
		var $tmp = js.Boot.__interfLoop(cc.__super__,cl);
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
js.Boot.__instanceof = function(o,cl) {
	$s.push("js.Boot::__instanceof");
	var $spos = $s.length;
	try {
		if(o instanceof cl) {
			if(cl == Array) {
				var $tmp = (o.__enum__ == null);
				$s.pop();
				return $tmp;
			}
			{
				$s.pop();
				return true;
			}
		}
		if(js.Boot.__interfLoop(o.__class__,cl)) {
			$s.pop();
			return true;
		}
	}
	catch( $e21 ) {
		{
			var e = $e21;
			{
				$e = [];
				while($s.length >= $spos) $e.unshift($s.pop());
				$s.push($e[0]);
				if(cl == null) {
					$s.pop();
					return false;
				}
			}
		}
	}
	switch(cl) {
	case Int:{
		{
			var $tmp = Math.ceil(o%2147483648.0) === o;
			$s.pop();
			return $tmp;
		}
	}break;
	case Float:{
		{
			var $tmp = typeof(o) == "number";
			$s.pop();
			return $tmp;
		}
	}break;
	case Bool:{
		{
			var $tmp = o === true || o === false;
			$s.pop();
			return $tmp;
		}
	}break;
	case String:{
		{
			var $tmp = typeof(o) == "string";
			$s.pop();
			return $tmp;
		}
	}break;
	case Dynamic:{
		{
			$s.pop();
			return true;
		}
	}break;
	default:{
		if(o == null) {
			$s.pop();
			return false;
		}
		{
			var $tmp = o.__enum__ == cl || (cl == Class && o.__name__ != null) || (cl == Enum && o.__ename__ != null);
			$s.pop();
			return $tmp;
		}
	}break;
	}
	$s.pop();
}
js.Boot.__init = function() {
	$s.push("js.Boot::__init");
	var $spos = $s.length;
	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) {
		$s.push("js.Boot::__init@199");
		var $spos = $s.length;
		this.splice(i,0,x);
		$s.pop();
	}
	Array.prototype.remove = (Array.prototype.indexOf?function(obj) {
		$s.push("js.Boot::__init@202");
		var $spos = $s.length;
		var idx = this.indexOf(obj);
		if(idx == -1) {
			$s.pop();
			return false;
		}
		this.splice(idx,1);
		{
			$s.pop();
			return true;
		}
		$s.pop();
	}:function(obj) {
		$s.push("js.Boot::__init@207");
		var $spos = $s.length;
		var i = 0;
		var l = this.length;
		while(i < l) {
			if(this[i] == obj) {
				this.splice(i,1);
				{
					$s.pop();
					return true;
				}
			}
			i++;
		}
		{
			$s.pop();
			return false;
		}
		$s.pop();
	});
	Array.prototype.iterator = function() {
		$s.push("js.Boot::__init@219");
		var $spos = $s.length;
		{
			var $tmp = { cur : 0, arr : this, hasNext : function() {
				$s.push("js.Boot::__init@219@223");
				var $spos = $s.length;
				{
					var $tmp = this.cur < this.arr.length;
					$s.pop();
					return $tmp;
				}
				$s.pop();
			}, next : function() {
				$s.push("js.Boot::__init@219@226");
				var $spos = $s.length;
				{
					var $tmp = this.arr[this.cur++];
					$s.pop();
					return $tmp;
				}
				$s.pop();
			}}
			$s.pop();
			return $tmp;
		}
		$s.pop();
	}
	var cca = String.prototype.charCodeAt;
	String.prototype.cca = cca;
	String.prototype.charCodeAt = function(i) {
		$s.push("js.Boot::__init@233");
		var $spos = $s.length;
		var x = cca.call(this,i);
		if(isNaN(x)) {
			$s.pop();
			return null;
		}
		{
			$s.pop();
			return x;
		}
		$s.pop();
	}
	var oldsub = String.prototype.substr;
	String.prototype.substr = function(pos,len) {
		$s.push("js.Boot::__init@240");
		var $spos = $s.length;
		if(pos != null && pos != 0 && len != null && len < 0) {
			$s.pop();
			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;
		}
		{
			var $tmp = oldsub.apply(this,[pos,len]);
			$s.pop();
			return $tmp;
		}
		$s.pop();
	}
	$closure = js.Boot.__closure;
	$s.pop();
}
js.Boot.prototype.__class__ = js.Boot;
IntHash = function(p) { if( p === $_ ) return; {
	$s.push("IntHash::new");
	var $spos = $s.length;
	this.h = {}
	if(this.h.__proto__ != null) {
		this.h.__proto__ = null;
		delete(this.h.__proto__);
	}
	else null;
	$s.pop();
}}
IntHash.__name__ = ["IntHash"];
IntHash.prototype.exists = function(key) {
	$s.push("IntHash::exists");
	var $spos = $s.length;
	{
		var $tmp = this.h[key] != null;
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
IntHash.prototype.get = function(key) {
	$s.push("IntHash::get");
	var $spos = $s.length;
	{
		var $tmp = this.h[key];
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
IntHash.prototype.h = null;
IntHash.prototype.iterator = function() {
	$s.push("IntHash::iterator");
	var $spos = $s.length;
	{
		var $tmp = { ref : this.h, it : this.keys(), hasNext : function() {
			$s.push("IntHash::iterator@186");
			var $spos = $s.length;
			{
				var $tmp = this.it.hasNext();
				$s.pop();
				return $tmp;
			}
			$s.pop();
		}, next : function() {
			$s.push("IntHash::iterator@187");
			var $spos = $s.length;
			var i = this.it.next();
			{
				var $tmp = this.ref[i];
				$s.pop();
				return $tmp;
			}
			$s.pop();
		}}
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
IntHash.prototype.keys = function() {
	$s.push("IntHash::keys");
	var $spos = $s.length;
	var a = new Array();
	
			for( x in this.h )
				a.push(x);
		;
	{
		var $tmp = a.iterator();
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
IntHash.prototype.remove = function(key) {
	$s.push("IntHash::remove");
	var $spos = $s.length;
	if(this.h[key] == null) {
		$s.pop();
		return false;
	}
	delete(this.h[key]);
	{
		$s.pop();
		return true;
	}
	$s.pop();
}
IntHash.prototype.set = function(key,value) {
	$s.push("IntHash::set");
	var $spos = $s.length;
	this.h[key] = value;
	$s.pop();
}
IntHash.prototype.toString = function() {
	$s.push("IntHash::toString");
	var $spos = $s.length;
	var s = new StringBuf();
	s.b[s.b.length] = "{";
	var it = this.keys();
	{ var $it22 = it;
	while( $it22.hasNext() ) { var i = $it22.next();
	{
		s.b[s.b.length] = i;
		s.b[s.b.length] = " => ";
		s.b[s.b.length] = Std.string(this.get(i));
		if(it.hasNext()) s.b[s.b.length] = ", ";
	}
	}}
	s.b[s.b.length] = "}";
	{
		var $tmp = s.b.join("");
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
IntHash.prototype.__class__ = IntHash;
DateTools = function() { }
DateTools.__name__ = ["DateTools"];
DateTools.__format_get = function(d,e) {
	$s.push("DateTools::__format_get");
	var $spos = $s.length;
	{
		var $tmp = function($this) {
			var $r;
			switch(e) {
			case "%":{
				$r = "%";
			}break;
			case "C":{
				$r = StringTools.lpad(Std.string(Std["int"](d.getFullYear() / 100)),"0",2);
			}break;
			case "d":{
				$r = StringTools.lpad(Std.string(d.getDate()),"0",2);
			}break;
			case "D":{
				$r = DateTools.__format(d,"%m/%d/%y");
			}break;
			case "e":{
				$r = Std.string(d.getDate());
			}break;
			case "H":case "k":{
				$r = StringTools.lpad(Std.string(d.getHours()),(e == "H"?"0":" "),2);
			}break;
			case "I":case "l":{
				$r = function($this) {
					var $r;
					var hour = d.getHours() % 12;
					$r = StringTools.lpad(Std.string((hour == 0?12:hour)),(e == "I"?"0":" "),2);
					return $r;
				}($this);
			}break;
			case "m":{
				$r = StringTools.lpad(Std.string(d.getMonth() + 1),"0",2);
			}break;
			case "M":{
				$r = StringTools.lpad(Std.string(d.getMinutes()),"0",2);
			}break;
			case "n":{
				$r = "\n";
			}break;
			case "p":{
				$r = (d.getHours() > 11?"PM":"AM");
			}break;
			case "r":{
				$r = DateTools.__format(d,"%I:%M:%S %p");
			}break;
			case "R":{
				$r = DateTools.__format(d,"%H:%M");
			}break;
			case "s":{
				$r = Std.string(Std["int"](d.getTime() / 1000));
			}break;
			case "S":{
				$r = StringTools.lpad(Std.string(d.getSeconds()),"0",2);
			}break;
			case "t":{
				$r = "\t";
			}break;
			case "T":{
				$r = DateTools.__format(d,"%H:%M:%S");
			}break;
			case "u":{
				$r = function($this) {
					var $r;
					var t = d.getDay();
					$r = (t == 0?"7":Std.string(t));
					return $r;
				}($this);
			}break;
			case "w":{
				$r = Std.string(d.getDay());
			}break;
			case "y":{
				$r = StringTools.lpad(Std.string(d.getFullYear() % 100),"0",2);
			}break;
			case "Y":{
				$r = Std.string(d.getFullYear());
			}break;
			default:{
				$r = function($this) {
					var $r;
					throw "Date.format %" + e + "- not implemented yet.";
					return $r;
				}($this);
			}break;
			}
			return $r;
		}(this);
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
DateTools.__format = function(d,f) {
	$s.push("DateTools::__format");
	var $spos = $s.length;
	var r = new StringBuf();
	var p = 0;
	while(true) {
		var np = f.indexOf("%",p);
		if(np < 0) break;
		r.b[r.b.length] = f.substr(p,np - p);
		r.b[r.b.length] = DateTools.__format_get(d,f.substr(np + 1,1));
		p = np + 2;
	}
	r.b[r.b.length] = f.substr(p,f.length - p);
	{
		var $tmp = r.b.join("");
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
DateTools.format = function(d,f) {
	$s.push("DateTools::format");
	var $spos = $s.length;
	{
		var $tmp = DateTools.__format(d,f);
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
DateTools.delta = function(d,t) {
	$s.push("DateTools::delta");
	var $spos = $s.length;
	{
		var $tmp = Date.fromTime(d.getTime() + t);
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
DateTools.getMonthDays = function(d) {
	$s.push("DateTools::getMonthDays");
	var $spos = $s.length;
	var month = d.getMonth();
	var year = d.getFullYear();
	if(month != 1) {
		var $tmp = DateTools.DAYS_OF_MONTH[month];
		$s.pop();
		return $tmp;
	}
	var isB = ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0);
	{
		var $tmp = (isB?29:28);
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
DateTools.seconds = function(n) {
	$s.push("DateTools::seconds");
	var $spos = $s.length;
	{
		var $tmp = n * 1000.0;
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
DateTools.minutes = function(n) {
	$s.push("DateTools::minutes");
	var $spos = $s.length;
	{
		var $tmp = n * 60.0 * 1000.0;
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
DateTools.hours = function(n) {
	$s.push("DateTools::hours");
	var $spos = $s.length;
	{
		var $tmp = n * 60.0 * 60.0 * 1000.0;
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
DateTools.days = function(n) {
	$s.push("DateTools::days");
	var $spos = $s.length;
	{
		var $tmp = n * 24.0 * 60.0 * 60.0 * 1000.0;
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
DateTools.parse = function(t) {
	$s.push("DateTools::parse");
	var $spos = $s.length;
	var s = t / 1000;
	var m = s / 60;
	var h = m / 60;
	{
		var $tmp = { ms : t % 1000, seconds : Std["int"](s % 60), minutes : Std["int"](m % 60), hours : Std["int"](h % 24), days : Std["int"](h / 24)}
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
DateTools.make = function(o) {
	$s.push("DateTools::make");
	var $spos = $s.length;
	{
		var $tmp = o.ms + 1000.0 * (o.seconds + 60.0 * (o.minutes + 60.0 * (o.hours + 24.0 * o.days)));
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
DateTools.prototype.__class__ = DateTools;
hxjson2.JSONTokenType = { __ename__ : ["hxjson2","JSONTokenType"], __constructs__ : ["UNKNOWN","COMMA","LEFT_BRACE","RIGHT_BRACE","LEFT_BRACKET","RIGHT_BRACKET","COLON","TRUE","FALSE","NULL","STRING","NUMBER","NAN"] }
hxjson2.JSONTokenType.COLON = ["COLON",6];
hxjson2.JSONTokenType.COLON.toString = $estr;
hxjson2.JSONTokenType.COLON.__enum__ = hxjson2.JSONTokenType;
hxjson2.JSONTokenType.COMMA = ["COMMA",1];
hxjson2.JSONTokenType.COMMA.toString = $estr;
hxjson2.JSONTokenType.COMMA.__enum__ = hxjson2.JSONTokenType;
hxjson2.JSONTokenType.FALSE = ["FALSE",8];
hxjson2.JSONTokenType.FALSE.toString = $estr;
hxjson2.JSONTokenType.FALSE.__enum__ = hxjson2.JSONTokenType;
hxjson2.JSONTokenType.LEFT_BRACE = ["LEFT_BRACE",2];
hxjson2.JSONTokenType.LEFT_BRACE.toString = $estr;
hxjson2.JSONTokenType.LEFT_BRACE.__enum__ = hxjson2.JSONTokenType;
hxjson2.JSONTokenType.LEFT_BRACKET = ["LEFT_BRACKET",4];
hxjson2.JSONTokenType.LEFT_BRACKET.toString = $estr;
hxjson2.JSONTokenType.LEFT_BRACKET.__enum__ = hxjson2.JSONTokenType;
hxjson2.JSONTokenType.NAN = ["NAN",12];
hxjson2.JSONTokenType.NAN.toString = $estr;
hxjson2.JSONTokenType.NAN.__enum__ = hxjson2.JSONTokenType;
hxjson2.JSONTokenType.NULL = ["NULL",9];
hxjson2.JSONTokenType.NULL.toString = $estr;
hxjson2.JSONTokenType.NULL.__enum__ = hxjson2.JSONTokenType;
hxjson2.JSONTokenType.NUMBER = ["NUMBER",11];
hxjson2.JSONTokenType.NUMBER.toString = $estr;
hxjson2.JSONTokenType.NUMBER.__enum__ = hxjson2.JSONTokenType;
hxjson2.JSONTokenType.RIGHT_BRACE = ["RIGHT_BRACE",3];
hxjson2.JSONTokenType.RIGHT_BRACE.toString = $estr;
hxjson2.JSONTokenType.RIGHT_BRACE.__enum__ = hxjson2.JSONTokenType;
hxjson2.JSONTokenType.RIGHT_BRACKET = ["RIGHT_BRACKET",5];
hxjson2.JSONTokenType.RIGHT_BRACKET.toString = $estr;
hxjson2.JSONTokenType.RIGHT_BRACKET.__enum__ = hxjson2.JSONTokenType;
hxjson2.JSONTokenType.STRING = ["STRING",10];
hxjson2.JSONTokenType.STRING.toString = $estr;
hxjson2.JSONTokenType.STRING.__enum__ = hxjson2.JSONTokenType;
hxjson2.JSONTokenType.TRUE = ["TRUE",7];
hxjson2.JSONTokenType.TRUE.toString = $estr;
hxjson2.JSONTokenType.TRUE.__enum__ = hxjson2.JSONTokenType;
hxjson2.JSONTokenType.UNKNOWN = ["UNKNOWN",0];
hxjson2.JSONTokenType.UNKNOWN.toString = $estr;
hxjson2.JSONTokenType.UNKNOWN.__enum__ = hxjson2.JSONTokenType;
hxjson2.JSONDecoder = function(s,strict) { if( s === $_ ) return; {
	$s.push("hxjson2.JSONDecoder::new");
	var $spos = $s.length;
	this.strict = strict;
	this.tokenizer = new hxjson2.JSONTokenizer(s,strict);
	this.nextToken();
	this.value = this.parseValue();
	if(strict && this.nextToken() != null) this.tokenizer.parseError("Unexpected characters left in input stream!");
	$s.pop();
}}
hxjson2.JSONDecoder.__name__ = ["hxjson2","JSONDecoder"];
hxjson2.JSONDecoder.prototype.getValue = function() {
	$s.push("hxjson2.JSONDecoder::getValue");
	var $spos = $s.length;
	{
		var $tmp = this.value;
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
hxjson2.JSONDecoder.prototype.nextToken = function() {
	$s.push("hxjson2.JSONDecoder::nextToken");
	var $spos = $s.length;
	{
		var $tmp = this.token = this.tokenizer.getNextToken();
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
hxjson2.JSONDecoder.prototype.parseArray = function() {
	$s.push("hxjson2.JSONDecoder::parseArray");
	var $spos = $s.length;
	var a = new Array();
	this.nextToken();
	if(this.token.type == hxjson2.JSONTokenType.RIGHT_BRACKET) {
		{
			$s.pop();
			return a;
		}
	}
	else {
		if(!this.strict && this.token.type == hxjson2.JSONTokenType.COMMA) {
			this.nextToken();
			if(this.token.type == hxjson2.JSONTokenType.RIGHT_BRACKET) {
				{
					$s.pop();
					return a;
				}
			}
			else {
				this.tokenizer.parseError("Leading commas are not supported.  Expecting ']' but found " + this.token.value);
			}
		}
	}
	while(true) {
		a.push(this.parseValue());
		this.nextToken();
		if(this.token.type == hxjson2.JSONTokenType.RIGHT_BRACKET) {
			{
				$s.pop();
				return a;
			}
		}
		else if(this.token.type == hxjson2.JSONTokenType.COMMA) {
			this.nextToken();
			if(!this.strict) {
				if(this.token.type == hxjson2.JSONTokenType.RIGHT_BRACKET) {
					{
						$s.pop();
						return a;
					}
				}
			}
		}
		else {
			this.tokenizer.parseError("Expecting ] or , but found " + this.token.value);
		}
	}
	{
		$s.pop();
		return null;
	}
	$s.pop();
}
hxjson2.JSONDecoder.prototype.parseObject = function() {
	$s.push("hxjson2.JSONDecoder::parseObject");
	var $spos = $s.length;
	var o = { }
	var key;
	this.nextToken();
	if(this.token.type == hxjson2.JSONTokenType.RIGHT_BRACE) {
		{
			$s.pop();
			return o;
		}
	}
	else {
		if(!this.strict && this.token.type == hxjson2.JSONTokenType.COMMA) {
			this.nextToken();
			if(this.token.type == hxjson2.JSONTokenType.RIGHT_BRACE) {
				{
					$s.pop();
					return o;
				}
			}
			else {
				this.tokenizer.parseError("Leading commas are not supported.  Expecting '}' but found " + this.token.value);
			}
		}
	}
	while(true) {
		if(this.token.type == hxjson2.JSONTokenType.STRING) {
			key = Std.string(this.token.value);
			this.nextToken();
			if(this.token.type == hxjson2.JSONTokenType.COLON) {
				this.nextToken();
				o[key] = this.parseValue();
				this.nextToken();
				if(this.token.type == hxjson2.JSONTokenType.RIGHT_BRACE) {
					{
						$s.pop();
						return o;
					}
				}
				else if(this.token.type == hxjson2.JSONTokenType.COMMA) {
					this.nextToken();
					if(!this.strict) {
						if(this.token.type == hxjson2.JSONTokenType.RIGHT_BRACE) {
							{
								$s.pop();
								return o;
							}
						}
					}
				}
				else {
					this.tokenizer.parseError("Expecting } or , but found " + this.token.value);
				}
			}
			else {
				this.tokenizer.parseError("Expecting : but found " + this.token.value);
			}
		}
		else {
			this.tokenizer.parseError("Expecting string but found " + this.token.value);
		}
	}
	{
		$s.pop();
		return null;
	}
	$s.pop();
}
hxjson2.JSONDecoder.prototype.parseValue = function() {
	$s.push("hxjson2.JSONDecoder::parseValue");
	var $spos = $s.length;
	if(this.token == null) this.tokenizer.parseError("Unexpected end of input");
	var $e = (this.token.type);
	switch( $e[1] ) {
	case 2:
	{
		{
			var $tmp = this.parseObject();
			$s.pop();
			return $tmp;
		}
	}break;
	case 4:
	{
		{
			var $tmp = this.parseArray();
			$s.pop();
			return $tmp;
		}
	}break;
	case 10:
	{
		{
			var $tmp = this.token.value;
			$s.pop();
			return $tmp;
		}
	}break;
	case 11:
	{
		{
			var $tmp = this.token.value;
			$s.pop();
			return $tmp;
		}
	}break;
	case 7:
	{
		{
			$s.pop();
			return true;
		}
	}break;
	case 8:
	{
		{
			$s.pop();
			return false;
		}
	}break;
	case 9:
	{
		{
			$s.pop();
			return null;
		}
	}break;
	case 12:
	{
		if(!this.strict) {
			var $tmp = this.token.value;
			$s.pop();
			return $tmp;
		}
		else this.tokenizer.parseError("Unexpected " + this.token.value);
	}break;
	default:{
		this.tokenizer.parseError("Unexpected " + this.token.value);
	}break;
	}
	{
		$s.pop();
		return null;
	}
	$s.pop();
}
hxjson2.JSONDecoder.prototype.strict = null;
hxjson2.JSONDecoder.prototype.token = null;
hxjson2.JSONDecoder.prototype.tokenizer = null;
hxjson2.JSONDecoder.prototype.value = null;
hxjson2.JSONDecoder.prototype.__class__ = hxjson2.JSONDecoder;
Hash = function(p) { if( p === $_ ) return; {
	$s.push("Hash::new");
	var $spos = $s.length;
	this.h = {}
	if(this.h.__proto__ != null) {
		this.h.__proto__ = null;
		delete(this.h.__proto__);
	}
	else null;
	$s.pop();
}}
Hash.__name__ = ["Hash"];
Hash.prototype.exists = function(key) {
	$s.push("Hash::exists");
	var $spos = $s.length;
	try {
		key = "$" + key;
		{
			var $tmp = this.hasOwnProperty.call(this.h,key);
			$s.pop();
			return $tmp;
		}
	}
	catch( $e23 ) {
		{
			var e = $e23;
			{
				$e = [];
				while($s.length >= $spos) $e.unshift($s.pop());
				$s.push($e[0]);
				
				for(var i in this.h)
					if( i == key ) return true;
			;
				{
					$s.pop();
					return false;
				}
			}
		}
	}
	$s.pop();
}
Hash.prototype.get = function(key) {
	$s.push("Hash::get");
	var $spos = $s.length;
	{
		var $tmp = this.h["$" + key];
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
Hash.prototype.h = null;
Hash.prototype.iterator = function() {
	$s.push("Hash::iterator");
	var $spos = $s.length;
	{
		var $tmp = { ref : this.h, it : this.keys(), hasNext : function() {
			$s.push("Hash::iterator@200");
			var $spos = $s.length;
			{
				var $tmp = this.it.hasNext();
				$s.pop();
				return $tmp;
			}
			$s.pop();
		}, next : function() {
			$s.push("Hash::iterator@201");
			var $spos = $s.length;
			var i = this.it.next();
			{
				var $tmp = this.ref["$" + i];
				$s.pop();
				return $tmp;
			}
			$s.pop();
		}}
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
Hash.prototype.keys = function() {
	$s.push("Hash::keys");
	var $spos = $s.length;
	var a = new Array();
	
			for(var i in this.h)
				a.push(i.substr(1));
		;
	{
		var $tmp = a.iterator();
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
Hash.prototype.remove = function(key) {
	$s.push("Hash::remove");
	var $spos = $s.length;
	if(!this.exists(key)) {
		$s.pop();
		return false;
	}
	delete(this.h["$" + key]);
	{
		$s.pop();
		return true;
	}
	$s.pop();
}
Hash.prototype.set = function(key,value) {
	$s.push("Hash::set");
	var $spos = $s.length;
	this.h["$" + key] = value;
	$s.pop();
}
Hash.prototype.toString = function() {
	$s.push("Hash::toString");
	var $spos = $s.length;
	var s = new StringBuf();
	s.b[s.b.length] = "{";
	var it = this.keys();
	{ var $it24 = it;
	while( $it24.hasNext() ) { var i = $it24.next();
	{
		s.b[s.b.length] = i;
		s.b[s.b.length] = " => ";
		s.b[s.b.length] = Std.string(this.get(i));
		if(it.hasNext()) s.b[s.b.length] = ", ";
	}
	}}
	s.b[s.b.length] = "}";
	{
		var $tmp = s.b.join("");
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
Hash.prototype.__class__ = Hash;
hxjson2.JSON = function() { }
hxjson2.JSON.__name__ = ["hxjson2","JSON"];
hxjson2.JSON.encode = function(o) {
	$s.push("hxjson2.JSON::encode");
	var $spos = $s.length;
	{
		var $tmp = new hxjson2.JSONEncoder(o).getString();
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
hxjson2.JSON.decode = function(s,strict) {
	$s.push("hxjson2.JSON::decode");
	var $spos = $s.length;
	if(strict == null) strict = true;
	{
		var $tmp = new hxjson2.JSONDecoder(s,strict).getValue();
		$s.pop();
		return $tmp;
	}
	$s.pop();
}
hxjson2.JSON.prototype.__class__ = hxjson2.JSON;
Main = function() { }
Main.__name__ = ["Main"];
Main.main = function() {
	$s.push("Main::main");
	var $spos = $s.length;
	js.Lib.window.onload = function(e) {
		$s.push("Main::main@18");
		var $spos = $s.length;
		twitterface.Twitterface.getInstance();
		$s.pop();
	}
	$s.pop();
}
Main.prototype.__class__ = Main;
twitterface.controllers = {}
twitterface.controllers.UserUpdatesRequest = function(url) { if( url === $_ ) return; {
	$s.push("twitterface.controllers.UserUpdatesRequest::new");
	var $spos = $s.length;
	haxe.Http.apply(this,[url]);
	$s.pop();
}}
twitterface.controllers.UserUpdatesRequest.__name__ = ["twitterface","controllers","UserUpdatesRequest"];
twitterface.controllers.UserUpdatesRequest.__super__ = haxe.Http;
for(var k in haxe.Http.prototype ) twitterface.controllers.UserUpdatesRequest.prototype[k] = haxe.Http.prototype[k];
twitterface.controllers.UserUpdatesRequest.prototype.__class__ = twitterface.controllers.UserUpdatesRequest;
$Main = function() { }
$Main.__name__ = ["@Main"];
$Main.prototype.__class__ = $Main;
$_ = {}
js.Boot.__res = {}
$s = [];
$e = [];
js.Boot.__init();
{
	Date.now = function() {
		$s.push("@Main::new@119");
		var $spos = $s.length;
		{
			var $tmp = new Date();
			$s.pop();
			return $tmp;
		}
		$s.pop();
	}
	Date.fromTime = function(t) {
		$s.push("@Main::new@122");
		var $spos = $s.length;
		var d = new Date();
		d["setTime"](t);
		{
			$s.pop();
			return d;
		}
		$s.pop();
	}
	Date.fromString = function(s) {
		$s.push("@Main::new@131");
		var $spos = $s.length;
		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]);
			{
				$s.pop();
				return d;
			}
		}break;
		case 10:{
			var k = s.split("-");
			{
				var $tmp = new Date(k[0],k[1] - 1,k[2],0,0,0);
				$s.pop();
				return $tmp;
			}
		}break;
		case 19:{
			var k = s.split(" ");
			var y = k[0].split("-");
			var t = k[1].split(":");
			{
				var $tmp = new Date(y[0],y[1] - 1,y[2],t[0],t[1],t[2]);
				$s.pop();
				return $tmp;
			}
		}break;
		default:{
			throw "Invalid date format : " + s;
		}break;
		}
		$s.pop();
	}
	Date.prototype["toString"] = function() {
		$s.push("@Main::new@160");
		var $spos = $s.length;
		var date = this;
		var m = date.getMonth() + 1;
		var d = date.getDate();
		var h = date.getHours();
		var mi = date.getMinutes();
		var s = date.getSeconds();
		{
			var $tmp = 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));
			$s.pop();
			return $tmp;
		}
		$s.pop();
	}
	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) {
		$s.push("@Main::new@73");
		var $spos = $s.length;
		{
			var $tmp = isFinite(i);
			$s.pop();
			return $tmp;
		}
		$s.pop();
	}
	Math.isNaN = function(i) {
		$s.push("@Main::new@85");
		var $spos = $s.length;
		{
			var $tmp = isNaN(i);
			$s.pop();
			return $tmp;
		}
		$s.pop();
	}
	Math.__name__ = ["Math"];
}
{
	js.Lib.document = document;
	js.Lib.window = window;
	onerror = function(msg,url,line) {
		var stack = $s.copy();
		var f = js.Lib.onerror;
		$s.splice(0,$s.length);
		if( f == null ) {
			var i = stack.length;
			var s = "";
			while( --i >= 0 )
				s += "Called from "+stack[i]+"\n";
			alert(msg+"\n\n"+s);
			return false;
		}
		return f(msg,stack);
	}
}
{
	js["XMLHttpRequest"] = (window.XMLHttpRequest?XMLHttpRequest:(window.ActiveXObject?function() {
		$s.push("@Main::new@53");
		var $spos = $s.length;
		try {
			{
				var $tmp = new ActiveXObject("Msxml2.XMLHTTP");
				$s.pop();
				return $tmp;
			}
		}
		catch( $e25 ) {
			{
				var e = $e25;
				{
					$e = [];
					while($s.length >= $spos) $e.unshift($s.pop());
					$s.push($e[0]);
					try {
						{
							var $tmp = new ActiveXObject("Microsoft.XMLHTTP");
							$s.pop();
							return $tmp;
						}
					}
					catch( $e26 ) {
						{
							var e1 = $e26;
							{
								$e = [];
								while($s.length >= $spos) $e.unshift($s.pop());
								$s.push($e[0]);
								throw "Unable to create XMLHttpRequest object.";
							}
						}
					}
				}
			}
		}
		$s.pop();
	}:function($this) {
		var $r;
		throw "Unable to create XMLHttpRequest object.";
		return $r;
	}(this)));
}
twitterface.views.InlineListView.HTML_CLASSNAME = "twitter_inline_listview";
twitterface.views.InlineListView.HTML_TITLE_CLASSNAME = "twitter_inline_listview_title";
twitterface.views.InlineListView.HTML_LIST_CLASSNAME = "twitter_inline_listview_list";
twitterface.models.TwitterEntry.HTML_CLASSNAME = "twitter_entry";
twitterface.models.TwitterEntry.DATE_HTML_CLASSNAME = "twitter_entry_date";
twitterface.models.TwitterEntry.CONTENT_HTML_CLASSNAME = "twitter_entry_content";
twitterface.models.TwitterEntry.MONTHS = ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];
twitterface.models.TwitterEntry.DATE_REG = new EReg("^[a-zA-Z]{3} ([a-zA-Z]{3}) ([0-9]{0,2}) ([0-9]{2}):([0-9]{2}):([0-9]{2}) \\+[0-9]{4} ([0-9]{4})$","");
twitterface.models.TwitterUser.TWITTER_URL = "http://twitter.com/";
js.Lib.onerror = null;
DateTools.DAYS_OF_MONTH = [31,28,31,30,31,30,31,31,30,31,30,31];
Main.INSTANCE = null;
$Main.init = Main.main();