First commit

hGameTest/bin/linux/obj/include/haxe/CallStack.h

@@ -0,0 +1,71 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_CallStack
+#define INCLUDED_haxe_CallStack
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(StringBuf)
+HX_DECLARE_CLASS1(haxe,CallStack)
+HX_DECLARE_CLASS1(haxe,StackItem)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES CallStack_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef CallStack_obj OBJ_;
+		CallStack_obj();
+
+	public:
+		enum { _hx_ClassId = 0x6207a884 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.CallStack")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"haxe.CallStack"); }
+
+		inline static hx::ObjectPtr< CallStack_obj > __new() {
+			hx::ObjectPtr< CallStack_obj > __this = new CallStack_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< CallStack_obj > __alloc(hx::Ctx *_hx_ctx) {
+			CallStack_obj *__this = (CallStack_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(CallStack_obj), false, "haxe.CallStack"));
+			*(void **)__this = CallStack_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~CallStack_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("CallStack",aa,a1,1d,b2); }
+
+		static ::Array< ::Dynamic> exceptionStack();
+		static ::Dynamic exceptionStack_dyn();
+
+		static ::String toString(::Array< ::Dynamic> stack);
+		static ::Dynamic toString_dyn();
+
+		static void itemToString( ::StringBuf b, ::haxe::StackItem s);
+		static ::Dynamic itemToString_dyn();
+
+		static ::Array< ::Dynamic> makeStack( ::Dynamic s);
+		static ::Dynamic makeStack_dyn();
+
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_CallStack */ 

hGameTest/bin/linux/obj/include/haxe/Exception.h

@@ -0,0 +1,68 @@
+// Generated by Haxe 4.1.5
+#ifndef INCLUDED_haxe_Exception
+#define INCLUDED_haxe_Exception
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,Exception)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES Exception_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Exception_obj OBJ_;
+		Exception_obj();
+
+	public:
+		enum { _hx_ClassId = 0x677ddc49 };
+
+		void __construct(::String message, ::haxe::Exception previous, ::Dynamic native);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.Exception")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.Exception"); }
+		static ::hx::ObjectPtr< Exception_obj > __new(::String message, ::haxe::Exception previous, ::Dynamic native);
+		static ::hx::ObjectPtr< Exception_obj > __alloc(::hx::Ctx *_hx_ctx,::String message, ::haxe::Exception previous, ::Dynamic native);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Exception_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Exception",2f,f0,6c,eb); }
+
+		static  ::haxe::Exception caught( ::Dynamic value);
+		static ::Dynamic caught_dyn();
+
+		static  ::Dynamic thrown( ::Dynamic value);
+		static ::Dynamic thrown_dyn();
+
+		::String _hx___exceptionMessage;
+		::Array< ::String > _hx___nativeStack;
+		int _hx___skipStack;
+		 ::Dynamic _hx___nativeException;
+		 ::haxe::Exception _hx___previousException;
+		virtual  ::Dynamic unwrap();
+		::Dynamic unwrap_dyn();
+
+		 ::Dynamic get_native();
+		::Dynamic get_native_dyn();
+
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_Exception */ 

hGameTest/bin/linux/obj/include/haxe/IMap.h

@@ -0,0 +1,35 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_IMap
+#define INCLUDED_haxe_IMap
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES IMap_obj {
+	public:
+		typedef hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		void (hx::Object :: *_hx_set)( ::Dynamic k, ::Dynamic v); 
+		static inline void set( ::Dynamic _hx_, ::Dynamic k, ::Dynamic v) {
+			(_hx_.mPtr->*( hx::interface_cast< ::haxe::IMap_obj *>(_hx_.mPtr->_hx_getInterface(0x09c2bd39)))->_hx_set)(k,v);
+		}
+		bool (hx::Object :: *_hx_exists)( ::Dynamic k); 
+		static inline bool exists( ::Dynamic _hx_, ::Dynamic k) {
+			return (_hx_.mPtr->*( hx::interface_cast< ::haxe::IMap_obj *>(_hx_.mPtr->_hx_getInterface(0x09c2bd39)))->_hx_exists)(k);
+		}
+		bool (hx::Object :: *_hx_remove)( ::Dynamic k); 
+		static inline bool remove( ::Dynamic _hx_, ::Dynamic k) {
+			return (_hx_.mPtr->*( hx::interface_cast< ::haxe::IMap_obj *>(_hx_.mPtr->_hx_getInterface(0x09c2bd39)))->_hx_remove)(k);
+		}
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_IMap */ 

hGameTest/bin/linux/obj/include/haxe/Log.h

@@ -0,0 +1,62 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_Log
+#define INCLUDED_haxe_Log
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,Log)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES Log_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Log_obj OBJ_;
+		Log_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0446b9f6 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.Log")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"haxe.Log"); }
+
+		inline static hx::ObjectPtr< Log_obj > __new() {
+			hx::ObjectPtr< Log_obj > __this = new Log_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< Log_obj > __alloc(hx::Ctx *_hx_ctx) {
+			Log_obj *__this = (Log_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Log_obj), false, "haxe.Log"));
+			*(void **)__this = Log_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Log_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Log",64,0c,3a,00); }
+
+		static void __boot();
+		static ::Dynamic trace;
+		static inline ::Dynamic &trace_dyn() {return trace; }
+
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_Log */ 

hGameTest/bin/linux/obj/include/haxe/NativeStackTrace.h

@@ -0,0 +1,70 @@
+// Generated by Haxe 4.1.5
+#ifndef INCLUDED_haxe_NativeStackTrace
+#define INCLUDED_haxe_NativeStackTrace
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,NativeStackTrace)
+HX_DECLARE_CLASS1(haxe,StackItem)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES NativeStackTrace_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef NativeStackTrace_obj OBJ_;
+		NativeStackTrace_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3984963e };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.NativeStackTrace")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"haxe.NativeStackTrace"); }
+
+		inline static ::hx::ObjectPtr< NativeStackTrace_obj > __new() {
+			::hx::ObjectPtr< NativeStackTrace_obj > __this = new NativeStackTrace_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< NativeStackTrace_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			NativeStackTrace_obj *__this = (NativeStackTrace_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(NativeStackTrace_obj), false, "haxe.NativeStackTrace"));
+			*(void **)__this = NativeStackTrace_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~NativeStackTrace_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("NativeStackTrace",b4,5e,6d,3c); }
+
+		static void saveStack( ::Dynamic exception);
+		static ::Dynamic saveStack_dyn();
+
+		static ::Array< ::String > callStack();
+		static ::Dynamic callStack_dyn();
+
+		static ::Array< ::String > exceptionStack();
+		static ::Dynamic exceptionStack_dyn();
+
+		static ::Array< ::Dynamic> toHaxe(::Array< ::String > native,::hx::Null< int >  skip);
+		static ::Dynamic toHaxe_dyn();
+
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_NativeStackTrace */ 

hGameTest/bin/linux/obj/include/haxe/Resource.h

