text: (function () { "use strict";
  var HxOverrides = function() { };
  HxOverrides.__name__ = true;
  HxOverrides.cca = function(s,index) {
  	var x = s.charCodeAt(index);
  	if(x != x) return undefined;
  	return x;
  };
  HxOverrides.substr = function(s,pos,len) {
  	if(pos != null && pos != 0 && len != null && len < 0) return "";
  	if(len == null) len = s.length;
  	if(pos < 0) {
  		pos = s.length + pos;
  		if(pos < 0) pos = 0;
  	} else if(len < 0) len = s.length + len - pos;
  	return s.substr(pos,len);
  };
  var Main = function() { };
  Main.__name__ = true;
  Main.main = function() {
  	var max_size = 5000;
  	var data_str = "";
  	var data_buf = new Uint8Array(max_size);
  	var data_f32 = new Float32Array(max_size);
  	var _g = 0;
  	while(_g < max_size) {
  		var i = _g++;
  		var v = Std["int"](Math.random() * 10);
  		data_str += Std.string(v) + "";
  		data_buf[i] = v;
  		data_f32[i] = Math.random();
  	}
  	var is_base64 = true;
  	var d = new Uint8Array(data_f32.buffer);
  	console.log("Input> " + Std.string(d.length) + " bytes");
  	if(!is_base64) js.lzma.LZMA.Compress(d,2,function(cr) {
  		console.log("Output> " + cr.length + " bytes");
  		js.lzma.LZMA.Decompress(cr,function(res) {
  			var is_eq = true;
  			var _g1 = 0;
  			var _g2 = d.length;
  			while(_g1 < _g2) {
  				var i1 = _g1++;
  				if(res[i1] != d[i1]) is_eq = false;
  			}
  			console.log(is_eq);
  		});
  	}); else js.lzma.LZMA.Compress64(d,2,function(cr1) {
  		console.log("Output> " + cr1.length + " bytes");
  		console.log(cr1);
  		js.lzma.LZMA.Decompress64(cr1,function(res1) {
  			var is_eq1 = true;
  			var _g11 = 0;
  			var _g3 = d.length;
  			while(_g11 < _g3) {
  				var i2 = _g11++;
  				if(res1[i2] != d[i2]) is_eq1 = false;
  			}
  			var f32 = new Float32Array(res1.buffer);
  			console.log(is_eq1);
  		});
  	});
  };
  Math.__name__ = true;
  var Std = function() { };
  Std.__name__ = true;
  Std.string = function(s) {
  	return js.Boot.__string_rec(s,"");
  };
  Std["int"] = function(x) {
  	return x | 0;
  };
  var StringTools = function() { };
  StringTools.__name__ = true;
  StringTools.fastCodeAt = function(s,index) {
  	return s.charCodeAt(index);
  };
  var haxe = {};
  haxe.io = {};
  haxe.io.Bytes = function(length,b) {
  	this.length = length;
  	this.b = b;
  };
  haxe.io.Bytes.__name__ = true;
  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 i = 0;
  	while(i < s.length) {
  		var c = StringTools.fastCodeAt(s,i++);
  		if(55296 <= c && c <= 56319) c = c - 55232 << 10 | StringTools.fastCodeAt(s,i++) & 1023;
  		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.prototype = {
  	get: function(pos) {
  		return this.b[pos];
  	}
  	,set: function(pos,v) {
  		this.b[pos] = v & 255;
  	}
  	,getString: 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 = 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 c21 = b[i++];
  				var c3 = b[i++];
  				var u = (c & 15) << 18 | (c21 & 127) << 12 | (c3 & 127) << 6 | b[i++] & 127;
  				s += fcc((u >> 10) + 55232);
  				s += fcc(u & 1023 | 56320);
  			}
  		}
  		return s;
  	}
  	,toString: function() {
  		return this.getString(0,this.length);
  	}
  	,__class__: haxe.io.Bytes
  };
  haxe.crypto = {};
  haxe.crypto.Base64 = function() { };
  haxe.crypto.Base64.__name__ = true;
  haxe.crypto.Base64.encode = function(bytes,complement) {
  	if(complement == null) complement = true;
  	var str = new haxe.crypto.BaseCode(haxe.crypto.Base64.BYTES).encodeBytes(bytes).toString();
  	if(complement) {
  		var _g1 = 0;
  		var _g = (3 - bytes.length * 4 % 3) % 3;
  		while(_g1 < _g) {
  			var i = _g1++;
  			str += "=";
  		}
  	}
  	return str;
  };
  haxe.crypto.Base64.decode = function(str,complement) {
  	if(complement == null) complement = true;
  	if(complement) while(HxOverrides.cca(str,str.length - 1) == 61) str = HxOverrides.substr(str,0,-1);
  	return new haxe.crypto.BaseCode(haxe.crypto.Base64.BYTES).decodeBytes(haxe.io.Bytes.ofString(str));
  };
  haxe.crypto.BaseCode = function(base) {
  	var len = base.length;
  	var nbits = 1;
  	while(len > 1 << nbits) nbits++;
  	if(nbits > 8 || len != 1 << nbits) throw "BaseCode : base length must be a power of two.";
  	this.base = base;
  	this.nbits = nbits;
  };
  haxe.crypto.BaseCode.__name__ = true;
  haxe.crypto.BaseCode.prototype = {
  	encodeBytes: function(b) {
  		var nbits = this.nbits;
  		var base = this.base;
  		var size = b.length * 8 / nbits | 0;
  		var out = haxe.io.Bytes.alloc(size + (b.length * 8 % nbits == 0?0:1));
  		var buf = 0;
  		var curbits = 0;
  		var mask = (1 << nbits) - 1;
  		var pin = 0;
  		var pout = 0;
  		while(pout < size) {
  			while(curbits < nbits) {
  				curbits += 8;
  				buf <<= 8;
  				buf |= b.get(pin++);
  			}
  			curbits -= nbits;
  			out.set(pout++,base.b[buf >> curbits & mask]);
  		}
  		if(curbits > 0) out.set(pout++,base.b[buf << nbits - curbits & mask]);
  		return out;
  	}
  	,initTable: function() {
  		var tbl = new Array();
  		var _g = 0;
  		while(_g < 256) {
  			var i = _g++;
  			tbl[i] = -1;
  		}
  		var _g1 = 0;
  		var _g2 = this.base.length;
  		while(_g1 < _g2) {
  			var i1 = _g1++;
  			tbl[this.base.b[i1]] = i1;
  		}
  		this.tbl = tbl;
  	}
  	,decodeBytes: function(b) {
  		var nbits = this.nbits;
  		var base = this.base;
  		if(this.tbl == null) this.initTable();
  		var tbl = this.tbl;
  		var size = b.length * nbits >> 3;
  		var out = haxe.io.Bytes.alloc(size);
  		var buf = 0;
  		var curbits = 0;
  		var pin = 0;
  		var pout = 0;
  		while(pout < size) {
  			while(curbits < 8) {
  				curbits += nbits;
  				buf <<= nbits;
  				var i = tbl[b.get(pin++)];
  				if(i == -1) throw "BaseCode : invalid encoded char";
  				buf |= i;
  			}
  			curbits -= 8;
  			out.set(pout++,buf >> curbits & 255);
  		}
  		return out;
  	}
  	,__class__: haxe.crypto.BaseCode
  };
  haxe.io.Eof = function() { };
  haxe.io.Eof.__name__ = true;
  haxe.io.Eof.prototype = {
  	toString: function() {
  		return "Eof";
  	}
  	,__class__: haxe.io.Eof
  };
  haxe.io.Error = { __ename__ : true, __constructs__ : ["Blocked","Overflow","OutsideBounds","Custom"] };
  haxe.io.Error.Blocked = ["Blocked",0];
  haxe.io.Error.Blocked.__enum__ = haxe.io.Error;
  haxe.io.Error.Overflow = ["Overflow",1];
  haxe.io.Error.Overflow.__enum__ = haxe.io.Error;
  haxe.io.Error.OutsideBounds = ["OutsideBounds",2];
  haxe.io.Error.OutsideBounds.__enum__ = haxe.io.Error;
  haxe.io.Error.Custom = function(e) { var $x = ["Custom",3,e]; $x.__enum__ = haxe.io.Error; return $x; };
  var js = {};
  js.Boot = function() { };
  js.Boot.__name__ = true;
  js.Boot.getClass = function(o) {
  	if((o instanceof Array) && o.__enum__ == null) return Array; else return o.__class__;
  };
  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__ || o.__ename__)) t = "object";
  	switch(t) {
  	case "object":
  		if(o instanceof Array) {
  			if(o.__enum__) {
  				if(o.length == 2) return o[0];
  				var str = o[0] + "(";
  				s += "\t";
  				var _g1 = 2;
  				var _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 i1;
  			var str1 = "[";
  			s += "\t";
  			var _g2 = 0;
  			while(_g2 < l) {
  				var i2 = _g2++;
  				str1 += (i2 > 0?",":"") + js.Boot.__string_rec(o[i2],s);
  			}
  			str1 += "]";
  			return str1;
  		}
  		var tostr;
  		try {
  			tostr = o.toString;
  		} catch( e ) {
  			return "???";
  		}
  		if(tostr != null && tostr != Object.toString) {
  			var s2 = o.toString();
  			if(s2 != "[object Object]") return s2;
  		}
  		var k = null;
  		var str2 = "{\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__" || k == "__properties__") {
  			continue;
  		}
  		if(str2.length != 2) str2 += ", \n";
  		str2 += s + k + " : " + js.Boot.__string_rec(o[k],s);
  		}
  		s = s.substring(1);
  		str2 += "\n" + s + "}";
  		return str2;
  	case "function":
  		return "<function>";
  	case "string":
  		return o;
  	default:
  		return String(o);
  	}
  };
  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;
  		var _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) {
  	if(cl == null) return false;
  	switch(cl) {
  	case Int:
  		return (o|0) === o;
  	case Float:
  		return typeof(o) == "number";
  	case Bool:
  		return typeof(o) == "boolean";
  	case String:
  		return typeof(o) == "string";
  	case Array:
  		return (o instanceof Array) && o.__enum__ == null;
  	case Dynamic:
  		return true;
  	default:
  		if(o != null) {
  			if(typeof(cl) == "function") {
  				if(o instanceof cl) return true;
  				if(js.Boot.__interfLoop(js.Boot.getClass(o),cl)) return true;
  			}
  		} else return false;
  		if(cl == Class && o.__name__ != null) return true;
  		if(cl == Enum && o.__ename__ != null) return true;
  		return o.__enum__ == cl;
  	}
  };
  js.lzma = {};
  js.lzma.LZMA = function() { };
  js.lzma.LZMA.__name__ = true;
  js.lzma.LZMA.get_m_instance = function() {
  	if(js.lzma.LZMA.m_instance != null) return js.lzma.LZMA.m_instance;
  	try {
  		js.lzma.LZMA.m_instance = require('./lzma.js').LZMA();
  		if(js.lzma.LZMA.m_instance != null) return js.lzma.LZMA.m_instance;
  	} catch( e ) {
  		if( js.Boot.__instanceof(e,Error) ) {
  			js.lzma.LZMA.m_instance = LZMA;
  		} else throw(e);
  	}
  	return js.lzma.LZMA.m_instance;
  };
  js.lzma.LZMA.Compress = function(p_data,p_mode,p_on_finish,p_on_progress) {
  	var opc = p_on_progress;
  	if(opc == null) opc = function(r) {
  	};
  	js.lzma.LZMA.get_m_instance().compress(p_data,p_mode,p_on_finish,opc);
  };
  js.lzma.LZMA.Compress64 = function(p_data,p_mode,p_on_finish,p_on_progress) {
  	js.lzma.LZMA.Compress(p_data,p_mode,function(p_result) {
  		var buf = haxe.io.Bytes.alloc(p_result.length);
  		var _g1 = 0;
  		var _g = buf.length;
  		while(_g1 < _g) {
  			var i = _g1++;
  			buf.b[i] = p_result[i] & 255;
  		}
  		p_on_finish(haxe.crypto.Base64.encode(buf));
  	},p_on_progress);
  };
  js.lzma.LZMA.DecompressString = function(p_data,p_on_finish,p_on_progress) {
  	var opc = p_on_progress;
  	if(opc == null) opc = function(r) {
  	};
  	js.lzma.LZMA.get_m_instance().decompress(p_data,p_on_finish,opc);
  };
  js.lzma.LZMA.Decompress = function(p_data,p_on_finish,p_on_progress) {
  	js.lzma.LZMA.DecompressString(p_data,function(p_string) {
  		var buf = new Uint8Array(p_string.length);
  		var _g1 = 0;
  		var _g = buf.length;
  		while(_g1 < _g) {
  			var i = _g1++;
  			buf[i] = HxOverrides.cca(p_string,i);
  		}
  		p_on_finish(buf);
  	},p_on_progress);
  };
  js.lzma.LZMA.Decompress64 = function(p_data,p_on_finish,p_on_progress) {
  	var buf = haxe.crypto.Base64.decode(p_data);
  	var buf8 = new Uint8Array(buf.length);
  	var _g1 = 0;
  	var _g = buf8.length;
  	while(_g1 < _g) {
  		var i = _g1++;
  		buf8[i] = buf.b[i];
  	}
  	js.lzma.LZMA.Decompress(buf8,p_on_finish,p_on_progress);
  };
  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(i1) {
  	return isNaN(i1);
  };
  String.prototype.__class__ = String;
  String.__name__ = true;
  Array.__name__ = true;
  var Int = { __name__ : ["Int"]};
  var Dynamic = { __name__ : ["Dynamic"]};
  var Float = Number;
  Float.__name__ = ["Float"];
  var Bool = Boolean;
  Bool.__ename__ = ["Bool"];
  var Class = { __name__ : ["Class"]};
  var Enum = { };
  haxe.crypto.Base64.CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  haxe.crypto.Base64.BYTES = haxe.io.Bytes.ofString(haxe.crypto.Base64.CHARS);
  Main.main();
  })();
  