-- Generated by Haxe 4.0.5
local _hx_array_mt = {
	__newindex = function(t,k,v)
	  local len = t.length
	  t.length =  k >= len and (k + 1) or len
	  rawset(t,k,v)
	end
  }
  
  local function _hx_tab_array(tab,length)
	tab.length = length
	return setmetatable(tab, _hx_array_mt)
  end
  
  local function _hx_anon_newindex(t,k,v) t.__fields__[k] = true; rawset(t,k,v); end
  local _hx_anon_mt = {__newindex=_hx_anon_newindex}
  local function _hx_a(...)
	local __fields__ = {};
	local ret = {__fields__ = __fields__};
	local max = select('#',...);
	local tab = {...};
	local cur = 1;
	while cur < max do
	  local v = tab[cur];
	  __fields__[v] = true;
	  ret[v] = tab[cur+1];
	  cur = cur + 2
	end
	return setmetatable(ret, _hx_anon_mt)
  end
  
  local function _hx_e()
	return setmetatable({__fields__ = {}}, _hx_anon_mt)
  end
  
  local function _hx_o(obj)
	return setmetatable(obj, _hx_anon_mt)
  end
  
  local function _hx_new(prototype)
	return setmetatable({__fields__ = {}}, {__newindex=_hx_anon_newindex, __index=prototype})
  end
  
  local _hxClasses = {}
  local Int = _hx_e();
  local Dynamic = _hx_e();
  local Float = _hx_e();
  local Bool = _hx_e();
  local Class = _hx_e();
  local Enum = _hx_e();
  
  local Array = _hx_e()
  __lua_lib_luautf8_Utf8 = _G.require("lua-utf8")
  local Main = _hx_e()
  local Math = _hx_e()
  local String = _hx_e()
  local Std = _hx_e()
  __haxe_Log = _hx_e()
  __lua_Boot = _hx_e()
  
  local _hx_bind, _hx_bit, _hx_staticToInstance, _hx_funcToField, _hx_maxn, _hx_print, _hx_apply_self, _hx_box_mr, _hx_bit_clamp, _hx_table, _hx_bit_raw
  local _hx_pcall_default = {};
  local _hx_pcall_break = {};
  
  Array.new = function() 
	local self = _hx_new(Array.prototype)
	Array.super(self)
	return self
  end
  Array.super = function(self) 
	_hx_tab_array(self, 0);
  end
  Array.prototype = _hx_a();
  Array.prototype.concat = function(self,a) 
	local _g = _hx_tab_array({}, 0);
	local _g1 = 0;
	local _g2 = self;
	while (_g1 < _g2.length) do 
	  local i = _g2[_g1];
	  _g1 = _g1 + 1;
	  _g:push(i);
	end;
	local ret = _g;
	local _g3 = 0;
	while (_g3 < a.length) do 
	  local i1 = a[_g3];
	  _g3 = _g3 + 1;
	  ret:push(i1);
	end;
	do return ret end
  end
  Array.prototype.join = function(self,sep) 
	local tbl = ({});
	local _gthis = self;
	local cur_length = 0;
	local i = _hx_o({__fields__={hasNext=true,next=true},hasNext=function(self) 
	  do return cur_length < _gthis.length end;
	end,next=function(self) 
	  cur_length = cur_length + 1;
	  do return _gthis[cur_length - 1] end;
	end});
	while (i:hasNext()) do 
	  local i1 = i:next();
	  _G.table.insert(tbl, Std.string(i1));
	end;
	do return _G.table.concat(tbl, sep) end
  end
  Array.prototype.pop = function(self) 
	if (self.length == 0) then 
	  do return nil end;
	end;
	local ret = self[self.length - 1];
	self[self.length - 1] = nil;
	self.length = self.length - 1;
	do return ret end
  end
  Array.prototype.push = function(self,x) 
	self[self.length] = x;
	do return self.length end
  end
  Array.prototype.reverse = function(self) 
	local tmp;
	local i = 0;
	while (i < Std.int(self.length / 2)) do 
	  tmp = self[i];
	  self[i] = self[(self.length - i) - 1];
	  self[(self.length - i) - 1] = tmp;
	  i = i + 1;
	end;
  end
  Array.prototype.shift = function(self) 
	if (self.length == 0) then 
	  do return nil end;
	end;
	local ret = self[0];
	if (self.length == 1) then 
	  self[0] = nil;
	else
	  if (self.length > 1) then 
		self[0] = self[1];
		_G.table.remove(self, 1);
	  end;
	end;
	local tmp = self;
	tmp.length = tmp.length - 1;
	do return ret end
  end
  Array.prototype.slice = function(self,pos,_end) 
	if ((_end == nil) or (_end > self.length)) then 
	  _end = self.length;
	else
	  if (_end < 0) then 
		_end = _G.math.fmod((self.length - (_G.math.fmod(-_end, self.length))), self.length);
	  end;
	end;
	if (pos < 0) then 
	  pos = _G.math.fmod((self.length - (_G.math.fmod(-pos, self.length))), self.length);
	end;
	if ((pos > _end) or (pos > self.length)) then 
	  do return _hx_tab_array({}, 0) end;
	end;
	local ret = _hx_tab_array({}, 0);
	local _g = pos;
	local _g1 = _end;
	while (_g < _g1) do 
	  _g = _g + 1;
	  local i = _g - 1;
	  ret:push(self[i]);
	end;
	do return ret end
  end
  Array.prototype.sort = function(self,f) 
	local i = 0;
	local l = self.length;
	while (i < l) do 
	  local swap = false;
	  local j = 0;
	  local max = (l - i) - 1;
	  while (j < max) do 
		if (f(self[j], self[j + 1]) > 0) then 
		  local tmp = self[j + 1];
		  self[j + 1] = self[j];
		  self[j] = tmp;
		  swap = true;
		end;
		j = j + 1;
	  end;
	  if (not swap) then 
		break;
	  end;
	  i = i + 1;
	end;
  end
  Array.prototype.splice = function(self,pos,len) 
	if ((len < 0) or (pos > self.length)) then 
	  do return _hx_tab_array({}, 0) end;
	else
	  if (pos < 0) then 
		pos = self.length - (_G.math.fmod(-pos, self.length));
	  end;
	end;
	len = Math.min(len, self.length - pos);
	local ret = _hx_tab_array({}, 0);
	local _g = pos;
	local _g1 = pos + len;
	while (_g < _g1) do 
	  _g = _g + 1;
	  local i = _g - 1;
	  ret:push(self[i]);
	  self[i] = self[i + len];
	end;
	local _g2 = pos + len;
	local _g3 = self.length;
	while (_g2 < _g3) do 
	  _g2 = _g2 + 1;
	  local i1 = _g2 - 1;
	  self[i1] = self[i1 + len];
	end;
	local tmp = self;
	tmp.length = tmp.length - len;
	do return ret end
  end
  Array.prototype.toString = function(self) 
	local tbl = ({});
	_G.table.insert(tbl, "[");
	_G.table.insert(tbl, self:join(","));
	_G.table.insert(tbl, "]");
	do return _G.table.concat(tbl, "") end
  end
  Array.prototype.unshift = function(self,x) 
	local len = self.length;
	local _g = 0;
	local _g1 = len;
	while (_g < _g1) do 
	  _g = _g + 1;
	  local i = _g - 1;
	  self[len - i] = self[(len - i) - 1];
	end;
	self[0] = x;
  end
  Array.prototype.insert = function(self,pos,x) 
	if (pos > self.length) then 
	  pos = self.length;
	end;
	if (pos < 0) then 
	  pos = self.length + pos;
	  if (pos < 0) then 
		pos = 0;
	  end;
	end;
	local cur_len = self.length;
	while (cur_len > pos) do 
	  self[cur_len] = self[cur_len - 1];
	  cur_len = cur_len - 1;
	end;
	self[pos] = x;
  end
  Array.prototype.remove = function(self,x) 
	local _g = 0;
	local _g1 = self.length;
	while (_g < _g1) do 
	  _g = _g + 1;
	  local i = _g - 1;
	  if (self[i] == x) then 
		local _g2 = i;
		local _g11 = self.length - 1;
		while (_g2 < _g11) do 
		  _g2 = _g2 + 1;
		  local j = _g2 - 1;
		  self[j] = self[j + 1];
		end;
		self[self.length - 1] = nil;
		self.length = self.length - 1;
		do return true end;
	  end;
	end;
	do return false end
  end
  Array.prototype.indexOf = function(self,x,fromIndex) 
	local _end = self.length;
	if (fromIndex == nil) then 
	  fromIndex = 0;
	else
	  if (fromIndex < 0) then 
		fromIndex = self.length + fromIndex;
		if (fromIndex < 0) then 
		  fromIndex = 0;
		end;
	  end;
	end;
	local _g = fromIndex;
	local _g1 = _end;
	while (_g < _g1) do 
	  _g = _g + 1;
	  local i = _g - 1;
	  if (x == self[i]) then 
		do return i end;
	  end;
	end;
	do return -1 end
  end
  Array.prototype.lastIndexOf = function(self,x,fromIndex) 
	if ((fromIndex == nil) or (fromIndex >= self.length)) then 
	  fromIndex = self.length - 1;
	else
	  if (fromIndex < 0) then 
		fromIndex = self.length + fromIndex;
		if (fromIndex < 0) then 
		  do return -1 end;
		end;
	  end;
	end;
	local i = fromIndex;
	while (i >= 0) do 
	  if (self[i] == x) then 
		do return i end;
	  else
		i = i - 1;
	  end;
	end;
	do return -1 end
  end
  Array.prototype.copy = function(self) 
	local _g = _hx_tab_array({}, 0);
	local _g1 = 0;
	local _g2 = self;
	while (_g1 < _g2.length) do 
	  local i = _g2[_g1];
	  _g1 = _g1 + 1;
	  _g:push(i);
	end;
	do return _g end
  end
  Array.prototype.map = function(self,f) 
	local _g = _hx_tab_array({}, 0);
	local _g1 = 0;
	local _g2 = self;
	while (_g1 < _g2.length) do 
	  local i = _g2[_g1];
	  _g1 = _g1 + 1;
	  _g:push(f(i));
	end;
	do return _g end
  end
  Array.prototype.filter = function(self,f) 
	local _g = _hx_tab_array({}, 0);
	local _g1 = 0;
	local _g2 = self;
	while (_g1 < _g2.length) do 
	  local i = _g2[_g1];
	  _g1 = _g1 + 1;
	  if (f(i)) then 
		_g:push(i);
	  end;
	end;
	do return _g end
  end
  Array.prototype.iterator = function(self) 
	local _gthis = self;
	local cur_length = 0;
	do return _hx_o({__fields__={hasNext=true,next=true},hasNext=function(self) 
	  do return cur_length < _gthis.length end;
	end,next=function(self) 
	  cur_length = cur_length + 1;
	  do return _gthis[cur_length - 1] end;
	end}) end
  end
  Array.prototype.resize = function(self,len) 
	if (self.length < len) then 
	  self.length = len;
	else
	  if (self.length > len) then 
		local _g = len;
		local _g1 = self.length;
		while (_g < _g1) do 
		  _g = _g + 1;
		  local i = _g - 1;
		  self[i] = nil;
		end;
		self.length = len;
	  end;
	end;
  end
  
  Main.new = {}
  Main.main = function() 
	__haxe_Log.trace("Hello World", _hx_o({__fields__={fileName=true,lineNumber=true,className=true,methodName=true},fileName="source/Main.hx",lineNumber=3,className="Main",methodName="main"}));
  end
  
  Math.new = {}
  Math.isNaN = function(f) 
	do return f ~= f end;
  end
  Math.isFinite = function(f) 
	if (f > -_G.math.huge) then 
	  do return f < _G.math.huge end;
	else
	  do return false end;
	end;
  end
  Math.min = function(a,b) 
	if (Math.isNaN(a) or Math.isNaN(b)) then 
	  do return (0/0) end;
	else
	  do return _G.math.min(a, b) end;
	end;
  end
  
  String.new = function(string) 
	local self = _hx_new(String.prototype)
	String.super(self,string)
	self = string
	return self
  end
  String.super = function(self,string) 
  end
  String.__index = function(s,k) 
	if (k == "length") then 
	  do return __lua_lib_luautf8_Utf8.len(s) end;
	else
	  local o = String.prototype;
	  local field = k;
	  if ((function() 
		local _hx_1
		if ((_G.type(o) == "string") and ((String.prototype[field] ~= nil) or (field == "length"))) then 
		_hx_1 = true; elseif (o.__fields__ ~= nil) then 
		_hx_1 = o.__fields__[field] ~= nil; else 
		_hx_1 = o[field] ~= nil; end
		return _hx_1
	  end )()) then 
		do return String.prototype[k] end;
	  else
		if (String.__oldindex ~= nil) then 
		  if (_G.type(String.__oldindex) == "function") then 
			do return String.__oldindex(s, k) end;
		  else
			if (_G.type(String.__oldindex) == "table") then 
			  do return String.__oldindex[k] end;
			end;
		  end;
		  do return nil end;
		else
		  do return nil end;
		end;
	  end;
	end;
  end
  String.fromCharCode = function(code) 
	do return __lua_lib_luautf8_Utf8.char(code) end;
  end
  String.prototype = _hx_a();
  String.prototype.toUpperCase = function(self) 
	do return __lua_lib_luautf8_Utf8.upper(self) end
  end
  String.prototype.toLowerCase = function(self) 
	do return __lua_lib_luautf8_Utf8.lower(self) end
  end
  String.prototype.indexOf = function(self,str,startIndex) 
	if (startIndex == nil) then 
	  startIndex = 1;
	else
	  startIndex = startIndex + 1;
	end;
	local r = __lua_lib_luautf8_Utf8.find(self, str, startIndex, true);
	if ((r ~= nil) and (r > 0)) then 
	  do return r - 1 end;
	else
	  do return -1 end;
	end;
  end
  String.prototype.lastIndexOf = function(self,str,startIndex) 
	local i = 0;
	local ret = -1;
	if (startIndex == nil) then 
	  startIndex = __lua_lib_luautf8_Utf8.len(self);
	end;
	while (true) do 
	  local startIndex1 = ret + 1;
	  if (startIndex1 == nil) then 
		startIndex1 = 1;
	  else
		startIndex1 = startIndex1 + 1;
	  end;
	  local r = __lua_lib_luautf8_Utf8.find(self, str, startIndex1, true);
	  local p = (function() 
		local _hx_1
		if ((r ~= nil) and (r > 0)) then 
		_hx_1 = r - 1; else 
		_hx_1 = -1; end
		return _hx_1
	  end )();
	  if ((p == -1) or (p > startIndex)) then 
		break;
	  end;
	  ret = p;
	end;
	do return ret end
  end
  String.prototype.split = function(self,delimiter) 
	local idx = 1;
	local ret = _hx_tab_array({}, 0);
	local delim_offset = (function() 
	  local _hx_1
	  if (__lua_lib_luautf8_Utf8.len(delimiter) > 0) then 
	  _hx_1 = __lua_lib_luautf8_Utf8.len(delimiter); else 
	  _hx_1 = 1; end
	  return _hx_1
	end )();
	while (idx ~= nil) do 
	  local newidx = 0;
	  if (__lua_lib_luautf8_Utf8.len(delimiter) > 0) then 
		newidx = __lua_lib_luautf8_Utf8.find(self, delimiter, idx, true);
	  else
		if (idx >= __lua_lib_luautf8_Utf8.len(self)) then 
		  newidx = nil;
		else
		  newidx = idx + 1;
		end;
	  end;
	  if (newidx ~= nil) then 
		local match = __lua_lib_luautf8_Utf8.sub(self, idx, newidx - 1);
		ret:push(match);
		idx = newidx + __lua_lib_luautf8_Utf8.len(delimiter);
	  else
		ret:push(__lua_lib_luautf8_Utf8.sub(self, idx, __lua_lib_luautf8_Utf8.len(self)));
		idx = nil;
	  end;
	end;
	do return ret end
  end
  String.prototype.toString = function(self) 
	do return self end
  end
  String.prototype.substring = function(self,startIndex,endIndex) 
	if (endIndex == nil) then 
	  endIndex = __lua_lib_luautf8_Utf8.len(self);
	end;
	if (endIndex < 0) then 
	  endIndex = 0;
	end;
	if (startIndex < 0) then 
	  startIndex = 0;
	end;
	if (endIndex < startIndex) then 
	  do return __lua_lib_luautf8_Utf8.sub(self, endIndex + 1, startIndex) end;
	else
	  do return __lua_lib_luautf8_Utf8.sub(self, startIndex + 1, endIndex) end;
	end;
  end
  String.prototype.charAt = function(self,index) 
	do return __lua_lib_luautf8_Utf8.sub(self, index + 1, index + 1) end
  end
  String.prototype.charCodeAt = function(self,index) 
	do return __lua_lib_luautf8_Utf8.byte(self, index + 1) end
  end
  String.prototype.substr = function(self,pos,len) 
	if ((len == nil) or (len > (pos + __lua_lib_luautf8_Utf8.len(self)))) then 
	  len = __lua_lib_luautf8_Utf8.len(self);
	else
	  if (len < 0) then 
		len = __lua_lib_luautf8_Utf8.len(self) + len;
	  end;
	end;
	if (pos < 0) then 
	  pos = __lua_lib_luautf8_Utf8.len(self) + pos;
	end;
	if (pos < 0) then 
	  pos = 0;
	end;
	do return __lua_lib_luautf8_Utf8.sub(self, pos + 1, pos + len) end
  end
  
  Std.new = {}
  Std.string = function(s) 
	do return __lua_Boot.__string_rec(s) end;
  end
  Std.int = function(x) 
	if (not Math.isFinite(x) or Math.isNaN(x)) then 
	  do return 0 end;
	else
	  do return _hx_bit_clamp(x) end;
	end;
  end
  
  __haxe_Log.new = {}
  __haxe_Log.formatOutput = function(v,infos) 
	local str = Std.string(v);
	if (infos == nil) then 
	  do return str end;
	end;
	local pstr = Std.string(Std.string(infos.fileName) .. Std.string(":")) .. Std.string(infos.lineNumber);
	if (infos.customParams ~= nil) then 
	  local _g = 0;
	  local _g1 = infos.customParams;
	  while (_g < _g1.length) do 
		local v1 = _g1[_g];
		_g = _g + 1;
		str = Std.string(str) .. Std.string((Std.string(", ") .. Std.string(Std.string(v1))));
	  end;
	end;
	do return Std.string(Std.string(pstr) .. Std.string(": ")) .. Std.string(str) end;
  end
  __haxe_Log.trace = function(v,infos) 
	local str = __haxe_Log.formatOutput(v, infos);
	_hx_print(str);
  end
  
  __lua_Boot.new = {}
  __lua_Boot.isArray = function(o) 
	if (_G.type(o) == "table") then 
	  if ((o.__enum__ == nil) and (_G.getmetatable(o) ~= nil)) then 
		do return _G.getmetatable(o).__index == Array.prototype end;
	  else
		do return false end;
	  end;
	else
	  do return false end;
	end;
  end
  __lua_Boot.printEnum = function(o,s) 
	if (o.length == 2) then 
	  do return o[0] end;
	else
	  local str = Std.string(Std.string(o[0])) .. Std.string("(");
	  s = Std.string(s) .. Std.string("\t");
	  local _g = 2;
	  local _g1 = o.length;
	  while (_g < _g1) do 
		_g = _g + 1;
		local i = _g - 1;
		if (i ~= 2) then 
		  str = Std.string(str) .. Std.string((Std.string(",") .. Std.string(__lua_Boot.__string_rec(o[i], s))));
		else
		  str = Std.string(str) .. Std.string(__lua_Boot.__string_rec(o[i], s));
		end;
	  end;
	  do return Std.string(str) .. Std.string(")") end;
	end;
  end
  __lua_Boot.printClassRec = function(c,result,s) 
	if (result == nil) then 
	  result = "";
	end;
	local f = __lua_Boot.__string_rec;
	for k,v in pairs(c) do if result ~= '' then result = result .. ', ' end result = result .. k .. ':' .. f(v, s.. '	') end;
	do return result end;
  end
  __lua_Boot.__string_rec = function(o,s) 
	if (s == nil) then 
	  s = "";
	end;
	if (__lua_lib_luautf8_Utf8.len(s) >= 5) then 
	  do return "<...>" end;
	end;
	local _g = type(o);
	if (_g) == "boolean" then 
	  do return tostring(o) end;
	elseif (_g) == "function" then 
	  do return "<function>" end;
	elseif (_g) == "nil" then 
	  do return "null" end;
	elseif (_g) == "number" then 
	  if (o == _G.math.huge) then 
		do return "Infinity" end;
	  else
		if (o == -_G.math.huge) then 
		  do return "-Infinity" end;
		else
		  if (o == 0) then 
			do return "0" end;
		  else
			if (o ~= o) then 
			  do return "NaN" end;
			else
			  do return tostring(o) end;
			end;
		  end;
		end;
	  end;
	elseif (_g) == "string" then 
	  do return o end;
	elseif (_g) == "table" then 
	  if (o.__enum__ ~= nil) then 
		do return __lua_Boot.printEnum(o, s) end;
	  else
		if ((_hx_wrap_if_string_field(o,'toString') ~= nil) and not __lua_Boot.isArray(o)) then 
		  do return _hx_wrap_if_string_field(o,'toString')(o) end;
		else
		  if (__lua_Boot.isArray(o)) then 
			local o2 = o;
			if (__lua_lib_luautf8_Utf8.len(s) > 5) then 
			  do return "[...]" end;
			else
			  local _g1 = _hx_tab_array({}, 0);
			  local _g11 = 0;
			  while (_g11 < o2.length) do 
				local i = o2[_g11];
				_g11 = _g11 + 1;
				_g1:push(__lua_Boot.__string_rec(i, Std.string(s) .. Std.string(1)));
			  end;
			  do return Std.string(Std.string("[") .. Std.string(_g1:join(","))) .. Std.string("]") end;
			end;
		  else
			if (o.__class__ ~= nil) then 
			  do return Std.string(Std.string("{") .. Std.string(__lua_Boot.printClassRec(o, "", Std.string(s) .. Std.string("\t")))) .. Std.string("}") end;
			else
			  local fields = __lua_Boot.fieldIterator(o);
			  local buffer = ({});
			  local first = true;
			  _G.table.insert(buffer, "{ ");
			  local f = fields;
			  while (f:hasNext()) do 
				local f1 = f:next();
				if (first) then 
				  first = false;
				else
				  _G.table.insert(buffer, ", ");
				end;
				_G.table.insert(buffer, Std.string(Std.string(Std.string("") .. Std.string(Std.string(f1))) .. Std.string(" : ")) .. Std.string(__lua_Boot.__string_rec(o[f1], Std.string(s) .. Std.string("\t"))));
			  end;
			  _G.table.insert(buffer, " }");
			  do return _G.table.concat(buffer, "") end;
			end;
		  end;
		end;
	  end;
	elseif (_g) == "thread" then 
	  do return "<thread>" end;
	elseif (_g) == "userdata" then 
	  local mt = _G.getmetatable(o);
	  if ((mt ~= nil) and (mt.__tostring ~= nil)) then 
		do return _G.tostring(o) end;
	  else
		do return "<userdata>" end;
	  end;else
	_G.error("Unknown Lua type",0); end;
  end
  __lua_Boot.fieldIterator = function(o) 
	if (_G.type(o) ~= "table") then 
	  do return _hx_o({__fields__={next=true,hasNext=true},next=function(self) 
		do return nil end;
	  end,hasNext=function(self) 
		do return false end;
	  end}) end;
	end;
	local tbl = (function() 
	  local _hx_1
	  if (o.__fields__ ~= nil) then 
	  _hx_1 = o.__fields__; else 
	  _hx_1 = o; end
	  return _hx_1
	end )();
	local cur = _G.pairs(tbl);
	local next_valid = function(tbl1,val) 
	  while (__lua_Boot.hiddenFields[val] ~= nil) do 
		val = cur(tbl1, val);
	  end;
	  do return val end;
	end;
	local cur_val = next_valid(tbl, cur(tbl, nil));
	do return _hx_o({__fields__={next=true,hasNext=true},next=function(self) 
	  local ret = cur_val;
	  cur_val = next_valid(tbl, cur(tbl, cur_val));
	  do return ret end;
	end,hasNext=function(self) 
	  do return cur_val ~= nil end;
	end}) end;
  end
  _hx_bit_clamp = function(v)
	if v <= 2147483647 and v >= -2147483648 then
	  if v > 0 then return _G.math.floor(v)
	  else return _G.math.ceil(v)
	  end
	end
	if v > 2251798999999999 then v = v*2 end;
	if (v ~= v or math.abs(v) == _G.math.huge) then return nil end
	return _hx_bit.band(v, 2147483647 ) - math.abs(_hx_bit.band(v, 2147483648))
  end
  
  -- require this for lua 5.1
  pcall(require, 'bit')
  if bit then
	_hx_bit = bit
  else
	local _hx_bit_raw = _G.require('bit32')
	_hx_bit = setmetatable({}, { __index = _hx_bit_raw });
	-- lua 5.2 weirdness
	_hx_bit.bnot = function(...) return _hx_bit_clamp(_hx_bit_raw.bnot(...)) end;
	_hx_bit.bxor = function(...) return _hx_bit_clamp(_hx_bit_raw.bxor(...)) end;
  end
  
  _hx_array_mt.__index = Array.prototype
  
  local _hx_static_init = function()
	__lua_Boot.hiddenFields = {__id__=true, hx__closures=true, super=true, prototype=true, __fields__=true, __ifields__=true, __class__=true, __properties__=true}
	
	
  end
  
  _hx_print = print or (function() end)
  
  _hx_wrap_if_string_field = function(o, fld)
	if _G.type(o) == 'string' then
	  if fld == 'length' then
		return _G.string.len(o)
	  else
		return String.prototype[fld]
	  end
	else
	  return o[fld]
	end
  end
  
  _hx_static_init();
  Main.main()