@@ -0,0 +1,61 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_Resource
+#define INCLUDED_haxe_Resource
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,Resource)
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES Resource_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Resource_obj OBJ_;
+		Resource_obj();
+
+	public:
+		enum { _hx_ClassId = 0x75b82b54 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.Resource")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"haxe.Resource"); }
+
+		inline static hx::ObjectPtr< Resource_obj > __new() {
+			hx::ObjectPtr< Resource_obj > __this = new Resource_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< Resource_obj > __alloc(hx::Ctx *_hx_ctx) {
+			Resource_obj *__this = (Resource_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Resource_obj), false, "haxe.Resource"));
+			*(void **)__this = Resource_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Resource_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Resource",ee,18,52,ec); }
+
+		static  ::haxe::io::Bytes getBytes(::String name);
+		static ::Dynamic getBytes_dyn();
+
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_Resource */ 

hGameTest/bin/linux/obj/include/haxe/Serializer.h

@@ -0,0 +1,84 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_Serializer
+#define INCLUDED_haxe_Serializer
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(StringBuf)
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS1(haxe,Serializer)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES Serializer_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Serializer_obj OBJ_;
+		Serializer_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0866dbc4 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.Serializer")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"haxe.Serializer"); }
+		static hx::ObjectPtr< Serializer_obj > __new();
+		static hx::ObjectPtr< Serializer_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Serializer_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Serializer",b2,ca,d0,55); }
+
+		static void __boot();
+		static bool USE_CACHE;
+		static bool USE_ENUM_INDEX;
+		static ::String BASE64;
+		static ::Array< ::Dynamic> BASE64_CODES;
+		static ::String run( ::Dynamic v);
+		static ::Dynamic run_dyn();
+
+		 ::StringBuf buf;
+		::cpp::VirtualArray cache;
+		 ::haxe::ds::StringMap shash;
+		int scount;
+		bool useCache;
+		bool useEnumIndex;
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+		void serializeString(::String s);
+		::Dynamic serializeString_dyn();
+
+		bool serializeRef( ::Dynamic v);
+		::Dynamic serializeRef_dyn();
+
+		void serializeFields( ::Dynamic v);
+		::Dynamic serializeFields_dyn();
+
+		void serialize( ::Dynamic v);
+		::Dynamic serialize_dyn();
+
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_Serializer */ 

hGameTest/bin/linux/obj/include/haxe/StackItem.h

@@ -0,0 +1,41 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_StackItem
+#define INCLUDED_haxe_StackItem
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,StackItem)
+namespace haxe{
+
+
+class StackItem_obj : public hx::EnumBase_obj
+{
+	typedef hx::EnumBase_obj super;
+		typedef StackItem_obj OBJ_;
+
+	public:
+		StackItem_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("haxe.StackItem",13,26,c7,2d); }
+		::String __ToString() const { return HX_("StackItem.",73,53,dc,cb) + _hx_tag; }
+
+		static ::haxe::StackItem CFunction;
+		static inline ::haxe::StackItem CFunction_dyn() { return CFunction; }
+		static ::haxe::StackItem FilePos( ::haxe::StackItem s,::String file,int line, ::Dynamic column);
+		static ::Dynamic FilePos_dyn();
+		static ::haxe::StackItem LocalFunction( ::Dynamic v);
+		static ::Dynamic LocalFunction_dyn();
+		static ::haxe::StackItem Method(::String classname,::String method);
+		static ::Dynamic Method_dyn();
+		static ::haxe::StackItem Module(::String m);
+		static ::Dynamic Module_dyn();
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_StackItem */ 

hGameTest/bin/linux/obj/include/haxe/SysTools.h

@@ -0,0 +1,66 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_SysTools
+#define INCLUDED_haxe_SysTools
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,SysTools)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES SysTools_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef SysTools_obj OBJ_;
+		SysTools_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5eccb454 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.SysTools")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"haxe.SysTools"); }
+
+		inline static hx::ObjectPtr< SysTools_obj > __new() {
+			hx::ObjectPtr< SysTools_obj > __this = new SysTools_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< SysTools_obj > __alloc(hx::Ctx *_hx_ctx) {
+			SysTools_obj *__this = (SysTools_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(SysTools_obj), false, "haxe.SysTools"));
+			*(void **)__this = SysTools_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~SysTools_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SysTools",ee,a1,66,d5); }
+
+		static void __boot();
+		static ::Array< int > winMetaCharacters;
+		static ::String quoteUnixArg(::String argument);
+		static ::Dynamic quoteUnixArg_dyn();
+
+		static ::String quoteWinArg(::String argument,bool escapeMetaCharacters);
+		static ::Dynamic quoteWinArg_dyn();
+
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_SysTools */ 

hGameTest/bin/linux/obj/include/haxe/Timer.h

@@ -0,0 +1,101 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_Timer
+#define INCLUDED_haxe_Timer
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_102f69689d37b2bb_230_new)
+HX_DECLARE_CLASS1(haxe,Timer)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES Timer_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Timer_obj OBJ_;
+		Timer_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4623e5b7 };
+
+		void __construct(Float time);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.Timer")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"haxe.Timer"); }
+
+		inline static hx::ObjectPtr< Timer_obj > __new(Float time) {
+			hx::ObjectPtr< Timer_obj > __this = new Timer_obj();
+			__this->__construct(time);
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< Timer_obj > __alloc(hx::Ctx *_hx_ctx,Float time) {
+			Timer_obj *__this = (Timer_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Timer_obj), true, "haxe.Timer"));
+			*(void **)__this = Timer_obj::_hx_vtable;
+			haxe::Timer_obj::__alloc_dynamic_functions(_hx_ctx,__this);
+{
+            	HX_STACKFRAME(&_hx_pos_102f69689d37b2bb_230_new)
+HXLINE( 231)		( ( ::haxe::Timer)(__this) )->mTime = time;
+HXLINE( 232)		::haxe::Timer_obj::sRunningTimers->push(__this);
+HXLINE( 233)		Float _hx_tmp = ::haxe::Timer_obj::getMS();
+HXDLIN( 233)		( ( ::haxe::Timer)(__this) )->mFireAt = (_hx_tmp + ( ( ::haxe::Timer)(__this) )->mTime);
+HXLINE( 234)		( ( ::haxe::Timer)(__this) )->mRunning = true;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		static void __alloc_dynamic_functions(hx::Ctx *_hx_alloc,Timer_obj *_hx_obj);
+		//~Timer_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Timer",a5,2f,63,a3); }
+
+		static void __boot();
+		static ::Array< ::Dynamic> sRunningTimers;
+		static  ::haxe::Timer delay( ::Dynamic f,int time);
+		static ::Dynamic delay_dyn();
+
+		static Float getMS();
+		static ::Dynamic getMS_dyn();
+
+		static  ::Dynamic measure( ::Dynamic f, ::Dynamic pos);
+		static ::Dynamic measure_dyn();
+
+		static Float stamp();
+		static ::Dynamic stamp_dyn();
+
+		Float mTime;
+		Float mFireAt;
+		bool mRunning;
+		::Dynamic run;
+		inline ::Dynamic &run_dyn() {return run; }
+
+		void stop();
+		::Dynamic stop_dyn();
+
+		void _hx___check(Float inTime);
+		::Dynamic _hx___check_dyn();
+
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_Timer */ 

hGameTest/bin/linux/obj/include/haxe/Unserializer.h

@@ -0,0 +1,83 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_Unserializer
+#define INCLUDED_haxe_Unserializer
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,Unserializer)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES Unserializer_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Unserializer_obj OBJ_;
+		Unserializer_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7af2b435 };
+
+		void __construct(::String buf);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.Unserializer")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"haxe.Unserializer"); }
+		static hx::ObjectPtr< Unserializer_obj > __new(::String buf);
+		static hx::ObjectPtr< Unserializer_obj > __alloc(hx::Ctx *_hx_ctx,::String buf);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Unserializer_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Unserializer",4b,42,41,93); }
+
+		static void __boot();
+		static  ::Dynamic DEFAULT_RESOLVER;
+		static ::String BASE64;
+		static ::Array< int > CODES;
+		static ::Array< int > initCodes();
+		static ::Dynamic initCodes_dyn();
+
+		static  ::Dynamic run(::String v);
+		static ::Dynamic run_dyn();
+
+		::String buf;
+		int pos;
+		int length;
+		::cpp::VirtualArray cache;
+		::Array< ::String > scache;
+		 ::Dynamic resolver;
+		int readDigits();
+		::Dynamic readDigits_dyn();
+
+		Float readFloat();
+		::Dynamic readFloat_dyn();
+
+		void unserializeObject( ::Dynamic o);
+		::Dynamic unserializeObject_dyn();
+
+		 ::Dynamic unserializeEnum(hx::Class edecl,::String tag);
+		::Dynamic unserializeEnum_dyn();
+
+		 ::Dynamic unserialize();
+		::Dynamic unserialize_dyn();
+
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_Unserializer */ 

hGameTest/bin/linux/obj/include/haxe/ValueException.h

@@ -0,0 +1,57 @@
+// Generated by Haxe 4.1.5
+#ifndef INCLUDED_haxe_ValueException
+#define INCLUDED_haxe_ValueException
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_Exception
+#include <haxe/Exception.h>
+#endif
+HX_DECLARE_CLASS1(haxe,Exception)
+HX_DECLARE_CLASS1(haxe,ValueException)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES ValueException_obj : public  ::haxe::Exception_obj
+{
+	public:
+		typedef  ::haxe::Exception_obj super;
+		typedef ValueException_obj OBJ_;
+		ValueException_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0af01d58 };
+
+		void __construct( ::Dynamic value, ::haxe::Exception previous, ::Dynamic native);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.ValueException")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.ValueException"); }
+		static ::hx::ObjectPtr< ValueException_obj > __new( ::Dynamic value, ::haxe::Exception previous, ::Dynamic native);
+		static ::hx::ObjectPtr< ValueException_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic value, ::haxe::Exception previous, ::Dynamic native);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ValueException_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ValueException",be,0e,61,3f); }
+
+		 ::Dynamic value;
+		 ::Dynamic unwrap();
+
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_ValueException */ 

hGameTest/bin/linux/obj/include/haxe/_CallStack/CallStack_Impl_.h

@@ -0,0 +1,79 @@
+// Generated by Haxe 4.1.5
+#ifndef INCLUDED_haxe__CallStack_CallStack_Impl_
+#define INCLUDED_haxe__CallStack_CallStack_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(StringBuf)
+HX_DECLARE_CLASS1(haxe,StackItem)
+HX_DECLARE_CLASS2(haxe,_CallStack,CallStack_Impl_)
+
+namespace haxe{
+namespace _CallStack{
+
+
+class HXCPP_CLASS_ATTRIBUTES CallStack_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef CallStack_Impl__obj OBJ_;
+		CallStack_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x29a173d9 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe._CallStack.CallStack_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"haxe._CallStack.CallStack_Impl_"); }
+
+		inline static ::hx::ObjectPtr< CallStack_Impl__obj > __new() {
+			::hx::ObjectPtr< CallStack_Impl__obj > __this = new CallStack_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< CallStack_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			CallStack_Impl__obj *__this = (CallStack_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(CallStack_Impl__obj), false, "haxe._CallStack.CallStack_Impl_"));
+			*(void **)__this = CallStack_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~CallStack_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("CallStack_Impl_",ca,79,56,8f); }
+
+		static ::Array< ::Dynamic> callStack();
+		static ::Dynamic callStack_dyn();
+
+		static ::Array< ::Dynamic> exceptionStack(::hx::Null< bool >  fullStack);
+		static ::Dynamic exceptionStack_dyn();
+
+		static ::String toString(::Array< ::Dynamic> stack);
+		static ::Dynamic toString_dyn();
+
+		static ::Array< ::Dynamic> subtract(::Array< ::Dynamic> this1,::Array< ::Dynamic> stack);
+		static ::Dynamic subtract_dyn();
+
+		static bool equalItems( ::haxe::StackItem item1, ::haxe::StackItem item2);
+		static ::Dynamic equalItems_dyn();
+
+		static void itemToString( ::StringBuf b, ::haxe::StackItem s);
+		static ::Dynamic itemToString_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace _CallStack
+
+#endif /* INCLUDED_haxe__CallStack_CallStack_Impl_ */ 

hGameTest/bin/linux/obj/include/haxe/_Unserializer/DefaultResolver.h

@@ -0,0 +1,54 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe__Unserializer_DefaultResolver
+#define INCLUDED_haxe__Unserializer_DefaultResolver
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,_Unserializer,DefaultResolver)
+
+namespace haxe{
+namespace _Unserializer{
+
+
+class HXCPP_CLASS_ATTRIBUTES DefaultResolver_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef DefaultResolver_obj OBJ_;
+		DefaultResolver_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2712964b };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe._Unserializer.DefaultResolver")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"haxe._Unserializer.DefaultResolver"); }
+		static hx::ObjectPtr< DefaultResolver_obj > __new();
+		static hx::ObjectPtr< DefaultResolver_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~DefaultResolver_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DefaultResolver",c7,41,4a,96); }
+
+		hx::Class resolveClass(::String name);
+		::Dynamic resolveClass_dyn();
+
+		hx::Class resolveEnum(::String name);
+		::Dynamic resolveEnum_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace _Unserializer
+
+#endif /* INCLUDED_haxe__Unserializer_DefaultResolver */ 

hGameTest/bin/linux/obj/include/haxe/crypto/Adler32.h

@@ -0,0 +1,64 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_crypto_Adler32
+#define INCLUDED_haxe_crypto_Adler32
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,crypto,Adler32)
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Input)
+
+namespace haxe{
+namespace crypto{
+
+
+class HXCPP_CLASS_ATTRIBUTES Adler32_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Adler32_obj OBJ_;
+		Adler32_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4f124546 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.crypto.Adler32")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"haxe.crypto.Adler32"); }
+		static hx::ObjectPtr< Adler32_obj > __new();
+		static hx::ObjectPtr< Adler32_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Adler32_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Adler32",d5,1c,03,fd); }
+
+		static  ::haxe::crypto::Adler32 read( ::haxe::io::Input i);
+		static ::Dynamic read_dyn();
+
+		int a1;
+		int a2;
+		void update( ::haxe::io::Bytes b,int pos,int len);
+		::Dynamic update_dyn();
+
+		bool equals( ::haxe::crypto::Adler32 a);
+		::Dynamic equals_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace crypto
+
+#endif /* INCLUDED_haxe_crypto_Adler32 */ 

hGameTest/bin/linux/obj/include/haxe/crypto/Base64.h

@@ -0,0 +1,67 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_crypto_Base64
+#define INCLUDED_haxe_crypto_Base64
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,crypto,Base64)
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+
+namespace haxe{
+namespace crypto{
+
+
+class HXCPP_CLASS_ATTRIBUTES Base64_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Base64_obj OBJ_;
+		Base64_obj();
+
+	public:
+		enum { _hx_ClassId = 0x65bbd7fa };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.crypto.Base64")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"haxe.crypto.Base64"); }
+
+		inline static hx::ObjectPtr< Base64_obj > __new() {
+			hx::ObjectPtr< Base64_obj > __this = new Base64_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< Base64_obj > __alloc(hx::Ctx *_hx_ctx) {
+			Base64_obj *__this = (Base64_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Base64_obj), false, "haxe.crypto.Base64"));
+			*(void **)__this = Base64_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Base64_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Base64",af,71,bc,89); }
+
+		static void __boot();
+		static ::String CHARS;
+		static  ::haxe::io::Bytes BYTES;
+		static  ::haxe::io::Bytes decode(::String str,hx::Null< bool >  complement);
+		static ::Dynamic decode_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace crypto
+
+#endif /* INCLUDED_haxe_crypto_Base64 */ 

hGameTest/bin/linux/obj/include/haxe/crypto/BaseCode.h

@@ -0,0 +1,62 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_crypto_BaseCode
+#define INCLUDED_haxe_crypto_BaseCode
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,crypto,BaseCode)
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+
+namespace haxe{
+namespace crypto{
+
+
+class HXCPP_CLASS_ATTRIBUTES BaseCode_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef BaseCode_obj OBJ_;
+		BaseCode_obj();
+
+	public:
+		enum { _hx_ClassId = 0x234bc1a5 };
+
+		void __construct( ::haxe::io::Bytes base);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.crypto.BaseCode")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"haxe.crypto.BaseCode"); }
+		static hx::ObjectPtr< BaseCode_obj > __new( ::haxe::io::Bytes base);
+		static hx::ObjectPtr< BaseCode_obj > __alloc(hx::Ctx *_hx_ctx, ::haxe::io::Bytes base);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~BaseCode_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("BaseCode",fe,5d,c4,cf); }
+
+		 ::haxe::io::Bytes base;
+		int nbits;
+		::Array< int > tbl;
+		void initTable();
+		::Dynamic initTable_dyn();
+
+		 ::haxe::io::Bytes decodeBytes( ::haxe::io::Bytes b);
+		::Dynamic decodeBytes_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace crypto
+
+#endif /* INCLUDED_haxe_crypto_BaseCode */ 

hGameTest/bin/linux/obj/include/haxe/ds/ArraySort.h

@@ -0,0 +1,83 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_ds_ArraySort
+#define INCLUDED_haxe_ds_ArraySort
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,ds,ArraySort)
+
+namespace haxe{
+namespace ds{
+
+
+class HXCPP_CLASS_ATTRIBUTES ArraySort_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ArraySort_obj OBJ_;
+		ArraySort_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7ffbe7fa };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.ds.ArraySort")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"haxe.ds.ArraySort"); }
+
+		inline static hx::ObjectPtr< ArraySort_obj > __new() {
+			hx::ObjectPtr< ArraySort_obj > __this = new ArraySort_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< ArraySort_obj > __alloc(hx::Ctx *_hx_ctx) {
+			ArraySort_obj *__this = (ArraySort_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(ArraySort_obj), false, "haxe.ds.ArraySort"));
+			*(void **)__this = ArraySort_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ArraySort_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ArraySort",77,e1,9c,37); }
+
+		static void sort(::cpp::VirtualArray a, ::Dynamic cmp);
+		static ::Dynamic sort_dyn();
+
+		static void rec(::cpp::VirtualArray a, ::Dynamic cmp,int from,int to);
+		static ::Dynamic rec_dyn();
+
+		static void doMerge(::cpp::VirtualArray a, ::Dynamic cmp,int from,int pivot,int to,int len1,int len2);
+		static ::Dynamic doMerge_dyn();
+
+		static void rotate(::cpp::VirtualArray a, ::Dynamic cmp,int from,int mid,int to);
+		static ::Dynamic rotate_dyn();
+
+		static int gcd(int m,int n);
+		static ::Dynamic gcd_dyn();
+
+		static int upper(::cpp::VirtualArray a, ::Dynamic cmp,int from,int to,int val);
+		static ::Dynamic upper_dyn();
+
+		static int lower(::cpp::VirtualArray a, ::Dynamic cmp,int from,int to,int val);
+		static ::Dynamic lower_dyn();
+
+		static void swap(::cpp::VirtualArray a,int i,int j);
+		static ::Dynamic swap_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace ds
+
+#endif /* INCLUDED_haxe_ds_ArraySort */ 

hGameTest/bin/linux/obj/include/haxe/ds/IntMap.h

@@ -0,0 +1,110 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_ds_IntMap
+#define INCLUDED_haxe_ds_IntMap
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,IntMap)
+
+namespace haxe{
+namespace ds{
+
+
+class HXCPP_CLASS_ATTRIBUTES IntMap_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef IntMap_obj OBJ_;
+		IntMap_obj();
+
+	public:
+		enum { _hx_ClassId = 0x50b86242 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.ds.IntMap")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"haxe.ds.IntMap"); }
+		static hx::ObjectPtr< IntMap_obj > __new();
+		static hx::ObjectPtr< IntMap_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~IntMap_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		bool remove_5889326f( ::Dynamic k);
+
+		bool exists_5889326f( ::Dynamic k);
+
+		void set_41d0cb46( ::Dynamic k, ::Dynamic v);
+		::String __ToString() const { return HX_("IntMap",0d,a9,08,d3); }
+
+		 ::Dynamic h;
+		void set(int key, ::Dynamic value);
+		::Dynamic set_dyn();
+
+		 ::Dynamic get(int key);
+		::Dynamic get_dyn();
+
+		bool exists(int key);
+		::Dynamic exists_dyn();
+
+		bool remove(int key);
+		::Dynamic remove_dyn();
+
+		 ::Dynamic keys();
+		::Dynamic keys_dyn();
+
+		 ::Dynamic iterator();
+		::Dynamic iterator_dyn();
+
+
+  inline void set(int key, ::null value) { __int_hash_set(HX_MAP_THIS,key,value); }
+  inline void set(int key, bool value) { __int_hash_set(HX_MAP_THIS,key,value); }
+  inline void set(int key, char value) { __int_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(int key, unsigned char value) { __int_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(int key, signed char value) { __int_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(int key, short value) { __int_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(int key, unsigned short value) { __int_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(int key, int value) { __int_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(int key, unsigned int value) { __int_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(int key, float value) { __int_hash_set_float(HX_MAP_THIS,key,value); }
+  inline void set(int key, double value) { __int_hash_set_float(HX_MAP_THIS,key,value); }
+  inline void set(int key, ::String value) { __int_hash_set_string(HX_MAP_THIS,key,value); }
+
+  template<typename V, typename H>
+  inline void set(int key, const ::cpp::Struct<V,H> &value) {__int_hash_set(HX_MAP_THIS,key,value); }
+  template<typename F>
+  inline void set(int key, const ::cpp::Function<F> &value) {__int_hash_set(HX_MAP_THIS,key,value); }
+  template<typename V>
+  inline void set(int key, const ::cpp::Pointer<V> &value) {__int_hash_set(HX_MAP_THIS,key,(Dynamic)value ); }
+
+  template<typename VALUE>
+  inline void set(Dynamic &key, const VALUE &value) { set( (int)key, value ); }
+
+  inline bool get_bool(int key) { return __int_hash_get_bool(h,key); }
+  inline int get_int(int key) { return __int_hash_get_int(h,key); }
+  inline Float get_float(int key) { return __int_hash_get_float(h,key); }
+  inline String get_string(int key) { return __int_hash_get_string(h,key); }
+
+};
+
+} // end namespace haxe
+} // end namespace ds
+
+#endif /* INCLUDED_haxe_ds_IntMap */ 

hGameTest/bin/linux/obj/include/haxe/ds/List.h

@@ -0,0 +1,75 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_ds_List
+#define INCLUDED_haxe_ds_List
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,ds,List)
+HX_DECLARE_CLASS3(haxe,ds,_List,ListIterator)
+HX_DECLARE_CLASS3(haxe,ds,_List,ListNode)
+
+namespace haxe{
+namespace ds{
+
+
+class HXCPP_CLASS_ATTRIBUTES List_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef List_obj OBJ_;
+		List_obj();
+
+	public:
+		enum { _hx_ClassId = 0x57bbda73 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.ds.List")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"haxe.ds.List"); }
+		static hx::ObjectPtr< List_obj > __new();
+		static hx::ObjectPtr< List_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~List_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("List",7e,48,8c,32); }
+
+		 ::haxe::ds::_List::ListNode h;
+		 ::haxe::ds::_List::ListNode q;
+		int length;
+		void add( ::Dynamic item);
+		::Dynamic add_dyn();
+
+		void push( ::Dynamic item);
+		::Dynamic push_dyn();
+
+		 ::Dynamic pop();
+		::Dynamic pop_dyn();
+
+		void clear();
+		::Dynamic clear_dyn();
+
+		bool remove( ::Dynamic v);
+		::Dynamic remove_dyn();
+
+		 ::haxe::ds::_List::ListIterator iterator();
+		::Dynamic iterator_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace ds
+
+#endif /* INCLUDED_haxe_ds_List */ 

hGameTest/bin/linux/obj/include/haxe/ds/ObjectMap.h

@@ -0,0 +1,102 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_ds_ObjectMap
+#define INCLUDED_haxe_ds_ObjectMap
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,ObjectMap)
+
+namespace haxe{
+namespace ds{
+
+
+class HXCPP_CLASS_ATTRIBUTES ObjectMap_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ObjectMap_obj OBJ_;
+		ObjectMap_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4a82dae8 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.ds.ObjectMap")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"haxe.ds.ObjectMap"); }
+		static hx::ObjectPtr< ObjectMap_obj > __new();
+		static hx::ObjectPtr< ObjectMap_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ObjectMap_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		void set_41d0cb46( ::Dynamic k, ::Dynamic v);
+		::String __ToString() const { return HX_("ObjectMap",fd,a4,50,e5); }
+
+		 ::Dynamic h;
+		void set( ::Dynamic key, ::Dynamic value);
+		::Dynamic set_dyn();
+
+		 ::Dynamic get( ::Dynamic key);
+		::Dynamic get_dyn();
+
+		bool exists( ::Dynamic key);
+		::Dynamic exists_dyn();
+
+		bool remove( ::Dynamic key);
+		::Dynamic remove_dyn();
+
+		 ::Dynamic keys();
+		::Dynamic keys_dyn();
+
+
+  inline void set(Dynamic key, ::null value) { __object_hash_set(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, bool value) { __object_hash_set(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, char value) { __object_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, unsigned char value) { __object_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, signed char value) { __object_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, short value) { __object_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, unsigned short value) { __object_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, int value) { __object_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, unsigned int value) { __object_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, float value) { __object_hash_set_float(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, double value) { __object_hash_set_float(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, ::String value) { __object_hash_set_string(HX_MAP_THIS,key,value); }
+
+
+  template<typename V, typename H>
+  inline void set(Dynamic key, const ::cpp::Struct<V,H> &value) {__object_hash_set(HX_MAP_THIS,key,value); }
+  template<typename V>
+  inline void set(Dynamic key, const ::cpp::Function<V> &value) {__object_hash_set(HX_MAP_THIS,key,(Dynamic)value ); }
+  template<typename V>
+  inline void set(Dynamic key, const ::cpp::Pointer<V> &value) {__object_hash_set(HX_MAP_THIS,key,(Dynamic)value ); }
+
+  inline bool get_bool(Dynamic key) { return __object_hash_get_bool(h,key); }
+  inline int get_int(Dynamic key) { return __object_hash_get_int(h,key); }
+  inline Float get_float(Dynamic key) { return __object_hash_get_float(h,key); }
+  inline String get_string(Dynamic key) { return __object_hash_get_string(h,key); }
+
+
+};
+
+} // end namespace haxe
+} // end namespace ds
+
+#endif /* INCLUDED_haxe_ds_ObjectMap */ 

hGameTest/bin/linux/obj/include/haxe/ds/StringMap.h

@@ -0,0 +1,110 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_ds_StringMap
+#define INCLUDED_haxe_ds_StringMap
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+
+namespace haxe{
+namespace ds{
+
+
+class HXCPP_CLASS_ATTRIBUTES StringMap_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef StringMap_obj OBJ_;
+		StringMap_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7fd15eaa };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.ds.StringMap")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"haxe.ds.StringMap"); }
+		static hx::ObjectPtr< StringMap_obj > __new();
+		static hx::ObjectPtr< StringMap_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~StringMap_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		bool remove_5889326f( ::Dynamic k);
+
+		bool exists_5889326f( ::Dynamic k);
+
+		void set_41d0cb46( ::Dynamic k, ::Dynamic v);
+		::String __ToString() const { return HX_("StringMap",2b,12,8c,69); }
+
+		 ::Dynamic h;
+		void set(::String key, ::Dynamic value);
+		::Dynamic set_dyn();
+
+		 ::Dynamic get(::String key);
+		::Dynamic get_dyn();
+
+		bool exists(::String key);
+		::Dynamic exists_dyn();
+
+		bool remove(::String key);
+		::Dynamic remove_dyn();
+
+		 ::Dynamic keys();
+		::Dynamic keys_dyn();
+
+		 ::Dynamic iterator();
+		::Dynamic iterator_dyn();
+
+
+  inline void set(String key, ::null value) { __string_hash_set(HX_MAP_THIS,key,value); }
+  inline void set(String key, bool value) { __string_hash_set(HX_MAP_THIS,key,value); }
+  inline void set(String key, char value) { __string_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(String key, unsigned char value) { __string_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(String key, signed char value) { __string_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(String key, short value) { __string_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(String key, unsigned short value) { __string_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(String key, int value) { __string_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(String key, unsigned int value) { __string_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(String key, float value) { __string_hash_set_float(HX_MAP_THIS,key,value); }
+  inline void set(String key, double value) { __string_hash_set_float(HX_MAP_THIS,key,value); }
+  inline void set(String key, ::String value) { __string_hash_set_string(HX_MAP_THIS,key,value); }
+
+  template<typename V, typename H>
+  inline void set(String key, const ::cpp::Struct<V,H> &value) {__string_hash_set(HX_MAP_THIS,key,value); }
+  template<typename V>
+  inline void set(String key, const ::cpp::Function<V> &value) {__string_hash_set(HX_MAP_THIS,key,(Dynamic)value ); }
+  template<typename V>
+  inline void set(String key, const ::cpp::Pointer<V> &value) {__string_hash_set(HX_MAP_THIS,key,(Dynamic)value ); }
+
+  template<typename VALUE>
+  inline void set(Dynamic &key, const VALUE &value) { set( (String)key, value ); }
+
+  inline bool get_bool(String key) { return __string_hash_get_bool(h,key); }
+  inline int get_int(String key) { return __string_hash_get_int(h,key); }
+  inline Float get_float(String key) { return __string_hash_get_float(h,key); }
+  inline String get_string(String key) { return __string_hash_get_string(h,key); }
+
+};
+
+} // end namespace haxe
+} // end namespace ds
+
+#endif /* INCLUDED_haxe_ds_StringMap */ 

hGameTest/bin/linux/obj/include/haxe/ds/_List/ListIterator.h

@@ -0,0 +1,62 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_ds__List_ListIterator
+#define INCLUDED_haxe_ds__List_ListIterator
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(haxe,ds,_List,ListIterator)
+HX_DECLARE_CLASS3(haxe,ds,_List,ListNode)
+
+namespace haxe{
+namespace ds{
+namespace _List{
+
+
+class HXCPP_CLASS_ATTRIBUTES ListIterator_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ListIterator_obj OBJ_;
+		ListIterator_obj();
+
+	public:
+		enum { _hx_ClassId = 0x06484168 };
+
+		void __construct( ::haxe::ds::_List::ListNode head);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.ds._List.ListIterator")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"haxe.ds._List.ListIterator"); }
+		static hx::ObjectPtr< ListIterator_obj > __new( ::haxe::ds::_List::ListNode head);
+		static hx::ObjectPtr< ListIterator_obj > __alloc(hx::Ctx *_hx_ctx, ::haxe::ds::_List::ListNode head);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ListIterator_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ListIterator",8c,fc,31,c4); }
+
+		 ::haxe::ds::_List::ListNode head;
+		bool hasNext();
+		::Dynamic hasNext_dyn();
+
+		 ::Dynamic next();
+		::Dynamic next_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace ds
+} // end namespace _List
+
+#endif /* INCLUDED_haxe_ds__List_ListIterator */ 

hGameTest/bin/linux/obj/include/haxe/ds/_List/ListNode.h

@@ -0,0 +1,74 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_ds__List_ListNode
+#define INCLUDED_haxe_ds__List_ListNode
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_33b72a992501f206_266_new)
+HX_DECLARE_CLASS3(haxe,ds,_List,ListNode)
+
+namespace haxe{
+namespace ds{
+namespace _List{
+
+
+class HXCPP_CLASS_ATTRIBUTES ListNode_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ListNode_obj OBJ_;
+		ListNode_obj();
+
+	public:
+		enum { _hx_ClassId = 0x714cdb28 };
+
+		void __construct( ::Dynamic item, ::haxe::ds::_List::ListNode next);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.ds._List.ListNode")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"haxe.ds._List.ListNode"); }
+
+		inline static hx::ObjectPtr< ListNode_obj > __new( ::Dynamic item, ::haxe::ds::_List::ListNode next) {
+			hx::ObjectPtr< ListNode_obj > __this = new ListNode_obj();
+			__this->__construct(item,next);
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< ListNode_obj > __alloc(hx::Ctx *_hx_ctx, ::Dynamic item, ::haxe::ds::_List::ListNode next) {
+			ListNode_obj *__this = (ListNode_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(ListNode_obj), true, "haxe.ds._List.ListNode"));
+			*(void **)__this = ListNode_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_33b72a992501f206_266_new)
+HXLINE( 267)		( ( ::haxe::ds::_List::ListNode)(__this) )->item = item;
+HXLINE( 268)		( ( ::haxe::ds::_List::ListNode)(__this) )->next = next;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ListNode_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ListNode",a0,95,b0,02); }
+
+		 ::Dynamic item;
+		 ::haxe::ds::_List::ListNode next;
+};
+
+} // end namespace haxe
+} // end namespace ds
+} // end namespace _List
+
+#endif /* INCLUDED_haxe_ds__List_ListNode */ 

hGameTest/bin/linux/obj/include/haxe/format/JsonParser.h

@@ -0,0 +1,69 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_format_JsonParser
+#define INCLUDED_haxe_format_JsonParser
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,format,JsonParser)
+
+namespace haxe{
+namespace format{
+
+
+class HXCPP_CLASS_ATTRIBUTES JsonParser_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef JsonParser_obj OBJ_;
+		JsonParser_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5b04dba4 };
+
+		void __construct(::String str);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.format.JsonParser")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"haxe.format.JsonParser"); }
+		static hx::ObjectPtr< JsonParser_obj > __new(::String str);
+		static hx::ObjectPtr< JsonParser_obj > __alloc(hx::Ctx *_hx_ctx,::String str);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~JsonParser_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("JsonParser",47,65,2e,25); }
+
+		::String str;
+		int pos;
+		 ::Dynamic doParse();
+		::Dynamic doParse_dyn();
+
+		 ::Dynamic parseRec();
+		::Dynamic parseRec_dyn();
+
+		::String parseString();
+		::Dynamic parseString_dyn();
+
+		void invalidChar();
+		::Dynamic invalidChar_dyn();
+
+		void invalidNumber(int start);
+		::Dynamic invalidNumber_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace format
+
+#endif /* INCLUDED_haxe_format_JsonParser */ 

hGameTest/bin/linux/obj/include/haxe/format/JsonPrinter.h

@@ -0,0 +1,75 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_format_JsonPrinter
+#define INCLUDED_haxe_format_JsonPrinter
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(StringBuf)
+HX_DECLARE_CLASS2(haxe,format,JsonPrinter)
+
+namespace haxe{
+namespace format{
+
+
+class HXCPP_CLASS_ATTRIBUTES JsonPrinter_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef JsonPrinter_obj OBJ_;
+		JsonPrinter_obj();
+
+	public:
+		enum { _hx_ClassId = 0x55464e91 };
+
+		void __construct( ::Dynamic replacer,::String space);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.format.JsonPrinter")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"haxe.format.JsonPrinter"); }
+		static hx::ObjectPtr< JsonPrinter_obj > __new( ::Dynamic replacer,::String space);
+		static hx::ObjectPtr< JsonPrinter_obj > __alloc(hx::Ctx *_hx_ctx, ::Dynamic replacer,::String space);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~JsonPrinter_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("JsonPrinter",72,68,9d,fd); }
+
+		static ::String print( ::Dynamic o, ::Dynamic replacer,::String space);
+		static ::Dynamic print_dyn();
+
+		 ::StringBuf buf;
+		 ::Dynamic replacer;
+		Dynamic replacer_dyn() { return replacer;}
+		::String indent;
+		bool pretty;
+		int nind;
+		void write( ::Dynamic k, ::Dynamic v);
+		::Dynamic write_dyn();
+
+		void classString( ::Dynamic v);
+		::Dynamic classString_dyn();
+
+		void fieldsString( ::Dynamic v,::Array< ::String > fields);
+		::Dynamic fieldsString_dyn();
+
+		void quote(::String s);
+		::Dynamic quote_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace format
+
+#endif /* INCLUDED_haxe_format_JsonPrinter */ 

hGameTest/bin/linux/obj/include/haxe/io/Bytes.h

@@ -0,0 +1,138 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_io_Bytes
+#define INCLUDED_haxe_io_Bytes
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_38344beec7696400
+#define INCLUDED_38344beec7696400
+#include "cpp/Int64.h"
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Encoding)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES Bytes_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Bytes_obj OBJ_;
+		Bytes_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5b931193 };
+
+		void __construct(int length,::Array< unsigned char > b);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.io.Bytes")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"haxe.io.Bytes"); }
+		static hx::ObjectPtr< Bytes_obj > __new(int length,::Array< unsigned char > b);
+		static hx::ObjectPtr< Bytes_obj > __alloc(hx::Ctx *_hx_ctx,int length,::Array< unsigned char > b);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Bytes_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Bytes",4b,78,c5,50); }
+
+		static  ::haxe::io::Bytes alloc(int length);
+		static ::Dynamic alloc_dyn();
+
+		static  ::haxe::io::Bytes ofString(::String s, ::haxe::io::Encoding encoding);
+		static ::Dynamic ofString_dyn();
+
+		static  ::haxe::io::Bytes ofData(::Array< unsigned char > b);
+		static ::Dynamic ofData_dyn();
+
+		static  ::haxe::io::Bytes ofHex(::String s);
+		static ::Dynamic ofHex_dyn();
+
+		static int fastGet(::Array< unsigned char > b,int pos);
+		static ::Dynamic fastGet_dyn();
+
+		int length;
+		::Array< unsigned char > b;
+		int get(int pos);
+		::Dynamic get_dyn();
+
+		void set(int pos,int v);
+		::Dynamic set_dyn();
+
+		void blit(int pos, ::haxe::io::Bytes src,int srcpos,int len);
+		::Dynamic blit_dyn();
+
+		void fill(int pos,int len,int value);
+		::Dynamic fill_dyn();
+
+		 ::haxe::io::Bytes sub(int pos,int len);
+		::Dynamic sub_dyn();
+
+		int compare( ::haxe::io::Bytes other);
+		::Dynamic compare_dyn();
+
+		Float getDouble(int pos);
+		::Dynamic getDouble_dyn();
+
+		Float getFloat(int pos);
+		::Dynamic getFloat_dyn();
+
+		void setDouble(int pos,Float v);
+		::Dynamic setDouble_dyn();
+
+		void setFloat(int pos,Float v);
+		::Dynamic setFloat_dyn();
+
+		int getUInt16(int pos);
+		::Dynamic getUInt16_dyn();
+
+		void setUInt16(int pos,int v);
+		::Dynamic setUInt16_dyn();
+
+		int getInt32(int pos);
+		::Dynamic getInt32_dyn();
+
+		 cpp::Int64Struct getInt64(int pos);
+		::Dynamic getInt64_dyn();
+
+		void setInt32(int pos,int v);
+		::Dynamic setInt32_dyn();
+
+		void setInt64(int pos, cpp::Int64Struct v);
+		::Dynamic setInt64_dyn();
+
+		::String getString(int pos,int len, ::haxe::io::Encoding encoding);
+		::Dynamic getString_dyn();
+
+		::String readString(int pos,int len);
+		::Dynamic readString_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+		::String toHex();
+		::Dynamic toHex_dyn();
+
+		::Array< unsigned char > getData();
+		::Dynamic getData_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Bytes */ 

hGameTest/bin/linux/obj/include/haxe/io/BytesBuffer.h

@@ -0,0 +1,57 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_io_BytesBuffer
+#define INCLUDED_haxe_io_BytesBuffer
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,BytesBuffer)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES BytesBuffer_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef BytesBuffer_obj OBJ_;
+		BytesBuffer_obj();
+
+	public:
+		enum { _hx_ClassId = 0x418818bb };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.io.BytesBuffer")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"haxe.io.BytesBuffer"); }
+		static hx::ObjectPtr< BytesBuffer_obj > __new();
+		static hx::ObjectPtr< BytesBuffer_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~BytesBuffer_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("BytesBuffer",ab,73,22,f6); }
+
+		::Array< unsigned char > b;
+		 ::haxe::io::Bytes getBytes();
+		::Dynamic getBytes_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_BytesBuffer */ 

hGameTest/bin/linux/obj/include/haxe/io/BytesInput.h

@@ -0,0 +1,65 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_io_BytesInput
+#define INCLUDED_haxe_io_BytesInput
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_io_Input
+#include <haxe/io/Input.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,BytesInput)
+HX_DECLARE_CLASS2(haxe,io,Input)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES BytesInput_obj : public  ::haxe::io::Input_obj
+{
+	public:
+		typedef  ::haxe::io::Input_obj super;
+		typedef BytesInput_obj OBJ_;
+		BytesInput_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2a8878af };
+
+		void __construct( ::haxe::io::Bytes b, ::Dynamic pos, ::Dynamic len);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.io.BytesInput")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"haxe.io.BytesInput"); }
+		static hx::ObjectPtr< BytesInput_obj > __new( ::haxe::io::Bytes b, ::Dynamic pos, ::Dynamic len);
+		static hx::ObjectPtr< BytesInput_obj > __alloc(hx::Ctx *_hx_ctx, ::haxe::io::Bytes b, ::Dynamic pos, ::Dynamic len);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~BytesInput_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("BytesInput",bf,cb,76,e6); }
+
+		::Array< unsigned char > b;
+		int pos;
+		int len;
+		int totlen;
+		int readByte();
+
+		int readBytes( ::haxe::io::Bytes buf,int pos,int len);
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_BytesInput */ 

hGameTest/bin/linux/obj/include/haxe/io/Encoding.h

@@ -0,0 +1,37 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_io_Encoding
+#define INCLUDED_haxe_io_Encoding
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Encoding)
+namespace haxe{
+namespace io{
+
+
+class Encoding_obj : public hx::EnumBase_obj
+{
+	typedef hx::EnumBase_obj super;
+		typedef Encoding_obj OBJ_;
+
+	public:
+		Encoding_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("haxe.io.Encoding",33,a6,6d,22); }
+		::String __ToString() const { return HX_("Encoding.",db,8b,f5,be) + _hx_tag; }
+
+		static ::haxe::io::Encoding RawNative;
+		static inline ::haxe::io::Encoding RawNative_dyn() { return RawNative; }
+		static ::haxe::io::Encoding UTF8;
+		static inline ::haxe::io::Encoding UTF8_dyn() { return UTF8; }
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Encoding */ 

hGameTest/bin/linux/obj/include/haxe/io/Eof.h

@@ -0,0 +1,67 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_io_Eof
+#define INCLUDED_haxe_io_Eof
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_f9cd114f27426261_29_new)
+HX_DECLARE_CLASS2(haxe,io,Eof)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES Eof_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Eof_obj OBJ_;
+		Eof_obj();
+
+	public:
+		enum { _hx_ClassId = 0x41324090 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.io.Eof")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"haxe.io.Eof"); }
+
+		inline static hx::ObjectPtr< Eof_obj > __new() {
+			hx::ObjectPtr< Eof_obj > __this = new Eof_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< Eof_obj > __alloc(hx::Ctx *_hx_ctx) {
+			Eof_obj *__this = (Eof_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Eof_obj), false, "haxe.io.Eof"));
+			*(void **)__this = Eof_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_f9cd114f27426261_29_new)
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Eof_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Eof",9c,bc,34,00); }
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Eof */ 

hGameTest/bin/linux/obj/include/haxe/io/Error.h

@@ -0,0 +1,41 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_io_Error
+#define INCLUDED_haxe_io_Error
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Error)
+namespace haxe{
+namespace io{
+
+
+class Error_obj : public hx::EnumBase_obj
+{
+	typedef hx::EnumBase_obj super;
+		typedef Error_obj OBJ_;
+
+	public:
+		Error_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("haxe.io.Error",68,16,01,55); }
+		::String __ToString() const { return HX_("Error.",86,f7,fc,85) + _hx_tag; }
+
+		static ::haxe::io::Error Blocked;
+		static inline ::haxe::io::Error Blocked_dyn() { return Blocked; }
+		static ::haxe::io::Error Custom( ::Dynamic e);
+		static ::Dynamic Custom_dyn();
+		static ::haxe::io::Error OutsideBounds;
+		static inline ::haxe::io::Error OutsideBounds_dyn() { return OutsideBounds; }
+		static ::haxe::io::Error Overflow;
+		static inline ::haxe::io::Error Overflow_dyn() { return Overflow; }
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Error */ 

hGameTest/bin/linux/obj/include/haxe/io/FPHelper.h

@@ -0,0 +1,75 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_io_FPHelper
+#define INCLUDED_haxe_io_FPHelper
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_38344beec7696400
+#define INCLUDED_38344beec7696400
+#include "cpp/Int64.h"
+#endif
+HX_DECLARE_CLASS2(haxe,io,FPHelper)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES FPHelper_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef FPHelper_obj OBJ_;
+		FPHelper_obj();
+
+	public:
+		enum { _hx_ClassId = 0x349ee9e4 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.io.FPHelper")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"haxe.io.FPHelper"); }
+
+		inline static hx::ObjectPtr< FPHelper_obj > __new() {
+			hx::ObjectPtr< FPHelper_obj > __this = new FPHelper_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< FPHelper_obj > __alloc(hx::Ctx *_hx_ctx) {
+			FPHelper_obj *__this = (FPHelper_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(FPHelper_obj), false, "haxe.io.FPHelper"));
+			*(void **)__this = FPHelper_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~FPHelper_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("FPHelper",58,42,63,db); }
+
+		static Float i32ToFloat(int i);
+		static ::Dynamic i32ToFloat_dyn();
+
+		static int floatToI32(Float f);
+		static ::Dynamic floatToI32_dyn();
+
+		static Float i64ToDouble(int low,int high);
+		static ::Dynamic i64ToDouble_dyn();
+
+		static  cpp::Int64Struct doubleToI64(Float v);
+		static ::Dynamic doubleToI64_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_FPHelper */ 

hGameTest/bin/linux/obj/include/haxe/io/Input.h

@@ -0,0 +1,94 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_io_Input
+#define INCLUDED_haxe_io_Input
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Encoding)
+HX_DECLARE_CLASS2(haxe,io,Input)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES Input_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Input_obj OBJ_;
+		Input_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5c18cd32 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.io.Input")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"haxe.io.Input"); }
+
+		inline static hx::ObjectPtr< Input_obj > __new() {
+			hx::ObjectPtr< Input_obj > __this = new Input_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< Input_obj > __alloc(hx::Ctx *_hx_ctx) {
+			Input_obj *__this = (Input_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Input_obj), false, "haxe.io.Input"));
+			*(void **)__this = Input_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Input_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Input",ea,33,4b,51); }
+
+		bool bigEndian;
+		virtual int readByte();
+		::Dynamic readByte_dyn();
+
+		virtual int readBytes( ::haxe::io::Bytes s,int pos,int len);
+		::Dynamic readBytes_dyn();
+
+		virtual void close();
+		::Dynamic close_dyn();
+
+		void readFullBytes( ::haxe::io::Bytes s,int pos,int len);
+		::Dynamic readFullBytes_dyn();
+
+		 ::haxe::io::Bytes read(int nbytes);
+		::Dynamic read_dyn();
+
+		::String readLine();
+		::Dynamic readLine_dyn();
+
+		int readInt16();
+		::Dynamic readInt16_dyn();
+
+		int readUInt16();
+		::Dynamic readUInt16_dyn();
+
+		int readInt32();
+		::Dynamic readInt32_dyn();
+
+		::String readString(int len, ::haxe::io::Encoding encoding);
+		::Dynamic readString_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Input */ 

hGameTest/bin/linux/obj/include/haxe/io/Output.h

@@ -0,0 +1,58 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_io_Output
+#define INCLUDED_haxe_io_Output
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Output)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES Output_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Output_obj OBJ_;
+		Output_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3473efad };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.io.Output")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"haxe.io.Output"); }
+
+		inline static hx::ObjectPtr< Output_obj > __new() {
+			hx::ObjectPtr< Output_obj > __this = new Output_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< Output_obj > __alloc(hx::Ctx *_hx_ctx) {
+			Output_obj *__this = (Output_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Output_obj), false, "haxe.io.Output"));
+			*(void **)__this = Output_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Output_obj();
+
+		HX_DO_RTTI_ALL;
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Output",21,83,15,41); }
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Output */ 

hGameTest/bin/linux/obj/include/haxe/io/Path.h

@@ -0,0 +1,72 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_io_Path
+#define INCLUDED_haxe_io_Path
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Path)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES Path_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Path_obj OBJ_;
+		Path_obj();
+
+	public:
+		enum { _hx_ClassId = 0x044b6ab5 };
+
+		void __construct(::String path);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.io.Path")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"haxe.io.Path"); }
+		static hx::ObjectPtr< Path_obj > __new(::String path);
+		static hx::ObjectPtr< Path_obj > __alloc(hx::Ctx *_hx_ctx,::String path);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Path_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Path",c5,11,2b,35); }
+
+		static ::String withoutDirectory(::String path);
+		static ::Dynamic withoutDirectory_dyn();
+
+		static ::String directory(::String path);
+		static ::Dynamic directory_dyn();
+
+		static ::String addTrailingSlash(::String path);
+		static ::Dynamic addTrailingSlash_dyn();
+
+		static ::String removeTrailingSlashes(::String path);
+		static ::Dynamic removeTrailingSlashes_dyn();
+
+		::String dir;
+		::String file;
+		::String ext;
+		bool backslash;
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Path */ 

hGameTest/bin/linux/obj/include/haxe/iterators/ArrayIterator.h

@@ -0,0 +1,78 @@
+// Generated by Haxe 4.1.5
+#ifndef INCLUDED_haxe_iterators_ArrayIterator
+#define INCLUDED_haxe_iterators_ArrayIterator
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_4080537b5ff1f511_28_new)
+HX_DECLARE_CLASS2(haxe,iterators,ArrayIterator)
+
+namespace haxe{
+namespace iterators{
+
+
+class HXCPP_CLASS_ATTRIBUTES ArrayIterator_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef ArrayIterator_obj OBJ_;
+		ArrayIterator_obj();
+
+	public:
+		enum { _hx_ClassId = 0x189859c8 };
+
+		void __construct(::cpp::VirtualArray array);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.iterators.ArrayIterator")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.iterators.ArrayIterator"); }
+
+		inline static ::hx::ObjectPtr< ArrayIterator_obj > __new(::cpp::VirtualArray array) {
+			::hx::ObjectPtr< ArrayIterator_obj > __this = new ArrayIterator_obj();
+			__this->__construct(array);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< ArrayIterator_obj > __alloc(::hx::Ctx *_hx_ctx,::cpp::VirtualArray array) {
+			ArrayIterator_obj *__this = (ArrayIterator_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(ArrayIterator_obj), true, "haxe.iterators.ArrayIterator"));
+			*(void **)__this = ArrayIterator_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_4080537b5ff1f511_28_new)
+HXLINE(  30)		( ( ::haxe::iterators::ArrayIterator)(__this) )->current = 0;
+HXLINE(  37)		( ( ::haxe::iterators::ArrayIterator)(__this) )->array = array;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ArrayIterator_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ArrayIterator",87,84,c8,5d); }
+
+		::cpp::VirtualArray array;
+		int current;
+		bool hasNext();
+		::Dynamic hasNext_dyn();
+
+		 ::Dynamic next();
+		::Dynamic next_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace iterators
+
+#endif /* INCLUDED_haxe_iterators_ArrayIterator */ 

hGameTest/bin/linux/obj/include/haxe/lang/Iterable.h

@@ -0,0 +1,31 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_lang_Iterable
+#define INCLUDED_haxe_lang_Iterable
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,lang,Iterable)
+HX_DECLARE_CLASS2(haxe,lang,Iterator)
+
+namespace haxe{
+namespace lang{
+
+
+class HXCPP_CLASS_ATTRIBUTES Iterable_obj {
+	public:
+		typedef hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		static void __boot();
+		::Dynamic (hx::Object :: *_hx_iterator)(); 
+		static inline ::Dynamic iterator( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( hx::interface_cast< ::haxe::lang::Iterable_obj *>(_hx_.mPtr->_hx_getInterface(0x1f692be6)))->_hx_iterator)();
+		}
+};
+
+} // end namespace haxe
+} // end namespace lang
+
+#endif /* INCLUDED_haxe_lang_Iterable */ 

hGameTest/bin/linux/obj/include/haxe/lang/Iterator.h

@@ -0,0 +1,34 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_lang_Iterator
+#define INCLUDED_haxe_lang_Iterator
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,lang,Iterator)
+
+namespace haxe{
+namespace lang{
+
+
+class HXCPP_CLASS_ATTRIBUTES Iterator_obj {
+	public:
+		typedef hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		static void __boot();
+		bool (hx::Object :: *_hx_hasNext)(); 
+		static inline bool hasNext( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( hx::interface_cast< ::haxe::lang::Iterator_obj *>(_hx_.mPtr->_hx_getInterface(0x1f76d722)))->_hx_hasNext)();
+		}
+		 ::Dynamic (hx::Object :: *_hx_next)(); 
+		static inline  ::Dynamic next( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( hx::interface_cast< ::haxe::lang::Iterator_obj *>(_hx_.mPtr->_hx_getInterface(0x1f76d722)))->_hx_next)();
+		}
+};
+
+} // end namespace haxe
+} // end namespace lang
+
+#endif /* INCLUDED_haxe_lang_Iterator */ 

hGameTest/bin/linux/obj/include/haxe/zip/ExtraField.h

@@ -0,0 +1,40 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_zip_ExtraField
+#define INCLUDED_haxe_zip_ExtraField
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,zip,ExtraField)
+namespace haxe{
+namespace zip{
+
+
+class ExtraField_obj : public hx::EnumBase_obj
+{
+	typedef hx::EnumBase_obj super;
+		typedef ExtraField_obj OBJ_;
+
+	public:
+		ExtraField_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("haxe.zip.ExtraField",df,af,f8,91); }
+		::String __ToString() const { return HX_("ExtraField.",c4,80,7a,63) + _hx_tag; }
+
+		static ::haxe::zip::ExtraField FInfoZipUnicodePath(::String name,int crc);
+		static ::Dynamic FInfoZipUnicodePath_dyn();
+		static ::haxe::zip::ExtraField FUnknown(int tag, ::haxe::io::Bytes bytes);
+		static ::Dynamic FUnknown_dyn();
+		static ::haxe::zip::ExtraField FUtf8;
+		static inline ::haxe::zip::ExtraField FUtf8_dyn() { return FUtf8; }
+};
+
+} // end namespace haxe
+} // end namespace zip
+
+#endif /* INCLUDED_haxe_zip_ExtraField */ 

hGameTest/bin/linux/obj/include/haxe/zip/HuffTools.h

@@ -0,0 +1,66 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_zip_HuffTools
+#define INCLUDED_haxe_zip_HuffTools
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,IntMap)
+HX_DECLARE_CLASS2(haxe,zip,HuffTools)
+HX_DECLARE_CLASS2(haxe,zip,Huffman)
+
+namespace haxe{
+namespace zip{
+
+
+class HXCPP_CLASS_ATTRIBUTES HuffTools_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef HuffTools_obj OBJ_;
+		HuffTools_obj();
+
+	public:
+		enum { _hx_ClassId = 0x10a15413 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.zip.HuffTools")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"haxe.zip.HuffTools"); }
+		static hx::ObjectPtr< HuffTools_obj > __new();
+		static hx::ObjectPtr< HuffTools_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~HuffTools_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HuffTools",2e,d1,43,79); }
+
+		int treeDepth( ::haxe::zip::Huffman t);
+		::Dynamic treeDepth_dyn();
+
+		 ::haxe::zip::Huffman treeCompress( ::haxe::zip::Huffman t);
+		::Dynamic treeCompress_dyn();
+
+		void treeWalk(::Array< ::Dynamic> table,int p,int cd,int d, ::haxe::zip::Huffman t);
+		::Dynamic treeWalk_dyn();
+
+		 ::haxe::zip::Huffman treeMake( ::haxe::ds::IntMap bits,int maxbits,int v,int len);
+		::Dynamic treeMake_dyn();
+
+		 ::haxe::zip::Huffman make(::Array< int > lengths,int pos,int nlengths,int maxbits);
+		::Dynamic make_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace zip
+
+#endif /* INCLUDED_haxe_zip_HuffTools */ 

hGameTest/bin/linux/obj/include/haxe/zip/Huffman.h

@@ -0,0 +1,39 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_zip_Huffman
+#define INCLUDED_haxe_zip_Huffman
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,zip,Huffman)
+namespace haxe{
+namespace zip{
+
+
+class Huffman_obj : public hx::EnumBase_obj
+{
+	typedef hx::EnumBase_obj super;
+		typedef Huffman_obj OBJ_;
+
+	public:
+		Huffman_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("haxe.zip.Huffman",38,d8,1f,47); }
+		::String __ToString() const { return HX_("Huffman.",81,94,1b,e3) + _hx_tag; }
+
+		static ::haxe::zip::Huffman Found(int i);
+		static ::Dynamic Found_dyn();
+		static ::haxe::zip::Huffman NeedBit( ::haxe::zip::Huffman left, ::haxe::zip::Huffman right);
+		static ::Dynamic NeedBit_dyn();
+		static ::haxe::zip::Huffman NeedBits(int n,::Array< ::Dynamic> table);
+		static ::Dynamic NeedBits_dyn();
+};
+
+} // end namespace haxe
+} // end namespace zip
+
+#endif /* INCLUDED_haxe_zip_Huffman */ 

hGameTest/bin/linux/obj/include/haxe/zip/InflateImpl.h

@@ -0,0 +1,121 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_zip_InflateImpl
+#define INCLUDED_haxe_zip_InflateImpl
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Input)
+HX_DECLARE_CLASS2(haxe,zip,HuffTools)
+HX_DECLARE_CLASS2(haxe,zip,Huffman)
+HX_DECLARE_CLASS2(haxe,zip,InflateImpl)
+HX_DECLARE_CLASS3(haxe,zip,_InflateImpl,State)
+HX_DECLARE_CLASS3(haxe,zip,_InflateImpl,Window)
+
+namespace haxe{
+namespace zip{
+
+
+class HXCPP_CLASS_ATTRIBUTES InflateImpl_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef InflateImpl_obj OBJ_;
+		InflateImpl_obj();
+
+	public:
+		enum { _hx_ClassId = 0x53e7f50c };
+
+		void __construct( ::haxe::io::Input i, ::Dynamic __o_header, ::Dynamic __o_crc);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.zip.InflateImpl")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"haxe.zip.InflateImpl"); }
+		static hx::ObjectPtr< InflateImpl_obj > __new( ::haxe::io::Input i, ::Dynamic __o_header, ::Dynamic __o_crc);
+		static hx::ObjectPtr< InflateImpl_obj > __alloc(hx::Ctx *_hx_ctx, ::haxe::io::Input i, ::Dynamic __o_header, ::Dynamic __o_crc);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~InflateImpl_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("InflateImpl",e7,2e,f8,07); }
+
+		static void __boot();
+		static ::Array< int > LEN_EXTRA_BITS_TBL;
+		static ::Array< int > LEN_BASE_VAL_TBL;
+		static ::Array< int > DIST_EXTRA_BITS_TBL;
+		static ::Array< int > DIST_BASE_VAL_TBL;
+		static ::Array< int > CODE_LENGTHS_POS;
+		static  ::haxe::zip::Huffman FIXED_HUFFMAN;
+		int nbits;
+		int bits;
+		 ::haxe::zip::_InflateImpl::State state;
+		bool isFinal;
+		 ::haxe::zip::Huffman huffman;
+		 ::haxe::zip::Huffman huffdist;
+		 ::haxe::zip::HuffTools htools;
+		int len;
+		int dist;
+		int needed;
+		 ::haxe::io::Bytes output;
+		int outpos;
+		 ::haxe::io::Input input;
+		::Array< int > lengths;
+		 ::haxe::zip::_InflateImpl::Window window;
+		 ::haxe::zip::Huffman buildFixedHuffman();
+		::Dynamic buildFixedHuffman_dyn();
+
+		int readBytes( ::haxe::io::Bytes b,int pos,int len);
+		::Dynamic readBytes_dyn();
+
+		int getBits(int n);
+		::Dynamic getBits_dyn();
+
+		bool getBit();
+		::Dynamic getBit_dyn();
+
+		int getRevBits(int n);
+		::Dynamic getRevBits_dyn();
+
+		void resetBits();
+		::Dynamic resetBits_dyn();
+
+		void addBytes( ::haxe::io::Bytes b,int p,int len);
+		::Dynamic addBytes_dyn();
+
+		void addByte(int b);
+		::Dynamic addByte_dyn();
+
+		void addDistOne(int n);
+		::Dynamic addDistOne_dyn();
+
+		void addDist(int d,int len);
+		::Dynamic addDist_dyn();
+
+		int applyHuffman( ::haxe::zip::Huffman h);
+		::Dynamic applyHuffman_dyn();
+
+		void inflateLengths(::Array< int > a,int max);
+		::Dynamic inflateLengths_dyn();
+
+		bool inflateLoop();
+		::Dynamic inflateLoop_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace zip
+
+#endif /* INCLUDED_haxe_zip_InflateImpl */ 

hGameTest/bin/linux/obj/include/haxe/zip/Reader.h

@@ -0,0 +1,76 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_zip_Reader
+#define INCLUDED_haxe_zip_Reader
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(Date)
+HX_DECLARE_CLASS2(haxe,ds,List)
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Input)
+HX_DECLARE_CLASS2(haxe,zip,Reader)
+
+namespace haxe{
+namespace zip{
+
+
+class HXCPP_CLASS_ATTRIBUTES Reader_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Reader_obj OBJ_;
+		Reader_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2836055e };
+
+		void __construct( ::haxe::io::Input i);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.zip.Reader")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"haxe.zip.Reader"); }
+		static hx::ObjectPtr< Reader_obj > __new( ::haxe::io::Input i);
+		static hx::ObjectPtr< Reader_obj > __alloc(hx::Ctx *_hx_ctx, ::haxe::io::Input i);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Reader_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Reader",63,19,26,31); }
+
+		static  ::haxe::ds::List readZip( ::haxe::io::Input i);
+		static ::Dynamic readZip_dyn();
+
+		static  ::haxe::io::Bytes unzip( ::Dynamic f);
+		static ::Dynamic unzip_dyn();
+
+		 ::haxe::io::Input i;
+		 ::Date readZipDate();
+		::Dynamic readZipDate_dyn();
+
+		 ::haxe::ds::List readExtraFields(int length);
+		::Dynamic readExtraFields_dyn();
+
+		 ::Dynamic readEntryHeader();
+		::Dynamic readEntryHeader_dyn();
+
+		 ::haxe::ds::List read();
+		::Dynamic read_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace zip
+
+#endif /* INCLUDED_haxe_zip_Reader */ 

hGameTest/bin/linux/obj/include/haxe/zip/_InflateImpl/State.h

@@ -0,0 +1,51 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_zip__InflateImpl_State
+#define INCLUDED_haxe_zip__InflateImpl_State
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(haxe,zip,_InflateImpl,State)
+namespace haxe{
+namespace zip{
+namespace _InflateImpl{
+
+
+class State_obj : public hx::EnumBase_obj
+{
+	typedef hx::EnumBase_obj super;
+		typedef State_obj OBJ_;
+
+	public:
+		State_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("haxe.zip._InflateImpl.State",a0,c2,8b,f6); }
+		::String __ToString() const { return HX_("State.",1d,4d,90,3a) + _hx_tag; }
+
+		static ::haxe::zip::_InflateImpl::State Block;
+		static inline ::haxe::zip::_InflateImpl::State Block_dyn() { return Block; }
+		static ::haxe::zip::_InflateImpl::State CData;
+		static inline ::haxe::zip::_InflateImpl::State CData_dyn() { return CData; }
+		static ::haxe::zip::_InflateImpl::State Crc;
+		static inline ::haxe::zip::_InflateImpl::State Crc_dyn() { return Crc; }
+		static ::haxe::zip::_InflateImpl::State Dist;
+		static inline ::haxe::zip::_InflateImpl::State Dist_dyn() { return Dist; }
+		static ::haxe::zip::_InflateImpl::State DistOne;
+		static inline ::haxe::zip::_InflateImpl::State DistOne_dyn() { return DistOne; }
+		static ::haxe::zip::_InflateImpl::State Done;
+		static inline ::haxe::zip::_InflateImpl::State Done_dyn() { return Done; }
+		static ::haxe::zip::_InflateImpl::State Flat;
+		static inline ::haxe::zip::_InflateImpl::State Flat_dyn() { return Flat; }
+		static ::haxe::zip::_InflateImpl::State Head;
+		static inline ::haxe::zip::_InflateImpl::State Head_dyn() { return Head; }
+};
+
+} // end namespace haxe
+} // end namespace zip
+} // end namespace _InflateImpl
+
+#endif /* INCLUDED_haxe_zip__InflateImpl_State */ 

hGameTest/bin/linux/obj/include/haxe/zip/_InflateImpl/Window.h

@@ -0,0 +1,77 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_zip__InflateImpl_Window
+#define INCLUDED_haxe_zip__InflateImpl_Window
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,crypto,Adler32)
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS3(haxe,zip,_InflateImpl,Window)
+
+namespace haxe{
+namespace zip{
+namespace _InflateImpl{
+
+
+class HXCPP_CLASS_ATTRIBUTES Window_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Window_obj OBJ_;
+		Window_obj();
+
+	public:
+		enum { _hx_ClassId = 0x021b9cf3 };
+
+		void __construct(bool hasCrc);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.zip._InflateImpl.Window")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"haxe.zip._InflateImpl.Window"); }
+		static hx::ObjectPtr< Window_obj > __new(bool hasCrc);
+		static hx::ObjectPtr< Window_obj > __alloc(hx::Ctx *_hx_ctx,bool hasCrc);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Window_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Window",10,08,21,87); }
+
+		 ::haxe::io::Bytes buffer;
+		int pos;
+		 ::haxe::crypto::Adler32 crc;
+		void slide();
+		::Dynamic slide_dyn();
+
+		void addBytes( ::haxe::io::Bytes b,int p,int len);
+		::Dynamic addBytes_dyn();
+
+		void addByte(int c);
+		::Dynamic addByte_dyn();
+
+		int getLastChar();
+		::Dynamic getLastChar_dyn();
+
+		int available();
+		::Dynamic available_dyn();
+
+		 ::haxe::crypto::Adler32 checksum();
+		::Dynamic checksum_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace zip
+} // end namespace _InflateImpl
+
+#endif /* INCLUDED_haxe_zip__InflateImpl_Window */