Update Files

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Anon.h

@@ -0,0 +1,755 @@
+#ifndef HX_ANON_H
+#define HX_ANON_H
+
+
+namespace hx
+{
+
+typedef Dynamic FieldMap;
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic FieldMapCreate();
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+bool FieldMapGet(Dynamic *inMap, const ::String &inName, ::Dynamic &outValue);
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+bool FieldMapHas(Dynamic *inMap, const ::String &inName);
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+bool FieldMapGet(Dynamic *inMap, int inID, ::Dynamic &outValue);
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+#ifdef HXCPP_GC_GENERATIONAL
+void FieldMapSet(hx::Object *inThis,Dynamic *inMap, const ::String &inName, const ::Dynamic &inValue);
+#else
+void FieldMapSet(Dynamic *inMap, const ::String &inName, const ::Dynamic &inValue);
+#endif
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+void FieldMapAppendFields(Dynamic *inMap,::Array< ::String> &outFields);
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+void FieldMapMark(Dynamic *inMap,hx::MarkContext *__inCtx);
+#ifdef HXCPP_VISIT_ALLOCS
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+void FieldMapVisit(Dynamic **inMap,hx::VisitContext *__inCtx);
+#endif
+
+} // end namespace hx
+
+
+
+
+namespace hx
+{
+
+// --- hx::Anon_obj ----------------------------------------------
+//
+// The hx::Anon_obj contains an arbitrary string map of fields.
+
+class HXCPP_EXTERN_CLASS_ATTRIBUTES Anon_obj : public hx::Object
+{
+   typedef hx::Anon_obj OBJ_;
+   typedef hx::ObjectPtr<hx::Anon_obj> Anon;
+   typedef hx::Object super;
+
+   inline void *operator new( size_t inSize, int inExtra )
+   {
+      return hx::Object::operator new(inSize+inExtra, true, 0);
+   }
+
+   struct VariantKey
+   {
+      int    hash;
+      String key;
+      cpp::Variant value;
+   };
+
+   Dynamic mFields;
+   int     mFixedFields;
+
+public:
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdDynamic };
+
+   inline void *operator new( size_t inSize )
+   {
+      return hx::Object::operator new(inSize, true, 0);
+   }
+   inline void operator delete(void *, size_t inSize ) { }
+   inline void operator delete(void *, size_t inSize, int inExtra ) { }
+
+   inline Anon_obj *setFixed(int index, const String &inName, const ::cpp::Variant &inValue)
+   {
+      VariantKey *fixed = getFixed() + index;
+      fixed->hash = inName.hash();
+      fixed->key = inName;
+      fixed->value = inValue;
+      if (inValue.type == ::cpp::Variant::typeObject) {
+        HX_OBJ_WB_GET(this, inValue.valObject);
+      }
+      else if (inValue.type == ::cpp::Variant::typeString) {
+        HX_OBJ_WB_GET(this, inValue.valStringPtr);
+      }
+      return this;
+   }
+   inline VariantKey *getFixed()
+   {
+      return (VariantKey *)(this + 1);
+   }
+   inline int findFixed(const ::String &inKey,bool inSkip5 = false);
+
+
+
+
+   Anon_obj(int inFixedFields = 0);
+
+   static Anon Create(int inElements)
+   {
+      return Anon(new (inElements*sizeof(VariantKey) ) hx::Anon_obj(inElements) );
+   }
+
+   static Anon Create() { return Anon(new (0) hx::Anon_obj); }
+   static Anon Create(const Dynamic &inSrc) { return Anon(new (0) hx::Anon_obj); }
+
+   static Dynamic __CreateEmpty() { return Anon(new (0) hx::Anon_obj); }
+   static Dynamic __Create(DynamicArray inArgs);
+   static void __boot();
+
+   void operator delete( void *, int) { }
+
+
+   hx::Val __Field(const String &inString ,hx::PropertyAccess inCallProp);
+   bool __HasField(const String &inString);
+   hx::Val __SetField(const String &inString,const hx::Val &inValue ,hx::PropertyAccess inCallProp);
+   virtual void __GetFields(Array<String> &outFields);
+   Dynamic *__GetFieldMap() { return &mFields; }
+
+   virtual int __GetType() const { return vtObject; }
+
+   hx::Anon_obj *Add(const String &inName,const Dynamic &inValue,bool inSetThisPointer=true);
+   void __Mark(hx::MarkContext *__inCtx);
+   #ifdef HXCPP_VISIT_ALLOCS
+   void __Visit(hx::VisitContext *__inCtx);
+   #endif
+
+   String __ToString() const;
+   String toString();
+
+   static hx::ObjectPtr<hx::Class_obj> __mClass; \
+   static hx::ObjectPtr<hx::Class_obj> &__SGetClass() { return __mClass; }
+   #if (HXCPP_API_LEVEL<331)
+   bool __Is(hx::Object *inObj) const { return dynamic_cast<OBJ_ *>(inObj)!=0; }
+   #endif
+   hx::ObjectPtr<hx::Class_obj > __GetClass() const { return __mClass; }
+
+   bool __Remove(String inKey);
+};
+
+
+typedef hx::ObjectPtr<hx::Anon_obj> Anon;
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Anon SourceInfo(String inFile, int inLine, String inClass, String inMethod);
+
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES String StringFromAnonFields(hx::Object *inPtr);
+
+
+template<typename _hx_T0>
+class AnonStruct1_obj : public hx::Object
+{
+public:
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdDynamic };
+
+   String name0; _hx_T0 t0;
+
+   inline static hx::Object *Create(const String &inName0, _hx_T0 inT0)
+   {
+      AnonStruct1_obj *result = new AnonStruct1_obj;
+      result->name0 = inName0; result->t0 = inT0;
+      if (hx::ContainsPointers<_hx_T0>()) {
+        HX_OBJ_WB_GET(result, hx::PointerOf(inT0));
+      }
+      return result;
+   }
+   hx::Val __Field(const String &inField, hx::PropertyAccess)
+   {
+      if (HX_QSTR_EQ(inField,name0)) return t0;
+      return null();
+   }
+   hx::Val __SetField(const String &inField,const hx::Val &inValue, hx::PropertyAccess inCallProp)
+   {
+      if (inField.__s==name0.__s || HX_QSTR_EQ(inField,name0)) {
+        t0 = inValue.Cast< _hx_T0 >();
+        if (hx::ContainsPointers<_hx_T0>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t0));
+        }
+        return inValue;
+      }
+      hx::Throw(HX_CSTRING("Missing field ") + inField);
+      return inValue;
+   }
+
+   void __Mark(hx::MarkContext *__inCtx)
+   {
+      HX_MARK_MEMBER(t0);
+   }
+   #ifdef HXCPP_VISIT_ALLOCS
+   void __Visit(hx::VisitContext *__inCtx)
+   {
+      HX_VISIT_MEMBER(t0);
+   }
+   #endif
+
+    void __GetFields(Array<String> &outFields)
+    {
+       outFields->push(name0);
+    }
+
+   String toString() { return StringFromAnonFields(this); }
+};
+
+
+
+template<typename _hx_T0, typename _hx_T1>
+class AnonStruct2_obj : public hx::Object
+{
+public:
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdDynamic };
+
+   String name0; _hx_T0 t0;
+   String name1; _hx_T1 t1;
+
+   inline static hx::Object *Create(const String &inName0, _hx_T0 inT0,
+                             const String &inName1, _hx_T1 inT1)
+   {
+      AnonStruct2_obj *result = new AnonStruct2_obj;
+      result->name0 = inName0; result->t0 = inT0;
+      if (hx::ContainsPointers<_hx_T0>()) {
+        HX_OBJ_WB_GET(result, hx::PointerOf(inT0));
+      }
+      result->name1 = inName1; result->t1 = inT1;
+      if (hx::ContainsPointers<_hx_T1>()) {
+        HX_OBJ_WB_GET(result, hx::PointerOf(inT1));
+      }
+      return result;
+   }
+   hx::Val __Field(const String &inField, hx::PropertyAccess)
+   {
+      if (inField.__s==name0.__s) return t0;
+      if (inField.__s==name1.__s) return t1;
+
+      #ifdef HX_SMART_STRINGS
+      if (!inField.isAsciiEncodedQ())
+         return null();
+      #endif
+
+      if (HX_QSTR_EQ_AE(inField,name0)) return t0;
+      if (HX_QSTR_EQ_AE(inField,name1)) return t1;
+      return null();
+   }
+   hx::Val __SetField(const String &inField,const hx::Val &inValue, hx::PropertyAccess inCallProp)
+   {
+      if (inField.__s==name0.__s) {
+        t0 = inValue.Cast< _hx_T0 >();
+        if (hx::ContainsPointers<_hx_T0>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t0));
+        }
+        return inValue;
+      }
+      if (inField.__s==name1.__s) {
+        t1 = inValue.Cast< _hx_T1 >();
+        if (hx::ContainsPointers<_hx_T1>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t1));
+        }
+        return inValue;
+      }
+
+      if (HX_QSTR_EQ(inField,name0)) {
+        t0 = inValue.Cast< _hx_T0 >();
+        if (hx::ContainsPointers<_hx_T0>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t0));
+        }
+        return inValue;
+      }
+      if (HX_QSTR_EQ(inField,name1)) {
+        t1 = inValue.Cast< _hx_T1 >();
+        if (hx::ContainsPointers<_hx_T1>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t1));
+        }
+        return inValue;
+      }
+      hx::Throw(HX_CSTRING("Missing field ") + inField);
+      return inValue;
+   }
+
+   void __Mark(hx::MarkContext *__inCtx)
+   {
+      HX_MARK_MEMBER(t0);
+      HX_MARK_MEMBER(t1);
+   }
+   #ifdef HXCPP_VISIT_ALLOCS
+   void __Visit(hx::VisitContext *__inCtx)
+   {
+      HX_VISIT_MEMBER(t0);
+      HX_VISIT_MEMBER(t1);
+   }
+   #endif
+
+    void __GetFields(Array<String> &outFields)
+    {
+       outFields->push(name0);
+       outFields->push(name1);
+    }
+
+   String toString() { return StringFromAnonFields(this); }
+
+};
+
+
+
+template<typename _hx_T0, typename _hx_T1, typename _hx_T2>
+class AnonStruct3_obj : public hx::Object
+{
+public:
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdDynamic };
+
+   String name0; _hx_T0 t0;
+   String name1; _hx_T1 t1;
+   String name2; _hx_T2 t2;
+
+   inline static hx::Object *Create(const String &inName0, _hx_T0 inT0,
+                             const String &inName1, _hx_T1 inT1,
+                             const String &inName2, _hx_T2 inT2)
+   {
+      AnonStruct3_obj *result = new AnonStruct3_obj;
+      result->name0 = inName0; result->t0 = inT0;
+      if (hx::ContainsPointers<_hx_T0>()) {
+        HX_OBJ_WB_GET(result, hx::PointerOf(inT0));
+      }
+      result->name1 = inName1; result->t1 = inT1;
+      if (hx::ContainsPointers<_hx_T1>()) {
+        HX_OBJ_WB_GET(result, hx::PointerOf(inT1));
+      }
+      result->name2 = inName2; result->t2 = inT2;
+      if (hx::ContainsPointers<_hx_T2>()) {
+        HX_OBJ_WB_GET(result, hx::PointerOf(inT2));
+      }
+      return result;
+   }
+   hx::Val __Field(const String &inField, hx::PropertyAccess)
+   {
+      if (inField.__s==name0.__s) return t0;
+      if (inField.__s==name1.__s) return t1;
+      if (inField.__s==name2.__s) return t2;
+      #ifdef HX_SMART_STRINGS
+      if (!inField.isAsciiEncodedQ())
+         return null();
+      #endif
+      if (HX_QSTR_EQ_AE(inField,name0)) return t0;
+      if (HX_QSTR_EQ_AE(inField,name1)) return t1;
+      if (HX_QSTR_EQ_AE(inField,name2)) return t2;
+      return null();
+   }
+   hx::Val __SetField(const String &inField,const hx::Val &inValue, hx::PropertyAccess inCallProp)
+   {
+      if (inField.__s==name0.__s) {
+        t0 = inValue.Cast< _hx_T0 >();
+        if (hx::ContainsPointers<_hx_T0>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t0));
+        }
+        return inValue;
+      }
+      if (inField.__s==name1.__s) {
+        t1 = inValue.Cast< _hx_T1 >();
+        if (hx::ContainsPointers<_hx_T1>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t1));
+        }
+        return inValue;
+      }
+      if (inField.__s==name2.__s) {
+        t2 = inValue.Cast< _hx_T2 >();
+        if (hx::ContainsPointers<_hx_T2>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t2));
+        }
+        return inValue;
+      }
+
+
+      if (HX_QSTR_EQ(inField,name0)) {
+        t0 = inValue.Cast< _hx_T0 >();
+        if (hx::ContainsPointers<_hx_T0>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t0));
+        }
+        return inValue;
+      }
+      if (HX_QSTR_EQ(inField,name1)) {
+        t1 = inValue.Cast< _hx_T1 >();
+        if (hx::ContainsPointers<_hx_T1>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t1));
+        }
+        return inValue;
+      }
+      if (HX_QSTR_EQ(inField,name2)) {
+        t2 = inValue.Cast< _hx_T2 >();
+        if (hx::ContainsPointers<_hx_T2>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t2));
+        }
+        return inValue;
+      }
+      hx::Throw(HX_CSTRING("Missing field ") + inField);
+      return inValue;
+   }
+
+   void __Mark(hx::MarkContext *__inCtx)
+   {
+      HX_MARK_MEMBER(t0);
+      HX_MARK_MEMBER(t1);
+      HX_MARK_MEMBER(t2);
+   }
+   #ifdef HXCPP_VISIT_ALLOCS
+   void __Visit(hx::VisitContext *__inCtx)
+   {
+      HX_VISIT_MEMBER(t0);
+      HX_VISIT_MEMBER(t1);
+      HX_VISIT_MEMBER(t2);
+   }
+   #endif
+
+    void __GetFields(Array<String> &outFields)
+    {
+       outFields->push(name0);
+       outFields->push(name1);
+       outFields->push(name2);
+    }
+
+   String toString() { return StringFromAnonFields(this); }
+};
+
+
+template<typename _hx_T0, typename _hx_T1, typename _hx_T2, typename _hx_T3>
+class AnonStruct4_obj : public hx::Object
+{
+public:
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdDynamic };
+
+   String name0; _hx_T0 t0;
+   String name1; _hx_T1 t1;
+   String name2; _hx_T2 t2;
+   String name3; _hx_T3 t3;
+
+   inline static hx::Object *Create(const String &inName0, _hx_T0 inT0,
+                             const String &inName1, _hx_T1 inT1,
+                             const String &inName2, _hx_T2 inT2,
+                             const String &inName3, _hx_T3 inT3
+                             )
+   {
+      AnonStruct4_obj *result = new AnonStruct4_obj;
+      result->name0 = inName0; result->t0 = inT0;
+      if (hx::ContainsPointers<_hx_T0>()) {
+        HX_OBJ_WB_GET(result, hx::PointerOf(inT0));
+      }
+      result->name1 = inName1; result->t1 = inT1;
+      if (hx::ContainsPointers<_hx_T1>()) {
+        HX_OBJ_WB_GET(result, hx::PointerOf(inT1));
+      }
+      result->name2 = inName2; result->t2 = inT2;
+      if (hx::ContainsPointers<_hx_T2>()) {
+        HX_OBJ_WB_GET(result, hx::PointerOf(inT2));
+      }
+      result->name3 = inName3; result->t3 = inT3;
+      if (hx::ContainsPointers<_hx_T3>()) {
+        HX_OBJ_WB_GET(result, hx::PointerOf(inT3));
+      }
+      return result;
+   }
+   hx::Val __Field(const String &inField, hx::PropertyAccess)
+   {
+      if (inField.__s==name0.__s) return t0;
+      if (inField.__s==name1.__s) return t1;
+      if (inField.__s==name2.__s) return t2;
+      if (inField.__s==name3.__s) return t3;
+      #ifdef HX_SMART_STRINGS
+      if (!inField.isAsciiEncodedQ())
+         return null();
+      #endif
+      if (HX_QSTR_EQ_AE(inField,name0)) return t0;
+      if (HX_QSTR_EQ_AE(inField,name1)) return t1;
+      if (HX_QSTR_EQ_AE(inField,name2)) return t2;
+      if (HX_QSTR_EQ_AE(inField,name3)) return t3;
+      return null();
+   }
+   hx::Val __SetField(const String &inField,const hx::Val &inValue, hx::PropertyAccess inCallProp)
+   {
+      if (inField.__s==name0.__s) {
+        t0 = inValue.Cast< _hx_T0 >();
+        if (hx::ContainsPointers<_hx_T0>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t0));
+        }
+        return inValue;
+      }
+      if (inField.__s==name1.__s) {
+        t1 = inValue.Cast< _hx_T1 >();
+        if (hx::ContainsPointers<_hx_T1>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t1));
+        }
+        return inValue;
+      }
+      if (inField.__s==name2.__s) {
+        t2 = inValue.Cast< _hx_T2 >();
+        if (hx::ContainsPointers<_hx_T2>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t2));
+        }
+        return inValue;
+      }
+      if (inField.__s==name3.__s) {
+        t3 = inValue.Cast< _hx_T3 >();
+        if (hx::ContainsPointers<_hx_T3>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t3));
+        }
+        return inValue;
+      }
+
+
+
+      if (HX_QSTR_EQ(inField,name0)) {
+        t0 = inValue.Cast< _hx_T0 >();
+        if (hx::ContainsPointers<_hx_T0>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t0));
+        }
+        return inValue;
+      }
+      if (HX_QSTR_EQ(inField,name1)) {
+        t1 = inValue.Cast< _hx_T1 >();
+        if (hx::ContainsPointers<_hx_T1>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t1));
+        }  
+        return inValue;
+      }
+      if (HX_QSTR_EQ(inField,name2)) {
+        t2 = inValue.Cast< _hx_T2 >();
+        if (hx::ContainsPointers<_hx_T2>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t2));
+        }
+        return inValue;
+      }
+      if (HX_QSTR_EQ(inField,name3)) {
+        t3 = inValue.Cast< _hx_T3 >();
+        if (hx::ContainsPointers<_hx_T3>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t3));
+        }
+        return inValue;
+      }
+      hx::Throw(HX_CSTRING("Missing field ") + inField);
+      return inValue;
+   }
+
+   void __Mark(hx::MarkContext *__inCtx)
+   {
+      HX_MARK_MEMBER(t0);
+      HX_MARK_MEMBER(t1);
+      HX_MARK_MEMBER(t2);
+      HX_MARK_MEMBER(t3);
+   }
+   #ifdef HXCPP_VISIT_ALLOCS
+   void __Visit(hx::VisitContext *__inCtx)
+   {
+      HX_VISIT_MEMBER(t0);
+      HX_VISIT_MEMBER(t1);
+      HX_VISIT_MEMBER(t2);
+      HX_VISIT_MEMBER(t3);
+   }
+   #endif
+
+    void __GetFields(Array<String> &outFields)
+    {
+       outFields->push(name0);
+       outFields->push(name1);
+       outFields->push(name2);
+       outFields->push(name3);
+    }
+
+   String toString() { return StringFromAnonFields(this); }
+};
+
+
+
+
+template<typename _hx_T0, typename _hx_T1, typename _hx_T2, typename _hx_T3, typename _hx_T4>
+class AnonStruct5_obj : public hx::Object
+{
+public:
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdDynamic };
+
+   String name0; _hx_T0 t0;
+   String name1; _hx_T1 t1;
+   String name2; _hx_T2 t2;
+   String name3; _hx_T3 t3;
+   String name4; _hx_T4 t4;
+
+   inline static hx::Object *Create(const String &inName0, _hx_T0 inT0,
+                             const String &inName1, _hx_T1 inT1,
+                             const String &inName2, _hx_T2 inT2,
+                             const String &inName3, _hx_T3 inT3,
+                             const String &inName4, _hx_T4 inT4
+                             )
+   {
+      AnonStruct5_obj *result = new AnonStruct5_obj;
+      result->name0 = inName0; result->t0 = inT0;
+      if (hx::ContainsPointers<_hx_T0>()) {
+        HX_OBJ_WB_GET(result, hx::PointerOf(inT0));
+      }
+      result->name1 = inName1; result->t1 = inT1;
+      if (hx::ContainsPointers<_hx_T1>()) {
+        HX_OBJ_WB_GET(result, hx::PointerOf(inT1));
+      }
+      result->name2 = inName2; result->t2 = inT2;
+      if (hx::ContainsPointers<_hx_T2>()) {
+        HX_OBJ_WB_GET(result, hx::PointerOf(inT2));
+      }
+      result->name3 = inName3; result->t3 = inT3;
+      if (hx::ContainsPointers<_hx_T3>()) {
+        HX_OBJ_WB_GET(result, hx::PointerOf(inT3));
+      }
+      result->name4 = inName4; result->t4 = inT4;
+      if (hx::ContainsPointers<_hx_T4>()) {
+        HX_OBJ_WB_GET(result, hx::PointerOf(inT4));
+      }
+      return result;
+   }
+   hx::Val __Field(const String &inField, hx::PropertyAccess)
+   {
+      if (inField.__s==name0.__s) return t0;
+      if (inField.__s==name1.__s) return t1;
+      if (inField.__s==name2.__s) return t2;
+      if (inField.__s==name3.__s) return t3;
+      if (inField.__s==name4.__s) return t4;
+      #ifdef HX_SMART_STRINGS
+      if (!inField.isAsciiEncodedQ())
+         return null();
+      #endif
+      if (HX_QSTR_EQ_AE(inField,name0)) return t0;
+      if (HX_QSTR_EQ_AE(inField,name1)) return t1;
+      if (HX_QSTR_EQ_AE(inField,name2)) return t2;
+      if (HX_QSTR_EQ_AE(inField,name3)) return t3;
+      if (HX_QSTR_EQ_AE(inField,name4)) return t4;
+      return null();
+   }
+   hx::Val __SetField(const String &inField,const hx::Val &inValue, hx::PropertyAccess inCallProp)
+   {
+      if (inField.__s==name0.__s) {
+        t0 = inValue.Cast< _hx_T0 >();
+        if (hx::ContainsPointers<_hx_T0>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t0));
+        }
+        return inValue;
+      }
+      if (inField.__s==name1.__s) {
+        t1 = inValue.Cast< _hx_T1 >();
+        if (hx::ContainsPointers<_hx_T1>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t1));
+        }
+        return inValue;
+      }
+      if (inField.__s==name2.__s) {
+        t2 = inValue.Cast< _hx_T2 >();
+        if (hx::ContainsPointers<_hx_T2>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t2));
+        }
+        return inValue;
+      }
+      if (inField.__s==name3.__s) {
+        t3 = inValue.Cast< _hx_T3 >();
+        if (hx::ContainsPointers<_hx_T3>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t3));
+        }
+        return inValue;
+      }
+      if (inField.__s==name4.__s) {
+        t4 = inValue.Cast< _hx_T4 >();
+        if (hx::ContainsPointers<_hx_T4>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t4));
+        }
+        return inValue;
+      }
+
+
+
+
+      if (HX_QSTR_EQ(inField,name0)) {
+        t0 = inValue.Cast< _hx_T0 >();
+        if (hx::ContainsPointers<_hx_T0>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t0));
+        }
+        return inValue;
+      }
+      if (HX_QSTR_EQ(inField,name1)) {
+        t1 = inValue.Cast< _hx_T1 >();
+        if (hx::ContainsPointers<_hx_T1>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t1));
+        }
+        return inValue;
+      }
+      if (HX_QSTR_EQ(inField,name2)) {
+        t2 = inValue.Cast< _hx_T2 >();
+        if (hx::ContainsPointers<_hx_T2>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t2));
+        }
+        return inValue;
+      }
+      if (HX_QSTR_EQ(inField,name3)) {
+        t3 = inValue.Cast< _hx_T3 >();
+        if (hx::ContainsPointers<_hx_T3>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t3));
+        }
+        return inValue;
+      }
+      if (HX_QSTR_EQ(inField,name4)) {
+        t4 = inValue.Cast< _hx_T4 >();
+        if (hx::ContainsPointers<_hx_T4>()) {
+          HX_OBJ_WB_GET(this, hx::PointerOf(t4));
+        }
+        return inValue;
+      }
+      hx::Throw(HX_CSTRING("Missing field ") + inField);
+      return inValue;
+   }
+
+   void __Mark(hx::MarkContext *__inCtx)
+   {
+      HX_MARK_MEMBER(t0);
+      HX_MARK_MEMBER(t1);
+      HX_MARK_MEMBER(t2);
+      HX_MARK_MEMBER(t3);
+      HX_MARK_MEMBER(t4);
+   }
+   #ifdef HXCPP_VISIT_ALLOCS
+   void __Visit(hx::VisitContext *__inCtx)
+   {
+      HX_VISIT_MEMBER(t0);
+      HX_VISIT_MEMBER(t1);
+      HX_VISIT_MEMBER(t2);
+      HX_VISIT_MEMBER(t3);
+      HX_VISIT_MEMBER(t4);
+   }
+   #endif
+
+    void __GetFields(Array<String> &outFields)
+    {
+       outFields->push(name0);
+       outFields->push(name1);
+       outFields->push(name2);
+       outFields->push(name3);
+       outFields->push(name4);
+    }
+
+   String toString() { return StringFromAnonFields(this); }
+};
+
+
+
+
+
+
+} // end namespace hx
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+bool __hxcpp_anon_remove(Dynamic inObj,::String inKey);
+
+#endif

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Boot.h

@@ -0,0 +1,15 @@
+#ifndef HX_BOOT_H
+#define HX_BOOT_H
+
+// Properly construct all the classes defined in the haxe code
+void __boot_all();
+
+namespace hx
+{
+
+// Initializer the hxcpp runtime system
+HXCPP_EXTERN_CLASS_ATTRIBUTES void Boot();
+
+}
+
+#endif

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/CFFI.h

@@ -0,0 +1,469 @@
+#ifndef HX_CFFI_H
+#define HX_CFFI_H
+
+// 410 - adds gc_try_unblocking
+#define HX_CFFI_API_VERSION 410
+
+#ifdef HXCPP_JS_PRIME
+#include <emscripten/bind.h>
+using namespace emscripten;
+
+typedef struct emscripten::val value;
+typedef struct _vkind  *vkind;
+typedef struct _buffer  *buffer;
+#define HAVE_NEKO_TYPES 1
+#endif
+
+#include "OS.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#if defined(BLACKBERRY)
+using namespace std;
+#endif
+// --- Register functions (primitives) ----
+
+#ifdef STATIC_LINK
+
+#define DEFINE_PRIM_MULT(func) \
+int __reg_##func = hx_register_prim(#func "__MULT",(void *)(&func)); \
+
+#define DEFINE_PRIM(func,nargs) \
+int __reg_##func = hx_register_prim(#func "__" #nargs,(void *)(&func)); \
+
+
+#define DEFINE_PRIM_MULT_NATIVE(func,ext) \
+int __reg_##func = hx_register_prim(#func "__MULT",(void *)(&func)) + \
+                   hx_register_prim(#func "__"  #ext,(void *)(&func##_##ext)) ; 
+
+#define DEFINE_PRIM_NATIVE(func,nargs,ext) \
+int __reg_##func = hx_register_prim(#func "__" #nargs,(void *)(&func)) + \
+                   hx_register_prim(#func "__" #ext,(void *)(&func##_##ext)) ; 
+
+
+#define DEFINE_LIB_PRIM_MULT(lib,func) \
+int __reg_##func = hx_register_prim(lib "_" #func "__MULT",(void *)(&func)); \
+
+#define DEFINE_LIB_PRIM(lib,func,nargs) \
+int __reg_##func = hx_register_prim(lib "_" #func "__" #nargs,(void *)(&func)); \
+
+
+#elif defined(HXCPP_JS_PRIME)
+
+//#define DEFINE_PRIM_MULT(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+//TODO
+#define DEFINE_PRIM_MULT(func)
+
+#define DEFINE_PRIM(func,nargs) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+
+
+#else
+
+
+#define DEFINE_PRIM_MULT(func) extern "C" { \
+  EXPORT void *func##__MULT() { return (void*)(&func); } \
+}
+
+
+#define DEFINE_PRIM(func,nargs) extern "C" { \
+  EXPORT void *func##__##nargs() { return (void*)(&func); } \
+}
+
+
+#define DEFINE_PRIM_MULT_NATIVE(func,ext) extern "C" { \
+  EXPORT void *func##__MULT() { return (void*)(&func); } \
+  EXPORT void *func##__##ext() { return (void*)(&func##_##ext); } \
+}
+
+
+#define DEFINE_PRIM_NATIVE(func,nargs,ext) extern "C" { \
+  EXPORT void *func##__##nargs() { return (void*)(&func); } \
+  EXPORT void *func##__##ext() { return (void*)(&func##_##ext); } \
+}
+
+
+#define DEFINE_LIB_PRIM_MULT(lib,func) extern "C" { \
+  EXPORT void *func##__MULT() { return (void*)(&func); } \
+}
+
+
+#define DEFINE_LIB_PRIM(lib,func,nargs) extern "C" { \
+  EXPORT void *func##__##nargs() { return (void*)(&func); } \
+}
+
+
+
+#endif // !STATIC_LINK
+
+
+
+
+ 
+#define DEFFUNC_0(ret,name) DEFFUNC(name,ret, (), ())
+#define DEFFUNC_1(ret,name,t1) DEFFUNC(name,ret, (t1 a1), (a1))
+#define DEFFUNC_2(ret,name,t1,t2) DEFFUNC(name,ret, (t1 a1, t2 a2), (a1,a2))
+#define DEFFUNC_3(ret,name,t1,t2,t3) DEFFUNC(name,ret, (t1 a1, t2 a2, t3 a3), (a1,a2,a3))
+#define DEFFUNC_4(ret,name,t1,t2,t3,t4) DEFFUNC(name,ret, (t1 a1, t2 a2, t3 a3, t4 a4), (a1,a2,a3,a4))
+#define DEFFUNC_5(ret,name,t1,t2,t3,t4,t5) DEFFUNC(name,ret, (t1 a1, t2 a2, t3 a3, t4 a4,t5 a5), (a1,a2,a3,a4,a5))
+ 
+
+enum hxValueType
+{
+   valtUnknown = -1,
+   valtInt = 0xff,
+   valtNull = 0,
+   valtFloat = 1,
+   valtBool = 2,
+   valtString = 3,
+   valtObject = 4,
+   valtArray = 5,
+   valtFunction = 6,
+   valtEnum,
+   valtClass,
+   valtRoot = 0xff,
+   valtAbstractBase = 0x100,
+};
+
+namespace hx
+{
+enum StringEncoding
+{
+   StringAscii,
+   StringUtf8,
+   StringUtf16
+};
+}
+
+// val_fun_nargs may return a special value
+enum { faNotFunction = -2, faVarArgs=-1, faArgs0=0 /* ... */ };
+
+typedef int field;
+
+
+
+#ifdef IMPLEMENT_API
+#include "CFFILoader.h"
+#endif
+
+
+#if !defined(HAVE_NEKO_TYPES)
+#ifdef HXCPP_NATIVE_CFFI_VALUE
+namespace hx { class Object; }
+typedef hx::Object _value;
+#else
+struct _value;
+#endif
+typedef _value *value;
+typedef struct _vkind  *vkind;
+typedef struct _buffer  *buffer;
+#endif
+
+typedef buffer cffiByteBuffer;
+
+typedef struct _gcroot  *gcroot;
+
+typedef void (*hxFinalizer)(value v);
+typedef void (*hxPtrFinalizer)(void *v);
+
+typedef void (__hx_field_iter)(value v,field f,void *);
+
+#define hx_failure(msg)		hx_fail(msg,__FILE__,__LINE__)
+
+#ifndef IGNORE_CFFI_API_H
+
+
+#ifndef IMPLEMENT_API
+ 
+#if defined(STATIC_LINK) || defined(HXCPP_JS_PRIME)
+
+#define DEFFUNC(name,ret,def_args,call_args) \
+extern "C" ret name def_args;
+
+
+#else
+
+#define DEFFUNC(name,ret,def_args,call_args) \
+typedef ret (*FUNC_##name) def_args; \
+extern FUNC_##name name;
+
+#endif
+
+#endif
+ 
+
+#include "CFFIAPI.h"
+
+
+#ifdef WANT_DYNALLOC_ALLOC_BYTES
+void *DynAlloc::allocBytes(size_t n)
+{
+   return hx_alloc((int)n);
+}
+#endif
+
+
+
+#define DEFINE_KIND(name) extern "C" { vkind name = 0; }
+
+#ifdef STATIC_LINK
+#	define DEFINE_ENTRY_POINT(name)
+#else
+#	define DEFINE_ENTRY_POINT(name) extern "C" {  void name(); EXPORT void *__neko_entry_point() { return (void *)&name; } }
+#endif
+
+#ifdef HEADER_IMPORTS
+#	define H_EXTERN IMPORT
+#else
+#	define H_EXTERN EXPORT
+#endif
+
+#define DECLARE_PRIM(func,nargs) extern "C" {  H_EXTERN void *func##__##nargs(); }
+#define DECLARE_KIND(name) extern "C" {  H_EXTERN extern vkind name; }
+
+
+
+// --- Helpers ----------------------------------------------------------------
+
+// Check type...
+inline bool val_is_null(value inVal) { return val_type(inVal)==valtNull; }
+inline bool val_is_int(value inVal) { return val_type(inVal)==valtInt; }
+inline bool val_is_bool(value inVal) { return val_type(inVal)==valtBool; }
+inline bool val_is_float(value inVal) { return val_type(inVal)==valtFloat; }
+inline bool val_is_string(value inVal) { return val_type(inVal)==valtString; }
+inline bool val_is_function(value inVal) { return val_type(inVal)==valtFunction; }
+inline bool val_is_array(value inVal) { return val_type(inVal)==valtArray; }
+inline bool val_is_abstract(value inVal) { return val_type(inVal)>=valtAbstractBase; }
+inline bool val_is_kind(value inVal,vkind inKind) { return val_to_kind(inVal,inKind)!=0; }
+
+inline bool val_is_number(value inVal)
+{
+	int t = val_type(inVal);
+	return t==valtInt || t==valtFloat;
+}
+inline bool val_is_object(value inVal)
+{
+	int t = val_type(inVal);
+	return t==valtObject || t==valtEnum ||t==valtClass;
+}
+
+class AutoGCBlocking
+{
+public:
+	inline AutoGCBlocking(bool inSoftUnlock=false) :
+      mSoftUnlock(inSoftUnlock), mLocked( gc_try_blocking() ) {  }
+	inline ~AutoGCBlocking() { Close(); }
+	inline void Close()
+   {
+      if (mLocked)
+      {
+         if (mSoftUnlock)
+            gc_try_unblocking();
+         else
+            gc_exit_blocking();
+      }
+      mLocked = false;
+   }
+
+	bool mLocked;
+	bool mSoftUnlock;
+};
+
+class AutoGCUnblocking
+{
+public:
+	AutoGCUnblocking() : mUnlocked( gc_try_unblocking() ) {  }
+	~AutoGCUnblocking() { Close(); }
+	void Close() { if (mUnlocked) gc_enter_blocking(); mUnlocked = false; }
+
+	bool mUnlocked;
+};
+
+
+class AutoGCRoot
+{
+public:
+   AutoGCRoot(value inValue)
+   {
+		mRoot = 0;
+		mPtr = alloc_root();
+		if (mPtr)
+			*mPtr = inValue;
+		else
+			mRoot = create_root(inValue);
+   }
+
+  ~AutoGCRoot()
+   {
+		if (mPtr)
+			free_root(mPtr);
+		else if (mRoot)
+         destroy_root(mRoot);
+   }
+   value get()const { return mPtr ? *mPtr : query_root(mRoot); }
+   void set(value inValue)
+	{ 
+		if (mPtr)
+			*mPtr = inValue;
+		else
+		{
+			if (mRoot) destroy_root(mRoot);
+			mRoot = create_root(inValue);
+		}
+	}
+   
+private:
+   value *mPtr;
+   gcroot mRoot;
+   AutoGCRoot(const AutoGCRoot &);
+   void operator=(const AutoGCRoot &);
+};
+
+struct CffiBytes
+{
+   CffiBytes( unsigned char *inData=0, int inLength=0) : data(inData), length(inLength) {}
+
+   unsigned char *data;
+   int length;
+};
+
+inline CffiBytes getByteData(value inValue)
+{
+   static field bField = 0;
+   static field lengthField = 0;
+   if (bField==0)
+   {
+      bField = val_id("b");
+      lengthField = val_id("length");
+   }
+
+   if (val_is_object(inValue))
+   {
+      value b = val_field(inValue, bField);
+      value len = val_field(inValue, lengthField);
+      if (val_is_string(b) && val_is_int(len))
+         return CffiBytes( (unsigned char *)val_string(b), val_int(len) );
+      if (val_is_buffer(b) && val_is_int(len))
+         return CffiBytes( (unsigned char *)buffer_data(val_to_buffer(b)), val_int(len) );
+   }
+   else if (val_is_buffer(inValue))
+   {
+      value len = val_field(inValue, lengthField);
+      if (val_is_int(len))
+      {
+         buffer b = val_to_buffer(inValue);
+         return CffiBytes( (unsigned char *)buffer_data(b), val_int(len) );
+      }
+   }
+   return CffiBytes();
+}
+
+inline bool resizeByteData(value inValue, int inNewLen)
+{
+   if (!val_is_object(inValue))
+      return false;
+
+   static field bField = 0;
+   static field lengthField = 0;
+   if (bField==0)
+   {
+      bField = val_id("b");
+      lengthField = val_id("length");
+   }
+   value len = val_field(inValue, lengthField);
+   if (!val_is_int(len))
+      return false;
+   int oldLen = val_int(len);
+   value b = val_field(inValue, bField);
+   if (val_is_string(b))
+   {
+      if (inNewLen>oldLen)
+      {
+         value newString = alloc_raw_string(inNewLen);
+         memcpy( (char *)val_string(newString), val_string(b), inNewLen);
+         alloc_field(inValue, bField, newString );
+      }
+      alloc_field(inValue, lengthField, alloc_int(inNewLen) );
+   }
+   else if (val_is_buffer(b))
+   {
+      cffiByteBuffer buf = val_to_buffer(b);
+      buffer_set_size(buf,inNewLen);
+      alloc_field(inValue, lengthField, alloc_int(inNewLen) );
+   }
+   else
+      return false;
+
+   return true;
+}
+
+
+#define val_null alloc_null()
+
+#define bfailure(x) val_throw(buffer_to_string(x))
+
+#define copy_string(str,len) alloc_string_len(str,len)
+
+
+// The "Check" macros throw an error if assumtion is false
+#define val_check_kind(v,t)	if( !val_is_kind(v,t) ) hx_failure("invalid kind");
+#define val_check_function(f,n) if( !val_is_function(f) || (val_fun_nargs(f) != (n) && val_fun_nargs(f) != faVarArgs) ) hx_failure("Bad function");
+#define val_check(v,t)		if( !val_is_##t(v) ) hx_failure("type not " #t);
+
+// The "Get" function will return or force an error
+inline bool val_get_bool(value inVal) {  val_check(inVal,bool); return val_bool(inVal); }
+inline int val_get_int(value inVal) {  val_check(inVal,int); return val_int(inVal); }
+inline double val_get_double(value inVal) {  val_check(inVal,number); return val_number(inVal); }
+inline const char *val_get_string(value inVal) {  val_check(inVal,string); return val_string(inVal); }
+inline void *val_get_handle(value inVal,vkind inKind)
+  {  val_check_kind(inVal,inKind); return val_to_kind(inVal,inKind); }
+
+
+inline value alloc_string(const char *inStr)
+{
+   const char *end = inStr;
+   while(*end) end++;
+   return alloc_string_len(inStr,(int)(end-inStr));
+}
+
+inline value alloc_wstring(const wchar_t *inStr)
+{
+   const wchar_t *end = inStr;
+   while(*end) end++;
+   return alloc_wstring_len(inStr,(int)(end-inStr));
+}
+
+inline void hxcpp_unscramble(const unsigned char *bytes, int len, const char *key, unsigned char *dest)
+{
+   int keyLen = 0;
+   while(key[keyLen])
+      keyLen++;
+   int state = 0;
+   //state = ((state + key[i]) ^ ch) & 0xff);
+   for(int i=0;i<len;i++)
+   {
+      dest[i] = ( (state + key[i%keyLen]) ^ bytes[i] ) & 0xff;
+      state = bytes[i];
+   }
+}
+
+
+//additional glue for easier neko modules compilation
+#define val_true    alloc_bool(true)
+#define val_false    alloc_bool(false)
+inline void neko_error() { hx_error(); }
+
+
+// Conservative marking within a buffer is not yet supported.
+//inline void * alloc(int i) { return hx_alloc(i); }
+
+// The bytes themselves will be GC'd, but not the pointers contained within.
+inline void * alloc_private(int i) { return hx_alloc(i); }
+
+// You should use alloc_buffer_len/buffer_data instead
+//value alloc_empty_string(int len) { }
+
+
+#endif
+
+
+#endif

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/CFFIAPI.h

@@ -0,0 +1,189 @@
+/*
+ This bit of Macro magic is used to define extern function pointers
+  in ndlls, define stub implementations that link back to the hxcpp dll
+  and glue up the implementation in the hxcpp runtime.
+*/
+
+DEFFUNC_1(void,val_throw,value)
+DEFFUNC_0(void,hx_error)
+DEFFUNC_3(void,hx_fail,const char *,const char *,int)
+
+// Determine value type
+DEFFUNC_1(int,val_type,value)
+DEFFUNC_1(vkind,val_kind,value)
+DEFFUNC_2(void *,val_to_kind,value,vkind)
+// don't check the 'kind' ...
+DEFFUNC_1(void *,val_data,value)
+DEFFUNC_1(int,val_fun_nargs,value)
+
+
+// Extract value type
+DEFFUNC_1(bool,val_bool,value)
+DEFFUNC_1(int,val_int,value)
+DEFFUNC_1(double,val_float,value)
+DEFFUNC_1(double,val_number,value)
+
+// Create value type
+
+DEFFUNC_0(value,alloc_null)
+DEFFUNC_1(value,alloc_bool,bool)
+DEFFUNC_1(value,alloc_int,int)
+DEFFUNC_1(value,alloc_float,double)
+DEFFUNC_0(value,alloc_empty_object)
+DEFFUNC_2(value,alloc_abstract,vkind,void *)
+// Allocates conservative-collected memory
+DEFFUNC_3(value,create_abstract,vkind,int,hxFinalizer)
+DEFFUNC_1(void,free_abstract,value)
+DEFFUNC_1(value,alloc_best_int,int)
+DEFFUNC_1(value,alloc_int32,int)
+
+// String access
+DEFFUNC_1(int,val_strlen,value)
+DEFFUNC_2(value,alloc_string_len,const char *,int)
+DEFFUNC_2(value,alloc_wstring_len,const wchar_t *,int)
+
+DEFFUNC_1(const wchar_t *,val_wstring,value)
+DEFFUNC_1(const char *,val_string,value)
+DEFFUNC_1(wchar_t *,val_dup_wstring,value)
+DEFFUNC_1(char *,val_dup_string,value)
+DEFFUNC_2(char *,alloc_string_data,const char *,int)
+
+#ifdef HXCPP_PRIME
+/*DEFFUNC_2(HxString,alloc_hxs_wchar,const wchar_t *,int)
+DEFFUNC_2(HxString,alloc_hxs_utf16,const char16_t *,int)
+DEFFUNC_2(HxString,alloc_hxs_utf8,const char *,int)*/
+
+DEFFUNC_2(const char *,hxs_utf8,const HxString &,hx::IStringAlloc *)
+DEFFUNC_2(const wchar_t *,hxs_wchar,const HxString &,hx::IStringAlloc *)
+DEFFUNC_2(const char16_t *,hxs_utf16,const HxString &,hx::IStringAlloc *)
+
+DEFFUNC_1(hx::StringEncoding,hxs_encoding,const HxString &)
+#endif
+
+
+// Array access - generic
+DEFFUNC_1(value,alloc_array,int)
+DEFFUNC_1(int,val_array_size,value)
+DEFFUNC_2(void,val_array_set_size,value,int)
+DEFFUNC_2(value,val_array_i,value,int)
+DEFFUNC_3(void,val_array_set_i,value,int,value)
+DEFFUNC_2(void,val_array_push,value,value)
+
+
+// Array access - fast if possible - may return null
+// Resizing the array may invalidate the pointer
+DEFFUNC_1(bool *,val_array_bool,value)
+DEFFUNC_1(int *,val_array_int,value)
+DEFFUNC_1(double *,val_array_double,value)
+DEFFUNC_1(float *,val_array_float,value)
+DEFFUNC_1(value *,val_array_value,value)
+
+// String Buffer
+// A 'buffer' is a tool for joining strings together.
+// The C++ implementation is haxe.io.BytesData
+// The neko implementation is something else again, and can't be passes as a value, only copied to a string
+
+// Create a buffer from string of an empty buffer of a given length
+DEFFUNC_1(buffer,alloc_buffer,const char *)
+DEFFUNC_1(buffer,alloc_buffer_len,int)
+
+// Append a string representation of a value to the buffer
+DEFFUNC_2(void,val_buffer,buffer,value)
+
+// Append a c-string to a buffer
+DEFFUNC_2(void,buffer_append,buffer,const char *)
+
+// Append given number of bytes of a c-string to the buffer
+DEFFUNC_3(void,buffer_append_sub,buffer,const char *,int)
+
+// Append given character to string
+DEFFUNC_2(void,buffer_append_char,buffer,int)
+
+// Convert buffer back into string value
+DEFFUNC_1(value,buffer_to_string,buffer)
+
+
+
+// These routines are for direct access to the c++ BytesData structure
+// Use getByteData and resizeByteData for more generic access to haxe.io.Bytes
+
+// This will never return true on a neko host.
+DEFFUNC_1(bool,val_is_buffer,value)
+
+// These functions are only valid if val_is_buffer returns true
+// Currently, cffiByteBuffer is the same struct as buffer, but the usage is quite different
+DEFFUNC_1(cffiByteBuffer,val_to_buffer,value)
+
+// Number of byes in the array
+DEFFUNC_1(int,buffer_size,cffiByteBuffer)
+
+// Pointer to the byte data - will become invalid if the array is resized
+DEFFUNC_1(char *,buffer_data,cffiByteBuffer)
+
+// Convert c++ ByteBuffer back to 'value' - no copy involved
+DEFFUNC_1(value,buffer_val,cffiByteBuffer)
+
+// Resize the array - will invalidate the data
+DEFFUNC_2(void,buffer_set_size,cffiByteBuffer,int)
+
+// This is used by resizeByteData for manipulating bytes directly on neko
+DEFFUNC_1(value,alloc_raw_string,int)
+
+// Call Function 
+DEFFUNC_1(value,val_call0,value)
+DEFFUNC_2(value,val_call1,value,value)
+DEFFUNC_3(value,val_call2,value,value,value)
+DEFFUNC_4(value,val_call3,value,value,value,value)
+DEFFUNC_3(value,val_callN,value,value *,int)
+
+// Call the function - catch and print any exceptions
+DEFFUNC_1(value,val_call0_traceexcept,value)
+
+// Call object field
+DEFFUNC_2(value,val_ocall0,value,int)
+DEFFUNC_3(value,val_ocall1,value,int,value)
+DEFFUNC_4(value,val_ocall2,value,int,value,value)
+DEFFUNC_4(value,val_ocallN,value,int,value *,int)
+
+// Objects access
+DEFFUNC_1(int,val_id,const char *)
+DEFFUNC_3(void,alloc_field,value,int,value)
+DEFFUNC_3(void,alloc_field_numeric,value,int,double)
+DEFFUNC_2(value,val_field,value,int)
+DEFFUNC_2(double,val_field_numeric,value,int)
+
+DEFFUNC_1(value,val_field_name,field)
+DEFFUNC_3(void,val_iter_fields,value,__hx_field_iter,void *)
+DEFFUNC_3(void,val_iter_field_vals,value,__hx_field_iter,void *)
+
+// Abstract types
+DEFFUNC_0(vkind,alloc_kind)
+DEFFUNC_2(void,kind_share,vkind *,const char *)
+
+// Garbage Collection
+DEFFUNC_1(void *,hx_alloc,int)
+DEFFUNC_2(void, val_gc,value,hxFinalizer)
+DEFFUNC_2(void, val_gc_ptr,void *,hxPtrFinalizer)
+DEFFUNC_0(value *, alloc_root)
+DEFFUNC_1(void, free_root,value *)
+DEFFUNC_2(void, gc_change_managed_memory,int,const char *)
+
+// Only available on cpp target...
+DEFFUNC_1(void, val_gc_add_root,value *)
+DEFFUNC_1(void, val_gc_remove_root,value *)
+// Only available on js target - use AutoGCRoot to assist
+DEFFUNC_1(gcroot, create_root,value)
+DEFFUNC_1(value, query_root,gcroot)
+DEFFUNC_1(void, destroy_root,gcroot)
+
+DEFFUNC_0(void, gc_enter_blocking)
+DEFFUNC_0(void, gc_exit_blocking)
+DEFFUNC_0(bool, gc_try_blocking)
+DEFFUNC_0(void, gc_safe_point)
+DEFFUNC_2(void, gc_set_top_of_stack,int *,bool)
+DEFFUNC_0(bool, gc_try_unblocking)
+
+// Used for finding functions in static libraries
+DEFFUNC_2(int, hx_register_prim, const char *, void*)
+
+

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/CFFIJsPrime.h

@@ -0,0 +1,202 @@
+
+extern "C"
+{
+
+typedef std::map<std::string,int> IdMap;
+static IdMap sIdMap;
+static std::vector<val> sIdKeys;
+
+int val_id(const char *inName)
+{
+   IdMap::iterator id = sIdMap.find(inName);
+   if (id==sIdMap.end())
+   {
+      int result = sIdMap.size();
+      sIdMap[inName] = result;
+      sIdKeys.push_back(value(inName));
+      return result;
+   }
+   return id->second;
+}
+
+
+double val_field_numeric(value inObject, int inFieldId)
+{
+   return inObject[sIdKeys[inFieldId]].as<double>();
+}
+
+int val_int(value inValue) { return inValue.as<int>(); }
+bool val_bool(value inValue) { return inValue.as<bool>(); }
+double val_number(value inValue) { return inValue.as<double>(); }
+double val_float(value inValue) { return inValue.as<double>(); }
+
+value alloc_null() { return emscripten::val::null(); }
+value alloc_int(int inValue) { return value(inValue); }
+value alloc_best_int(int inValue) { return value(inValue); }
+value alloc_int32(int inValue) { return value(inValue); }
+value alloc_bool(bool inValue) { return value(inValue); }
+value alloc_float(double inValue) { return value(inValue); }
+
+value val_field(value inObject, int inIndex) { return inObject[sIdKeys[inIndex]]; }
+void alloc_field(value inObject, int inIndex, value inValue) { inObject.set(sIdKeys[inIndex],inValue); }
+
+
+
+/*
+DEFFUNC_1(void,val_throw,value)
+DEFFUNC_0(void,hx_error)
+DEFFUNC_3(void,hx_fail,const char *,const char *,int)
+
+// Determine value type
+DEFFUNC_1(int,val_type,value)
+DEFFUNC_1(vkind,val_kind,value)
+DEFFUNC_2(void *,val_to_kind,value,vkind)
+// don't check the 'kind' ...
+DEFFUNC_1(void *,val_data,value)
+DEFFUNC_1(int,val_fun_nargs,value)
+
+
+
+// Create value type
+
+DEFFUNC_0(value,alloc_empty_object)
+DEFFUNC_2(value,alloc_abstract,vkind,void *)
+// Allocates conservative-collected memory
+DEFFUNC_3(value,create_abstract,vkind,int,hxFinalizer)
+DEFFUNC_1(void,free_abstract,value)
+
+// String access
+DEFFUNC_1(int,val_strlen,value)
+DEFFUNC_1(const wchar_t *,val_wstring,value)
+DEFFUNC_1(const char *,val_string,value)
+DEFFUNC_1(wchar_t *,val_dup_wstring,value)
+DEFFUNC_1(char *,val_dup_string,value)
+DEFFUNC_2(char *,alloc_string_data,const char *,int)
+DEFFUNC_2(value,alloc_string_len,const char *,int)
+DEFFUNC_2(value,alloc_wstring_len,const wchar_t *,int)
+
+// Array access - generic
+DEFFUNC_1(value,alloc_array,int)
+DEFFUNC_1(int,val_array_size,value)
+DEFFUNC_2(void,val_array_set_size,value,int)
+DEFFUNC_2(value,val_array_i,value,int)
+DEFFUNC_3(void,val_array_set_i,value,int,value)
+DEFFUNC_2(void,val_array_push,value,value)
+
+
+// Array access - fast if possible - may return null
+// Resizing the array may invalidate the pointer
+DEFFUNC_1(bool *,val_array_bool,value)
+DEFFUNC_1(int *,val_array_int,value)
+DEFFUNC_1(double *,val_array_double,value)
+DEFFUNC_1(float *,val_array_float,value)
+DEFFUNC_1(value *,val_array_value,value)
+
+// String Buffer
+// A 'buffer' is a tool for joining strings together.
+// The C++ implementation is haxe.io.BytesData
+// The neko implementation is something else again, and can't be passes as a value, only copied to a string
+
+// Create a buffer from string of an empty buffer of a given length
+DEFFUNC_1(buffer,alloc_buffer,const char *)
+DEFFUNC_1(buffer,alloc_buffer_len,int)
+
+// Append a string representation of a value to the buffer
+DEFFUNC_2(void,val_buffer,buffer,value)
+
+// Append a c-string to a buffer
+DEFFUNC_2(void,buffer_append,buffer,const char *)
+
+// Append given number of bytes of a c-string to the buffer
+DEFFUNC_3(void,buffer_append_sub,buffer,const char *,int)
+
+// Append given character to string
+DEFFUNC_2(void,buffer_append_char,buffer,int)
+
+// Convert buffer back into string value
+DEFFUNC_1(value,buffer_to_string,buffer)
+
+
+
+// These routines are for direct access to the c++ BytesData structure
+// Use getByteData and resizeByteData for more generic access to haxe.io.Bytes
+
+// This will never return true on a neko host.
+DEFFUNC_1(bool,val_is_buffer,value)
+
+// These functions are only valid if val_is_buffer returns true
+// Currently, cffiByteBuffer is the same struct as buffer, but the usage is quite different
+DEFFUNC_1(cffiByteBuffer,val_to_buffer,value)
+
+// Number of byes in the array
+DEFFUNC_1(int,buffer_size,cffiByteBuffer)
+
+// Pointer to the byte data - will become invalid if the array is resized
+DEFFUNC_1(char *,buffer_data,cffiByteBuffer)
+
+// Convert c++ ByteBuffer back to 'value' - no copy involved
+DEFFUNC_1(value,buffer_val,cffiByteBuffer)
+
+// Resize the array - will invalidate the data
+DEFFUNC_2(void,buffer_set_size,cffiByteBuffer,int)
+
+// This is used by resizeByteData for manipulating bytes directly on neko
+DEFFUNC_1(value,alloc_raw_string,int)
+
+// Call Function 
+DEFFUNC_1(value,val_call0,value)
+DEFFUNC_2(value,val_call1,value,value)
+DEFFUNC_3(value,val_call2,value,value,value)
+DEFFUNC_4(value,val_call3,value,value,value,value)
+DEFFUNC_3(value,val_callN,value,value *,int)
+
+// Call the function - catch and print any exceptions
+DEFFUNC_1(value,val_call0_traceexcept,value)
+
+// Call object field
+DEFFUNC_2(value,val_ocall0,value,int)
+DEFFUNC_3(value,val_ocall1,value,int,value)
+DEFFUNC_4(value,val_ocall2,value,int,value,value)
+DEFFUNC_4(value,val_ocallN,value,int,value *,int)
+
+// Objects access
+DEFFUNC_1(int,val_id,const char *)
+DEFFUNC_3(void,alloc_field,value,int,value)
+DEFFUNC_2(value,val_field,value,int)
+DEFFUNC_2(double,val_field_numeric,value,int)
+
+DEFFUNC_1(value,val_field_name,field)
+DEFFUNC_3(void,val_iter_fields,value,__hx_field_iter,void *)
+DEFFUNC_3(void,val_iter_field_vals,value,__hx_field_iter,void *)
+
+// Abstract types
+DEFFUNC_0(vkind,alloc_kind)
+DEFFUNC_2(void,kind_share,vkind *,const char *)
+
+// Garbage Collection
+DEFFUNC_1(void *,hx_alloc,int)
+DEFFUNC_2(void, val_gc,value,hxFinalizer)
+DEFFUNC_2(void, val_gc_ptr,void *,hxPtrFinalizer)
+DEFFUNC_0(value *, alloc_root)
+DEFFUNC_1(void, free_root,value *)
+DEFFUNC_2(void, gc_change_managed_memory,int,const char *)
+
+// Only available on cpp target...
+DEFFUNC_1(void, val_gc_add_root,value *)
+DEFFUNC_1(void, val_gc_remove_root,value *)
+// Only available on js target - use AutoGCRoot to assist
+DEFFUNC_1(gcroot, create_root,value)
+DEFFUNC_1(value, query_root,gcroot)
+DEFFUNC_1(void, destroy_root,gcroot)
+
+DEFFUNC_0(void, gc_enter_blocking)
+DEFFUNC_0(void, gc_exit_blocking)
+DEFFUNC_0(void, gc_safe_point)
+DEFFUNC_2(void, gc_set_top_of_stack,int *,bool)
+
+// Used for finding functions in static libraries
+DEFFUNC_2(int, hx_register_prim, const char *, void*)
+*/
+
+
+}

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/CFFILoader.h

@@ -0,0 +1,330 @@
+#ifndef HX_CFFI_LOADER_H
+#define HX_CFFI_LOADER_H
+
+/*
+  This file will only be incuded in one cpp file in the ndll library -
+    the one with IMPLEMENT_API #defined.
+
+  The other files will refer to the val_ functions via the "extern" in CFFI.h
+
+  For dynamic linking, a macro (DEFFUNC) implements the "val_..." functions as function pointers,
+   and the cpp code calls these function pointers directly.
+  The pointers starts off as function pointers to bootstrap code, so when they are first called
+   the bootstrap uses the "ResolveProc" to find the correct version of the function for the particular
+   platform, and replaces the function pointer with this value. Subsequent calls then go directly
+   to the correct fucntion.
+
+  The ResolveProc can come from:
+   Explicitly setting - the proc is set when a dll is loaded into the hxcpp exe
+   Via 'GetProcAddress' on the exe - if symbols are needed and the proc has not been set
+   Internal implementation (CFFINekoLoader) - when linking agaist a neko process.
+    - Old code used to find this in NekoApi.dll, but the glue code is now built into each ndll directly.
+
+  For static linking, the functions are resolved at link time.
+
+  For HXCPP_JS_PRIME, these functions are implemented in CFFIJsPrime
+*/
+
+#ifdef ANDROID
+#include <android/log.h>
+#endif
+
+#ifdef NEKO_WINDOWS
+#include <windows.h>
+#include <stdio.h>
+// Stoopid windows ...
+#ifdef RegisterClass
+#undef RegisterClass
+#endif
+#ifdef abs
+#undef abs
+#endif
+
+#else // NOT NEKO_WINDOWS
+
+#ifdef NEKO_LINUX
+#define EXT "dso"
+#define NEKO_EXT "so"
+//#define __USE_GNU 1
+
+#elif defined(HX_MACOS)
+#include <mach-o/dyld.h>
+#define EXT "dylib"
+#define NEKO_EXT "dylib"
+
+#else
+#if defined(EMSCRIPTEN)
+#define EXT "ll"
+#else
+#define EXT "so"
+#endif
+
+#endif
+
+#include <dlfcn.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <memory.h>
+
+
+#endif
+#if defined(BLACKBERRY)
+using namespace std;
+#endif
+typedef void *(*ResolveProc)(const char *inName);
+static ResolveProc sResolveProc = 0;
+
+extern "C" {
+EXPORT void hx_set_loader(ResolveProc inProc)
+{
+   #ifdef ANDROID
+   __android_log_print(ANDROID_LOG_INFO, "haxe plugin", "Got Load Proc %p", inProc );
+   #endif
+   sResolveProc = inProc;
+}
+}
+
+
+
+#ifdef HXCPP_JS_PRIME // { js prime
+
+#define DEFFUNC(name,ret,def_args,call_args) \
+extern "C" ret name def_args;
+
+#include "CFFIJsPrime.h"
+
+#elif defined(STATIC_LINK)  // js prime }   { not js prime, static link
+
+#define DEFFUNC(name,ret,def_args,call_args) \
+extern "C" ret name def_args;
+
+#else  // static link }   { Dynamic link
+
+   #ifdef NEKO_COMPATIBLE
+
+      #include "CFFINekoLoader.h"
+
+   #endif // NEKO_COMPATIBLE
+
+
+   // This code will get run when the library is compiled against a newer version of hxcpp,
+   //  and the application code uses an older version.
+   bool default_val_is_buffer(void *inBuffer)
+   {
+      typedef void *(ValToBufferFunc)(void *);
+      static ValToBufferFunc *valToBuffer = 0;
+      if (!valToBuffer)
+         valToBuffer = (ValToBufferFunc *)sResolveProc("val_to_buffer");
+
+      if (valToBuffer)
+         return valToBuffer(inBuffer)!=0;
+
+      return false;
+   }
+
+   // Neko, old cpp and js_prime are all utf8 based - and go through here
+   #ifdef HXCPP_PRIME
+   struct DynAlloc : public hx::IStringAlloc
+   {
+      #define WANT_DYNALLOC_ALLOC_BYTES
+      void *allocBytes(size_t n);
+   };
+
+
+   HxString default_string_wchar(const wchar_t *src,int len)
+   {
+      hx::strbuf buf;
+      const char *str = cffi::to_utf8(src,len,&buf);
+      return HxString(str,len);
+   }
+   HxString default_string_utf8(const char *str,int len)
+   {
+      return HxString(str,len);
+   }
+   HxString default_string_utf16(const char16_t *src,int len)
+   {
+      hx::strbuf buf;
+      const char *str = cffi::to_utf8(src,len,&buf);
+      return HxString(str,len);
+   }
+
+   const char *default_to_utf8(const HxString &str,hx::IStringAlloc *alloc)
+   {
+      return str.c_str();
+   }
+   const wchar_t *default_to_wchar(const HxString &str,hx::IStringAlloc *alloc)
+   {
+      DynAlloc d;
+      if (!alloc)
+         alloc = &d;
+      return cffi::from_utf8<wchar_t>(str.c_str(),str.size(),alloc);
+   }
+   const char16_t *default_to_utf16(const HxString &str,hx::IStringAlloc *alloc)
+   {
+      DynAlloc d;
+      if (!alloc)
+         alloc = &d;
+      return cffi::from_utf8<char16_t>(str.c_str(),str.size(),alloc);
+   }
+   #endif
+
+
+   hx::StringEncoding default_get_encoding(void *inPtr) { return hx::StringUtf8; }
+
+   void * default_alloc_empty_string(int) { return 0; }
+
+   // Do nothing on earlier versions of hxcpp that do not know what to do
+   void default_gc_change_managed_memory(int,const char *) { }
+
+   void *ResolveDefault(const char *inName)
+   {
+      void *result = sResolveProc(inName);
+      if (result)
+         return result;
+      if (!strcmp(inName,"val_is_buffer"))
+         return (void *)default_val_is_buffer;
+      if (!strcmp(inName,"alloc_empty_string"))
+         return (void *)default_alloc_empty_string;
+      if (!strcmp(inName,"gc_change_managed_memory"))
+         return (void *)default_gc_change_managed_memory;
+      if (!strcmp(inName,"hxs_encoding"))
+         return (void *)default_get_encoding;
+      #ifdef HXCPP_PRIME
+      if (!strcmp(inName,"alloc_hxs_wchar"))
+         return (void *)default_string_wchar;
+      if (!strcmp(inName,"alloc_hxs_utf16"))
+         return (void *)default_string_utf16;
+      if (!strcmp(inName,"alloc_hxs_utf8"))
+         return (void *)default_string_utf8;
+      if (!strcmp(inName,"hxs_utf8"))
+         return (void *)default_to_utf8;
+      if (!strcmp(inName,"hxs_utf16"))
+         return (void *)default_to_utf16;
+      if (!strcmp(inName,"hxs_wchar"))
+         return (void *)default_to_wchar;
+      #endif
+
+      return 0;
+   }
+
+   #ifdef NEKO_WINDOWS // {
+
+   void *LoadFunc(const char *inName)
+   {
+      #ifndef HX_WINRT
+      static const char *modules[] = { 0, "hxcpp", "hxcpp-debug" };
+      for(int i=0; i<3 && sResolveProc==0; i++)
+      {
+         HMODULE handle = GetModuleHandleA(modules[i]);
+         if (handle)
+         {
+            sResolveProc = (ResolveProc)GetProcAddress(handle,"hx_cffi");
+            if (sResolveProc==0)
+               FreeLibrary(handle);
+         }
+      }
+      #endif
+
+      #ifdef NEKO_COMPATIBLE
+      if (sResolveProc==0)
+      {
+         sResolveProc = InitDynamicNekoLoader();
+      }
+      #endif
+
+      if (sResolveProc==0)
+      {
+         fprintf(stderr,"Could not link plugin to process (hxCFFILoader.h %d)\n",__LINE__);
+         exit(1);
+      }
+      return ResolveDefault(inName);
+   }
+
+   #else // windows }  { not windows
+
+
+   void *LoadFunc(const char *inName)
+   {
+      #ifndef ANDROID // {
+         if (sResolveProc==0)
+         {
+            sResolveProc = (ResolveProc)dlsym(RTLD_DEFAULT,"hx_cffi");
+         }
+
+         #ifdef NEKO_COMPATIBLE
+         if (sResolveProc==0)
+         {
+            sResolveProc = InitDynamicNekoLoader();
+         }
+         #endif
+      #endif // !Android  }
+
+      if (sResolveProc==0)
+      {
+         #ifdef ANDROID
+         __android_log_print(ANDROID_LOG_ERROR, "CFFILoader.h", "Could not API %s", inName);
+         return 0;
+         #else
+         #ifdef NEKO_COMPATIBLE
+         fprintf(stderr,"Could not link plugin to process (CFFILoader.h %d) - with neko\n",__LINE__);
+         #else
+         fprintf(stderr,"Could not link plugin to process (CFFILoader.h %d)\n",__LINE__);
+         #endif
+         exit(1);
+         #endif
+      }
+      return ResolveDefault(inName);
+   }
+
+   #undef EXT
+
+   #endif // not windows }
+
+
+
+   #ifndef ANDROID // not android {
+
+   #define DEFFUNC(name,ret,def_args,call_args) \
+   typedef ret (*FUNC_##name)def_args; \
+   extern FUNC_##name name; \
+   ret IMPL_##name def_args \
+   { \
+      name = (FUNC_##name)LoadFunc(#name); \
+      if (!name) \
+      { \
+         fprintf(stderr,"Could not find function:" #name " \n"); \
+         exit(1); \
+      } \
+      return name call_args; \
+   }\
+   FUNC_##name name = IMPL_##name;
+    
+   #ifdef NEKO_COMPATIBLE
+   DEFINE_PRIM(neko_init,5)
+   #endif
+
+   #else // not android }  { android
+
+
+   #define DEFFUNC(name,ret,def_args,call_args) \
+   typedef ret (*FUNC_##name)def_args; \
+   extern FUNC_##name name; \
+   ret IMPL_##name def_args \
+   { \
+      name = (FUNC_##name)LoadFunc(#name); \
+      if (!name) \
+      { \
+         __android_log_print(ANDROID_LOG_ERROR,"CFFILoader", "Could not find function:" #name "\n"); \
+      } \
+      return name call_args; \
+   }\
+   FUNC_##name name = IMPL_##name;
+    
+
+   #endif // android }
+
+#endif // dynamic link }
+
+#endif
+
+

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/CFFINekoLoader.h

@@ -0,0 +1,723 @@
+#ifndef HX_CFFI_NEKO_LOADER_H
+#define HX_CFFI_NEKO_LOADER_H
+
+//-------- NEKO Interface -----------------------------------------------------
+namespace
+{
+
+#include <hx/NekoFunc.h>
+
+
+void *sNekoDllHandle = 0;
+
+void *LoadNekoFunc(const char *inName)
+{
+   #ifdef HX_WINRT
+   return 0;
+   #else
+   static bool tried = false;
+   if (tried && !sNekoDllHandle)
+       return 0;
+   tried = true;
+
+   if (!sNekoDllHandle)
+   {
+      #ifdef HX_WINDOWS
+      sNekoDllHandle = GetModuleHandleA("neko.dll");
+      #else
+      sNekoDllHandle = dlopen("libneko." NEKO_EXT, RTLD_NOW);
+      // The debian package creates libneko.so.0 without libneko.so...
+      // The fedora/openSUSE rpm packages create libneko.so.1...
+      if (!sNekoDllHandle)
+         sNekoDllHandle = dlopen("libneko." NEKO_EXT ".0", RTLD_NOW);
+      if (!sNekoDllHandle)
+         sNekoDllHandle = dlopen("libneko." NEKO_EXT ".1", RTLD_NOW);
+      if (!sNekoDllHandle)
+         sNekoDllHandle = dlopen("libneko." NEKO_EXT ".2", RTLD_NOW);
+      #endif
+  
+      if (!sNekoDllHandle)
+      {
+         fprintf(stderr,"Could not link to neko.\n");
+         return 0;
+      }
+   }
+
+
+   #ifdef HX_WINDOWS
+   void *result = (void *)GetProcAddress((HMODULE)sNekoDllHandle,inName);
+   #else
+   void *result = dlsym(sNekoDllHandle,inName);
+   #endif
+
+   //printf(" %s = %p\n", inName, result );
+   return result;
+   #endif // !HX_WINRT
+}
+
+
+static int __a_id = 0;
+static int __s_id = 0;
+static int b_id = 0;
+static int length_id = 0;
+static int push_id = 0;
+
+neko_value *gNeko2HaxeString = 0;
+neko_value *gNekoNewArray = 0;
+neko_value gNekoNull = 0;
+neko_value gNekoTrue = 0;
+neko_value gNekoFalse = 0;
+
+
+namespace
+{
+void CheckInitDynamicNekoLoader()
+{
+   if (!gNekoNull)
+   {
+      printf("Haxe code is missing a call to cpp.Prime.nekoInit().\n");
+   }
+}
+}
+
+
+/*
+
+
+*/
+
+void *DynamicNekoLoader(const char *inName);
+
+typedef neko_value (*alloc_object_func)(neko_value);
+typedef neko_value (*alloc_string_func)(const char *);
+typedef neko_value (*alloc_abstract_func)(neko_vkind,void *);
+typedef neko_value (*val_call1_func)(neko_value,neko_value);
+typedef neko_value (*val_field_func)(neko_value,int);
+typedef neko_value (*alloc_float_func)(double);
+typedef void (*alloc_field_func)(neko_value,int,neko_value);
+typedef neko_value *(*alloc_root_func)(int);
+typedef char *(*alloc_private_func)(int);
+typedef neko_value (*copy_string_func)(const char *,int);
+typedef int (*val_id_func)(const char *);
+typedef neko_buffer (*alloc_buffer_func)(const char *);
+typedef neko_value (*val_buffer_func)(neko_buffer);
+typedef void (*buffer_append_sub_func)(neko_buffer,const char *,int);
+typedef void (*fail_func)(neko_value,const char *,int);
+typedef neko_value (*alloc_array_func)(unsigned int);
+typedef void (*val_gc_func)(neko_value,void *);
+typedef void (*val_ocall1_func)(neko_value,int,neko_value);
+typedef neko_value (*alloc_empty_string_func)(int);
+
+static alloc_object_func dyn_alloc_object = 0;
+static alloc_string_func dyn_alloc_string = 0;
+static alloc_abstract_func dyn_alloc_abstract = 0;
+static val_call1_func dyn_val_call1 = 0;
+static val_field_func dyn_val_field = 0;
+static alloc_field_func dyn_alloc_field = 0;
+static alloc_float_func dyn_alloc_float = 0;
+static alloc_root_func dyn_alloc_root = 0;
+static alloc_private_func dyn_alloc_private = 0;
+static alloc_private_func dyn_alloc = 0;
+static copy_string_func dyn_copy_string = 0;
+static val_id_func dyn_val_id = 0;
+static alloc_buffer_func dyn_alloc_buffer = 0;
+static val_buffer_func dyn_val_buffer = 0;
+static fail_func dyn_fail = 0;
+static buffer_append_sub_func dyn_buffer_append_sub = 0;
+static alloc_array_func dyn_alloc_array = 0;
+static val_gc_func dyn_val_gc = 0;
+static val_ocall1_func dyn_val_ocall1 = 0;
+static alloc_empty_string_func dyn_alloc_empty_string = 0;
+
+
+neko_value api_alloc_string(const char *inString)
+{
+   CheckInitDynamicNekoLoader();
+   neko_value neko_string = dyn_alloc_string(inString);
+   if (gNeko2HaxeString)
+      return dyn_val_call1(*gNeko2HaxeString,neko_string);
+   return neko_string;
+}
+
+
+char *api_alloc_string_data(const char *inString,int inLength)
+{
+   CheckInitDynamicNekoLoader();
+   char *result = (char *)dyn_alloc_private(inLength+1);
+   memcpy(result,inString,inLength);
+   result[inLength]='\0';
+   return result;
+}
+
+
+neko_value api_alloc_raw_string(int inLength)
+{
+   CheckInitDynamicNekoLoader();
+   return dyn_alloc_empty_string(inLength);
+}
+
+
+#define NEKO_NOT_IMPLEMENTED(func) dyn_fail(api_alloc_string("NOT Implemented:" func),__FILE__,__LINE__)
+
+void * api_empty() { return 0; }
+
+bool api_val_bool(neko_value  arg1) { return arg1==gNekoTrue; }
+int api_val_int(neko_value  arg1) { return neko_val_int(arg1); }
+double api_val_float(neko_value  arg1) { return *(double *)( ((char *)arg1) + 4 ); }
+double api_val_number(neko_value  arg1) { return neko_val_is_int(arg1) ? neko_val_int(arg1) : api_val_float(arg1); }
+
+
+neko_value api_alloc_bool(bool arg1) { CheckInitDynamicNekoLoader(); return arg1 ? gNekoTrue : gNekoFalse; }
+neko_value api_alloc_int(int arg1) { return neko_alloc_int(arg1); }
+neko_value api_alloc_empty_object()
+{
+   return dyn_alloc_object(gNekoNull);
+}
+
+neko_value api_buffer_to_string(neko_buffer arg1)
+{
+   neko_value neko_string = dyn_val_buffer(arg1);
+   if (gNeko2HaxeString)
+      return dyn_val_call1(*gNeko2HaxeString,neko_string);
+   return neko_string;
+}
+
+
+const char * api_val_string(neko_value  arg1)
+{
+	if (neko_val_is_string(arg1))
+	   return neko_val_string(arg1);
+
+	if (neko_val_is_object(arg1))
+   {
+	   neko_value s = dyn_val_field(arg1,__s_id);
+      if (neko_val_is_string(s))
+	      return neko_val_string(s);
+   }
+
+   return 0;
+}
+
+void api_alloc_field_numeric(neko_value  arg1,int arg2, double arg3)
+{
+   dyn_alloc_field(arg1, arg2, dyn_alloc_float(arg3) );
+}
+
+double  api_val_field_numeric(neko_value  arg1,int arg2)
+{
+	neko_value field = dyn_val_field(arg1, arg2);
+	if (neko_val_is_number(field))
+		return api_val_number(field);
+	if (field==gNekoTrue)
+      return 1;
+	return 0;
+}
+
+
+
+
+int api_val_strlen(neko_value  arg1)
+{
+	if (neko_val_is_string(arg1))
+	   return neko_val_strlen(arg1);
+
+	if (neko_val_is_object(arg1))
+   {
+      neko_value l =  dyn_val_field(arg1,length_id);
+      if (neko_val_is_int(l))
+         return api_val_int(l);
+   }
+	return 0;
+}
+void api_buffer_set_size(neko_buffer inBuffer,int inLen) { 
+   NEKO_NOT_IMPLEMENTED("api_buffer_set_size");
+}
+
+
+void api_buffer_append_char(neko_buffer inBuffer,int inChar)
+{
+   NEKO_NOT_IMPLEMENTED("api_buffer_append_char");
+}
+
+
+
+// Byte arrays - use strings
+neko_buffer api_val_to_buffer(neko_value  arg1)
+{
+   return (neko_buffer)api_val_string(arg1);
+}
+bool api_val_is_buffer(neko_value  arg1) { return neko_val_is_string(arg1); } 
+int api_buffer_size(neko_buffer inBuffer) { return neko_val_strlen((neko_value)inBuffer); }
+char * api_buffer_data(neko_buffer inBuffer) { return (char *)api_val_string((neko_value)inBuffer); }
+
+char * api_val_dup_string(neko_value inVal)
+{
+	int len = api_val_strlen(inVal);
+	const char *ptr = api_val_string(inVal);
+	char *result = dyn_alloc_private(len+1);
+	memcpy(result,ptr,len);
+	result[len] = '\0';
+	return result;
+}
+
+neko_value api_alloc_string_len(const char *inStr,int inLen)
+{
+	if (gNeko2HaxeString)
+   {
+      if (!inStr)
+		   return dyn_val_call1(*gNeko2HaxeString,api_alloc_raw_string(inLen));
+		return dyn_val_call1(*gNeko2HaxeString,dyn_copy_string(inStr,inLen));
+   }
+   if (!inStr)
+		inStr = dyn_alloc_private(inLen);
+   return dyn_copy_string(inStr,inLen);
+}
+
+neko_buffer api_alloc_buffer_len(int inLen)
+{
+	neko_value str=api_alloc_string_len(0,inLen+1);
+	char *s=(char *)api_val_string(str);
+	memset(s,0,inLen+1);
+	return (neko_buffer)str;
+}
+
+
+
+neko_value api_alloc_wstring_len(const wchar_t *inStr,int inLen)
+{
+  int len = 0;
+  const wchar_t *chars = inStr;
+  for(int i=0;i<inLen;i++)
+   {
+      int c = chars[i];
+      if( c <= 0x7F ) len++;
+      else if( c <= 0x7FF ) len+=2;
+      else if( c <= 0xFFFF ) len+=3;
+      else len+= 4;
+   }
+
+   char *result = dyn_alloc_private(len);//+1?
+   unsigned char *data =  (unsigned char *) &result[0];
+   for(int i=0;i<inLen;i++)
+   {
+      int c = chars[i];
+      if( c <= 0x7F )
+         *data++ = c;
+      else if( c <= 0x7FF )
+      {
+         *data++ = 0xC0 | (c >> 6);
+         *data++ = 0x80 | (c & 63);
+      }
+      else if( c <= 0xFFFF )
+      {
+         *data++ = 0xE0 | (c >> 12);
+         *data++ = 0x80 | ((c >> 6) & 63);
+         *data++ = 0x80 | (c & 63);
+      }
+      else
+      {
+         *data++ = 0xF0 | (c >> 18);
+         *data++ = 0x80 | ((c >> 12) & 63);
+         *data++ = 0x80 | ((c >> 6) & 63);
+         *data++ = 0x80 | (c & 63);
+      }
+   }
+   //result[len] = 0;
+
+   return api_alloc_string_len(result,len);
+}
+
+
+
+const wchar_t *api_val_wstring(neko_value  arg1)
+{
+	int len = api_val_strlen(arg1);
+
+   unsigned char *b = (unsigned char *)api_val_string(arg1);
+   wchar_t *result = (wchar_t *)dyn_alloc_private((len+1)*sizeof(wchar_t));
+   int l = 0;
+
+   for(int i=0;i<len;)
+   {
+       int c = b[i++];
+       if (c==0) break;
+       else if( c < 0x80 )
+       {
+           result[l++] = c;
+       }
+       else if( c < 0xE0 )
+           result[l++] = ( ((c & 0x3F) << 6) | (b[i++] & 0x7F) );
+       else if( c < 0xF0 )
+       {
+           int c2 = b[i++];
+           result[l++] = ( ((c & 0x1F) << 12) | ((c2 & 0x7F) << 6) | ( b[i++] & 0x7F) );
+       }
+       else
+       {
+           int c2 = b[i++];
+           int c3 = b[i++];
+           result[l++] = ( ((c & 0x0F) << 18) | ((c2 & 0x7F) << 12) | ((c3 << 6) & 0x7F) | (b[i++] & 0x7F) );
+       }
+   }
+   result[l] = '\0';
+
+   return result;
+}
+
+
+wchar_t * api_val_dup_wstring(neko_value inVal)
+{
+	return (wchar_t *)api_val_wstring(inVal);
+}
+
+
+
+int api_val_type(neko_value  arg1)
+{
+	int t=neko_val_type(arg1);
+
+	if (t==VAL_OBJECT)
+	{
+		neko_value __a = dyn_val_field(arg1,__a_id);
+		if (neko_val_is_array(__a))
+			return valtArray;
+		neko_value __s = dyn_val_field(arg1,__s_id);
+		if (neko_val_is_string(__s))
+			return valtString;
+	}
+	if (t<7)
+		return (hxValueType)t;
+	if (t==VAL_ABSTRACT)
+		return valtAbstractBase;
+
+	if (t==VAL_PRIMITIVE || t==VAL_JITFUN)
+		return valtFunction;
+	if (t==VAL_32_BITS || t==VAL_INT)
+		return valtInt;
+	return valtNull;
+}
+
+neko_value *api_alloc_root()
+{
+   return dyn_alloc_root(1);
+}
+
+
+void * api_val_to_kind(neko_value  arg1,neko_vkind arg2)
+{
+	neko_vkind k = (neko_vkind)neko_val_kind(arg1);
+	if (k!=arg2)
+		return 0;
+	return neko_val_data(arg1);
+}
+
+
+int api_alloc_kind()
+{
+	static int id = 1;
+	int result = id;
+	id += 4;
+	return result;
+}
+neko_value api_alloc_null()
+{
+   CheckInitDynamicNekoLoader();
+   return gNekoNull;
+}
+
+neko_value api_create_abstract(neko_vkind inKind,int inSize,void *inFinalizer)
+{
+   void *data = dyn_alloc(inSize);
+   neko_value val = dyn_alloc_abstract(inKind, data);
+   dyn_val_gc(val, inFinalizer);
+   return val;
+}
+
+void api_free_abstract(neko_value inAbstract)
+{
+   if (neko_val_is_abstract(inAbstract))
+   {
+      dyn_val_gc(inAbstract,0);
+      neko_val_kind(inAbstract) = 0;
+   }
+}
+
+
+neko_value api_buffer_val(neko_buffer arg1)
+{
+        if (neko_val_is_string(arg1))
+            return (neko_value)arg1;
+
+        if (neko_val_is_object(arg1))
+        {
+            neko_value s = dyn_val_field((neko_value)arg1,__s_id);
+            if (neko_val_is_string(s))
+                return (neko_value)(s);
+        }
+
+
+   return api_alloc_null();
+}
+
+
+void api_hx_error()
+{
+   dyn_fail(dyn_alloc_string("An unknown error has occurred."),"",1);
+}
+
+void * api_val_data(neko_value  arg1) { return neko_val_data(arg1); }
+
+// Array access - generic
+int api_val_array_size(neko_value  arg1)
+{
+	if (neko_val_is_array(arg1))
+	   return neko_val_array_size(arg1);
+	neko_value l = dyn_val_field(arg1,length_id);
+	return neko_val_int(l);
+}
+
+
+neko_value  api_val_array_i(neko_value  arg1,int arg2)
+{
+	if (neko_val_is_array(arg1))
+	   return neko_val_array_ptr(arg1)[arg2];
+	return neko_val_array_ptr(dyn_val_field(arg1,__a_id))[arg2];
+}
+
+void api_val_array_set_i(neko_value  arg1,int arg2,neko_value inVal)
+{
+	if (!neko_val_is_array(arg1))
+		arg1 = dyn_val_field(arg1,__a_id);
+	neko_val_array_ptr(arg1)[arg2] = inVal;
+}
+
+void api_val_array_set_size(neko_value  arg1,int inLen)
+{
+	NEKO_NOT_IMPLEMENTED("api_val_array_set_size");
+}
+
+void api_val_array_push(neko_value  inArray,neko_value inValue)
+{
+   dyn_val_ocall1(inArray,push_id,inValue);
+}
+
+
+neko_value  api_alloc_array(int arg1)
+{
+   if (!gNekoNewArray)
+	   return dyn_alloc_array(arg1);
+	return dyn_val_call1(*gNekoNewArray,neko_alloc_int(arg1));
+}
+
+
+neko_value * api_val_array_value(neko_value  arg1)
+{
+	if (neko_val_is_array(arg1))
+	   return neko_val_array_ptr(arg1);
+	return neko_val_array_ptr(dyn_val_field(arg1,__a_id));
+}
+
+neko_value  api_val_call0_traceexcept(neko_value  arg1)
+{
+	NEKO_NOT_IMPLEMENTED("api_val_call0_traceexcept");
+	return gNekoNull;
+}
+
+
+int  api_val_fun_nargs(neko_value arg1)
+{
+   if (!arg1 || !neko_val_is_function(arg1) )
+      return faNotFunction;
+   return neko_val_fun_nargs(arg1);
+}
+
+
+
+void api_val_gc(neko_value obj, void *finalizer)
+{
+   // Let neko deal with ints or abstracts ...
+   if (neko_val_is_int(obj) || neko_val_is_abstract(obj))
+   {
+      dyn_val_gc(obj,finalizer);
+   }
+   else
+   {
+      // Hack type to abstract for the duration
+      neko_val_type old_tag = neko_val_tag(obj);
+      neko_val_tag(obj) = VAL_ABSTRACT;
+      dyn_val_gc(obj,finalizer);
+      neko_val_tag(obj) = old_tag;
+   }
+}
+
+void api_gc_change_managed_memory(int,const char *)
+{
+   // Nothing to do here
+}
+
+bool api_gc_try_blocking() { return false; }
+bool api_gc_try_unblocking() { return false; }
+
+#define IMPLEMENT_HERE(x) if (!strcmp(inName,#x)) return (void *)api_##x;
+#define IGNORE_API(x) if (!strcmp(inName,#x)) return (void *)api_empty;
+
+
+void *DynamicNekoLoader(const char *inName)
+{
+   IMPLEMENT_HERE(alloc_kind)
+   IMPLEMENT_HERE(alloc_null)
+   IMPLEMENT_HERE(val_to_kind)
+   if (!strcmp(inName,"hx_fail"))
+      return LoadNekoFunc("_neko_failure");
+   IMPLEMENT_HERE(val_type)
+   IMPLEMENT_HERE(val_bool)
+   IMPLEMENT_HERE(val_int)
+   IMPLEMENT_HERE(val_float)
+   IMPLEMENT_HERE(val_number)
+   IMPLEMENT_HERE(val_field_numeric)
+   IMPLEMENT_HERE(alloc_bool)
+   IMPLEMENT_HERE(alloc_int)
+   IMPLEMENT_HERE(alloc_empty_object)
+   IMPLEMENT_HERE(alloc_root)
+   IMPLEMENT_HERE(val_gc)
+   IMPLEMENT_HERE(gc_try_blocking)
+   IMPLEMENT_HERE(gc_try_unblocking)
+
+   IMPLEMENT_HERE(create_abstract)
+   IMPLEMENT_HERE(free_abstract)
+
+   IGNORE_API(gc_enter_blocking)
+   IGNORE_API(gc_exit_blocking)
+   IGNORE_API(gc_safe_point)
+   IGNORE_API(gc_add_root)
+   IGNORE_API(gc_remove_root)
+   IGNORE_API(gc_set_top_of_stack)
+   IGNORE_API(gc_change_managed_memory)
+   IGNORE_API(create_root)
+   IGNORE_API(query_root)
+   IGNORE_API(destroy_root)
+   IGNORE_API(hx_register_prim)
+   IGNORE_API(val_array_int)
+   IGNORE_API(val_array_double)
+   IGNORE_API(val_array_float)
+   IGNORE_API(val_array_bool)
+
+   if (!strcmp(inName,"hx_alloc"))
+      return LoadNekoFunc("neko_alloc");
+
+   IMPLEMENT_HERE(buffer_to_string)
+   IMPLEMENT_HERE(buffer_val)
+
+   if (!strcmp(inName,"val_iter_field_vals"))
+      return LoadNekoFunc("neko_val_iter_fields");
+
+   IMPLEMENT_HERE(val_strlen)
+   IMPLEMENT_HERE(val_wstring)
+   IMPLEMENT_HERE(val_string)
+   IMPLEMENT_HERE(alloc_string)
+   IMPLEMENT_HERE(alloc_raw_string)
+   IMPLEMENT_HERE(alloc_string_data)
+   IMPLEMENT_HERE(val_dup_wstring)
+   IMPLEMENT_HERE(val_dup_string)
+   IMPLEMENT_HERE(alloc_string_len)
+   IMPLEMENT_HERE(alloc_wstring_len)
+
+   IMPLEMENT_HERE(val_is_buffer)
+   IMPLEMENT_HERE(val_to_buffer)
+   IMPLEMENT_HERE(alloc_buffer_len)
+   IMPLEMENT_HERE(buffer_size)
+   IMPLEMENT_HERE(buffer_set_size)
+   IMPLEMENT_HERE(buffer_append_char)
+   IMPLEMENT_HERE(buffer_data)
+
+   IMPLEMENT_HERE(hx_error)
+   IMPLEMENT_HERE(val_array_i)
+   IMPLEMENT_HERE(val_array_size)
+   IMPLEMENT_HERE(val_data)
+   IMPLEMENT_HERE(val_array_set_i)
+   IMPLEMENT_HERE(val_array_set_size)
+   IMPLEMENT_HERE(val_array_push)
+   IMPLEMENT_HERE(alloc_array)
+   IMPLEMENT_HERE(alloc_field_numeric)
+   IMPLEMENT_HERE(val_array_value)
+
+   IMPLEMENT_HERE(val_fun_nargs)
+
+   IMPLEMENT_HERE(val_call0_traceexcept)
+
+
+   char buffer[100];
+   strcpy(buffer,"neko_");
+   strcat(buffer,inName);
+   void *result = LoadNekoFunc(buffer);
+   if (result)
+      return result;
+
+	return 0;
+}
+
+
+ResolveProc InitDynamicNekoLoader()
+{
+   static bool init = false;
+   if (!init)
+   {
+      dyn_alloc_private = (alloc_private_func)LoadNekoFunc("neko_alloc_private");
+      dyn_alloc = (alloc_private_func)LoadNekoFunc("neko_alloc");
+      dyn_alloc_object = (alloc_object_func)LoadNekoFunc("neko_alloc_object");
+      dyn_alloc_string = (alloc_string_func)LoadNekoFunc("neko_alloc_string");
+      dyn_alloc_abstract = (alloc_abstract_func)LoadNekoFunc("neko_alloc_abstract");
+      dyn_val_call1 = (val_call1_func)LoadNekoFunc("neko_val_call1");
+      dyn_val_field = (val_field_func)LoadNekoFunc("neko_val_field");
+      dyn_alloc_field = (alloc_field_func)LoadNekoFunc("neko_alloc_field");
+      dyn_alloc_float = (alloc_float_func)LoadNekoFunc("neko_alloc_float");
+      dyn_alloc_root = (alloc_root_func)LoadNekoFunc("neko_alloc_root");
+      dyn_copy_string = (copy_string_func)LoadNekoFunc("neko_copy_string");
+      dyn_val_id = (val_id_func)LoadNekoFunc("neko_val_id");
+      dyn_alloc_buffer = (alloc_buffer_func)LoadNekoFunc("neko_alloc_buffer");
+      dyn_val_buffer = (val_buffer_func)LoadNekoFunc("neko_buffer_to_string");
+      dyn_fail = (fail_func)LoadNekoFunc("_neko_failure");
+      dyn_buffer_append_sub = (buffer_append_sub_func)LoadNekoFunc("neko_buffer_append_sub");
+      dyn_alloc_array = (alloc_array_func)LoadNekoFunc("neko_alloc_array");
+      dyn_val_gc = (val_gc_func)LoadNekoFunc("neko_val_gc");
+      dyn_val_ocall1 = (val_ocall1_func)LoadNekoFunc("neko_val_ocall1");
+      dyn_alloc_empty_string = (alloc_empty_string_func)LoadNekoFunc("neko_alloc_empty_string");
+      init = true;
+   }
+
+   if (!dyn_val_id)
+     return 0;
+
+
+   __a_id = dyn_val_id("__a");
+   __s_id = dyn_val_id("__s");
+   b_id = dyn_val_id("b");
+   length_id = dyn_val_id("length");
+   push_id = dyn_val_id("push");
+
+   return DynamicNekoLoader;
+}
+
+
+neko_value neko_init(neko_value inNewString,neko_value inNewArray,neko_value inNull, neko_value inTrue, neko_value inFalse)
+{
+   InitDynamicNekoLoader();
+
+   gNekoNull = inNull;
+   gNekoTrue = inTrue;
+   gNekoFalse = inFalse;
+
+   gNeko2HaxeString = dyn_alloc_root(1);
+   *gNeko2HaxeString = inNewString;
+   gNekoNewArray = dyn_alloc_root(1);
+   *gNekoNewArray = inNewArray;
+
+   return gNekoNull;
+}
+
+
+
+} // end anon namespace
+
+#endif
+

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Class.h

@@ -0,0 +1,307 @@
+   #ifndef HX_CLASS_H
+#define HX_CLASS_H
+
+
+namespace hx
+{
+// --- hxClassOf --------------------------------------------------------------
+//
+// Gets the class definition that relates to a specific type.
+// Most classes have their own class data, but the standard types (non-classes)
+//  use the template traits to get the class
+
+
+template<typename T> 
+inline hx::Class &ClassOf() { typedef typename T::Obj Obj; return Obj::__SGetClass(); }
+
+template<> 
+inline hx::Class &ClassOf<int>() { return GetIntClass(); }
+
+template<> 
+inline hx::Class &ClassOf<double>() { return GetFloatClass(); }
+
+template<> 
+inline hx::Class &ClassOf<float>() { return GetFloatClass(); }
+
+template<> 
+inline hx::Class &ClassOf<bool>() { return GetBoolClass(); }
+
+template<> 
+inline hx::Class &ClassOf<null>() { return GetVoidClass(); }
+
+template<> 
+inline hx::Class &ClassOf<String>() { return GetStringClass(); }
+
+template<>
+inline hx::Class &ClassOf< ::cpp::Int64>() { return GetInt64Class(); }
+
+
+template<typename T>
+struct hxBaseType { typedef T type; };
+template<typename T>
+struct hxBaseType< hx::ObjectPtr<T> > { typedef T type; };
+
+template<typename T> inline int ClassSizeOf() { return sizeof( typename hx::hxBaseType<T>::type ); }
+
+} // end namespace hx
+
+
+// --- Class_obj --------------------------------------------------------------------
+//
+// The Class_obj provides the type information required by the Reflect and type APIs.
+
+namespace hx
+{
+typedef Dynamic (*ConstructEmptyFunc)();
+typedef Dynamic (*ConstructArgsFunc)(DynamicArray inArgs);
+typedef Dynamic (*ConstructEnumFunc)(String inName,DynamicArray inArgs);
+typedef void (*MarkFunc)(hx::MarkContext *__inCtx);
+typedef bool (*CanCastFunc)(hx::Object *inPtr);
+#ifdef HXCPP_VISIT_ALLOCS
+typedef void (*VisitFunc)(hx::VisitContext *__inCtx);
+#endif
+typedef bool (*GetStaticFieldFunc)(const String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+typedef bool (*SetStaticFieldFunc)(const String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+}
+
+inline bool operator!=(hx::ConstructEnumFunc inFunc,const null &inNull) { return inFunc!=0; }
+
+#ifdef HXCPP_SCRIPTABLE
+namespace hx
+{
+enum FieldStorage
+{
+   fsUnknown = 0,
+   fsBool,
+   fsInt,
+   fsFloat,
+   fsString,
+   fsByte,
+   fsObject,
+};
+struct StorageInfo
+{
+   FieldStorage type;
+   int          offset;
+   String       name;
+};
+struct StaticInfo
+{
+   FieldStorage type;
+   void         *address;
+   String       name;
+};
+
+}
+#endif
+
+namespace hx
+{
+
+class HXCPP_EXTERN_CLASS_ATTRIBUTES Class_obj : public hx::Object
+{
+public:
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdClass };
+
+
+   inline void *operator new( size_t inSize )
+   {
+      return hx::InternalCreateConstBuffer(0,(int)inSize);
+   }
+   void operator delete( void *) { }
+
+
+   Class_obj() : mSuper(0) { };
+   Class_obj(const String &inClassName, String inStatics[], String inMembers[],
+             hx::ConstructEmptyFunc inConstructEmpty, hx::ConstructArgsFunc inConstructArgs,
+             hx::Class *inSuperClass, hx::ConstructEnumFunc inConstructEnum,
+             hx::CanCastFunc inCanCast, hx::MarkFunc inMarkFunc
+             #ifdef HXCPP_VISIT_ALLOCS
+             , hx::VisitFunc inVisitFunc
+             #endif
+             #ifdef HXCPP_SCRIPTABLE
+             ,const hx::StorageInfo *inStorageInfo
+             ,const hx::StaticInfo *inStaticInfo
+             #endif
+             );
+
+   String __ToString() const;
+
+   void MarkStatics(hx::MarkContext *__inCtx);
+
+   #ifdef HXCPP_VISIT_ALLOCS
+   void VisitStatics(hx::VisitContext *__inCtx);
+   #endif
+
+   static ::Array< ::String > dupFunctions(String inStatics[]);
+
+   // the "Class class"
+   hx::Class              __GetClass() const;
+   static hx::Class      & __SGetClass();
+	static void       __boot();
+
+   hx::Val __Field(const String &inString ,hx::PropertyAccess inCallProp);
+
+   hx::Val __SetField(const String &inString,const hx::Val &inValue ,hx::PropertyAccess inCallProp);
+
+   bool __HasField(const String &inString);
+
+   virtual Dynamic ConstructEmpty();
+   virtual Dynamic ConstructArgs(hx::DynamicArray inArgs);
+   virtual Dynamic ConstructEnum(String inName,hx::DynamicArray inArgs);
+   virtual bool VCanCast(hx::Object *inPtr) { return false; }
+
+   int __GetType() const { return vtObject; }
+
+   virtual bool __IsEnum();
+
+	inline bool CanCast(hx::Object *inPtr) { return mCanCast ? mCanCast(inPtr) : VCanCast(inPtr); }
+   static bool GetNoStaticField(const String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+   static bool SetNoStaticField(const String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+
+   void registerScriptable(bool inOverwrite);
+  
+	hx::CanCastFunc     mCanCast;
+
+
+
+   virtual Array<String>  GetInstanceFields();
+   virtual Array<String>  GetClassFields();
+   hx::Class              GetSuper();
+   #ifdef HXCPP_SCRIPTABLE
+   const hx::StorageInfo*  GetMemberStorage(String inName);
+   const hx::StaticInfo*  GetStaticStorage(String inName);
+   #endif
+
+   static hx::Class       Resolve(String inName);
+
+
+   hx::Class              *mSuper;
+   String             mName;
+   Dynamic            __meta__;
+   String             __rtti__;
+
+	hx::ConstructArgsFunc  mConstructArgs;
+	hx::ConstructEmptyFunc mConstructEmpty;
+	hx::ConstructEnumFunc  mConstructEnum;
+   hx::GetStaticFieldFunc mGetStaticField;
+   hx::SetStaticFieldFunc mSetStaticField;
+
+	hx::MarkFunc           mMarkFunc;
+   #ifdef HXCPP_VISIT_ALLOCS
+	hx::VisitFunc           mVisitFunc;
+   #endif
+   Array<String>      mStatics;
+   Array<String>      mMembers;
+
+   #ifdef HXCPP_SCRIPTABLE
+   const hx::StorageInfo*    mMemberStorageInfo;
+   const hx::StaticInfo*    mStaticStorageInfo;
+   #endif
+};
+
+} // end namespace hx
+
+void __hxcpp_boot_std_classes();
+
+
+// --- All classes should be registered with this function via the "__boot" method
+#ifdef RegisterClass
+#undef RegisterClass
+#endif
+
+namespace hx
+{
+
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+hx::Class _hx_RegisterClass(const String &inClassName, CanCastFunc inCanCast,
+                    String inStatics[], String inMembers[],
+                    ConstructEmptyFunc inConstructEmpty, ConstructArgsFunc inConstructArgs,
+                    hx::Class *inSuperClass, ConstructEnumFunc inConst=0, MarkFunc inMarkFunc=0
+                    #ifdef HXCPP_VISIT_ALLOCS
+                    , VisitFunc inVisitFunc=0
+                    #endif
+                    #ifdef HXCPP_SCRIPTABLE
+                    ,const hx::StorageInfo *inStorageInfo=0
+                    ,const hx::StaticInfo *inStaticInfo=0
+                    #endif
+                    );
+
+// For older versions
+inline hx::Class RegisterClass(
+                    const String &inClassName, CanCastFunc inCanCast,
+                    String inStatics[], String inMembers[],
+                    ConstructEmptyFunc inConstructEmpty, ConstructArgsFunc inConstructArgs,
+                    hx::Class *inSuperClass, ConstructEnumFunc inConst=0, MarkFunc inMarkFunc=0
+                    #ifdef HXCPP_VISIT_ALLOCS
+                    , VisitFunc inVisitFunc=0
+                    #endif
+                    #ifdef HXCPP_SCRIPTABLE
+                    ,const hx::StorageInfo *inStorageInfo=0
+                    ,const hx::StaticInfo *inStaticInfo=0
+                    #endif
+                    )
+{
+   return _hx_RegisterClass(inClassName, inCanCast, inStatics, inMembers,
+                    inConstructEmpty, inConstructArgs, inSuperClass, inConst, inMarkFunc
+                    #ifdef HXCPP_VISIT_ALLOCS
+                    , inVisitFunc
+                    #endif
+                    #ifdef HXCPP_SCRIPTABLE
+                    ,inStorageInfo ,inStaticInfo
+                    #endif
+                    );
+}
+
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+void _hx_RegisterClass(const String &inClassName, hx::Class inClass);
+
+inline void RegisterClass(const String &inClassName, hx::Class inClass)
+{
+   _hx_RegisterClass(inClassName, inClass);
+}
+
+template<typename T>
+inline bool TCanCast(hx::Object *inPtr)
+{
+	return inPtr && (
+                  #if (HXCPP_API_LEVEL >= 332)
+                     inPtr->_hx_isInstanceOf(T::_hx_ClassId)
+                  #elif (HXCPP_API_LEVEL==331)
+                     dynamic_cast<T *>(inPtr)
+                  #else
+                     dynamic_cast<T *>(inPtr->__GetRealObject())
+                     #if (HXCPP_API_LEVEL < 330)
+                     || inPtr->__ToInterface(typeid(T))
+                     #endif
+                  #endif
+                  );
+}
+
+
+#if (HXCPP_API_LEVEL >= 330)
+template<int HASH>
+inline bool TIsInterface(hx::Object *inPtr)
+{
+	return inPtr && inPtr->_hx_getInterface(HASH);
+}
+#endif
+
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES void RegisterVTableOffset(int inOffset);
+
+#define HX_REGISTER_VTABLE_OFFSET( CLASS, INTERFACE ) \
+{ \
+   CLASS *dummy = (CLASS *)0; \
+   INTERFACE *intf = dummy; \
+   hx::RegisterVTableOffset( (int)( (size_t)((char *)intf - (char *)dummy)) ); \
+}
+
+
+
+}
+
+
+#endif

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Debug.h

@@ -0,0 +1,365 @@
+#ifndef HX_DEBUG_H
+#define HX_DEBUG_H
+
+#include <hxcpp.h>
+
+// Some functions used by AdvancedDebug.cpp
+// Returns the thread number of the calling thread
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+int __hxcpp_GetCurrentThreadNumber();
+
+namespace hx
+{
+
+#ifdef HXCPP_DEBUGGER
+
+template<typename T> struct StackVariableWrapper
+{
+   typedef T wrapper;
+};
+template<> struct StackVariableWrapper<size_t>
+{
+   #ifdef HXCPP_M64
+   typedef cpp::Int64 wrapper;
+   #else
+   typedef int wrapper;
+   #endif
+};
+
+
+template<typename T> struct StackVariableWrapper<T *>
+{
+   typedef cpp::Pointer<T> wrapper;
+};
+
+
+
+
+class StackVariable
+{
+public:
+
+    const char *mHaxeName;
+    bool mIsArg;
+    StackVariable *mNext;
+
+    template<typename T>
+    StackVariable(StackVariable *&inHead, bool inIsArg,
+                  const char *inHaxeName, T *inCppVar)
+        : mHaxeName(inHaxeName), mIsArg(inIsArg), mHead(inHead),
+          mCppVar((void *) inCppVar)
+    {
+        mGetOrSetFunction = GetOrSetFunction<T>;
+        mNext = mHead;
+        mHead = this;
+    }
+
+    StackVariable(StackVariable *&inHead, bool inIsArg,
+                  const char *inHaxeName, hx::Object **inCppVar)
+        : mHaxeName(inHaxeName), mIsArg(inIsArg), mHead(inHead),
+          mCppVar((void *) inCppVar)
+    {
+        mGetOrSetFunction = GetOrSetFunctionHxObject;
+        mNext = mHead;
+        mHead = this;
+    }
+
+
+    // For StackThis
+    template<typename T>
+    StackVariable(StackVariable *&inHead, T *inCppVar)
+        : mHaxeName("this"), mIsArg(true), mHead(inHead),
+          mCppVar((void *) inCppVar)
+    {
+        mNext = mHead;
+        mHead = this;
+    }
+
+    ~StackVariable()
+    {
+        // Stack variables are always deleted in the reverse order that they
+        // are created, so a simple pop_front is sufficient; no need to hunt
+        // for and remove the variable, it's always in the front ...
+        mHead = mNext;
+    }
+
+    operator Dynamic()
+    {
+        return mGetOrSetFunction(true, mCppVar, 0);
+    }
+
+    StackVariable &operator =(Dynamic &other)
+    {
+        (void) mGetOrSetFunction(false, mCppVar, &other);
+
+        return *this;
+    }
+
+protected:
+
+	typedef Dynamic (*GetOrSetFunctionType)(bool, void *, Dynamic *);
+
+    GetOrSetFunctionType mGetOrSetFunction;
+
+private:
+
+    template<typename T>
+    static Dynamic GetOrSetFunction(bool get, void *ptr, Dynamic *dynamic)
+    {
+       typedef typename StackVariableWrapper<T>::wrapper Wrap;
+
+        if (get) {
+            return Wrap(* (T *) ptr);
+        }
+        else {
+            * (T *) ptr = Wrap(*dynamic);
+            return null();
+        }
+    }
+
+    static Dynamic GetOrSetFunctionHxObject(bool get, void *ptr, Dynamic *dynamic)
+    {
+        if (get) {
+            return * (hx::Object **) ptr;
+        }
+        else {
+            * (hx::Object **)ptr = dynamic->mPtr;
+            return null();
+        }
+    }
+
+
+    StackVariable *&mHead;
+
+    void *mCppVar;
+
+};
+
+
+class StackThis : public StackVariable
+{
+public:
+
+    template<typename T>
+    StackThis(StackVariable *&inHead, T *inThis)
+        : StackVariable(inHead, inThis)
+    {
+        mGetOrSetFunction = GetFunction<T>;
+    }
+
+    template<typename T>
+    StackThis(StackVariable *&inHead, hx::ObjectPtr<T> &inThis)
+        : StackVariable(inHead, &inThis.mPtr)
+    {
+        mGetOrSetFunction = GetObjectPtr<T>;
+    }
+
+    template<typename T>
+    static Dynamic GetObjectPtr(bool get, void *ptr, Dynamic *val)
+    {
+        if (get) {
+            return *(hx::Object **) ptr;
+        }
+        else {
+            return null();
+        }
+    }
+
+
+    template<typename T>
+    static Dynamic GetFunction(bool get, void *ptr, Dynamic *val)
+    {
+        if (get) {
+            return (T *) ptr;
+        }
+        else {
+            return null();
+        }
+    }
+};
+
+
+class StackCatchable
+{
+public:
+
+    StackCatchable *mNext;
+
+    template<typename T>
+    StackCatchable(StackFrame &frame, T * /* dummy required by template*/)
+        : mFrame(frame)
+{
+        mNext = frame.catchables;
+        frame.catchables = this;
+        mTestFunction = TestFunction<T>;
+    }
+
+    ~StackCatchable()
+{
+        mFrame.catchables = mNext;
+    }
+
+    bool Catches(Dynamic e) const
+   {
+        return mTestFunction(e);
+   }
+
+private:
+
+   template<typename T>
+    static bool TestFunction(Dynamic e)
+   {
+        return e.IsClass<T>();
+   }
+
+    StackFrame &mFrame;
+    bool (*mTestFunction)(Dynamic e);
+};
+
+
+
+#endif // HXCPP_DEBUGGER
+
+} // end namespace hx
+
+
+
+void __hxcpp_dbg_getScriptableFiles( Array< ::String> ioPaths );
+void __hxcpp_dbg_getScriptableFilesFullPath( Array< ::String> ioPaths );
+void __hxcpp_dbg_getScriptableClasses( Array< ::String> ioClasses );
+
+
+
+#ifdef HXCPP_DEBUGGER
+
+
+namespace hx
+{
+
+// These must match the values present in cpp.vm.Debugger
+
+enum ThreadEvent
+{
+    THREAD_CREATED = 1,
+    THREAD_TERMINATED = 2,
+    THREAD_STARTED = 3,
+    THREAD_STOPPED = 4
+};
+
+enum StepType
+{
+    STEP_NONE = 0, // Not present or needed in cpp.vm.Debugger
+    STEP_INTO = 1,
+    STEP_OVER = 2,
+    STEP_OUT = 3
+};
+
+
+}  // end namespace hx
+
+
+// The following functions are called directly, and only, by the haxe standard
+// library's cpp.vm.Debugger.hx class
+void __hxcpp_dbg_setEventNotificationHandler(Dynamic handler);
+void __hxcpp_dbg_enableCurrentThreadDebugging(bool enable);
+int __hxcpp_dbg_getCurrentThreadNumber();
+Array< ::String> __hxcpp_dbg_getFiles();
+Array< ::String> __hxcpp_dbg_getFilesFullPath();
+Array< ::String> __hxcpp_dbg_getClasses();
+Array<Dynamic> __hxcpp_dbg_getThreadInfos();
+Dynamic __hxcpp_dbg_getThreadInfo(int threadNumber, bool unsafe);
+int __hxcpp_dbg_addFileLineBreakpoint(String fileName, int lineNumber);
+int __hxcpp_dbg_addClassFunctionBreakpoint(String className,
+                                            String functionName);
+void __hxcpp_dbg_deleteAllBreakpoints();
+void __hxcpp_dbg_deleteBreakpoint(int number);
+void __hxcpp_dbg_breakNow(bool wait);
+void __hxcpp_dbg_continueThreads(int threadNumber, int count);
+void __hxcpp_dbg_stepThread(int threadNumber, int stepType, int stepCount);
+Array<Dynamic> __hxcpp_dbg_getStackVariables(int threadNumber,
+                                             int stackFrameNumber,
+                                             bool unsafe,
+                                             Dynamic markThreadNotStopped);
+Dynamic __hxcpp_dbg_getStackVariableValue(int threadNumber,
+                                          int stackFrameNumber,
+                                          String name,
+                                          bool unsafe,
+                                          Dynamic markNonexistent,
+                                          Dynamic markThreadNotStopped);
+
+Dynamic __hxcpp_dbg_setStackVariableValue(int threadNumber,
+                                          int stackFrameNumber,
+                                          String name, Dynamic value,
+                                          bool unsafe,
+                                          Dynamic markNonexistent,
+                                          Dynamic markThreadNotStopped);
+void __hxcpp_dbg_setNewParameterFunction(Dynamic function);
+void __hxcpp_dbg_setNewStackFrameFunction(Dynamic function);
+void __hxcpp_dbg_setNewThreadInfoFunction(Dynamic function);
+void __hxcpp_dbg_setAddParameterToStackFrameFunction(Dynamic function);
+void __hxcpp_dbg_setAddStackFrameToThreadInfoFunction(Dynamic function);
+
+bool __hxcpp_dbg_fix_critical_error(String inErr);
+
+// The following functions are called by Thread.cpp to notify of thread
+// created and terminated
+void __hxcpp_dbg_threadCreatedOrTerminated(int threadNumber, bool created);
+
+// The following is called by the stack macros, but only if
+// HXCPP_DEBUGGER is set
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic __hxcpp_dbg_checkedThrow(Dynamic toThrow);
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic __hxcpp_dbg_checkedRethrow(Dynamic toThrow);
+
+#else // !HXCPP_DEBUGGER
+
+// If no debugger, provide empty implementations of the debugging functions
+
+inline void __hxcpp_dbg_setEventNotificationHandler(Dynamic)
+    { hx::Throw("Debugging is not enabled for this program; try\n"
+                "rebuilding it with the -D HXCPP_DEBUGGER option"); }
+inline void __hxcpp_dbg_enableCurrentThreadDebugging(bool) { }
+inline int __hxcpp_dbg_getCurrentThreadNumber() { return -1; }
+inline Array< ::String> __hxcpp_dbg_getFiles()
+    { return Array_obj< String>::__new(); }
+inline Array< ::String> __hxcpp_dbg_getFilesFullPath()
+    { return Array_obj< String>::__new(); }
+inline Array< ::String> __hxcpp_dbg_getClasses()
+    { return Array_obj< String>::__new(); }
+inline Array<Dynamic> __hxcpp_dbg_getThreadInfos()
+    { return Array_obj< ::Dynamic>::__new(); }
+inline Dynamic __hxcpp_dbg_getThreadInfo(int, bool) { return null(); }
+inline int __hxcpp_dbg_addFileLineBreakpoint(String, int) { return -1; }
+inline int __hxcpp_dbg_addClassFunctionBreakpoint(String, String)
+    { return -1; }
+inline void __hxcpp_dbg_deleteAllBreakpoints() { }
+inline void __hxcpp_dbg_deleteBreakpoint(int) { }
+inline void __hxcpp_dbg_breakNow(bool) { }
+inline void __hxcpp_dbg_continueThreads(int, int) { }
+inline void __hxcpp_dbg_stepThread(int, int, int) { }
+inline Array<Dynamic> __hxcpp_dbg_getStackVariables(int, int, bool, Dynamic)
+    { return Array_obj< String>::__new(); }
+inline Dynamic __hxcpp_dbg_getStackVariableValue(int, int, String, bool,
+                                                 Dynamic, Dynamic)
+    { return null(); }
+inline Dynamic __hxcpp_dbg_setStackVariableValue(int, int, String, Dynamic,
+                                                 bool, Dynamic, Dynamic)
+    { return null(); }
+inline void __hxcpp_dbg_setNewParameterFunction(Dynamic) { }
+inline void __hxcpp_dbg_setNewStackFrameFunction(Dynamic) { }
+inline void __hxcpp_dbg_setNewThreadInfoFunction(Dynamic) { }
+inline void __hxcpp_dbg_setAddParameterToStackFrameFunction(Dynamic) { }
+inline void __hxcpp_dbg_setAddStackFrameToThreadInfoFunction(Dynamic) { }
+
+// The following functions are called by Thread.cpp to notify of thread
+// created and terminated
+inline void __hxcpp_dbg_threadCreatedOrTerminated(int, bool) { }
+
+inline Dynamic __hxcpp_dbg_checkedThrow(Dynamic toThrow) { return hx::Throw(toThrow); }
+inline Dynamic __hxcpp_dbg_checkedRethrow(Dynamic toThrow) { return hx::Rethrow(toThrow); }
+
+#endif // HXCPP_DEBUGGER
+
+
+#endif // HX_DEBUG_H

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/DynamicImpl.tpl

@@ -0,0 +1,210 @@
+
+::foreach PARAMS:: ::if (ARG>=6)::
+Dynamic Dynamic::NS::operator()(::DYNAMIC_ARG_LIST::)
+{
+   CheckFPtr();
+   return mPtr->__Run(Array_obj<Dynamic>::NS::__new(::ARG::)::DYNAMIC_ADDS::);
+}
+
+namespace cpp
+{
+::NS::Dynamic Variant::NS::operator()(::DYNAMIC_ARG_LIST::)
+{
+   if (isNull()) Dynamic::ThrowBadFunctionError();
+   return valObject->__Run(Array_obj<Dynamic>::NS::__new(::ARG::)::DYNAMIC_ADDS::);
+}
+}
+
+
+::else::
+
+namespace hx {
+
+struct CMemberFunction::ARG:: : public hx::Object 
+{ 
+   hx::ObjectPtr<Object> mThis; 
+   MemberFunction::ARG:: mFunction;
+   const char *mName;
+
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::NS::clsIdCMember::ARG:: };
+
+
+   CMemberFunction::ARG::(const char *inName, hx::Object *inObj, MemberFunction::ARG:: inFunction)
+   {
+      mName = inName;
+      mThis = inObj;
+      mFunction = inFunction;
+   }
+   int __Compare(const hx::Object *inRHS) const
+   {
+      const CMemberFunction::ARG:: *other = dynamic_cast<const CMemberFunction::ARG:: *>(inRHS);
+      if (!other)
+         return -1;
+      return (mName==other->mName && mFunction==other->mFunction && mThis.GetPtr()==other->mThis.GetPtr())? 0 : -1;
+   }
+
+   int __GetType() const { return vtFunction; } 
+   int __ArgCount() const { return ::ARG::; } 
+   ::String __ToString() const{ return String(mName); } 
+   void __Mark(hx::MarkContext *__inCtx) { HX_MARK_MEMBER_NAME(mThis,"CMemberFunction::ARG::.this"); } 
+   #ifdef HXCPP_VISIT_ALLOCS
+   void __Visit(hx::VisitContext *__inCtx) { HX_VISIT_MEMBER(mThis); } 
+   #endif
+   void *__GetHandle() const { return mThis.GetPtr(); } 
+   Dynamic __Run(const Array<Dynamic> &inArgs) 
+   { 
+      ::if (ARG>0)::
+      return mFunction(mThis.GetPtr(), ::ARR_LIST::);
+      ::else::
+      return mFunction(mThis.GetPtr());
+      ::end::
+   } 
+   Dynamic __run(::DYNAMIC_ARG_LIST::) 
+   { 
+      ::if (ARG>0)::
+      return mFunction(mThis.GetPtr(), ::ARG_LIST::);
+      ::else::
+      return mFunction(mThis.GetPtr());
+      ::end::
+   } 
+}; 
+
+
+
+struct CStaticFunction::ARG:: : public hx::Object 
+{ 
+   StaticFunction::ARG:: mFunction;
+   const char *mName;
+
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::NS::clsIdCStatic::ARG:: };
+
+
+   CStaticFunction::ARG::(const char *inName,StaticFunction::ARG:: inFunction)
+   {
+      mName = inName;
+      mFunction = inFunction;
+   }
+   int __Compare(const hx::Object *inRHS) const
+   {
+      const CStaticFunction::ARG:: *other = dynamic_cast<const CStaticFunction::ARG:: *>(inRHS);
+      if (!other)
+         return -1;
+      return mName==other->mName && mFunction==other->mFunction && mName==other->mName ? 0 : -1;
+   }
+
+   int __GetType() const { return vtFunction; } 
+   int __ArgCount() const { return ::ARG::; } 
+   ::String __ToString() const{ return String(mName); } 
+   Dynamic __Run(const Array<Dynamic> &inArgs) 
+   { 
+      return mFunction(::ARR_LIST::);
+   } 
+   Dynamic __run(::DYNAMIC_ARG_LIST::) 
+   { 
+      return mFunction(::ARG_LIST::);
+   } 
+}; 
+
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateMemberFunction::ARG::(const char *inName,hx::Object *inObj, MemberFunction::ARG:: inFunc)
+   { return new CMemberFunction::ARG::(inName,inObj,inFunc); }
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateStaticFunction::ARG::(const char *inName,StaticFunction::ARG:: inFunc)
+   { return new CStaticFunction::ARG::(inName,inFunc); }
+
+}
+
+::end::
+::end::
+
+namespace hx
+{
+
+
+struct CMemberFunctionVar : public hx::Object 
+{ 
+   hx::ObjectPtr<Object> mThis; 
+   MemberFunctionVar mFunction;
+   const char *mName;
+   int N;
+
+
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdCMemberVar };
+
+
+   CMemberFunctionVar(const char *inName,hx::Object *inObj, MemberFunctionVar inFunction,int inN)
+   {
+      mThis = inObj;
+      mFunction = inFunction;
+      mName = inName;
+      N = inN;
+   }
+   int __Compare(const hx::Object *inRHS) const
+   {
+      const CMemberFunctionVar *other = dynamic_cast<const CMemberFunctionVar *>(inRHS);
+      if (!other)
+         return -1;
+      return (mFunction==other->mFunction && mName==other->mName && mThis.GetPtr()==other->mThis.GetPtr())? 0 : -1;
+   }
+
+
+   int __GetType() const { return vtFunction; } 
+   int __ArgCount() const { return N; } 
+   ::String __ToString() const{ return String(mName); } 
+   void __Mark(hx::MarkContext *__inCtx) { HX_MARK_MEMBER_NAME(mThis,"CMemberFunctionVar.this"); } 
+   #ifdef HXCPP_VISIT_ALLOCS
+   void __Visit(hx::VisitContext *__inCtx) { HX_VISIT_MEMBER(mThis); } 
+   #endif
+   void *__GetHandle() const { return mThis.GetPtr(); } 
+   Dynamic __Run(const Array<Dynamic> &inArgs) 
+   { 
+      return mFunction(mThis.GetPtr(), inArgs);
+   } 
+}; 
+
+
+
+struct CStaticFunctionVar : public hx::Object 
+{ 
+   StaticFunctionVar mFunction;
+   const char *mName;
+   int N;
+
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdCStaticVar };
+
+   CStaticFunctionVar(const char *inName,StaticFunctionVar inFunction,int inN)
+   {
+      mFunction = inFunction;
+      mName = inName;
+      N = inN;
+   }
+   int __Compare(const hx::Object *inRHS) const
+   {
+      const CStaticFunctionVar *other = dynamic_cast<const CStaticFunctionVar *>(inRHS);
+      if (!other)
+         return -1;
+      return mName==other->mName && mFunction==other->mFunction ? 0 : -1;
+   }
+
+
+   int __GetType() const { return vtFunction; } 
+   int __ArgCount() const { return N; } 
+   ::String __ToString() const { return String(mName); } 
+   Dynamic __Run(const Array<Dynamic> &inArgs) 
+   { 
+      return mFunction(inArgs);
+   } 
+}; 
+
+
+Dynamic CreateMemberFunctionVar(const char *inName, hx::Object *inObj, MemberFunctionVar inFunc,int inN)
+   { return new CMemberFunctionVar(inName, inObj,inFunc,inN); }
+
+Dynamic CreateStaticFunctionVar(const char *inName,StaticFunctionVar inFunc,int inN)
+   { return new CStaticFunctionVar(inName, inFunc,inN); }
+
+}
+
+

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/ErrorCodes.h

@@ -0,0 +1,27 @@
+#ifndef HX_ERROR_CODES
+#define HX_ERROR_CODES
+
+// --- Exteral constants, used inline
+#define HX_INVALID_CAST          Dynamic(HX_CSTRING("Invalid Cast"))
+#define HX_INVALID_INTERFACE     Dynamic(HX_CSTRING("Object does not implement interface"))
+#define HX_INDEX_OUT_OF_BOUNDS   Dynamic(HX_CSTRING("Index Out of Bounds"))
+#define HX_INVALID_CONSTRUCTOR   Dynamic(HX_CSTRING("Invalid constructor"))
+#define HX_INVALID_ENUM_CONSTRUCTOR(_enum_name, _constructor_name)      \
+    Dynamic(HX_CSTRING("Invalid enum constructor for ") +               \
+            HX_CSTRING(_enum_name) +                                    \
+            HX_CSTRING(": ") +                                          \
+            _constructor_name)
+#define HX_INVALID_OBJECT        Dynamic(HX_CSTRING("Invalid object"))
+#define HX_INVALID_ARG_COUNT     Dynamic(HX_CSTRING("Invalid Arg Count"))
+#define HX_NULL_FUNCTION_POINTER Dynamic(HX_CSTRING("Null Function Pointer"))
+#define HX_INVALID_ENUM_ARG_COUNT(_enum_name, _constructor_name, _count, _expected) \
+    Dynamic(HX_CSTRING("Invalid enum arg count for ") +                 \
+            HX_CSTRING(_enum_name) +                                    \
+            HX_CSTRING(".") +                                           \
+            _constructor_name +                                         \
+            HX_CSTRING(": expected ") +                                 \
+            ::String(_expected) +                                       \
+            HX_CSTRING(", got ") +                                      \
+            ::String(_count))
+
+#endif

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/FieldRef.h

@@ -0,0 +1,304 @@
+#ifndef HX_FIELD_REF_H
+#define HX_FIELD_REF_H
+
+namespace hx
+{
+
+// --- FieldRef ----------------------------------------------------------
+//
+//  This is used to provide syntaxe for setting fields by name.  This is because
+//   the field can't be returned by reference, because it may not exist as a dynamic.
+//
+//  eg, consider class 'A' with variable 'x':
+//  class A { int x; }
+//
+//  And you have a Dynamic pointing to it:
+//  Dynamic d = new A;  Then you access x by name:
+//  d->__Field("x") = 1;
+//
+//  __Field can't return a Dynamic & because x is a int, not Dynamic. So I use this class.
+//  Note that this may change if I fix the generator to create __SetField("x",1) directly.
+
+
+#define HX_FIELD_REF_MEM_OP(op,ret) \
+inline ret operator op (const FieldRef &inA) \
+  { return this->operator Dynamic() op inA.operator Dynamic(); } \
+inline ret operator op (const IndexRef &inA); \
+template<typename T> inline ret operator op (const T& inA) \
+   { return this->operator Dynamic() op inA; }
+
+#define HX_FIELD_REF_IMPL_MEM_OP(op,ret) \
+inline ret hx::FieldRef::operator op (const IndexRef &inA) \
+    { return this->operator Dynamic() op inA.operator Dynamic(); } \
+
+class FieldRef
+{
+public:
+   explicit FieldRef(hx::Object *inObj,const String &inName) : mObject(inObj), mName(inName)
+   {
+   }
+
+   hx::Val operator=(const hx::Val &inRHS)
+   {
+      return mObject->__SetField(mName,inRHS, HX_PROP_DYNAMIC );
+   }
+   #if HXCPP_API_LEVEL >= 330
+   inline operator hx::Val() const { return mObject ? mObject->__Field(mName, HX_PROP_DYNAMIC) : null(); }
+   #endif
+   inline operator Dynamic() const { return mObject ? Dynamic(mObject->__Field(mName, HX_PROP_DYNAMIC)) : null(); }
+   inline operator double() const { return mObject->__Field(mName, HX_PROP_DYNAMIC); }
+   inline operator float() const { return mObject->__Field(mName, HX_PROP_DYNAMIC); }
+   inline operator int() const { return mObject->__Field(mName, HX_PROP_DYNAMIC); }
+   inline operator cpp::UInt64() const { return mObject->__Field(mName, HX_PROP_DYNAMIC); }
+   inline operator cpp::Int64() const { return mObject->__Field(mName, HX_PROP_DYNAMIC); }
+
+
+   // post-increment
+   inline double operator++(int)
+   {
+      double d = mObject->__Field(mName, HX_PROP_DYNAMIC);
+      mObject->__SetField(mName,d+1, HX_PROP_DYNAMIC);
+      return d;
+   }
+   // pre-increment
+   inline double operator++()
+   {
+      double d = ((double)mObject->__Field(mName, HX_PROP_DYNAMIC)) + 1;
+      mObject->__SetField(mName,d, HX_PROP_DYNAMIC);
+      return d;
+   }
+   // post-decrement
+   inline double operator--(int)
+   {
+      double d = mObject->__Field(mName, HX_PROP_DYNAMIC);
+      mObject->__SetField(mName,d-1, HX_PROP_DYNAMIC);
+      return d;
+   }
+   // pre-decrement
+   inline double operator--()
+   {
+      double d = (double)(mObject->__Field(mName, HX_PROP_DYNAMIC)) - 1;
+      mObject->__SetField(mName,d,  HX_PROP_DYNAMIC);
+      return d;
+   }
+   bool operator !() { return ! ((int)(mObject->__Field(mName,  HX_PROP_DYNAMIC))); }
+   int operator ~() { return ~ ((int)mObject->__Field(mName,  HX_PROP_DYNAMIC)); }
+
+   inline bool operator==(const null &) const { return !mObject; }
+   inline bool operator!=(const null &) const { return mObject; }
+
+   double operator -() { return - (double)(mObject->__Field(mName,  HX_PROP_DYNAMIC)); }
+
+	bool HasPointer() const { return mObject; }
+
+
+   HX_FIELD_REF_MEM_OP(==,bool)
+   HX_FIELD_REF_MEM_OP(!=,bool)
+   HX_FIELD_REF_MEM_OP(<,bool)
+   HX_FIELD_REF_MEM_OP(<=,bool)
+   HX_FIELD_REF_MEM_OP(>,bool)
+   HX_FIELD_REF_MEM_OP(>=,bool)
+
+   HX_FIELD_REF_MEM_OP(+,Dynamic)
+   HX_FIELD_REF_MEM_OP(*,double)
+   HX_FIELD_REF_MEM_OP(/,double)
+   HX_FIELD_REF_MEM_OP(-,double)
+   HX_FIELD_REF_MEM_OP(%,double)
+
+
+
+   String  mName;
+   hx::Object *mObject;
+};
+
+// We can define this one now...
+template<typename T>
+inline FieldRef ObjectPtr<T>::FieldRef(const String &inString)
+{
+   return hx::FieldRef(mPtr,inString);
+}
+
+#define HX_FIELD_REF_OP(op,ret) \
+template<typename T> inline ret operator op (T &inT, const FieldRef &inA) \
+   { return inT op ( inA.operator Dynamic()); }
+
+HX_FIELD_REF_OP(==,bool)
+HX_FIELD_REF_OP(!=,bool)
+HX_FIELD_REF_OP(<,bool)
+HX_FIELD_REF_OP(<=,bool)
+HX_FIELD_REF_OP(>,bool)
+HX_FIELD_REF_OP(>=,bool)
+
+HX_FIELD_REF_OP(+,Dynamic)
+HX_FIELD_REF_OP(*,double)
+HX_FIELD_REF_OP(/,double)
+HX_FIELD_REF_OP(-,double)
+HX_FIELD_REF_OP(%,double)
+
+
+
+// --- IndexRef --------------------------------------------------------------
+//
+// Like FieldRef, but for integer array access
+//
+
+#define HX_INDEX_REF_MEM_OP(op,ret) \
+inline ret operator op (const IndexRef &inA) \
+    { return this->operator Dynamic() op inA.operator Dynamic(); } \
+inline ret operator op (const FieldRef &inA) \
+    { return this->operator Dynamic() op inA.operator Dynamic(); } \
+template<typename T> inline ret operator op (const T& inA) \
+   { return this->operator Dynamic() op inA; }
+
+
+class IndexRef
+{
+public:
+   explicit IndexRef(hx::Object *inObj,int inIndex) : mObject(inObj), mIndex(inIndex)
+   {
+   }
+
+   Dynamic operator=(const Dynamic &inRHS)
+   {
+      return mObject->__SetItem(mIndex,inRHS);
+   }
+   inline operator Dynamic() const { return mObject->__GetItem(mIndex); }
+   inline operator double() const { return mObject->__GetItem(mIndex); }
+   inline operator int() const { return mObject->__GetItem(mIndex); }
+
+   // post-increment
+   inline double operator++(int)
+   {
+      double d = mObject->__GetItem(mIndex)->__ToDouble();
+      mObject->__SetItem(mIndex,d+1);
+      return d;
+   }
+   // pre-increment
+   inline double operator++()
+   {
+      double d = mObject->__GetItem(mIndex)->__ToDouble() + 1;
+      mObject->__SetItem(mIndex,d);
+      return d;
+   }
+   // post-decrement
+   inline double operator--(int)
+   {
+      double d = mObject->__GetItem(mIndex)->__ToDouble();
+      mObject->__SetItem(mIndex,d-1);
+      return d;
+   }
+   // pre-decrement
+   inline double operator--()
+   {
+      double d = mObject->__GetItem(mIndex)->__ToDouble() - 1;
+      mObject->__SetItem(mIndex,d);
+      return d;
+   }
+   bool operator !() { return ! mObject->__GetItem(mIndex)->__ToInt(); }
+   int operator ~() { return ~ mObject->__GetItem(mIndex)->__ToInt(); }
+   double operator -() { return - mObject->__GetItem(mIndex)->__ToDouble(); }
+
+   inline bool operator==(const null &) const { return !mObject; }
+   inline bool operator!=(const null &) const { return mObject; }
+
+   HX_INDEX_REF_MEM_OP(==,bool)
+   HX_INDEX_REF_MEM_OP(!=,bool)
+   HX_INDEX_REF_MEM_OP(<,bool)
+   HX_INDEX_REF_MEM_OP(<=,bool)
+   HX_INDEX_REF_MEM_OP(>,bool)
+   HX_INDEX_REF_MEM_OP(>=,bool)
+
+   HX_INDEX_REF_MEM_OP(+,Dynamic)
+   HX_INDEX_REF_MEM_OP(*,double)
+   HX_INDEX_REF_MEM_OP(/,double)
+   HX_INDEX_REF_MEM_OP(-,double)
+   HX_INDEX_REF_MEM_OP(%,double)
+
+	bool HasPointer() const { return mObject; }
+
+   int mIndex;
+   hx::Object *mObject;
+};
+
+// We can define this one now...
+template<typename T>
+inline IndexRef ObjectPtr<T>::IndexRef(int inIndex)
+{
+   return hx::IndexRef(mPtr,inIndex);
+}
+
+#define HX_INDEX_REF_OP(op,ret) \
+template<typename T> inline ret operator op (T &inT, const IndexRef &inA) \
+   { return inT op ( inA. operator Dynamic()); }
+
+HX_INDEX_REF_OP(==,bool)
+HX_INDEX_REF_OP(!=,bool)
+HX_INDEX_REF_OP(<,bool)
+HX_INDEX_REF_OP(<=,bool)
+HX_INDEX_REF_OP(>,bool)
+HX_INDEX_REF_OP(>=,bool)
+
+HX_INDEX_REF_OP(+,Dynamic)
+HX_INDEX_REF_OP(*,double)
+HX_INDEX_REF_OP(/,double)
+HX_INDEX_REF_OP(-,double)
+HX_INDEX_REF_OP(%,double)
+
+
+// Implement once IndexRef has been defined.
+HX_FIELD_REF_IMPL_MEM_OP(==,bool)
+HX_FIELD_REF_IMPL_MEM_OP(!=,bool)
+HX_FIELD_REF_IMPL_MEM_OP(<,bool)
+HX_FIELD_REF_IMPL_MEM_OP(<=,bool)
+HX_FIELD_REF_IMPL_MEM_OP(>,bool)
+HX_FIELD_REF_IMPL_MEM_OP(>=,bool)
+
+HX_FIELD_REF_IMPL_MEM_OP(+,Dynamic)
+HX_FIELD_REF_IMPL_MEM_OP(*,double)
+HX_FIELD_REF_IMPL_MEM_OP(/,double)
+HX_FIELD_REF_IMPL_MEM_OP(-,double)
+HX_FIELD_REF_IMPL_MEM_OP(%,double)
+
+// Disambiguate Dynamic operators...
+
+#define HX_INDEX_REF_OP_DYNAMIC(op,ret) \
+inline ret operator op (const Dynamic &inT, const IndexRef &inA) \
+   { return inT op ( inA.operator Dynamic()); }
+
+HX_INDEX_REF_OP_DYNAMIC(==,bool)
+HX_INDEX_REF_OP_DYNAMIC(!=,bool)
+HX_INDEX_REF_OP_DYNAMIC(+,Dynamic)
+HX_INDEX_REF_OP_DYNAMIC(*,double)
+
+
+
+template<typename _OBJ>
+class __TArrayImplRef
+{
+public:
+   _OBJ mObject;
+   int mIndex;
+
+   explicit __TArrayImplRef(_OBJ inObj,int inIndex) : mObject(inObj), mIndex(inIndex) { }
+
+   template<typename _DATA>
+   inline operator _DATA() { return mObject->__get(mIndex); }
+   template<typename _DATA>
+   inline void operator=(_DATA inRHS)
+   {
+      mObject->__set(mIndex,inRHS);
+   }
+};
+
+template<typename _OBJ>
+__TArrayImplRef<_OBJ> __ArrayImplRef(_OBJ inObj, int inIndex)
+{
+   return __TArrayImplRef<_OBJ>(inObj,inIndex);
+}
+
+
+
+} // end namespace hx
+
+
+#endif

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Functions.h

@@ -0,0 +1,28 @@
+#ifndef HX_FUNCTIONS_H
+#define HX_FUNCTIONS_H
+#include <hxcpp.h>
+
+namespace hx
+{
+   struct HXCPP_EXTERN_CLASS_ATTRIBUTES LocalFunc : public hx::Object
+   {
+      int __GetType() const { return vtFunction; }
+      inline void DoMarkThis(hx::MarkContext *__inCtx) { }
+#ifdef HXCPP_VISIT_ALLOCS
+      inline void DoVisitThis(hx::VisitContext *__inCtx) { }
+#endif
+   };
+
+   struct HXCPP_EXTERN_CLASS_ATTRIBUTES LocalThisFunc : public LocalFunc
+   {
+      Dynamic __this;
+		void __SetThis(Dynamic inThis) { __this = inThis; }
+      inline void DoMarkThis(hx::MarkContext *__inCtx) { HX_MARK_MEMBER(__this); }
+#ifdef HXCPP_VISIT_ALLOCS
+      inline void DoVisitThis(hx::VisitContext *__inCtx) { HX_VISIT_MEMBER(__this); }
+#endif
+   };
+
+}
+
+#endif

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/GC.h

@@ -0,0 +1,580 @@
+#ifndef HX_GC_H
+#define HX_GC_H
+
+#include <hx/Tls.h>
+#include <stdio.h>
+
+// Under the current scheme (as defined by HX_HCSTRING/HX_CSTRING in hxcpp.h)
+//  each constant string data is prepended with a 4-byte header that says the string
+//  is constant (ie, not part of GC) and whether there is(not) a pre-computed hash at
+//  the end of the data.
+// When HX_SMART_STRINGS is active, a bit says whether it is char16_t encoded.
+
+#define HX_GC_CONST_ALLOC_BIT  0x80000000
+#define HX_GC_CONST_ALLOC_MARK_BIT  0x80
+
+
+
+
+// Tell compiler the extra functions are supported
+#define HXCPP_GC_FUNCTIONS_1
+
+// Function called by the haxe code...
+
+#ifdef HXCPP_TELEMETRY
+extern void __hxt_gc_new(hx::StackContext *inStack, void* obj, int inSize, const char *inName);
+#endif
+
+
+// Helpers for debugging code
+HXCPP_EXTERN_CLASS_ATTRIBUTES void  __hxcpp_reachable(hx::Object *inKeep);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void  __hxcpp_enable(bool inEnable);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void  __hxcpp_collect(bool inMajor=true);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void   __hxcpp_gc_compact();
+HXCPP_EXTERN_CLASS_ATTRIBUTES int   __hxcpp_gc_trace(hx::Class inClass, bool inPrint);
+HXCPP_EXTERN_CLASS_ATTRIBUTES int   __hxcpp_gc_used_bytes();
+HXCPP_EXTERN_CLASS_ATTRIBUTES double __hxcpp_gc_mem_info(int inWhat);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void  __hxcpp_enter_gc_free_zone();
+HXCPP_EXTERN_CLASS_ATTRIBUTES void  __hxcpp_exit_gc_free_zone();
+HXCPP_EXTERN_CLASS_ATTRIBUTES void  __hxcpp_gc_safe_point();
+HXCPP_EXTERN_CLASS_ATTRIBUTES void  __hxcpp_spam_collects(int inEveryNCalls);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void  __hxcpp_set_minimum_working_memory(int inBytes);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void  __hxcpp_set_minimum_free_space(int inBytes);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void  __hxcpp_set_target_free_space_percentage(int inPercentage);
+HXCPP_EXTERN_CLASS_ATTRIBUTES bool __hxcpp_is_const_string(const ::String &inString);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_gc_freeze(Dynamic inObject);
+
+typedef void (hx::Object::*_hx_member_finalizer)(void);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_add_member_finalizer(hx::Object *inObject, _hx_member_finalizer, bool inPin);
+
+typedef void (*_hx_alloc_finalizer)(void *inPtr);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_add_alloc_finalizer(void *inAlloc, _hx_alloc_finalizer, bool inPin);
+
+template<typename T>
+inline void _hx_add_finalizable( hx::ObjectPtr<T> inObj, bool inPin)
+{
+  _hx_member_finalizer finalizer = (_hx_member_finalizer)&T::finalize;
+  __hxcpp_add_member_finalizer(inObj.mPtr, finalizer, inPin);
+}
+template<typename T>
+inline void _hx_add_finalizable( T *inObj, bool inPin)
+{
+  _hx_member_finalizer finalizer = (_hx_member_finalizer)&T::finalize;
+  __hxcpp_add_member_finalizer(inObj, finalizer, inPin);
+}
+
+
+
+template<typename T>
+T _hx_allocate_extended(int inExtra)
+{
+   typedef typename T::Obj Obj;
+   Obj *obj = new (inExtra) Obj();
+   return obj;
+}
+
+/*
+template<typename T>
+inline void _hx_allocate_extended( hx::ObjectPtr<T> inObj, bool inPin)
+*/
+
+
+// Finalizers from haxe code...
+void  __hxcpp_gc_do_not_kill(Dynamic inObj);
+
+// This is the correctly typed version - no change of getting function proto wrong
+void _hx_set_finalizer(Dynamic inObj, void (*inFunc)(Dynamic) );
+
+void  __hxcpp_set_finalizer(Dynamic inObj, void *inFunction);
+hx::Object *__hxcpp_get_next_zombie();
+
+#ifdef HXCPP_TELEMETRY
+void __hxcpp_set_hxt_finalizer(void* inObj, void *inFunc);
+#endif
+
+hx::Object *__hxcpp_weak_ref_create(Dynamic inObject);
+hx::Object *__hxcpp_weak_ref_get(Dynamic inRef);
+
+
+unsigned int __hxcpp_obj_hash(Dynamic inObj);
+int __hxcpp_obj_id(Dynamic inObj);
+hx::Object *__hxcpp_id_obj(int);
+
+
+
+
+
+
+namespace hx
+{
+// Generic allocation routine.
+// If inSize is small (<4k) it will be allocated from the immix pool.
+// Larger, and it will be allocated from a separate memory pool
+// inIsObject specifies whether "__Mark"  should be called on the resulting object
+void *InternalNew(int inSize,bool inIsObject);
+
+// Used internall - realloc array data
+void *InternalRealloc(int inFromSize, void *inData,int inSize,bool inAllowExpansion=false);
+
+void InternalReleaseMem(void *inMem);
+
+unsigned int ObjectSizeSafe(void *inData);
+
+// Const buffers are allocated outside the GC system, and do not require marking
+// String buffers can optionally have a pre-computed hash appended with this method
+void *InternalCreateConstBuffer(const void *inData,int inSize,bool inAddStringHash=false);
+
+// Called after collection by an unspecified thread
+typedef void (*finalizer)(hx::Object *v);
+
+// Used internally by the runtime.
+// The constructor will add this object to the internal list of finalizers.
+// If the parent object is not marked by the end of the collect, the finalizer will trigger.
+struct InternalFinalizer
+{
+   InternalFinalizer(hx::Object *inObj, finalizer inFinalizer=0);
+
+   #ifdef HXCPP_VISIT_ALLOCS
+   void Visit(VisitContext *__inCtx);
+   #endif
+   void Detach();
+
+   bool      mValid;
+   finalizer mFinalizer;
+   hx::Object  *mObject;
+};
+
+// Attach a finalizer to any object allocation.  This can be called from haxe code, but be aware that
+// you can't make any GC calls from the finalizer.
+void  GCSetFinalizer( hx::Object *, hx::finalizer f );
+
+// If another thread wants to do a collect, it will signal this variable.
+// This automatically gets checked when you call "new", but if you are in long-running
+//  loop with no new call, you might starve another thread if you to not check this.
+//  0xffffffff = pause requested
+extern int gPauseForCollect;
+
+
+// Minimum total memory - used + buffer for new objects
+extern int sgMinimumWorkingMemory;
+
+// Minimum free memory - not counting used memory
+extern int sgMinimumFreeSpace;
+
+// Also ensure that the free memory is larger than this amount of used memory
+extern int sgTargetFreeSpacePercentage;
+
+
+extern HXCPP_EXTERN_CLASS_ATTRIBUTES int gByteMarkID;
+
+// Call in response to a gPauseForCollect. Normally, this is done for you in "new"
+void PauseForCollect();
+
+
+// Used by WeakHash to work out if it needs to dispose its keys
+bool IsWeakRefValid(hx::Object *inPtr);
+bool IsWeakRefValid(const HX_CHAR *inPtr);
+
+// Used by CFFI to scan a block of memory for GC Pointers. May picks up random crap
+//  that points to real, active objects.
+void MarkConservative(int *inBottom, int *inTop,hx::MarkContext *__inCtx);
+
+
+// Create/Remove a root.
+// All statics are explicitly registered - this saves adding the whole data segment
+//  to the collection list.
+// It takes a pointer-pointer so it can move the contents, and the caller can change the contents
+void GCAddRoot(hx::Object **inRoot);
+void GCRemoveRoot(hx::Object **inRoot);
+
+
+// This is used internally in hxcpp
+// It calls InternalNew, and takes care of null-terminating the result
+char *NewString(int inLen);
+
+// The concept of 'private' is from the old conservative Gc method.
+// Now with explicit marking, these functions do the same thing, which is
+//  to allocate some GC memory and optionally copy the 'inData' into those bytes
+HXCPP_EXTERN_CLASS_ATTRIBUTES void *NewGCBytes(void *inData,int inSize);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void *NewGCPrivate(void *inData,int inSize);
+
+// Force a collect from the calling thread
+// Only one thread should call this at a time
+int InternalCollect(bool inMajor,bool inCompact);
+
+
+// Disable the garbage collector.  It will try to increase its internal buffers to honour extra requests.
+//  If it runs out of memory, it will actually try to do a collect.
+void InternalEnableGC(bool inEnable);
+
+// Record that fact that external memory has been allocated and associated with a haxe object
+//  eg. BitmapData.  This will help the collector know when to collect
+void GCChangeManagedMemory(int inDelta, const char *inWhy=0);
+
+// Haxe threads can center GC free zones, where they can't make GC allocation calls, and should not mess with GC memory.
+// This means that they do not need to pause while the GC collections happen, and other threads will not
+//  wait for them to "check in" before collecting.  The standard runtime makes these calls around OS calls, such as "Sleep"
+void EnterGCFreeZone();
+void ExitGCFreeZone();
+// retuns true if ExitGCFreeZone should be called
+bool TryGCFreeZone();
+// retuns true if ExitGCFreeZone was called
+bool TryExitGCFreeZone();
+
+class HXCPP_EXTERN_CLASS_ATTRIBUTES AutoGCFreeZone
+{
+public:
+	AutoGCFreeZone() : locked(true) { EnterGCFreeZone(); }
+	~AutoGCFreeZone() { if (locked) ExitGCFreeZone(); }
+
+	void close() { if (locked) ExitGCFreeZone(); locked = false; }
+
+	bool locked;
+};
+
+
+// Defined in Class.cpp, these function is called from the Gc to start the marking/visiting
+void MarkClassStatics(hx::MarkContext *__inCtx);
+#ifdef HXCPP_VISIT_ALLOCS
+void VisitClassStatics(hx::VisitContext *__inCtx);
+#endif
+
+
+// Called by haxe/application code to mark allocations.
+//  "Object" allocs will recursively call __Mark
+inline void MarkAlloc(void *inPtr ,hx::MarkContext *__inCtx);
+inline void MarkObjectAlloc(hx::Object *inPtr ,hx::MarkContext *__inCtx);
+
+// Implemented differently for efficiency
+void MarkObjectArray(hx::Object **inPtr, int inLength, hx::MarkContext *__inCtx);
+void MarkStringArray(String *inPtr, int inLength, hx::MarkContext *__inCtx);
+
+// Provide extra debug info to the marking routines
+#ifdef HXCPP_DEBUG
+HXCPP_EXTERN_CLASS_ATTRIBUTES void MarkSetMember(const char *inName ,hx::MarkContext *__inCtx);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void MarkPushClass(const char *inName ,hx::MarkContext *__inCtx);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void MarkPopClass(hx::MarkContext *__inCtx);
+#endif
+
+
+// Used by runtime if it is being paranoid about pointers.  It checks that the pointer is real and alive at last collect.
+void GCCheckPointer(void *);
+void GCOnNewPointer(void *);
+
+
+// Called internally before and GC operations
+void CommonInitAlloc();
+
+
+// Threading ...
+void RegisterNewThread(void *inTopOfStack);
+void RegisterCurrentThread(void *inTopOfStack);
+void UnregisterCurrentThread();
+void GCPrepareMultiThreaded();
+
+
+
+
+} // end namespace hx
+
+
+// Inline code tied to the immix implementation
+
+namespace hx
+{
+
+#define HX_USE_INLINE_IMMIX_OPERATOR_NEW
+
+//#define HX_STACK_CTX ::hx::ImmixAllocator *_hx_stack_ctx =  hx::gMultiThreadMode ? hx::tlsImmixAllocator : hx::gMainThreadAlloc;
+
+
+// Each line ast 128 bytes (2^7)
+#define IMMIX_LINE_BITS    7
+#define IMMIX_LINE_LEN     (1<<IMMIX_LINE_BITS)
+
+#define HX_GC_REMEMBERED          0x40
+
+// The size info is stored in the header 8 bits to the right
+#define IMMIX_ALLOC_SIZE_SHIFT  6
+
+// Indicates that __Mark must be called recursively
+#define IMMIX_ALLOC_IS_CONTAINER   0x00800000
+// String is char16_t type
+#define HX_GC_STRING_CHAR16_T      0x00200000
+// String has hash data at end
+#define HX_GC_STRING_HASH          0x00100000
+
+#define HX_GC_STRING_HASH_BIT      0x10
+
+#ifdef HXCPP_BIG_ENDIAN
+   #define HX_GC_STRING_HASH_OFFSET        -3
+   #define HX_GC_CONST_ALLOC_MARK_OFFSET   -4
+   #define HX_ENDIAN_MARK_ID_BYTE        -4
+#else
+   #define HX_GC_STRING_HASH_OFFSET        -2
+   #define HX_GC_CONST_ALLOC_MARK_OFFSET   -1
+   #define HX_ENDIAN_MARK_ID_BYTE       -1
+#endif
+
+
+
+// The gPauseForCollect bits will turn spaceEnd negative, and so force the slow path
+#ifndef HXCPP_SINGLE_THREADED_APP
+   #define WITH_PAUSE_FOR_COLLECT_FLAG | hx::gPauseForCollect
+#else
+   #define WITH_PAUSE_FOR_COLLECT_FLAG
+#endif
+
+
+
+struct StackContext;
+
+EXTERN_FAST_TLS_DATA(StackContext, tlsStackContext);
+
+extern StackContext *gMainThreadContext;
+
+extern unsigned int gImmixStartFlag[128];
+extern int gMarkID;
+extern int gMarkIDWithContainer;
+extern void BadImmixAlloc();
+
+
+class ImmixAllocator
+{
+public:
+   virtual ~ImmixAllocator() {}
+   virtual void *CallAlloc(int inSize,unsigned int inObjectFlags) = 0;
+   virtual void SetupStackAndCollect(bool inMajor, bool inForceCompact, bool inLocked=false,bool inFreeIsFragged=false) = 0;
+
+   #ifdef HXCPP_GC_NURSERY
+   unsigned char  *spaceFirst;
+   unsigned char  *spaceOversize;
+   #else
+   int            spaceStart;
+   int            spaceEnd;
+   #endif
+   unsigned int   *allocStartFlags;
+   unsigned char  *allocBase;
+
+
+
+   // These allocate the function using the garbage-colleced malloc
+   inline static void *alloc(ImmixAllocator *alloc, size_t inSize, bool inContainer, const char *inName )
+   {
+      #ifdef HXCPP_GC_NURSERY
+
+         unsigned char *buffer = alloc->spaceFirst;
+         unsigned char *end = buffer + (inSize + 4);
+
+         if ( end > alloc->spaceOversize )
+         {
+            // Fall back to external method
+            buffer = (unsigned char *)alloc->CallAlloc(inSize, inContainer ? IMMIX_ALLOC_IS_CONTAINER : 0);
+         }
+         else
+         {
+            alloc->spaceFirst = end;
+
+            if (inContainer)
+               ((unsigned int *)buffer)[-1] = inSize | IMMIX_ALLOC_IS_CONTAINER;
+            else
+               ((unsigned int *)buffer)[-1] = inSize;
+         }
+
+         #ifdef HXCPP_TELEMETRY
+         __hxt_gc_new((hx::StackContext *)alloc,buffer, inSize, inName);
+         #endif
+
+         return buffer;
+
+      #else
+         #ifndef HXCPP_ALIGN_ALLOC
+            // Inline the fast-path if we can
+            // We know the object can hold a pointer (vtable) and that the size is int-aligned
+            int start = alloc->spaceStart;
+            int end = start + sizeof(int) + inSize;
+
+            if ( end <= alloc->spaceEnd )
+            {
+               alloc->spaceStart = end;
+
+               unsigned int *buffer = (unsigned int *)(alloc->allocBase + start);
+
+               int startRow = start>>IMMIX_LINE_BITS;
+
+               alloc->allocStartFlags[ startRow ] |= gImmixStartFlag[start&127];
+
+               if (inContainer)
+                  *buffer++ =  (( (end+(IMMIX_LINE_LEN-1))>>IMMIX_LINE_BITS) -startRow) |
+                               (inSize<<IMMIX_ALLOC_SIZE_SHIFT) |
+                               hx::gMarkIDWithContainer;
+               else
+                  *buffer++ =  (( (end+(IMMIX_LINE_LEN-1))>>IMMIX_LINE_BITS) -startRow) |
+                               (inSize<<IMMIX_ALLOC_SIZE_SHIFT) |
+                               hx::gMarkID;
+
+               #if defined(HXCPP_GC_CHECK_POINTER) && defined(HXCPP_GC_DEBUG_ALWAYS_MOVE)
+               hx::GCOnNewPointer(buffer);
+               #endif
+
+               #ifdef HXCPP_TELEMETRY
+               __hxt_gc_new((hx::StackContext *)alloc,buffer, inSize, inName);
+               #endif
+               return buffer;
+            }
+         #endif // HXCPP_ALIGN_ALLOC
+
+         // Fall back to external method
+         void *result = alloc->CallAlloc(inSize, inContainer ? IMMIX_ALLOC_IS_CONTAINER : 0);
+
+         #ifdef HXCPP_TELEMETRY
+            __hxt_gc_new((hx::StackContext *)alloc,result, inSize, inName);
+         #endif
+
+         return result;
+      #endif // HXCPP_GC_NURSERY
+   }
+};
+
+typedef ImmixAllocator GcAllocator;
+typedef ImmixAllocator Ctx;
+
+
+#ifdef HXCPP_GC_GENERATIONAL
+  #define HX_OBJ_WB_CTX(obj,value,ctx) { \
+        unsigned char &mark =  ((unsigned char *)(obj))[ HX_ENDIAN_MARK_ID_BYTE]; \
+        if (mark == hx::gByteMarkID && value && !((unsigned char *)(value))[ HX_ENDIAN_MARK_ID_BYTE  ] ) { \
+            mark|=HX_GC_REMEMBERED; \
+            ctx->pushReferrer(obj); \
+     } }
+  #define HX_OBJ_WB_PESSIMISTIC_CTX(obj,ctx) { \
+     unsigned char &mark =  ((unsigned char *)(obj))[ HX_ENDIAN_MARK_ID_BYTE]; \
+     if (mark == hx::gByteMarkID)  { \
+        mark|=HX_GC_REMEMBERED; \
+        ctx->pushReferrer(obj); \
+     } }
+  // I'm not sure if this will ever trigger...
+  #define HX_OBJ_WB_NEW_MARKED_OBJECT(obj) { \
+     if (((unsigned char *)(obj))[ HX_ENDIAN_MARK_ID_BYTE]==hx::gByteMarkID) hx::NewMarkedObject(obj); \
+  }
+#else
+  #define HX_OBJ_WB_CTX(obj,value,ctx)
+  #define HX_OBJ_WB_PESSIMISTIC_CTX(obj,ctx)
+  #define HX_OBJ_WB_NEW_MARKED_OBJECT(obj)
+#endif
+
+#define HX_OBJ_WB(obj,value) HX_OBJ_WB_CTX(obj,value,_hx_ctx)
+#define HX_ARRAY_WB(array,index,value) HX_OBJ_WB(array,value)
+#define HX_OBJ_WB_PESSIMISTIC(obj) HX_OBJ_WB_PESSIMISTIC_CTX(obj,_hx_ctx)
+#define HX_OBJ_WB_GET(obj,value) HX_OBJ_WB_CTX(obj,value,HX_CTX_GET)
+#define HX_OBJ_WB_PESSIMISTIC_GET(obj) HX_OBJ_WB_PESSIMISTIC_CTX(obj,HX_CTX_GET)
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES extern unsigned int gPrevMarkIdMask;
+
+// Called only once it is determined that a new mark is required
+HXCPP_EXTERN_CLASS_ATTRIBUTES void MarkAllocUnchecked(void *inPtr ,hx::MarkContext *__inCtx); 
+HXCPP_EXTERN_CLASS_ATTRIBUTES void MarkObjectAllocUnchecked(hx::Object *inPtr ,hx::MarkContext *__inCtx);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void NewMarkedObject(hx::Object *inPtr);
+
+inline void MarkAlloc(void *inPtr ,hx::MarkContext *__inCtx)
+{
+   #ifdef EMSCRIPTEN
+   // Unaligned must be constants...
+   if ( !( ((size_t)inPtr) & 3) )
+   #endif
+   // This will also skip const regions
+   if ( !(((unsigned int *)inPtr)[-1] & gPrevMarkIdMask) )
+      MarkAllocUnchecked(inPtr,__inCtx);
+}
+inline void MarkObjectAlloc(hx::Object *inPtr ,hx::MarkContext *__inCtx)
+{
+   #ifdef EMSCRIPTEN
+   // Unaligned must be constants...
+   if ( !( ((size_t)inPtr) & 3) )
+   #endif
+   // This will also skip const regions
+   if ( !(((unsigned int *)inPtr)[-1] & gPrevMarkIdMask) )
+      MarkObjectAllocUnchecked(inPtr,__inCtx);
+}
+
+
+} // end namespace hx
+
+
+
+
+// It was theoretically possible to redefine the MarkContext arg type (or skip it)
+//  incase the particular GC scheme did not need it.  This may take a bit of extra
+//  work to get going again
+
+#define HX_MARK_ARG __inCtx
+//#define HX_MARK_ADD_ARG ,__inCtx
+#define HX_MARK_PARAMS hx::MarkContext *__inCtx
+//#define HX_MARK_ADD_PARAMS ,hx::MarkContext *__inCtx
+
+#ifdef HXCPP_VISIT_ALLOCS
+#define HX_VISIT_ARG __inCtx
+#define HX_VISIT_PARAMS hx::VisitContext *__inCtx
+#else
+#define HX_VISIT_ARG
+#define HX_VISIT_PARAMS
+#endif
+
+
+
+
+
+// These macros add debug to the mark/visit calls if required
+// They also perform some inline checking to avoid function calls if possible
+
+
+#ifdef HXCPP_DEBUG
+
+#define HX_MARK_MEMBER_NAME(x,name) { hx::MarkSetMember(name, __inCtx); hx::MarkMember(x, __inCtx ); }
+#define HX_MARK_BEGIN_CLASS(x) hx::MarkPushClass(#x, __inCtx );
+#define HX_MARK_END_CLASS() hx::MarkPopClass(__inCtx );
+#define HX_MARK_MEMBER(x) { hx::MarkSetMember(0, __inCtx); hx::MarkMember(x, __inCtx ); }
+#define HX_MARK_MEMBER_ARRAY(x,len) { hx::MarkSetMember(0, __inCtx); hx::MarkMemberArray(x, len, __inCtx ); }
+
+#else
+
+#define HX_MARK_MEMBER_NAME(x,name) hx::MarkMember(x, __inCtx )
+#define HX_MARK_BEGIN_CLASS(x)
+#define HX_MARK_END_CLASS()
+#define HX_MARK_MEMBER(x) hx::MarkMember(x, __inCtx )
+#define HX_MARK_MEMBER_ARRAY(x,len) hx::MarkMemberArray(x, len, __inCtx )
+
+#endif
+
+#define HX_MARK_OBJECT(ioPtr) if (ioPtr) hx::MarkObjectAlloc(ioPtr, __inCtx );
+
+
+
+
+#define HX_MARK_STRING(ioPtr) \
+   if (ioPtr) hx::MarkAlloc((void *)ioPtr, __inCtx );
+
+#define HX_MARK_ARRAY(ioPtr) { if (ioPtr) hx::MarkAlloc((void *)ioPtr, __inCtx ); }
+
+
+
+
+#define HX_VISIT_MEMBER_NAME(x,name) hx::VisitMember(x, __inCtx )
+#define HX_VISIT_MEMBER(x) hx::VisitMember(x, __inCtx )
+
+#define HX_VISIT_OBJECT(ioPtr) \
+  { if (ioPtr && !(((unsigned char *)ioPtr)[HX_GC_CONST_ALLOC_MARK_OFFSET] & HX_GC_CONST_ALLOC_MARK_BIT) ) __inCtx->visitObject( (hx::Object **)&ioPtr); }
+
+#define HX_VISIT_STRING(ioPtr) \
+   if (ioPtr && !(((unsigned char *)ioPtr)[HX_GC_CONST_ALLOC_MARK_OFFSET] & HX_GC_CONST_ALLOC_MARK_BIT) ) __inCtx->visitAlloc((void **)&ioPtr);
+
+#define HX_VISIT_ARRAY(ioPtr) { if (ioPtr) __inCtx->visitAlloc((void **)&ioPtr); }
+
+
+
+
+
+
+
+#endif
+

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/GcTypeInference.h

@@ -0,0 +1,161 @@
+#ifndef HX_GC_TYPE_INFERENCE_H
+#define HX_GC_TYPE_INFERENCE_H
+
+
+// These templates allow you to call MarkMember(x) or VisitMember(x) and the
+// compiler will direct the call to the correct function
+
+namespace hx
+{
+
+
+template<typename T> inline void MarkMember(T &outT,hx::MarkContext *__inCtx) { }
+
+template<typename T> inline void MarkMember(hx::ObjectPtr<T> &outT,hx::MarkContext *__inCtx)
+{
+   HX_MARK_OBJECT(outT.mPtr);
+}
+template<> inline void MarkMember(Dynamic &outT,hx::MarkContext *__inCtx)
+{
+   HX_MARK_OBJECT(outT.mPtr);
+}
+template<typename T> inline void MarkMember(Array<T> &outT,hx::MarkContext *__inCtx)
+{
+   HX_MARK_OBJECT(outT.mPtr);
+}
+template<> inline void MarkMember<hx::Object *>(hx::Object *&outT,hx::MarkContext *__inCtx)
+{
+   HX_MARK_OBJECT(outT);
+}
+template<> inline void MarkMember<cpp::Variant>(cpp::Variant &outT,hx::MarkContext *__inCtx)
+{
+   outT.mark(__inCtx);
+}
+template<typename T> inline void MarkMember(hx::Native<T> &outT,hx::MarkContext *__inCtx)
+{
+   if (outT.ptr)
+   {
+      hx::Object *ptr = outT.ptr->__GetRealObject();
+      HX_MARK_OBJECT(ptr);
+   }
+}
+
+template<> inline void MarkMember<int>(int &outT,hx::MarkContext *__inCtx) {  }
+template<> inline void MarkMember<bool>(bool &outT,hx::MarkContext *__inCtx) {  }
+template<> inline void MarkMember<double>(double &outT,hx::MarkContext *__inCtx) {  }
+template<> inline void MarkMember<float>(float &outT,hx::MarkContext *__inCtx) {  }
+template<> inline void MarkMember<String>(String &outT,hx::MarkContext *__inCtx)
+{
+   HX_MARK_STRING(outT.raw_ptr());
+}
+template<> inline void MarkMember<null>(null &outT,hx::MarkContext *__inCtx) {  }
+
+
+
+
+template<typename T> inline void MarkMemberArray(T *,int, hx::MarkContext *__inCtx)
+{
+   //*(int *)0=0;
+}
+template<> inline void MarkMemberArray<String>(String *ioStrings,int inLen,hx::MarkContext *__inCtx)
+{
+   hx::MarkStringArray(ioStrings,inLen,__inCtx);
+}
+template<typename T> inline void MarkMemberArray(hx::ObjectPtr<T> *inObjects, int inLen, hx::MarkContext *__inCtx)
+{
+   hx::MarkObjectArray( (hx::Object **)inObjects ,inLen,__inCtx);
+}
+template<> inline void MarkMemberArray(Dynamic *outT,int inLen, hx::MarkContext *__inCtx)
+{
+   hx::MarkObjectArray( (hx::Object **)outT ,inLen,__inCtx);
+}
+template<> inline void MarkMemberArray(hx::Object **outT,int inLen, hx::MarkContext *__inCtx)
+{
+   hx::MarkObjectArray( outT ,inLen,__inCtx);
+}
+template<typename T> inline void MarkMemberArray(Array<T> *outT,int inLen,hx::MarkContext *__inCtx)
+{
+   hx::MarkObjectArray( (hx::Object **)outT ,inLen,__inCtx);
+}
+
+
+
+// Locate potential GC pointer inside member
+inline const void *PointerOf( ::Dynamic &d) { return d.mPtr; }
+inline const void *PointerOf( ::String &s) { return s.raw_ptr(); }
+template<typename T> inline const void *PointerOf( ::Array<T> &a) { return a.mPtr; }
+template<typename T> inline const void *PointerOf( ::hx::ObjectPtr<T> &o) { return o.mPtr; }
+template<typename T> inline const void *PointerOf( ::hx::Native<T> &o)
+{
+   if (o.ptr)
+      return o.ptr->__GetRealObject();
+   return 0;
+}
+
+inline const void *PointerOf(...) { return 0; }
+
+
+#ifdef HXCPP_VISIT_ALLOCS
+template<typename T> inline void VisitMember(T &outT,hx::VisitContext *__inCtx) { }
+
+template<typename T> inline void VisitMember(hx::ObjectPtr<T> &outT,hx::VisitContext *__inCtx)
+{
+   HX_VISIT_OBJECT(outT.mPtr);
+}
+template<> inline void VisitMember(Dynamic &outT,hx::VisitContext *__inCtx)
+{
+   HX_VISIT_OBJECT(outT.mPtr);
+}
+template<> inline void VisitMember<hx::Object *>(hx::Object *&outT,hx::VisitContext *__inCtx)
+{
+   HX_VISIT_OBJECT(outT);
+}
+template<typename T> inline void VisitMember(Array<T> &outT,hx::VisitContext *__inCtx)
+{
+   HX_VISIT_OBJECT(outT.mPtr);
+}
+template<> inline void VisitMember(cpp::Variant &outT,hx::VisitContext *__inCtx)
+{
+   outT.visit(__inCtx);
+}
+template<typename T> inline void VisitMember(hx::Native<T> &outT,hx::VisitContext *__inCtx)
+{
+   if (outT.ptr)
+   {
+      hx::Object *ptr0 = outT.ptr->__GetRealObject();
+      if (ptr0)
+      {
+         hx::Object *ptr1 = ptr0;
+         HX_VISIT_OBJECT(ptr1);
+         size_t delta = ( (char *)ptr1 - (char *)ptr0 );
+         if (delta)
+            outT.ptr = (T)( (char *)outT.ptr + delta );
+      }
+   }
+}
+
+
+template<> inline void VisitMember<int>(int &outT,hx::VisitContext *__inCtx) {  }
+template<> inline void VisitMember<bool>(bool &outT,hx::VisitContext *__inCtx) {  }
+template<> inline void VisitMember<double>(double &outT,hx::VisitContext *__inCtx) {  }
+template<> inline void VisitMember<float>(float &outT,hx::VisitContext *__inCtx) {  }
+template<> inline void VisitMember<String>(String &outT,hx::VisitContext *__inCtx)
+{
+   HX_VISIT_STRING(outT.raw_ref());
+}
+template<> inline void VisitMember<null>(null &outT,hx::VisitContext *__inCtx) {  }
+#endif
+
+
+
+// Template used to register and initialise the statics in the one call.
+//  Do nothing...
+template<typename T> inline T &Static(T &t) {  return t; }
+
+
+} // end namespace hx
+
+
+
+
+#endif

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/GenMacro.hx

@@ -0,0 +1,135 @@
+/*
+  This file is used to generate Macros.h and DynamicImpl.h.
+  To change the number of "fast" args, you will also need to change numbers in the tpl files.
+  Usage: haxe -x GenMacro.hx
+*/
+
+import haxe.Template;
+#if haxe3
+import sys.io.File;
+import sys.io.FileOutput;
+#else
+import neko.io.File;
+import neko.io.FileOutput;
+#end
+
+class GenMacro
+{
+   static var warning =
+    "//   ##  ##  ##   ##   ####   ##  ## ## ##  ##  ####    ##\n" +
+    "//   ##  ##  ## ##  ## ##  ## ### ## ## ### ## ##       ##\n" +
+    "//    ## ## ##  ###### ###### ###### ## ###### ## ###   ##\n" +
+    "//    ## ## ##  ##  ## ## ##  ## ### ## ## ### ##  ##     \n" +
+    "//     ## ##    ##  ## ##  ## ##  ## ## ##  ##  ####    ##\n\n" +
+    "// DO NOT EDIT\n// This file is generated from the .tpl file\n";
+
+   public function new()
+   {
+      var context = { };
+      var params = new Array<Dynamic>();
+      var arr_list = new Array<String>();
+      var arg_list = new Array<String>();
+      var dynamic_arg_list = new Array<String>();
+      var dynamic_in_args = new Array<String>();
+      var dynamic_var_args = new Array<String>();
+      var dynamic_adds = new Array<String>();
+
+      for(arg in 0...27)
+      {
+         if (arg>0)
+         {
+            arr_list.push( "inArgs[" + (arg-1) + "]");
+            arg_list.push( "inArg" + (arg-1));
+            dynamic_arg_list.push("const Dynamic &inArg" + (arg-1) );
+            dynamic_adds.push( "->init(" + (arg-1) + ",inArg" + (arg-1) + ")" );
+         }
+
+         params.push( {
+             ARG : arg,
+             ARR_LIST : arr_list.join(","),
+             DYNAMIC_ARG_LIST : dynamic_arg_list.join(","),
+             ARG_LIST : arg_list.join(","),
+             DYNAMIC_ADDS : dynamic_adds.join("")
+            } );
+      }
+
+      var locals = new Array<Dynamic>();
+      var jumboLocals = new Array<Dynamic>();
+      var marks = new Array<String>();
+      var visits = new Array<String>();
+      var type_vars = new Array<String>();
+      var type_args = new Array<String>();
+      var construct_args = new Array<String>();
+      var construct_vars = new Array<String>();
+      for(arg in 1...62)
+      {
+         var vid = arg-1;
+         if (vid>=0)
+         {
+            marks.push( "HX_MARK_MEMBER(v" + vid +");" );
+            visits.push( "HX_VISIT_MEMBER(v" + vid +");" );
+            type_args.push( "t" + vid +",v" + vid  );
+            type_vars.push( "t" + vid +" v" + vid  );
+            construct_args.push( "t" + vid +" __" + vid  );
+            construct_vars.push( "v" + vid +"(__" + vid + ")"  );
+         }
+
+         var local = {
+             ARG : arg,
+             MARKS : marks.join(" "),
+             VISITS : visits.join(" "),
+             TYPE_VARS : type_vars.join(","),
+             TYPE_ARGS : type_args.join(","),
+             TYPE_DECL : type_vars.join(";"),
+             CONSTRUCT_VARS : construct_vars.join(","),
+             CONSTRUCT_ARGS : construct_args.join(",")
+            };
+         if (arg<20)
+            locals.push(local);
+         else
+            jumboLocals.push(local);
+      }
+
+      Reflect.setField(context, "PARAMS", params);
+      Reflect.setField(context, "LOCALS", locals);
+      Reflect.setField(context, "NS", "::");
+      Reflect.setField(context, "hxNS", " ::hx::");
+
+      var fixed = File.getContent("MacrosFixed.h");
+      fixed = fixed.split("
+").join("");
+      var fileContents:String = File.getContent("Macros.tpl");
+      fileContents = fileContents.split("
+").join("");
+
+      var template:Template = new Template(fileContents);
+      var result:String = template.execute(context);
+      var fileOutput:FileOutput = File.write("Macros.h", true);
+      fileOutput.writeString(warning);
+      fileOutput.writeString(fixed);
+      fileOutput.writeString(result);
+      fileOutput.close();
+
+      var fileContents:String = File.getContent("MacrosJumbo.tpl");
+      fileContents = fileContents.split("
+").join("");
+      var template:Template = new Template(fileContents);
+      Reflect.setField(context, "LOCALS", jumboLocals);
+      var result:String = template.execute(context);
+      var fileOutput:FileOutput = File.write("MacrosJumbo.h", true);
+      fileOutput.writeString(warning);
+      fileOutput.writeString(result);
+      fileOutput.close();
+
+
+
+      var fileContents:String = File.getContent("DynamicImpl.tpl");
+      fileContents = fileContents.split("
+").join("");
+      var template:Template = new Template(fileContents);
+      var result:String = template.execute(context);
+      var fileOutput:FileOutput = File.write("DynamicImpl.h", true);
+      fileOutput.writeString(warning);
+      fileOutput.writeString(result);
+      fileOutput.close();
+

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/HeaderVersion.h

@@ -0,0 +1,3 @@
+#ifndef HXCPP_HEADER_VERSION
+#define HXCPP_HEADER_VERSION 330
+#endif

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/HxcppMain.h

@@ -0,0 +1,114 @@
+#ifdef HXCPP_DLL_IMPORT
+
+   extern "C" EXPORT_EXTRA void __main__()
+   {
+     __boot_all();
+     __hxcpp_main();
+   }
+
+#elif defined(HX_ANDROID) && !defined(HXCPP_EXE_LINK)
+
+   // Java Main....
+   #include <jni.h>
+   #include <hx/Thread.h>
+   #include <android/log.h>
+
+   extern "C" EXPORT_EXTRA void hxcpp_main()
+   {
+      HX_TOP_OF_STACK
+      try
+      {
+         hx::Boot();
+         __boot_all();
+         __hxcpp_main();
+      }
+      catch (Dynamic e)
+      {
+         __hx_dump_stack();
+         __android_log_print(ANDROID_LOG_ERROR, "Exception", "%s", e==null() ? "null" : e->toString().__CStr());
+      }
+      hx::SetTopOfStack((int *)0,true);
+   }
+
+   extern "C" EXPORT_EXTRA JNIEXPORT void JNICALL Java_org_haxe_HXCPP_main(JNIEnv * env)
+   {
+      hxcpp_main();
+   }
+
+#elif defined(HX_WINRT) && defined(__cplusplus_winrt)
+
+   #include <Roapi.h>
+   [ Platform::MTAThread ]
+   int main(Platform::Array<Platform::String^>^)
+   {
+      HX_TOP_OF_STACK
+      RoInitialize(RO_INIT_MULTITHREADED);
+      hx::Boot();
+      try
+      {
+         __boot_all();
+         __hxcpp_main();
+      }
+      catch (Dynamic e)
+      {
+         __hx_dump_stack();
+         return -1;
+      }
+      return 0;
+   }
+
+#else
+
+   #if defined(HX_WIN_MAIN) && !defined(_WINDOWS_)
+   #ifndef HINSTANCE
+   #define HINSTANCE void*
+   #endif
+   #ifndef LPSTR
+   #define LPSTR char*
+   #endif
+   extern "C" int __stdcall MessageBoxA(void *,const char *,const char *,int);
+   #endif
+
+
+   #if defined(TIZEN)
+   extern "C" EXPORT_EXTRA int OspMain (int argc, char* pArgv[])
+   {
+   #elif defined(HX_WIN_MAIN)
+   int __stdcall WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
+   {
+   #else
+
+   extern int _hxcpp_argc;
+   extern char **_hxcpp_argv;
+   int main(int argc,char **argv)
+   {
+      _hxcpp_argc = argc;
+      _hxcpp_argv = argv;
+   #endif
+      HX_TOP_OF_STACK
+      hx::Boot();
+      try
+      {
+         __boot_all();
+         __hxcpp_main();
+      }
+      catch (Dynamic e)
+      {
+         __hx_dump_stack();
+         #ifdef HX_WIN_MAIN
+         MessageBoxA(0,  e==null() ? "null" : e->toString().__CStr(), "Error", 0);
+         #else
+         printf("Error : %s\n",e==null() ? "null" : e->toString().__CStr());
+         #endif
+         return -1;
+      }
+      return 0;
+   }
+   #if 0
+   }
+   }
+   #endif
+
+#endif
+
+

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/IndexRef.h

@@ -0,0 +1,9 @@
+#ifndef HX_INDEX_REF_H
+#define HX_INDEX_REF_H
+
+namespace hx
+{
+
+}
+
+#endif

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Interface.h

@@ -0,0 +1,65 @@
+#ifndef HX_INTERFACE_H
+#define HX_INTERFACE_H
+
+namespace hx
+{
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES void InvalidInterface();
+
+template<typename T>
+inline T interface_cast(void *ptr)
+{
+   #if defined(HXCPP_GC_CHECK_POINTER) || defined(HXCPP_DEBUG)
+   if (!ptr) hx::InvalidInterface();
+   #endif
+   return static_cast<T>(ptr);
+}
+
+#if (HXCPP_API_LEVEL >= 330)
+template<typename T>
+inline T interface_check(T inObj,int interfaceId)
+{
+   Dynamic d(inObj);
+   if ( !d.mPtr || !d->_hx_getInterface(interfaceId))
+      hx::BadCast();
+   return inObj;
+}
+#endif
+
+
+#if (HXCPP_API_LEVEL < 330)
+class HXCPP_EXTERN_CLASS_ATTRIBUTES Interface : public hx::Object
+{
+public:
+   // The following functions make use of : hx::Object *__GetRealObject();
+
+	void __Mark(hx::MarkContext *__inCtx);
+   hx::Object *__ToInterface(const hx::type_info &);
+	int __GetType() const;
+	void *__GetHandle() const;
+	hx::FieldRef __FieldRef(const ::String &);
+	::String __ToString() const;
+	int __ToInt() const;
+	double __ToDouble() const;
+	const char * __CStr() const;
+	::String toString();
+	bool __HasField(const ::String &);
+   hx::Val __Field(const ::String &, hx::PropertyAccess inCallProp);
+	Dynamic __IField(int);
+   hx::Val __SetField(const ::String &,const hx::Val &, hx::PropertyAccess inCallProp);
+	void __SetThis(Dynamic);
+	void __GetFields(Array< ::String> &);
+	hx::Class __GetClass() const;
+	int __Compare(const hx::Object *) const;
+
+   /* No need for enum options - not in interfaces */
+   /* No need for array options - not in interfaces */
+   /* No need for function options - not in interfaces */
+};
+#endif
+
+}
+
+
+#endif
+

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/LessThanEq.h

@@ -0,0 +1,475 @@
+#ifndef HX_LESS_THAN_EQ_INCLUDED
+#define HX_LESS_THAN_EQ_INCLUDED
+
+namespace hx
+{
+
+enum {
+   CompareAsInt,
+   CompareAsInt64,
+   CompareAsDouble,
+   CompareAsString,
+   CompareAsDynamic,
+};
+
+
+template <typename T> 
+struct CompareTraits
+{
+   enum { type = (int)CompareAsDynamic };
+
+   inline static int toInt(Dynamic inValue) { return inValue; }
+   inline static double toDouble(Dynamic inValue) { return inValue; }
+   inline static cpp::Int64 toInt64(Dynamic inValue) { return inValue; }
+   inline static String toString(Dynamic inValue) { return inValue; }
+   inline static hx::Object *toObject(Dynamic inValue) { return inValue.mPtr; }
+   inline static int getDynamicCompareType(const Dynamic &inValue)
+   {
+      if (!inValue.mPtr)
+         return CompareAsDynamic;
+      switch(inValue->__GetType())
+      {
+         case vtInt: case vtBool: return CompareAsInt;
+         case vtInt64: return CompareAsInt64;
+         case vtFloat: return CompareAsDouble;
+         case vtString: return CompareAsString;
+         default: return CompareAsDynamic;
+      }
+   }
+   inline static bool isNull(const Dynamic &inValue) { return !inValue.mPtr; }
+};
+
+
+
+template <> 
+struct CompareTraits<null>
+{
+   enum { type = (int)CompareAsDynamic };
+
+   inline static int toInt(const null &inValue) { return 0; }
+   inline static double toDouble(const null & inValue) { return 0; }
+   inline static cpp::Int64 toInt64(const null & inValue) { return 0; }
+   inline static String toString(const null & inValue) { return String(); }
+   inline static hx::Object *toObject(const null & inValue) { return 0; }
+
+   inline static int getDynamicCompareType(const null &) { return type; }
+   inline static bool isNull(const null &) { return true; }
+};
+
+
+
+template <> 
+struct CompareTraits<signed int>
+{
+   enum { type = (int)CompareAsInt };
+
+   inline static int toInt(int inValue) { return inValue; }
+   inline static double toDouble(int inValue) { return inValue; }
+   inline static cpp::Int64 toInt64(int inValue) { return inValue; }
+   inline static String toString(int inValue) { return String(); }
+   inline static hx::Object *toObject(int inValue) { return 0; }
+
+   inline static int getDynamicCompareType(int) { return type; }
+   inline static bool isNull(int) { return false; }
+};
+
+template <> 
+struct CompareTraits<unsigned int>
+{
+   enum { type = (int)CompareAsInt };
+
+   // Return value is unsigned ...
+   inline static unsigned int toInt(unsigned int inValue) { return inValue; }
+   inline static double toDouble(unsigned int inValue) { return inValue; }
+   inline static cpp::Int64 toInt64(unsigned int inValue) { return inValue; }
+   inline static String toString(unsigned int inValue) { return String(); }
+   inline static hx::Object *toObject(unsigned int inValue) { return 0; }
+
+   inline static int getDynamicCompareType(int) { return type; }
+   inline static bool isNull(int) { return false; }
+};
+
+template <> struct CompareTraits<signed short> : public CompareTraits<int> { };
+template <> struct CompareTraits<unsigned short> : public CompareTraits<int> { };
+template <> struct CompareTraits<signed char> : public CompareTraits<int> { };
+template <> struct CompareTraits<unsigned char> : public CompareTraits<int> { };
+template <> struct CompareTraits<char> : public CompareTraits<int> { };
+template <> struct CompareTraits<wchar_t> : public CompareTraits<int> { };
+#if __cplusplus >= 201103L || defined(KORE_MICROSOFT)
+template <> struct CompareTraits<char16_t> : public CompareTraits<int> { };
+#endif
+
+
+template <> 
+struct CompareTraits<double>
+{
+   enum { type = (int)CompareAsDouble };
+
+   inline static int toInt(double inValue) { return inValue; }
+   inline static double toDouble(double inValue) { return inValue; }
+   inline static cpp::Int64 toInt64(double inValue) { return inValue; }
+   inline static String toString(double inValue) { return String(); }
+   inline static hx::Object *toObject(double inValue) { return 0; }
+
+   inline static int getDynamicCompareType(const double &) { return type; }
+   inline static bool isNull(const double &) { return false; }
+};
+template <> struct CompareTraits<float> : public CompareTraits<double> { };
+
+
+
+template <> 
+struct CompareTraits<cpp::Int64>
+{
+   enum { type = (int)CompareAsInt64 };
+
+   inline static int toInt(cpp::Int64 inValue) { return (int)inValue; }
+   inline static double toDouble(cpp::Int64 inValue) { return inValue; }
+   inline static cpp::Int64 toInt64(cpp::Int64 inValue) { return inValue; }
+   inline static String toString(cpp::Int64 inValue) { return String(); }
+   inline static hx::Object *toObject(cpp::Int64 inValue) { return 0; }
+
+   inline static int getDynamicCompareType(cpp::Int64) { return type; }
+   inline static bool isNull(cpp::Int64) { return false; }
+};
+
+template <> 
+struct CompareTraits<cpp::UInt64>
+{
+   enum { type = (int)CompareAsInt64 };
+
+   inline static int toInt(cpp::UInt64 inValue) { return (int)inValue; }
+   inline static double toDouble(cpp::UInt64 inValue) { return inValue; }
+   // Return value is unsigned ...
+   inline static cpp::UInt64 toInt64(cpp::UInt64 inValue) { return inValue; }
+   inline static String toString(cpp::UInt64 inValue) { return String(); }
+   inline static hx::Object *toObject(cpp::UInt64 inValue) { return 0; }
+
+   inline static int getDynamicCompareType(cpp::UInt64) { return type; }
+   inline static bool isNull(cpp::UInt64) { return false; }
+};
+
+
+template <> 
+struct CompareTraits< String >
+{
+   enum { type = (int)CompareAsString };
+
+   inline static int toInt(const String &) { return 0; }
+   inline static double toDouble(const String &) { return 0; }
+   inline static cpp::Int64 toInt64(const String &) { return 0; }
+   inline static String toString(const String &inValue ) { return inValue; }
+   inline static hx::Object *toObject(const String &inValue) { return Dynamic(inValue).mPtr; }
+
+   inline static int getDynamicCompareType(const String &) { return type; }
+   inline static bool isNull(const String &inValue) { return !inValue.raw_ptr(); }
+};
+
+
+template <> 
+struct CompareTraits< cpp::Variant >
+{
+   enum { type = (int)CompareAsDynamic };
+
+   // Might ne a
+   inline static int toInt(const cpp::Variant &inValue) { return inValue; }
+   inline static double toDouble(const cpp::Variant &inValue) { return inValue; }
+   inline static cpp::Int64 toInt64(const cpp::Variant &inValue) { return inValue; }
+   inline static String toString(const cpp::Variant &inValue ) { return inValue; }
+   inline static hx::Object *toObject(const cpp::Variant &inValue) {
+      if (inValue.type==cpp::Variant::typeObject)
+         return inValue.valObject;
+      return 0;
+   }
+
+   inline static int getDynamicCompareType(const cpp::Variant &inValue)
+   {
+      switch(inValue.type)
+      {
+         case cpp::Variant::typeInt: case cpp::Variant::typeBool: return CompareAsInt;
+         case cpp::Variant::typeInt64: return CompareAsInt64;
+         case cpp::Variant::typeDouble: return CompareAsDouble;
+         case cpp::Variant::typeString: return CompareAsString;
+
+         case cpp::Variant::typeObject:
+            {
+               if (!inValue.valObject)
+                  return CompareAsDynamic;
+               switch(inValue.valObject->__GetType())
+               {
+                  case vtInt: case vtBool: return CompareAsInt;
+                  case vtInt64: return CompareAsInt64;
+                  case vtFloat: return CompareAsDouble;
+                  case vtString: return CompareAsString;
+                  default: return CompareAsDynamic;
+               }
+            }
+         default:
+              return CompareAsDynamic;
+      }
+   }
+   inline static bool isNull(const cpp::Variant &inValue) { return inValue.isNull(); }
+};
+
+
+
+template <typename T> 
+struct CompareTraits< cpp::Pointer<T> >
+{
+   enum { type = (int)CompareAsDynamic };
+
+   inline static int toInt(Dynamic inValue) { return inValue; }
+   inline static double toDouble(Dynamic inValue) { return inValue; }
+   inline static cpp::Int64 toInt64(Dynamic inValue) { return inValue; }
+   inline static String toString(Dynamic inValue) { return inValue; }
+   inline static hx::Object *toObject(Dynamic inValue) { return inValue.mPtr; }
+   inline static int getDynamicCompareType(const Dynamic &inValue)
+   {
+      return CompareAsDynamic;
+   }
+   inline static bool isNull(const cpp::Pointer<T> &inValue) { return !inValue.ptr; }
+};
+
+
+template <typename T> 
+struct CompareTraits< T * >
+{
+   enum { type = (int)CompareAsInt64 };
+
+   inline static int toInt(T * inValue) { return 0; }
+   inline static double toDouble(T * inValue) { return 0; }
+   inline static cpp::Int64 toInt64(T * inValue) { return (cpp::Int64)inValue; }
+   inline static String toString(T * inValue) { return String(); }
+   inline static hx::Object *toObject(T * inValue) { return 0; }
+   inline static int getDynamicCompareType(T * inValue)
+   {
+      return CompareAsInt64;
+   }
+   inline static bool isNull(T *inValue) { return !inValue; }
+};
+
+
+template<typename T1>
+hx::Object *GetExistingObject(const T1 &v1)
+{
+   typedef CompareTraits<T1> traits1;
+   return traits1::toObject(v1);
+}
+
+
+template<typename T1>
+bool IsNull(const T1 &v1)
+{
+   typedef CompareTraits<T1> traits1;
+   return traits1::isNull(v1);
+}
+
+template<typename T1>
+bool IsNotNull(const T1 &v1)
+{
+   typedef CompareTraits<T1> traits1;
+   return !traits1::isNull(v1);
+}
+
+template<bool LESS, bool EQ, typename T1, typename T2>
+inline bool TestLessEq(const T1 &v1, const T2 &v2)
+{
+   typedef CompareTraits<T1> traits1;
+   typedef CompareTraits<T2> traits2;
+
+   if (traits1::type==(int)CompareAsInt && traits2::type==(int)CompareAsInt)
+   {
+      return LESS ? ( EQ ? traits1::toInt(v1) <= traits2::toInt(v2) :
+                           traits1::toInt(v1) <  traits2::toInt(v2)  ) :
+                    ( EQ ? traits1::toInt(v1) == traits2::toInt(v2) :
+                           traits1::toInt(v1) != traits2::toInt(v2)  );
+   }
+   else if (traits1::type<=(int)CompareAsInt64 && traits2::type<=(int)CompareAsInt64)
+   {
+      return LESS ? ( EQ ? traits1::toInt64(v1) <= traits2::toInt64(v2) :
+                           traits1::toInt64(v1) <  traits2::toInt64(v2)  ) :
+                    ( EQ ? traits1::toInt64(v1) == traits2::toInt64(v2) :
+                           traits1::toInt64(v1) != traits2::toInt64(v2)  );
+   }
+   else if (traits1::type<=(int)CompareAsDouble && traits2::type<=(int)CompareAsDouble)
+   {
+      return LESS ? ( EQ ? traits1::toDouble(v1) <= traits2::toDouble(v2) :
+                           traits1::toDouble(v1) <  traits2::toDouble(v2)  ) :
+                    ( EQ ? traits1::toDouble(v1) == traits2::toDouble(v2) :
+                           traits1::toDouble(v1) != traits2::toDouble(v2)  );
+   }
+   else if (traits1::type==(int)CompareAsString && traits2::type==(int)CompareAsString)
+   {
+      return LESS ? ( EQ ? traits1::toString(v1) <= traits2::toString(v2) :
+                           traits1::toString(v1) <  traits2::toString(v2)  ) :
+                    ( EQ ? traits1::toString(v1) == traits2::toString(v2) :
+                           traits1::toString(v1) != traits2::toString(v2)  );
+   }
+   else if (traits1::type<=(int)CompareAsString && traits2::type<=(int)CompareAsString)
+   {
+      // String with a number...
+      return false;
+   }
+   else if (traits1::type==(int)CompareAsString || traits2::type==(int)CompareAsString)
+   {
+      // String with a object...
+      return LESS ? ( EQ ? traits1::toString(v1) <= traits2::toString(v2) :
+                           traits1::toString(v1) <  traits2::toString(v2)  ) :
+                    ( EQ ? traits1::toString(v1) == traits2::toString(v2) :
+                           traits1::toString(v1) != traits2::toString(v2)  );
+   }
+   else if (traits1::type<=(int)CompareAsDouble || traits2::type<=(int)CompareAsDouble)
+   {
+      // numeric with a object...
+
+      // null can only be equal to null...
+      bool n1 = traits1::isNull(v1);
+      bool n2 = traits2::isNull(v2);
+      if (n1 || n2)
+         return EQ ? n1==n2 : !LESS && n1!=n2/* false,false = not equal*/;
+
+      return LESS ? ( EQ ? traits1::toDouble(v1) <= traits2::toDouble(v2) :
+                           traits1::toDouble(v1) <  traits2::toDouble(v2)  ) :
+                    ( EQ ? traits1::toDouble(v1) == traits2::toDouble(v2) :
+                           traits1::toDouble(v1) != traits2::toDouble(v2)  );
+   }
+   else
+   {
+      // Dynamic compare.
+      // This time, one or both types are calculated at run time
+
+      // Check null/not null compare
+      bool n1 = traits1::isNull(v1);
+      bool n2 = traits2::isNull(v2);
+      if (n1 || n2)
+         return EQ ? n1==n2 : !LESS && n1!=n2 /* false,false = not equal*/;
+
+      int t1 = traits1::getDynamicCompareType(v1);
+      int t2 = traits2::getDynamicCompareType(v2);
+
+      if (t1==(int)CompareAsInt && t2==(int)CompareAsInt)
+      {
+         return LESS ? ( EQ ? traits1::toInt(v1) <= traits2::toInt(v2) :
+                              traits1::toInt(v1) <  traits2::toInt(v2)  ) :
+                       ( EQ ? traits1::toInt(v1) == traits2::toInt(v2) :
+                              traits1::toInt(v1) != traits2::toInt(v2)  );
+      }
+      else if (t1<=(int)CompareAsInt64 && t2<=(int)CompareAsInt64)
+      {
+         return LESS ? ( EQ ? traits1::toInt64(v1) <= traits2::toInt64(v2) :
+                              traits1::toInt64(v1) <  traits2::toInt64(v2)  ) :
+                       ( EQ ? traits1::toInt64(v1) == traits2::toInt64(v2) :
+                              traits1::toInt64(v1) != traits2::toInt64(v2)  );
+      }
+      else if (t1<=(int)CompareAsDouble && t2<=(int)CompareAsDouble)
+      {
+         return LESS ? ( EQ ? traits1::toDouble(v1) <= traits2::toDouble(v2) :
+                              traits1::toDouble(v1) <  traits2::toDouble(v2)  ) :
+                       ( EQ ? traits1::toDouble(v1) == traits2::toDouble(v2) :
+                              traits1::toDouble(v1) != traits2::toDouble(v2)  );
+      }
+      else if (t1==(int)CompareAsString && t2==(int)CompareAsString)
+      {
+         return LESS ? ( EQ ? traits1::toString(v1) <= traits2::toString(v2) :
+                              traits1::toString(v1) <  traits2::toString(v2)  ) :
+                       ( EQ ? traits1::toString(v1) == traits2::toString(v2) :
+                              traits1::toString(v1) != traits2::toString(v2)  );
+      }
+      else if (t1<=(int)CompareAsString && t2<=(int)CompareAsString)
+      {
+         // String with a number...
+         return false;
+      }
+      else if (t1==(int)CompareAsString || t2==(int)CompareAsString)
+      {
+         // String with a object...
+         return LESS ? ( EQ ? traits1::toString(v1) <= traits2::toString(v2) :
+                              traits1::toString(v1) <  traits2::toString(v2)  ) :
+                       ( EQ ? traits1::toString(v1) == traits2::toString(v2) :
+                              traits1::toString(v1) != traits2::toString(v2)  );
+      }
+      else if (t1<=(int)CompareAsDouble || t2<=(int)CompareAsDouble)
+      {
+         // numeric with a object only works for not-equal
+         return !LESS && !EQ;
+      }
+      else
+      {
+         // Object with Object
+         hx::Object *o1 = traits1::toObject(v1);
+         hx::Object *o2 = traits2::toObject(v2);
+
+         int diff = o1->__Compare(o2);
+         return LESS ? ( EQ ? diff <= 0 :
+                              diff <  0  ) :
+                       ( EQ ? diff == 0 :
+                              diff != 0  );
+      }
+   }
+}
+
+
+template<typename T1, typename T2>
+bool IsEq(const T1 &v1, const T2 &v2) { return TestLessEq<false,true,T1,T2>(v1,v2); }
+
+template<typename T1, typename T2>
+bool IsNotEq(const T1 &v1, const T2 &v2) { return TestLessEq<false,false,T1,T2>(v1,v2); }
+
+template<typename T1, typename T2>
+bool IsLess(const T1 &v1, const T2 &v2) { return TestLessEq<true,false,T1,T2>(v1,v2); }
+
+template<typename T1, typename T2>
+bool IsLessEq(const T1 &v1, const T2 &v2) { return TestLessEq<true,true,T1,T2>(v1,v2); }
+
+
+template<typename T1, typename T2>
+bool IsGreater(const T1 &v1, const T2 &v2) { return TestLessEq<true,false,T2,T1>(v2,v1); }
+
+template<typename T1, typename T2>
+bool IsGreaterEq(const T1 &v1, const T2 &v2) { return TestLessEq<true,true,T2,T1>(v2,v1); }
+
+
+
+template<typename T1, typename T2>
+bool IsPointerEq(const T1 &v1, const T2 &v2)
+{
+   return GetExistingObject(v1) == GetExistingObject(v2);
+}
+
+template<typename T1, typename T2>
+bool IsPointerNotEq(const T1 &v1, const T2 &v2)
+{
+   return GetExistingObject(v1) != GetExistingObject(v2);
+}
+
+
+template<typename T1, typename T2>
+bool IsInstanceEq(const T1 &v1, const T2 &v2)
+{
+   hx::Object *p1 = GetExistingObject(v1);
+   hx::Object *p2 = GetExistingObject(v2);
+   if (p1==p2)
+      return true;
+   if (!p1 || !p2)
+      return false;
+   return !p1->__Compare(p2);
+}
+
+template<typename T1, typename T2>
+bool IsInstanceNotEq(const T1 &v1, const T2 &v2)
+{
+   hx::Object *p1 = GetExistingObject(v1);
+   hx::Object *p2 = GetExistingObject(v2);
+   if (p1==p2)
+      return false;
+   if (!p1 || !p2)
+      return true;
+   return p1->__Compare(p2);
+}
+
+
+
+}
+
+
+#endif

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Macros.tpl

@@ -0,0 +1,195 @@
+#ifndef HX_MACROS_H
+#define HX_MACROS_H
+
+// --- Functions and their parameters ----
+
+::foreach PARAMS::
+#define HX_ARR_LIST::ARG:: ::ARR_LIST::::end::
+
+::foreach PARAMS::
+#define HX_DYNAMIC_ARG_LIST::ARG:: ::DYNAMIC_ARG_LIST::::end::
+
+::foreach PARAMS::
+#define HX_ARG_LIST::ARG:: ::ARG_LIST::::end::
+
+#define HX_DEFINE_DYNAMIC_FUNC0(class,func,ret) \
+static ::NS::Dynamic __##class##func(::hxNS::Object *inObj) \
+{ \
+      ret reinterpret_cast<class *>(inObj)->func(); return  ::NS::Dynamic(); \
+}; \
+ ::NS::Dynamic class::func##_dyn() \
+{\
+   return ::hxNS::CreateMemberFunction0(#func,this,__##class##func); \
+}
+
+
+#define HX_DEFINE_DYNAMIC_FUNC(class,N,func,ret,array_list,dynamic_arg_list,arg_list) \
+static ::NS::Dynamic __##class##func(::hxNS::Object *inObj, dynamic_arg_list) \
+{ \
+      ret reinterpret_cast<class *>(inObj)->func(arg_list); return  ::NS::Dynamic(); \
+}; \
+ ::NS::Dynamic class::func##_dyn() \
+{\
+   return ::hxNS::CreateMemberFunction##N(#func,this,__##class##func); \
+}
+
+
+#define HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,N,func,ret,array_list,dynamic_arg_list,arg_list) \
+static ::NS::Dynamic __##class##func(::hxNS::Object *inObj, const Array< ::NS::Dynamic> &inArgs) \
+{ \
+      ret reinterpret_cast<class *>(inObj)->func(array_list); return  ::NS::Dynamic(); \
+}; \
+ ::NS::Dynamic class::func##_dyn() \
+{\
+   return ::hxNS::CreateMemberFunctionVar(#func,this,__##class##func,N); \
+}
+
+
+#define DELEGATE_0(ret,func) ret func() { return mDelegate->func(); }
+#define CDELEGATE_0(ret,func) ret func() const { return mDelegate->func(); }
+#define DELEGATE_1(ret,func,arg1) ret func(arg1 _a1) { return mDelegate->func(_a1); }
+#define CDELEGATE_1(ret,func,arg1) ret func(arg1 _a1) const { return mDelegate->func(_a1); }
+#define DELEGATE_2(ret,func,arg1,arg2) ret func(arg1 _a1,arg2 _a2) { return mDelegate->func(_a1,_a2); }
+
+
+
+
+
+#define HX_DECLARE_DYNAMIC_FUNC(func,dynamic_arg_list) \
+    ::NS::Dynamic func##_dyn(dynamic_arg_list);
+
+#define STATIC_HX_DECLARE_DYNAMIC_FUNC(func,dynamic_arg_list) \
+   static  ::NS::Dynamic func##_dyn(dynamic_arg_list);
+
+
+::foreach PARAMS::
+::if (ARG>0)::::if (ARG<6)::
+#define HX_DEFINE_DYNAMIC_FUNC::ARG::(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC(class,::ARG::,func,ret,HX_ARR_LIST::ARG::,HX_DYNAMIC_ARG_LIST::ARG::,HX_ARG_LIST::ARG::)
+::else::
+#define HX_DEFINE_DYNAMIC_FUNC::ARG::(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,::ARG::,func,ret,HX_ARR_LIST::ARG::,HX_DYNAMIC_ARG_LIST::ARG::,HX_ARG_LIST::ARG::)
+::end::
+::end::::end::
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC0(class,func,ret) \
+static ::NS::Dynamic __##class##func() \
+{ \
+      ret class::func(); return  ::NS::Dynamic(); \
+}; \
+ ::NS::Dynamic class::func##_dyn() \
+{\
+   return ::hxNS::CreateStaticFunction0(#func,__##class##func); \
+}
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC(class,N,func,ret,array_list,dynamic_arg_list,arg_list) \
+static ::NS::Dynamic __##class##func(dynamic_arg_list) \
+{ \
+      ret class::func(arg_list); return  ::NS::Dynamic(); \
+}; \
+ ::NS::Dynamic class::func##_dyn() \
+{\
+   return ::hxNS::CreateStaticFunction##N(#func,__##class##func); \
+}
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,N,func,ret,array_list,dynamic_arg_list,arg_list) \
+static ::NS::Dynamic __##class##func(const Array< ::NS::Dynamic> &inArgs) \
+{ \
+      ret class::func(array_list); return  ::NS::Dynamic(); \
+}; \
+ ::NS::Dynamic class::func##_dyn() \
+{\
+   return ::hxNS::CreateStaticFunctionVar(#func,__##class##func,N); \
+}
+
+
+
+::foreach PARAMS::
+::if (ARG>0)::::if (ARG<6)::
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC::ARG::(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC(class,::ARG::,func,ret,HX_ARR_LIST::ARG::,HX_DYNAMIC_ARG_LIST::ARG::,HX_ARG_LIST::ARG::)
+::else::
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC::ARG::(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,::ARG::,func,ret,HX_ARR_LIST::ARG::,HX_DYNAMIC_ARG_LIST::ARG::,HX_ARG_LIST::ARG::)
+::end::
+::end::::end::
+
+
+#define HX_DYNAMIC_CALL(ret,func,array_args,dyn_arg_list,arg_list) \
+    ::NS::Dynamic __Run(const Array< ::NS::Dynamic> &inArgs) { ret func( array_args ); return null();} \
+    ::NS::Dynamic __run(dyn_arg_list) { ret func( arg_list ); return null();}
+
+::foreach PARAMS::
+#define HX_DYNAMIC_CALL::ARG::(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST::ARG::,HX_DYNAMIC_ARG_LIST::ARG::,HX_ARG_LIST::ARG::)::end::
+
+#define HX_BEGIN_DEFAULT_FUNC(name,t0) \
+	namespace { \
+   struct name : public ::hxNS::Object { int __GetType() const { return vtFunction; } \
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = ::hxNS::clsIdClosure }; \
+   ::hxNS::ObjectPtr<t0> __this; \
+   name(::hxNS::ObjectPtr<t0> __0 = null()) : __this(__0) {} \
+   void __Mark(::hxNS::MarkContext *__inCtx) { HX_MARK_MEMBER(__this); } \
+   void __Visit(::hxNS::VisitContext *__inCtx) { HX_VISIT_MEMBER(__this); }
+
+
+#define HX_END_DEFAULT_FUNC \
+}
+
+#define HXARGC(x) int __ArgCount() const { return x; }
+
+#define HX_BEGIN_LOCAL_FUNC_S0(SUPER,name) \
+   struct name : public SUPER { \
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = ::hxNS::clsIdClosure }; \
+   void __Mark(::hxNS::MarkContext *__inCtx) { DoMarkThis(__inCtx); } \
+   void __Visit(::hxNS::VisitContext *__inCtx) { DoVisitThis(__inCtx); } \
+   name() {}
+
+::foreach LOCALS::
+#define HX_BEGIN_LOCAL_FUNC_S::ARG::(SUPER,name,::TYPE_ARGS::) \
+   struct name : public SUPER { \
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = ::hxNS::clsIdClosure }; \
+   ::TYPE_DECL::; \
+   void __Mark(::hxNS::MarkContext *__inCtx) { DoMarkThis(__inCtx); ::MARKS:: } \
+   void __Visit(::hxNS::VisitContext *__inCtx) { DoVisitThis(__inCtx); ::VISITS:: } \
+   name(::CONSTRUCT_ARGS::) : ::CONSTRUCT_VARS:: {}::end::
+
+#if (HXCPP_API_LEVEL>=330)
+  #define HX_LOCAL_RUN _hx_run
+#else
+  #define HX_LOCAL_RUN run
+#endif
+
+#define HX_END_LOCAL_FUNC0(ret) HX_DYNAMIC_CALL0(ret, HX_LOCAL_RUN ) };
+::foreach LOCALS::
+#define HX_END_LOCAL_FUNC::ARG::(ret) HX_DYNAMIC_CALL::ARG::(ret, HX_LOCAL_RUN ) };::end::
+
+// For compatibility until next version of haxe is released
+#define HX_BEGIN_LOCAL_FUNC0(name) \
+      HX_BEGIN_LOCAL_FUNC_S0(::hxNS::LocalFunc,name)
+::foreach LOCALS::
+#define HX_BEGIN_LOCAL_FUNC::ARG::(name,::TYPE_ARGS::) \
+      HX_BEGIN_LOCAL_FUNC_S::ARG::(::hxNS::LocalFunc,name,::TYPE_ARGS::)::end::
+
+
+#define HX_DECLARE_DYNAMIC_FUNCTIONS \
+::foreach PARAMS:: ::if (ARG<6)::::else::  ::NS::Dynamic operator()(::DYNAMIC_ARG_LIST::); \
+::end:: ::end::
+
+
+#define HX_DECLARE_VARIANT_FUNCTIONS \
+::foreach PARAMS:: ::if (ARG<6):: inline  ::NS::Dynamic operator()(::DYNAMIC_ARG_LIST::); \
+::else::  ::NS::Dynamic operator()(::DYNAMIC_ARG_LIST::); \
+::end:: ::end::
+
+
+#define HX_IMPLEMENT_INLINE_VARIANT_FUNCTIONS \
+::foreach PARAMS:: ::if (ARG<6):: ::NS::Dynamic Variant::NS::operator()(::DYNAMIC_ARG_LIST::) { CheckFPtr(); return valObject->__run(::ARG_LIST::); } \
+::end:: ::end::
+
+
+#endif
+
+

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/MacrosFixed.h

@@ -0,0 +1,355 @@
+#ifndef MACROS_FIXED_H
+#define MACROS_FIXED_H
+
+// ---- Forward Declare ---------------
+
+
+#define HX_DECLARE_CLASS0(klass) \
+	class klass##_obj; \
+	typedef ::hx::ObjectPtr<klass##_obj> klass;
+#define HX_DECLARE_CLASS1(ns1,klass) namespace ns1 { HX_DECLARE_CLASS0(klass) }
+#define HX_DECLARE_CLASS2(ns2,ns1,klass) namespace ns2 { HX_DECLARE_CLASS1(ns1,klass) }
+#define HX_DECLARE_CLASS3(ns3,ns2,ns1,klass) namespace ns3 { HX_DECLARE_CLASS2(ns2,ns1,klass) }
+#define HX_DECLARE_CLASS4(ns4,ns3,ns2,ns1,klass) namespace ns4 { HX_DECLARE_CLASS3(ns3,ns2,ns1,klass) }
+#define HX_DECLARE_CLASS5(ns5,ns4,ns3,ns2,ns1,klass) namespace ns5 { HX_DECLARE_CLASS4(ns4,ns3,ns2,ns1,klass) }
+#define HX_DECLARE_CLASS6(ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns6 { HX_DECLARE_CLASS5(ns5,ns4,ns3,ns2,ns1,klass) }
+#define HX_DECLARE_CLASS7(ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns7 { HX_DECLARE_CLASS6(ns6,ns5,ns4,ns3,ns2,ns1,klass) }
+#define HX_DECLARE_CLASS8(ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns8 { HX_DECLARE_CLASS7(ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
+#define HX_DECLARE_CLASS9(ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns9 { HX_DECLARE_CLASS8(ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
+#define HX_DECLARE_CLASS10(ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns10 { HX_DECLARE_CLASS9(ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
+#define HX_DECLARE_CLASS11(ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns11 { HX_DECLARE_CLASS10(ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
+#define HX_DECLARE_CLASS12(ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns12 { HX_DECLARE_CLASS11(ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
+#define HX_DECLARE_CLASS13(ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns13 { HX_DECLARE_CLASS12(ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
+#define HX_DECLARE_CLASS14(ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns14 { HX_DECLARE_CLASS13(ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
+#define HX_DECLARE_CLASS15(ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns15 { HX_DECLARE_CLASS14(ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
+#define HX_DECLARE_CLASS16(ns16,ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns16 { HX_DECLARE_CLASS15(ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
+#define HX_DECLARE_CLASS17(ns17,ns16,ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns17 { HX_DECLARE_CLASS16(ns16,ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
+#define HX_DECLARE_CLASS18(ns18,ns17,ns16,ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns18 { HX_DECLARE_CLASS17(ns17,ns16,ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
+#define HX_DECLARE_CLASS19(ns19,ns18,ns17,ns16,ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns19 { HX_DECLARE_CLASS18(ns18,ns17,ns16,ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
+#define HX_DECLARE_CLASS20(ns20,ns19,ns18,ns17,ns16,ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns20 { HX_DECLARE_CLASS19(ns19,ns18,ns17,ns16,ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
+
+// ---- Enum ----------------------
+
+#if (HXCPP_API_LEVEL >= 330)
+
+#define HX_DEFINE_CREATE_ENUM(enum_obj) \
+static  ::Dynamic Create##enum_obj(::String inName,::hx::DynamicArray inArgs) \
+{ \
+   int count =  enum_obj::__FindArgCount(inName); \
+   int args = inArgs.GetPtr() ? inArgs.__length() : 0; \
+   if (args!=count) __hxcpp_dbg_checkedThrow(HX_INVALID_ENUM_ARG_COUNT(#enum_obj, inName, count, args)); \
+   ::Dynamic result; \
+   if (!enum_obj::__GetStatic(inName,result,::hx::paccDynamic)) __hxcpp_dbg_checkedThrow(HX_INVALID_ENUM_CONSTRUCTOR(#enum_obj, inName)); \
+   if (args==0) return result; \
+   return result->__Run(inArgs); \
+}
+
+
+#else
+
+#define HX_DEFINE_CREATE_ENUM(enum_obj) \
+static  ::Dynamic Create##enum_obj(::String inName,::hx::DynamicArray inArgs) \
+{ \
+   int idx =  enum_obj::__FindIndex(inName); \
+   if (idx<0) __hxcpp_dbg_checkedThrow(HX_INVALID_ENUM_CONSTRUCTOR(#enum_obj, inName)); \
+   int count =  enum_obj::__FindArgCount(inName); \
+   int args = inArgs.GetPtr() ? inArgs.__length() : 0; \
+   if (args!=count) __hxcpp_dbg_checkedThrow(HX_INVALID_ENUM_ARG_COUNT(#enum_obj, inName, count, args)); \
+   ::Dynamic result =(new enum_obj())->__Field(inName,HX_PROP_DYNAMIC); \
+   if (args==0 || !result.mPtr) return result; \
+   return result->__Run(inArgs); \
+}
+
+#endif
+
+
+// ---- Fields ----------------------
+
+#if (HXCPP_API_LEVEL<331)
+   #define HX_DO_RTTI_BASE \
+      bool __Is(::hx::Object *inObj) const { return dynamic_cast<OBJ_ *>(inObj)!=0; }
+#else
+   #define HX_DO_RTTI_BASE
+#endif
+
+#if (HXCPP_API_LEVEL>331)
+   #define HX_IS_INSTANCE_OF bool _hx_isInstanceOf(int inClassId) { return inClassId==1 || inClassId==(int)_hx_ClassId; }
+#else
+   #define HX_IS_INSTANCE_OF
+#endif
+
+
+#define HX_DO_RTTI_ALL \
+   HX_DO_RTTI_BASE \
+   static ::hx::ObjectPtr< ::hx::Class_obj> __mClass; \
+   ::hx::ObjectPtr< ::hx::Class_obj > __GetClass() const { return __mClass; } \
+   inline static ::hx::ObjectPtr< ::hx::Class_obj> &__SGetClass() { return __mClass; } \
+   inline operator super *() { return this; }
+
+#define HX_DO_RTTI \
+   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);
+
+#define HX_DO_INTERFACE_RTTI \
+   static ::hx::ObjectPtr< ::hx::Class_obj> __mClass; \
+   static ::hx::ObjectPtr< ::hx::Class_obj> &__SGetClass() { return __mClass; } \
+	static void __register();
+
+#define HX_DO_ENUM_RTTI_INTERNAL \
+   HX_DO_RTTI_BASE  \
+    ::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp); \
+   static int __FindIndex(::String inName); \
+   static int __FindArgCount(::String inName);
+
+#define HX_DO_ENUM_RTTI \
+   HX_DO_ENUM_RTTI_INTERNAL \
+   static ::hx::ObjectPtr< ::hx::Class_obj> __mClass; \
+   ::hx::ObjectPtr< ::hx::Class_obj > __GetClass() const { return __mClass; } \
+   static ::hx::ObjectPtr< ::hx::Class_obj> &__SGetClass() { return __mClass; }
+
+
+#define HX_DECLARE_IMPLEMENT_DYNAMIC   ::Dynamic __mDynamicFields; \
+     ::Dynamic *__GetFieldMap() { return &__mDynamicFields; } \
+    bool __HasField(const String &inString) \
+      { return ::hx::FieldMapHas(&__mDynamicFields,inString) || super::__HasField(inString); }
+
+
+#define HX_INIT_IMPLEMENT_DYNAMIC
+
+#define HX_MARK_DYNAMIC HX_MARK_MEMBER(__mDynamicFields)
+
+
+#ifdef HX_VISIT_ALLOCS
+
+#define HX_VISIT_DYNAMIC HX_VISIT_MEMBER(__mDynamicFields);
+
+#else
+
+#define HX_VISIT_DYNAMIC do { } while (0);
+
+#endif
+
+#define HX_CHECK_DYNAMIC_GET_FIELD(inName) \
+   {  ::Dynamic d;  if (::hx::FieldMapGet(&__mDynamicFields,inName,d)) return d; }
+
+#define HX_CHECK_DYNAMIC_GET_INT_FIELD(inID) \
+   {  ::Dynamic d;  if (::hx::FieldMapGet(&__mDynamicFields,inID,d)) return d; }
+
+#ifdef HXCPP_GC_GENERATIONAL
+#define HX_DYNAMIC_SET_FIELD(inName,inValue) ::hx::FieldMapSet(this,&__mDynamicFields,inName,inValue)
+#else
+#define HX_DYNAMIC_SET_FIELD(inName,inValue) ::hx::FieldMapSet(&__mDynamicFields,inName,inValue)
+#endif
+
+#define HX_APPEND_DYNAMIC_FIELDS(outFields) ::hx::FieldMapAppendFields(&__mDynamicFields,outFields)
+
+
+
+
+
+
+// ---- Main ---------------
+
+
+namespace hx {
+HXCPP_EXTERN_CLASS_ATTRIBUTES void SetTopOfStack(int *inTopOfStack,bool);
+}
+#define HX_TOP_OF_STACK \
+		int t0 = 99; \
+		::hx::SetTopOfStack(&t0,false);
+
+
+#ifdef __GNUC__
+ #define EXPORT_EXTRA __attribute__ ((visibility("default")))
+#else
+ #define EXPORT_EXTRA __declspec(dllexport)
+#endif
+
+#ifdef HX_DECLARE_MAIN
+
+#ifdef HXCPP_DLL_IMPORT
+
+#define HX_BEGIN_MAIN \
+   extern "C" { \
+   EXPORT_EXTRA void __main__() { \
+	__boot_all();
+
+#define HX_END_MAIN \
+} \
+}
+
+
+#elif defined(HX_ANDROID)
+  #ifdef HXCPP_EXE_LINK
+   #define HX_BEGIN_MAIN \
+   \
+   int main(int argc,char **argv){ \
+      HX_TOP_OF_STACK \
+      ::hx::Boot(); \
+      try{ \
+         __boot_all();
+
+   #define HX_END_MAIN \
+      } \
+      catch ( ::Dynamic e){ \
+         __hx_dump_stack(); \
+         printf("Error : %s\n",e->toString().__CStr()); \
+         return -1; \
+      } \
+      return 0; \
+   }
+
+  #else
+   // Java Main....
+   #include <jni.h>
+   #include <hx/Thread.h>
+   #include <android/log.h>
+
+   #define HX_BEGIN_MAIN \
+   extern "C" EXPORT_EXTRA void hxcpp_main() { \
+      HX_TOP_OF_STACK \
+           try { \
+      ::hx::Boot(); \
+      __boot_all();
+
+
+   #define HX_END_MAIN \
+           } catch ( ::Dynamic e) { \
+        __hx_dump_stack(); \
+             __android_log_print(ANDROID_LOG_ERROR, "Exception", "%s", e->toString().__CStr()); \
+           }\
+      ::hx::SetTopOfStack((int *)0,true); \
+   } \
+   \
+   extern "C" EXPORT_EXTRA JNIEXPORT void JNICALL Java_org_haxe_HXCPP_main(JNIEnv * env) \
+   { hxcpp_main(); }
+  #endif
+
+#elif defined(HX_WINRT)
+
+#include <Roapi.h>
+
+#define HX_BEGIN_MAIN \
+[ Platform::MTAThread ] \
+int main(Platform::Array<Platform::String^>^) \
+{ \
+   HX_TOP_OF_STACK \
+   RoInitialize(RO_INIT_MULTITHREADED); \
+   ::hx::Boot(); \
+   try{ \
+      __boot_all();
+
+#define HX_END_MAIN \
+   } \
+   catch ( ::Dynamic e){ \
+      __hx_dump_stack(); \
+      return -1; \
+   } \
+   return 0; \
+}
+
+#elif defined(HX_WIN_MAIN)
+
+
+#ifdef HAVE_WINDOWS_H
+
+#define HX_BEGIN_MAIN \
+int __stdcall WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) \
+{ \
+	HX_TOP_OF_STACK \
+	::hx::Boot(); \
+	try{ \
+		__boot_all();
+
+#else
+
+#define HX_BEGIN_MAIN \
+extern "C" int __stdcall MessageBoxA(void *,const char *,const char *,int); \
+\
+int __stdcall WinMain( void * hInstance, void * hPrevInstance, const char *lpCmdLine, int nCmdShow) \
+{ \
+	HX_TOP_OF_STACK \
+	::hx::Boot(); \
+	try{ \
+		__boot_all();
+
+#endif
+
+#define HX_END_MAIN \
+	} \
+	catch ( ::Dynamic e){ \
+		__hx_dump_stack(); \
+		MessageBoxA(0,  e->toString().__CStr(), "Error", 0); \
+      return -1; \
+	} \
+	return 0; \
+}
+
+
+#elif defined(TIZEN)
+
+
+#define HX_BEGIN_MAIN \
+\
+extern "C" EXPORT_EXTRA int OspMain (int argc, char* pArgv[]){ \
+        HX_TOP_OF_STACK \
+        ::hx::Boot(); \
+        try{ \
+                __boot_all();
+
+#define HX_END_MAIN \
+        } \
+        catch ( ::Dynamic e){ \
+                __hx_dump_stack(); \
+                printf("Error : %s\n",e->toString().__CStr()); \
+                return -1; \
+        } \
+        return 0; \
+}
+
+
+#else
+// Console Main ...
+
+#define HX_BEGIN_MAIN \
+\
+int main(int argc,char **argv){ \
+	HX_TOP_OF_STACK \
+	::hx::Boot(); \
+	try{ \
+		__boot_all();
+
+#define HX_END_MAIN \
+	} \
+	catch ( ::Dynamic e){ \
+		__hx_dump_stack(); \
+		printf("Error : %s\n",e->toString().__CStr()); \
+      return -1; \
+	} \
+	return 0; \
+}
+
+#endif
+
+#endif // HX_DECLARE_MAIN
+
+// Run as library
+#define HX_BEGIN_LIB_MAIN \
+extern "C" {\
+\
+void __hxcpp_lib_main() \
+{ \
+	HX_TOP_OF_STACK \
+	::hx::Boot(); \
+	__boot_all();
+
+#define HX_END_LIB_MAIN \
+} }
+
+
+
+#endif
+
+

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/MacrosJumbo.h

@@ -0,0 +1,406 @@
+//   ##  ##  ##   ##   ####   ##  ## ## ##  ##  ####    ##
+//   ##  ##  ## ##  ## ##  ## ### ## ## ### ## ##       ##
+//    ## ## ##  ###### ###### ###### ## ###### ## ###   ##
+//    ## ## ##  ##  ## ## ##  ## ### ## ## ### ##  ##     
+//     ## ##    ##  ## ##  ## ##  ## ## ##  ##  ####    ##
+
+// DO NOT EDIT
+// This file is generated from the .tpl file
+#ifndef HX_MACROS_JUMBO_H
+#define HX_MACROS_JUMBO_H
+
+
+#define HX_BEGIN_LOCAL_FUNC_S20(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19) {}
+#define HX_BEGIN_LOCAL_FUNC_S21(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20) {}
+#define HX_BEGIN_LOCAL_FUNC_S22(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21) {}
+#define HX_BEGIN_LOCAL_FUNC_S23(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22) {}
+#define HX_BEGIN_LOCAL_FUNC_S24(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23) {}
+#define HX_BEGIN_LOCAL_FUNC_S25(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24) {}
+#define HX_BEGIN_LOCAL_FUNC_S26(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25) {}
+#define HX_BEGIN_LOCAL_FUNC_S27(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26) {}
+#define HX_BEGIN_LOCAL_FUNC_S28(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27) {}
+#define HX_BEGIN_LOCAL_FUNC_S29(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28) {}
+#define HX_BEGIN_LOCAL_FUNC_S30(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29) {}
+#define HX_BEGIN_LOCAL_FUNC_S31(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30) {}
+#define HX_BEGIN_LOCAL_FUNC_S32(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31) {}
+#define HX_BEGIN_LOCAL_FUNC_S33(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32) {}
+#define HX_BEGIN_LOCAL_FUNC_S34(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33) {}
+#define HX_BEGIN_LOCAL_FUNC_S35(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34) {}
+#define HX_BEGIN_LOCAL_FUNC_S36(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35) {}
+#define HX_BEGIN_LOCAL_FUNC_S37(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36) {}
+#define HX_BEGIN_LOCAL_FUNC_S38(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37) {}
+#define HX_BEGIN_LOCAL_FUNC_S39(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38) {}
+#define HX_BEGIN_LOCAL_FUNC_S40(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39) {}
+#define HX_BEGIN_LOCAL_FUNC_S41(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40) {}
+#define HX_BEGIN_LOCAL_FUNC_S42(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41) {}
+#define HX_BEGIN_LOCAL_FUNC_S43(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42) {}
+#define HX_BEGIN_LOCAL_FUNC_S44(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43) {}
+#define HX_BEGIN_LOCAL_FUNC_S45(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44) {}
+#define HX_BEGIN_LOCAL_FUNC_S46(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45) {}
+#define HX_BEGIN_LOCAL_FUNC_S47(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46) {}
+#define HX_BEGIN_LOCAL_FUNC_S48(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47) {}
+#define HX_BEGIN_LOCAL_FUNC_S49(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48) {}
+#define HX_BEGIN_LOCAL_FUNC_S50(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49) {}
+#define HX_BEGIN_LOCAL_FUNC_S51(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50) {}
+#define HX_BEGIN_LOCAL_FUNC_S52(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51) {}
+#define HX_BEGIN_LOCAL_FUNC_S53(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51;t52 v52; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); HX_MARK_MEMBER(v52); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); HX_VISIT_MEMBER(v52); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51,t52 __52) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51),v52(__52) {}
+#define HX_BEGIN_LOCAL_FUNC_S54(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51;t52 v52;t53 v53; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); HX_MARK_MEMBER(v52); HX_MARK_MEMBER(v53); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); HX_VISIT_MEMBER(v52); HX_VISIT_MEMBER(v53); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51,t52 __52,t53 __53) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51),v52(__52),v53(__53) {}
+#define HX_BEGIN_LOCAL_FUNC_S55(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51;t52 v52;t53 v53;t54 v54; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); HX_MARK_MEMBER(v52); HX_MARK_MEMBER(v53); HX_MARK_MEMBER(v54); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); HX_VISIT_MEMBER(v52); HX_VISIT_MEMBER(v53); HX_VISIT_MEMBER(v54); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51,t52 __52,t53 __53,t54 __54) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51),v52(__52),v53(__53),v54(__54) {}
+#define HX_BEGIN_LOCAL_FUNC_S56(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51;t52 v52;t53 v53;t54 v54;t55 v55; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); HX_MARK_MEMBER(v52); HX_MARK_MEMBER(v53); HX_MARK_MEMBER(v54); HX_MARK_MEMBER(v55); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); HX_VISIT_MEMBER(v52); HX_VISIT_MEMBER(v53); HX_VISIT_MEMBER(v54); HX_VISIT_MEMBER(v55); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51,t52 __52,t53 __53,t54 __54,t55 __55) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51),v52(__52),v53(__53),v54(__54),v55(__55) {}
+#define HX_BEGIN_LOCAL_FUNC_S57(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51;t52 v52;t53 v53;t54 v54;t55 v55;t56 v56; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); HX_MARK_MEMBER(v52); HX_MARK_MEMBER(v53); HX_MARK_MEMBER(v54); HX_MARK_MEMBER(v55); HX_MARK_MEMBER(v56); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); HX_VISIT_MEMBER(v52); HX_VISIT_MEMBER(v53); HX_VISIT_MEMBER(v54); HX_VISIT_MEMBER(v55); HX_VISIT_MEMBER(v56); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51,t52 __52,t53 __53,t54 __54,t55 __55,t56 __56) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51),v52(__52),v53(__53),v54(__54),v55(__55),v56(__56) {}
+#define HX_BEGIN_LOCAL_FUNC_S58(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51;t52 v52;t53 v53;t54 v54;t55 v55;t56 v56;t57 v57; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); HX_MARK_MEMBER(v52); HX_MARK_MEMBER(v53); HX_MARK_MEMBER(v54); HX_MARK_MEMBER(v55); HX_MARK_MEMBER(v56); HX_MARK_MEMBER(v57); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); HX_VISIT_MEMBER(v52); HX_VISIT_MEMBER(v53); HX_VISIT_MEMBER(v54); HX_VISIT_MEMBER(v55); HX_VISIT_MEMBER(v56); HX_VISIT_MEMBER(v57); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51,t52 __52,t53 __53,t54 __54,t55 __55,t56 __56,t57 __57) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51),v52(__52),v53(__53),v54(__54),v55(__55),v56(__56),v57(__57) {}
+#define HX_BEGIN_LOCAL_FUNC_S59(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57,t58,v58) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51;t52 v52;t53 v53;t54 v54;t55 v55;t56 v56;t57 v57;t58 v58; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); HX_MARK_MEMBER(v52); HX_MARK_MEMBER(v53); HX_MARK_MEMBER(v54); HX_MARK_MEMBER(v55); HX_MARK_MEMBER(v56); HX_MARK_MEMBER(v57); HX_MARK_MEMBER(v58); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); HX_VISIT_MEMBER(v52); HX_VISIT_MEMBER(v53); HX_VISIT_MEMBER(v54); HX_VISIT_MEMBER(v55); HX_VISIT_MEMBER(v56); HX_VISIT_MEMBER(v57); HX_VISIT_MEMBER(v58); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51,t52 __52,t53 __53,t54 __54,t55 __55,t56 __56,t57 __57,t58 __58) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51),v52(__52),v53(__53),v54(__54),v55(__55),v56(__56),v57(__57),v58(__58) {}
+#define HX_BEGIN_LOCAL_FUNC_S60(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57,t58,v58,t59,v59) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51;t52 v52;t53 v53;t54 v54;t55 v55;t56 v56;t57 v57;t58 v58;t59 v59; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); HX_MARK_MEMBER(v52); HX_MARK_MEMBER(v53); HX_MARK_MEMBER(v54); HX_MARK_MEMBER(v55); HX_MARK_MEMBER(v56); HX_MARK_MEMBER(v57); HX_MARK_MEMBER(v58); HX_MARK_MEMBER(v59); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); HX_VISIT_MEMBER(v52); HX_VISIT_MEMBER(v53); HX_VISIT_MEMBER(v54); HX_VISIT_MEMBER(v55); HX_VISIT_MEMBER(v56); HX_VISIT_MEMBER(v57); HX_VISIT_MEMBER(v58); HX_VISIT_MEMBER(v59); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51,t52 __52,t53 __53,t54 __54,t55 __55,t56 __56,t57 __57,t58 __58,t59 __59) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51),v52(__52),v53(__53),v54(__54),v55(__55),v56(__56),v57(__57),v58(__58),v59(__59) {}
+#define HX_BEGIN_LOCAL_FUNC_S61(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57,t58,v58,t59,v59,t60,v60) \
+   struct name : public SUPER { \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51;t52 v52;t53 v53;t54 v54;t55 v55;t56 v56;t57 v57;t58 v58;t59 v59;t60 v60; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); HX_MARK_MEMBER(v52); HX_MARK_MEMBER(v53); HX_MARK_MEMBER(v54); HX_MARK_MEMBER(v55); HX_MARK_MEMBER(v56); HX_MARK_MEMBER(v57); HX_MARK_MEMBER(v58); HX_MARK_MEMBER(v59); HX_MARK_MEMBER(v60); } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); HX_VISIT_MEMBER(v52); HX_VISIT_MEMBER(v53); HX_VISIT_MEMBER(v54); HX_VISIT_MEMBER(v55); HX_VISIT_MEMBER(v56); HX_VISIT_MEMBER(v57); HX_VISIT_MEMBER(v58); HX_VISIT_MEMBER(v59); HX_VISIT_MEMBER(v60); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51,t52 __52,t53 __53,t54 __54,t55 __55,t56 __56,t57 __57,t58 __58,t59 __59,t60 __60) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51),v52(__52),v53(__53),v54(__54),v55(__55),v56(__56),v57(__57),v58(__58),v59(__59),v60(__60) {}
+
+#if (HXCPP_API_LEVEL>=330)
+  #define HX_LOCAL_RUN _hx_run
+#else
+  #define HX_LOCAL_RUN run
+#endif
+
+
+#define HX_END_LOCAL_FUNC20(ret) HX_DYNAMIC_CALL20(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC21(ret) HX_DYNAMIC_CALL21(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC22(ret) HX_DYNAMIC_CALL22(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC23(ret) HX_DYNAMIC_CALL23(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC24(ret) HX_DYNAMIC_CALL24(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC25(ret) HX_DYNAMIC_CALL25(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC26(ret) HX_DYNAMIC_CALL26(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC27(ret) HX_DYNAMIC_CALL27(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC28(ret) HX_DYNAMIC_CALL28(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC29(ret) HX_DYNAMIC_CALL29(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC30(ret) HX_DYNAMIC_CALL30(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC31(ret) HX_DYNAMIC_CALL31(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC32(ret) HX_DYNAMIC_CALL32(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC33(ret) HX_DYNAMIC_CALL33(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC34(ret) HX_DYNAMIC_CALL34(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC35(ret) HX_DYNAMIC_CALL35(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC36(ret) HX_DYNAMIC_CALL36(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC37(ret) HX_DYNAMIC_CALL37(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC38(ret) HX_DYNAMIC_CALL38(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC39(ret) HX_DYNAMIC_CALL39(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC40(ret) HX_DYNAMIC_CALL40(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC41(ret) HX_DYNAMIC_CALL41(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC42(ret) HX_DYNAMIC_CALL42(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC43(ret) HX_DYNAMIC_CALL43(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC44(ret) HX_DYNAMIC_CALL44(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC45(ret) HX_DYNAMIC_CALL45(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC46(ret) HX_DYNAMIC_CALL46(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC47(ret) HX_DYNAMIC_CALL47(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC48(ret) HX_DYNAMIC_CALL48(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC49(ret) HX_DYNAMIC_CALL49(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC50(ret) HX_DYNAMIC_CALL50(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC51(ret) HX_DYNAMIC_CALL51(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC52(ret) HX_DYNAMIC_CALL52(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC53(ret) HX_DYNAMIC_CALL53(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC54(ret) HX_DYNAMIC_CALL54(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC55(ret) HX_DYNAMIC_CALL55(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC56(ret) HX_DYNAMIC_CALL56(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC57(ret) HX_DYNAMIC_CALL57(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC58(ret) HX_DYNAMIC_CALL58(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC59(ret) HX_DYNAMIC_CALL59(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC60(ret) HX_DYNAMIC_CALL60(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC61(ret) HX_DYNAMIC_CALL61(ret, HX_LOCAL_RUN ) };
+
+// For compatibility until next version of haxe is released
+
+#define HX_BEGIN_LOCAL_FUNC20(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19) \
+      HX_BEGIN_LOCAL_FUNC_S20(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19)
+#define HX_BEGIN_LOCAL_FUNC21(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20) \
+      HX_BEGIN_LOCAL_FUNC_S21(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20)
+#define HX_BEGIN_LOCAL_FUNC22(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21) \
+      HX_BEGIN_LOCAL_FUNC_S22(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21)
+#define HX_BEGIN_LOCAL_FUNC23(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22) \
+      HX_BEGIN_LOCAL_FUNC_S23(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22)
+#define HX_BEGIN_LOCAL_FUNC24(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23) \
+      HX_BEGIN_LOCAL_FUNC_S24(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23)
+#define HX_BEGIN_LOCAL_FUNC25(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24) \
+      HX_BEGIN_LOCAL_FUNC_S25(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24)
+#define HX_BEGIN_LOCAL_FUNC26(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25) \
+      HX_BEGIN_LOCAL_FUNC_S26(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25)
+#define HX_BEGIN_LOCAL_FUNC27(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26) \
+      HX_BEGIN_LOCAL_FUNC_S27(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26)
+#define HX_BEGIN_LOCAL_FUNC28(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27) \
+      HX_BEGIN_LOCAL_FUNC_S28(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27)
+#define HX_BEGIN_LOCAL_FUNC29(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28) \
+      HX_BEGIN_LOCAL_FUNC_S29(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28)
+#define HX_BEGIN_LOCAL_FUNC30(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29) \
+      HX_BEGIN_LOCAL_FUNC_S30(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29)
+#define HX_BEGIN_LOCAL_FUNC31(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30) \
+      HX_BEGIN_LOCAL_FUNC_S31(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30)
+#define HX_BEGIN_LOCAL_FUNC32(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31) \
+      HX_BEGIN_LOCAL_FUNC_S32(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31)
+#define HX_BEGIN_LOCAL_FUNC33(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32) \
+      HX_BEGIN_LOCAL_FUNC_S33(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32)
+#define HX_BEGIN_LOCAL_FUNC34(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33) \
+      HX_BEGIN_LOCAL_FUNC_S34(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33)
+#define HX_BEGIN_LOCAL_FUNC35(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34) \
+      HX_BEGIN_LOCAL_FUNC_S35(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34)
+#define HX_BEGIN_LOCAL_FUNC36(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35) \
+      HX_BEGIN_LOCAL_FUNC_S36(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35)
+#define HX_BEGIN_LOCAL_FUNC37(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36) \
+      HX_BEGIN_LOCAL_FUNC_S37(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36)
+#define HX_BEGIN_LOCAL_FUNC38(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37) \
+      HX_BEGIN_LOCAL_FUNC_S38(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37)
+#define HX_BEGIN_LOCAL_FUNC39(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38) \
+      HX_BEGIN_LOCAL_FUNC_S39(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38)
+#define HX_BEGIN_LOCAL_FUNC40(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39) \
+      HX_BEGIN_LOCAL_FUNC_S40(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39)
+#define HX_BEGIN_LOCAL_FUNC41(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40) \
+      HX_BEGIN_LOCAL_FUNC_S41(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40)
+#define HX_BEGIN_LOCAL_FUNC42(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41) \
+      HX_BEGIN_LOCAL_FUNC_S42(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41)
+#define HX_BEGIN_LOCAL_FUNC43(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42) \
+      HX_BEGIN_LOCAL_FUNC_S43(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42)
+#define HX_BEGIN_LOCAL_FUNC44(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43) \
+      HX_BEGIN_LOCAL_FUNC_S44(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43)
+#define HX_BEGIN_LOCAL_FUNC45(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44) \
+      HX_BEGIN_LOCAL_FUNC_S45(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44)
+#define HX_BEGIN_LOCAL_FUNC46(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45) \
+      HX_BEGIN_LOCAL_FUNC_S46(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45)
+#define HX_BEGIN_LOCAL_FUNC47(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46) \
+      HX_BEGIN_LOCAL_FUNC_S47(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46)
+#define HX_BEGIN_LOCAL_FUNC48(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47) \
+      HX_BEGIN_LOCAL_FUNC_S48(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47)
+#define HX_BEGIN_LOCAL_FUNC49(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48) \
+      HX_BEGIN_LOCAL_FUNC_S49(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48)
+#define HX_BEGIN_LOCAL_FUNC50(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49) \
+      HX_BEGIN_LOCAL_FUNC_S50(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49)
+#define HX_BEGIN_LOCAL_FUNC51(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50) \
+      HX_BEGIN_LOCAL_FUNC_S51(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50)
+#define HX_BEGIN_LOCAL_FUNC52(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51) \
+      HX_BEGIN_LOCAL_FUNC_S52(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51)
+#define HX_BEGIN_LOCAL_FUNC53(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52) \
+      HX_BEGIN_LOCAL_FUNC_S53(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52)
+#define HX_BEGIN_LOCAL_FUNC54(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53) \
+      HX_BEGIN_LOCAL_FUNC_S54(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53)
+#define HX_BEGIN_LOCAL_FUNC55(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54) \
+      HX_BEGIN_LOCAL_FUNC_S55(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54)
+#define HX_BEGIN_LOCAL_FUNC56(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55) \
+      HX_BEGIN_LOCAL_FUNC_S56(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55)
+#define HX_BEGIN_LOCAL_FUNC57(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56) \
+      HX_BEGIN_LOCAL_FUNC_S57(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56)
+#define HX_BEGIN_LOCAL_FUNC58(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57) \
+      HX_BEGIN_LOCAL_FUNC_S58(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57)
+#define HX_BEGIN_LOCAL_FUNC59(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57,t58,v58) \
+      HX_BEGIN_LOCAL_FUNC_S59(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57,t58,v58)
+#define HX_BEGIN_LOCAL_FUNC60(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57,t58,v58,t59,v59) \
+      HX_BEGIN_LOCAL_FUNC_S60(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57,t58,v58,t59,v59)
+#define HX_BEGIN_LOCAL_FUNC61(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57,t58,v58,t59,v59,t60,v60) \
+      HX_BEGIN_LOCAL_FUNC_S61(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57,t58,v58,t59,v59,t60,v60)
+
+
+#endif
+
+

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/MacrosJumbo.tpl

@@ -0,0 +1,29 @@
+#ifndef HX_MACROS_JUMBO_H
+#define HX_MACROS_JUMBO_H
+
+::foreach LOCALS::
+#define HX_BEGIN_LOCAL_FUNC_S::ARG::(SUPER,name,::TYPE_ARGS::) \
+   struct name : public SUPER { \
+   ::TYPE_DECL::; \
+   void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); ::MARKS:: } \
+   void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); ::VISITS:: } \
+   name(::CONSTRUCT_ARGS::) : ::CONSTRUCT_VARS:: {}::end::
+
+#if (HXCPP_API_LEVEL>=330)
+  #define HX_LOCAL_RUN _hx_run
+#else
+  #define HX_LOCAL_RUN run
+#endif
+
+::foreach LOCALS::
+#define HX_END_LOCAL_FUNC::ARG::(ret) HX_DYNAMIC_CALL::ARG::(ret, HX_LOCAL_RUN ) };::end::
+
+// For compatibility until next version of haxe is released
+::foreach LOCALS::
+#define HX_BEGIN_LOCAL_FUNC::ARG::(name,::TYPE_ARGS::) \
+      HX_BEGIN_LOCAL_FUNC_S::ARG::(hx::LocalFunc,name,::TYPE_ARGS::)::end::
+
+
+#endif
+
+

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Memory.h

@@ -0,0 +1,32 @@
+#ifdef HX_MEMORY_H_OVERRIDE
+// Users can define their own header to use here, but there is no API
+// compatibility gaurantee for future changes.
+#include HX_MEMORY_H_OVERRIDE
+
+// Todo - special version?
+inline void HxFreeGCBlock(void *p) {
+   HxFree(p);
+}
+
+#else
+
+#ifndef HX_MEMORY_H
+#define HX_MEMORY_H
+
+#include <stdlib.h>
+
+inline void *HxAlloc(size_t size) {
+   return malloc(size);
+}
+
+inline void HxFree(void *p) {
+   free(p);
+}
+
+void *HxAllocGCBlock(size_t size);
+void HxFreeGCBlock(void *p);
+
+
+#endif
+
+#endif

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Native.h

@@ -0,0 +1,183 @@
+#ifndef HX_NATIVE_INCLUDED_H
+#define HX_NATIVE_INCLUDED_H
+/*
+ *
+ This file is in the public domain, and can be freely distributed.
+
+*/
+
+#include <stdio.h>
+
+#ifndef HXCPP_H
+#define HXCPP_H
+typedef double Float;
+typedef void Void;
+
+//typedef int Int;
+//typedef bool Bool;
+
+#ifndef HXCPP_CLASS_ATTRIBUTES
+#define HXCPP_CLASS_ATTRIBUTES
+#endif
+
+#endif
+
+
+
+#define HX_DECLARE_NATIVE0(klass) \
+	class klass;
+#define HX_DECLARE_NATIVE1(ns1,klass) namespace ns1 { HX_DECLARE_NATIVE0(klass) }
+#define HX_DECLARE_NATIVE2(ns2,ns1,klass) namespace ns2 { HX_DECLARE_NATIVE1(ns1,klass) }
+#define HX_DECLARE_NATIVE3(ns3,ns2,ns1,klass) namespace ns3 { HX_DECLARE_NATIVE2(ns2,ns1,klass) }
+#define HX_DECLARE_NATIVE4(ns4,ns3,ns2,ns1,klass) namespace ns4 { HX_DECLARE_NATIVE3(ns3,ns2,ns1,klass) }
+#define HX_DECLARE_NATIVE5(ns5,ns4,ns3,ns2,ns1,klass) namespace ns5 { HX_DECLARE_NATIVE4(ns4,ns3,ns2,ns1,klass) }
+#define HX_DECLARE_NATIVE6(ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns6 { HX_DECLARE_NATIVE5(ns5,ns4,ns3,ns2,ns1,klass) }
+#define HX_DECLARE_NATIVE7(ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns7 { HX_DECLARE_NATIVE6(ns6,ns5,ns4,ns3,ns2,ns1,klass) }
+#define HX_DECLARE_NATIVE8(ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns8 { HX_DECLARE_NATIVE7(ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
+#define HX_DECLARE_NATIVE9(ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns9 { HX_DECLARE_NATIVE8(ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
+
+
+
+
+
+namespace hx
+{
+   class Object;
+
+   class HXCPP_CLASS_ATTRIBUTES NativeInterface
+   {
+      public:
+         virtual hx::Object *__GetRealObject() = 0;
+         void _hx_addRef();
+         void _hx_decRef();
+   };
+
+   template<typename T>
+   class Native
+   {
+      public:
+         T ptr;
+
+         Native () : ptr(0) { }
+         Native (T inPtr) : ptr(inPtr) { }
+         Native (const Native<T> &inNative) : ptr(inNative.ptr) { }
+         #ifdef CPP_VARIANT_ONCE_H
+         Native (const cpp::Variant &inVariant) {
+            hx::Object *obj = inVariant.asObject();
+            ptr = obj  ? (T)inVariant.valObject->__GetHandle() : 0;
+         }
+         #endif
+
+         inline Native &operator=(T inPtr) { ptr=inPtr; return *this; }
+         inline Native &operator=(const Native<T> &inNative) { ptr=inNative.ptr; return *this; }
+         #ifdef HX_NULL_H
+         inline Native &operator=(const ::null &) { ptr=0; return *this; }
+         #endif
+         inline T operator->() const { return ptr; }
+
+         inline operator T() const { return ptr; }
+
+         template<typename O>
+         inline bool operator==(const Native<O> &inOther) const
+            { return ptr == inOther.ptr; }
+         template<typename O>
+         inline bool operator!=(const Native<O> &inOther) const
+            { return ptr != inOther.ptr; }
+
+   };
+
+   HXCPP_CLASS_ATTRIBUTES const char *Init();
+   HXCPP_CLASS_ATTRIBUTES void PushTopOfStack(void *);
+   HXCPP_CLASS_ATTRIBUTES void PopTopOfStack();
+   HXCPP_CLASS_ATTRIBUTES void GcAddOffsetRoot(void *inRoot, int inOffset);
+   HXCPP_CLASS_ATTRIBUTES void GcSetOffsetRoot(void *inRoot, int inOffset);
+   HXCPP_CLASS_ATTRIBUTES void GcRemoveOffsetRoot(void *inRoot);
+   HXCPP_CLASS_ATTRIBUTES int  GcGetThreadAttachedCount();
+
+   class HXCPP_CLASS_ATTRIBUTES NativeAttach
+   {
+      bool isAttached;
+      public:
+         NativeAttach(bool inAttach=true)
+         {
+            isAttached = false;
+            if (inAttach)
+               attach();
+         }
+         ~NativeAttach()
+         {
+            detach();
+         }
+         void attach()
+         {
+            if (!isAttached)
+            {
+               isAttached = true;
+               hx::PushTopOfStack(this);
+            }
+         }
+         void detach()
+         {
+            if (isAttached)
+            {
+               isAttached = false;
+               hx::PopTopOfStack();
+            }
+         }
+   };
+
+   template<typename T>
+   class Ref
+   {
+   public:
+      T ptr;
+
+      Ref() : ptr(0) { }
+      Ref(const T &inT) : ptr(0) { setPtr(inT); }
+      template<typename O>
+      inline Ref(const Native<O> &inNative) : ptr(0) { setPtr(inNative.ptr); }
+      template<typename O>
+      inline Ref(const Ref<O> &inRef) : ptr(0) { setPtr(inRef.ptr); }
+
+      ~Ref() { setPtr(0); }
+      void setPtr(T inPtr)
+      {
+         hx::Object *old = ptr ? ptr->__GetRealObject() : 0;
+         int oldOffset = old ? (int)(size_t)((char *)inPtr - (char *)old) : 0;
+         hx::Object *next = inPtr ? inPtr->__GetRealObject() : 0;
+         int nextOffset = next ? (int)(size_t)((char *)inPtr - (char *)next) : 0;
+
+         ptr = inPtr;
+         if (next)
+         {
+            if (!old)
+               GcAddOffsetRoot(&ptr, nextOffset);
+            else if (oldOffset!=nextOffset)
+               GcSetOffsetRoot(&ptr, nextOffset);
+         }
+         else if (old)
+            GcRemoveOffsetRoot(&ptr);
+      }
+
+      inline Ref &operator=(const T &inPtr) { setPtr(inPtr); return *this; }
+      template<typename O>
+      inline Ref &operator=(const Native<O> &inNative) { setPtr(inNative.ptr); return *this; }
+      template<typename O>
+      inline Ref &operator=(const Ref<O> &inRef) { setPtr(inRef.ptr); return *this; }
+
+      template<typename O>
+      inline bool operator==(const Ref<O> &inOther) const
+            { return ptr == inOther.ptr; }
+      template<typename O>
+      inline bool operator!=(const Ref<O> &inOther) const
+            { return ptr != inOther.ptr; }
+
+      T operator->() { return ptr; }
+   };
+
+   #define HX_NATIVE_IMPLEMENTATION hx::Object *__GetRealObject() { return this; }
+   #define HX_EXTERN_NATIVE_IMPLEMENTATION hx::Object *__GetRealObject() { return 0; }
+}
+
+#endif
+

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/NekoFunc.h

@@ -0,0 +1,118 @@
+#ifndef HX_NEKO_FUNC_H
+#define HX_NEKO_FUNC_H
+
+#define NEKO_VERSION	180
+
+typedef intptr_t int_val;
+
+typedef enum {
+	VAL_INT			= 0xFF,
+	VAL_NULL		= 0,
+	VAL_FLOAT		= 1,
+	VAL_BOOL		= 2,
+	VAL_STRING		= 3,
+	VAL_OBJECT		= 4,
+	VAL_ARRAY		= 5,
+	VAL_FUNCTION	= 6,
+	VAL_ABSTRACT	= 7,
+	VAL_PRIMITIVE	= 6 | 8,
+	VAL_JITFUN		= 6 | 16,
+	VAL_32_BITS		= 0xFFFFFFFF
+} neko_val_type;
+
+struct _neko_value {
+	neko_val_type t;
+};
+
+struct _neko_objtable;
+struct _neko_buffer;
+
+#ifndef HAVE_NEKO_TYPES
+typedef struct _neko_vkind *neko_vkind;
+typedef struct _neko_value *neko_value;
+typedef struct _neko_buffer *neko_buffer;
+#endif
+
+typedef struct _neko_objtable* neko_objtable;
+typedef double tfloat;
+
+typedef void (*finalizer)(neko_value v);
+
+#pragma pack(4)
+typedef struct {
+	neko_val_type t;
+	tfloat f;
+} vfloat;
+#pragma pack()
+
+typedef struct _vobject {
+	neko_val_type t;
+	neko_objtable table;
+	struct _vobject *proto;
+} vobject;
+
+typedef struct {
+	neko_val_type t;
+	int nargs;
+	void *addr;
+	neko_value env;
+	void *module;
+} vfunction;
+
+typedef struct {
+	neko_val_type t;
+	char c;
+} vstring;
+
+typedef struct {
+	neko_val_type t;
+	neko_value ptr;
+} varray;
+
+typedef struct {
+	neko_val_type t;
+	neko_vkind kind;
+	void *data;
+} vabstract;
+
+
+
+#define neko_val_tag(v)			(*(neko_val_type*)(v))
+#define neko_val_is_null(v)		((v) == val_null)
+#define neko_val_is_int(v)		((((int)(int_val)(v)) & 1) != 0)
+#define neko_val_is_number(v)	(neko_val_is_int(v) || neko_val_tag(v) == VAL_FLOAT)
+#define neko_val_is_float(v)		(!neko_val_is_int(v) && neko_val_tag(v) == VAL_FLOAT)
+#define neko_val_is_string(v)	(!neko_val_is_int(v) && (neko_val_tag(v)&7) == VAL_STRING)
+#define neko_val_is_function(v)	(!neko_val_is_int(v) && (neko_val_tag(v)&7) == VAL_FUNCTION)
+#define neko_val_is_object(v)	(!neko_val_is_int(v) && neko_val_tag(v) == VAL_OBJECT)
+#define neko_val_is_array(v)		(!neko_val_is_int(v) && (neko_val_tag(v)&7) == VAL_ARRAY)
+#define neko_val_is_abstract(v)  (!neko_val_is_int(v) && neko_val_tag(v) == VAL_ABSTRACT)
+#define neko_val_is_kind(v,t)	(neko_val_is_abstract(v) && neko_val_kind(v) == (t))
+#define neko_val_check_kind(v,t)	if( !neko_val_is_kind(v,t) ) neko_error();
+#define neko_val_check_function(f,n) if( !neko_val_is_function(f) || (neko_val_fun_nargs(f) != (n) && neko_val_fun_nargs(f) != VAR_ARGS) ) neko_error();
+#define neko_val_check(v,t)		if( !neko_val_is_##t(v) ) neko_error();
+#define neko_val_data(v)			((vabstract*)(v))->data
+#define neko_val_kind(v)			((vabstract*)(v))->kind
+
+#define neko_val_type(v)			(neko_val_is_int(v) ? VAL_INT : (neko_val_tag(v)&7))
+#define neko_val_int(v)			(((int)(int_val)(v)) >> 1)
+#define neko_val_float(v)		(CONV_FLOAT ((vfloat*)(v))->f)
+#define neko_val_bool(v)			((v) == neko_val_true)
+#define neko_val_number(v)		(neko_val_is_int(v)?neko_val_int(v):neko_val_float(v))
+#define neko_val_hdata(v)		((vhash*)neko_val_data(v))
+#define neko_val_string(v)		(&((vstring*)(v))->c)
+#define neko_val_strlen(v)		(neko_val_tag(v) >> 3)
+#define neko_val_set_length(v,l) neko_val_tag(v) = (neko_val_tag(v)&7) | ((l) << 3)
+#define neko_val_set_size		neko_val_set_length
+
+#define neko_val_array_size(v)	(neko_val_tag(v) >> 3)
+#define neko_val_array_ptr(v)	(&((varray*)(v))->ptr)
+#define neko_val_fun_nargs(v)	((vfunction*)(v))->nargs
+#define neko_alloc_int(v)		((neko_value)(int_val)((((int)(v)) << 1) | 1))
+#define neko_alloc_bool(b)		((b)?neko_val_true:neko_val_false)
+
+#define neko_max_array_size		((1 << 29) - 1)
+#define neko_max_string_size		((1 << 29) - 1)
+#define neko_invalid_comparison	0xFE
+
+#endif // HX_NEKO_FUNC_H

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/OS.h

@@ -0,0 +1,100 @@
+#ifndef HX_OS_H
+#define HX_OS_H
+
+// OS FLAGS
+#if defined(_WIN32)
+#	define NEKO_WINDOWS
+#endif
+
+#if defined(__APPLE__) || defined(__MACH__) || defined(macintosh)
+#	define NEKO_MAC
+#endif
+
+#if defined(linux) || defined(__linux__)
+#	define NEKO_LINUX
+#endif
+
+#if defined(__FreeBSD_kernel__)
+#	define NEKO_GNUKBSD
+#endif
+
+#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
+#	define NEKO_BSD
+#endif
+
+// COMPILER/PROCESSOR FLAGS
+#if defined(__GNUC__)
+#	define NEKO_GCC
+#endif
+
+#if defined(_MSC_VER)
+#	define NEKO_VCC
+#endif
+
+#if defined(__MINGW32__)
+#	define NEKO_MINGW
+#endif
+
+#if defined(__i386__) || defined(_WIN32)
+#	define NEKO_X86
+#endif
+
+#if defined(__ppc__)
+#	define NEKO_PPC
+#endif
+
+#if !defined(_64BITS) && (defined(__LP64__) || defined(_LP64))
+#define _64BITS
+#endif
+
+#if defined(_64BITS)
+#	define NEKO_64BITS
+#endif
+
+#if defined(NEKO_LINUX) || defined(NEKO_MAC) || defined(NEKO_BSD) || defined(NEKO_GNUKBSD)
+#	define NEKO_POSIX
+#endif
+
+#if defined(NEKO_GCC)
+#	define NEKO_THREADED
+#	define NEKO_DIRECT_THREADED
+#endif
+
+#include <stddef.h>
+#ifndef NEKO_VCC
+#	include <stdint.h>
+#endif
+
+
+
+
+
+#undef EXPORT
+#undef IMPORT
+#if defined(NEKO_VCC) || defined(NEKO_MINGW)
+#	define INLINE __inline
+#	define EXPORT __declspec( dllexport )
+#	define IMPORT __declspec( dllimport )
+#elif defined (HX_LINUX)
+#	define INLINE inline
+#	define EXPORT __attribute__ ((visibility("default")))
+#	define IMPORT
+#else
+#	define INLINE inline
+#	define EXPORT __attribute__ ((visibility("default")))
+#	define IMPORT
+#endif
+
+#ifdef NEKO_POSIX
+#	include <errno.h>
+#	define POSIX_LABEL(name)	name:
+#	define HANDLE_EINTR(label)	if( errno == EINTR ) goto label
+#	define HANDLE_FINTR(f,label) if( ferror(f) && errno == EINTR ) goto label
+#else
+#	define POSIX_LABEL(name)
+#	define HANDLE_EINTR(label)
+#	define HANDLE_FINTR(f,label)
+#endif
+
+
+#endif

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/ObjcHelpers.h

@@ -0,0 +1,222 @@
+#ifndef HX_OBJC_HELPERS_INCLUDED
+#define HX_OBJC_HELPERS_INCLUDED
+
+
+
+@interface NSHaxeWrapperClass : NSObject {
+  @public hx::Object *haxeObject;
+}
+- (id)init:(hx::Object *) inHaxe;
+- (void)dealloc;
+@end
+
+
+NSDictionary<NSString *, id> *_hx_obj_to_nsdictionary(Dynamic d);
+
+id _hx_value_to_objc(Dynamic d);
+
+
+Dynamic _hx_nsdictionary_to_obj(NSDictionary<NSString *, id> *inDictionary);
+
+Dynamic _hx_objc_to_dynamic(id inValue);
+
+Array<unsigned char> _hx_objc_to_bytes(id value);
+
+
+namespace hx
+{
+
+
+// 0 args
+struct TObjcBlockVoidVoid
+{
+   typedef void (^t)();
+
+   static t create(Dynamic func)
+   {
+      NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
+      t wrap = ^ {
+         wrapper->haxeObject->__run();
+      };
+      return wrap;
+   }
+};
+
+
+template<typename Ret>
+struct TObjcBlockRetVoid
+{
+   typedef Ret (^t)();
+
+   static t create(Dynamic func)
+   {
+      NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
+      t wrap = ^() {
+         return (Ret) wrapper->haxeObject->__run();
+      };
+      return wrap;
+   }
+};
+
+
+// 1 arg
+template<typename Arg0>
+struct TObjcBlockVoidArgs1
+{
+   typedef void (^t)(Arg0 a);
+
+   static t create(Dynamic func)
+   {
+      NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
+      t wrap = ^(Arg0 a0) {
+         wrapper->haxeObject->__run(a0);
+      };
+      return wrap;
+   }
+};
+
+template<typename Ret, typename Arg0>
+struct TObjcBlockRetArgs1
+{
+   typedef Ret (^t)(Arg0 a);
+   inline static t create(Dynamic func)
+   {
+      NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
+      t wrap = ^(Arg0 a0) {
+         return (Ret) wrapper->haxeObject->__run(a0);
+      } ;
+   }
+};
+
+
+
+// 2 arg
+template<typename Arg0, typename Arg1>
+struct TObjcBlockVoidArgs2
+{
+   typedef void (^t)(Arg0 a0, Arg1 a1);
+
+   static t create(Dynamic func)
+   {
+      NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
+      t wrap = ^(Arg0 a0, Arg1 a1) {
+         wrapper->haxeObject->__run(a0,a1);
+      };
+      return wrap;
+   }
+};
+
+template<typename Ret, typename Arg0, typename Arg1>
+struct TObjcBlockRetArgs2
+{
+   typedef Ret (^t)(Arg0 a0, Arg1 a1);
+   inline static t create(Dynamic func)
+   {
+      NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
+      t wrap = ^(Arg0 a0, Arg1 a1) {
+         return (Ret) wrapper->haxeObject->__run(a0,a1);
+      } ;
+   }
+};
+
+
+// 3 arg
+template<typename Arg0, typename Arg1, typename Arg2>
+struct TObjcBlockVoidArgs3
+{
+   typedef void (^t)(Arg0 a0, Arg1 a1, Arg2 a2);
+
+   static t create(Dynamic func)
+   {
+      NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
+      t wrap = ^(Arg0 a0, Arg1 a1, Arg2 a2) {
+         wrapper->haxeObject->__run(a0,a1,a2);
+      };
+      return wrap;
+   }
+};
+
+template<typename Ret, typename Arg0, typename Arg1, typename Arg2>
+struct TObjcBlockRetArgs3
+{
+   typedef Ret (^t)(Arg0 a0, Arg1 a1, Arg2 a2);
+   inline static t create(Dynamic func)
+   {
+      NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
+      t wrap = ^(Arg0 a0, Arg1 a1, Arg2 a2) {
+         return (Ret) wrapper->haxeObject->__run(a0,a1,a2);
+      } ;
+   }
+};
+
+
+// 4 arg
+template<typename Arg0, typename Arg1, typename Arg2, typename Arg3>
+struct TObjcBlockVoidArgs4
+{
+   typedef void (^t)(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3);
+
+   static t create(Dynamic func)
+   {
+      NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
+      t wrap = ^(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3) {
+         wrapper->haxeObject->__run(a0,a1,a2,a3);
+      };
+      return wrap;
+   }
+};
+
+template<typename Ret, typename Arg0, typename Arg1, typename Arg2, typename Arg3>
+struct TObjcBlockRetArgs4
+{
+   typedef Ret (^t)(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3);
+   inline static t create(Dynamic func)
+   {
+      NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
+      t wrap = ^(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3) {
+         return (Ret) wrapper->haxeObject->__run(a0,a1,a2,a3);
+      } ;
+   }
+};
+
+
+// 5 arg
+template<typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+struct TObjcBlockVoidArgs5
+{
+   typedef void (^t)(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4);
+
+   static t create(Dynamic func)
+   {
+      NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
+      t wrap = ^(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4) {
+         wrapper->haxeObject->__run(a0,a1,a2,a3,a4);
+      };
+      return wrap;
+   }
+};
+
+template<typename Ret, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+struct TObjcBlockRetArgs5
+{
+   typedef Ret (^t)(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4);
+   inline static t create(Dynamic func)
+   {
+      NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
+      t wrap = ^(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4) {
+         return (Ret) wrapper->haxeObject->__run(a0,a1,a2,a3,a4);
+      } ;
+   }
+};
+
+
+
+
+
+
+
+
+}
+
+#endif
+

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Object.h

@@ -0,0 +1,450 @@
+#ifndef HX_OBJECT_H
+#define HX_OBJECT_H
+
+#ifndef HXCPP_H
+#error "Please include hxcpp.h, not hx/Object.h"
+#endif
+
+#if defined(KORE_LINUX) && __cplusplus < 201103L
+#include <math.h>
+#endif
+
+// --- Constants -------------------------------------------------------
+
+// These values are returned from the "__GetType" function
+enum hxObjectType
+{
+   vtUnknown = -1,
+   vtInt = 0xff,
+   vtNull = 0,
+   vtFloat = 1,
+   vtBool = 2,
+   vtString = 3,
+   vtObject = 4,
+   vtArray = 5,
+   vtFunction = 6,
+   vtEnum,
+   vtClass,
+   vtInt64,
+   vtAbstractBase = 0x100,
+};
+
+
+namespace hx
+{
+
+
+
+class FieldRef;
+class IndexRef;
+typedef Array<Dynamic> DynamicArray;
+HXCPP_EXTERN_CLASS_ATTRIBUTES null BadCast();
+
+#ifdef HXCPP_SCRIPTABLE
+
+// CPPIA_CALL = fastcall on x86(32), nothing otherwise
+#if (HXCPP_API_LEVEL >= 331)
+   #if (defined(_WIN32) && !defined(_M_X64) && !defined(__x86_64__) && !defined(_ARM_) ) || \
+      defined(HXCPP_X86) || defined(__i386__) || defined(__i386) || \
+        (!defined(_WIN32) && !defined(_ARM_) && !defined(__arm__) && !defined(__x86_64__) )
+
+      #if defined(__GNUC__) && !defined(__APPLE__) && !defined(EMSCRIPTEN)
+         #define CPPIA_CALL __attribute__ ((fastcall))
+      #elif defined(_MSC_VER)
+         #define CPPIA_CALL __fastcall
+      #endif
+   #endif
+#endif
+
+#ifndef CPPIA_CALL
+   #define CPPIA_CALL
+#endif
+
+
+typedef void (CPPIA_CALL *StackExecute)(struct StackContext *ctx);
+struct ScriptFunction
+{
+   ScriptFunction(StackExecute inExe=0,const char *inSig=0)
+      : execute(inExe), signature(inSig) { }
+   StackExecute execute;
+   const char   *signature;
+};
+struct ScriptCallable;
+
+#endif
+
+enum NewObjectType
+{
+   NewObjAlloc,
+   NewObjContainer,
+   NewObjConst,
+};
+
+enum
+{
+   clsIdDynamic = 1,
+   clsIdClass,
+   clsIdInt,
+   clsIdInt64,
+   clsIdFloat,
+   clsIdBool,
+   clsIdString,
+   clsIdMath,
+   clsIdEnum,
+   clsIdClosure,
+   clsIdVirtualArray,
+   clsIdArrayIterator,
+   clsIdArrayBase,
+   clsIdArrayByte,
+   clsIdArrayShort,
+   clsIdArrayInt,
+   clsIdArrayBool,
+   clsIdArrayFloat32,
+   clsIdArrayFloat64,
+   clsIdArrayString,
+   clsIdArrayInt64,
+   clsIdArrayObject,
+   clsIdAbstract,
+   clsIdHash,
+   clsIdWeakRef,
+   clsIdExternalPrimitive,
+   clsIdPointer,
+   clsIdStruct,
+   clsIdCMember0,
+   clsIdCMember1,
+   clsIdCMember2,
+   clsIdCMember3,
+   clsIdCMember4,
+   clsIdCMember5,
+   clsIdCMemberVar,
+   clsIdCStatic0,
+   clsIdCStatic1,
+   clsIdCStatic2,
+   clsIdCStatic3,
+   clsIdCStatic4,
+   clsIdCStatic5,
+   clsIdCStatic6,
+   clsIdCStaticVar,
+   clsIdMutex,
+   clsIdSemaphore,
+   clsIdCondition,
+   clsIdLock,
+   clsIdDeque,
+   clsIdThreadInfo,
+   clsIdPcreData,
+   clsIdFio,
+   clsIdProcess,
+   clsIdSocket,
+   clsIdRandom,
+   clsIdPollData,
+   clsIdSqlite,
+   clsIdMysql,
+   clsIdMysqlResult,
+   clsIdSsl,
+   clsIdSslCert,
+   clsIdSslConf,
+   clsIdSslKey,
+   clsIdZLib,
+
+};
+
+
+// --- hx::Object ------------------------------------------------------------
+//
+// Base for all hxcpp objects.
+// This contains the virtual functions required by the core to provide
+//  a generic interface to the specific classes.
+//
+// Hxcpp classes inherit from this.
+//
+class HXCPP_EXTERN_CLASS_ATTRIBUTES Object
+{
+public:
+   enum { _hx_ClassId = hx::clsIdDynamic };
+
+
+   inline void *operator new( size_t inSize, bool inContainer=true, const char *inName=0 )
+   {
+      #ifdef HX_USE_INLINE_IMMIX_OPERATOR_NEW
+         ImmixAllocator *alloc =  HX_CTX_GET;
+
+         #ifdef HXCPP_DEBUG
+         if (!alloc)
+            BadImmixAlloc();
+         #endif
+
+         return ImmixAllocator::alloc(alloc, inSize, inContainer, inName);
+
+      #else // Not HX_USE_INLINE_IMMIX_OPERATOR_NEW ...
+
+         void *result = hx::InternalNew(inSize,inContainer);
+
+         #ifdef HXCPP_TELEMETRY
+            __hxt_gc_new(result, inSize, inName);
+         #endif
+         return result;
+      #endif
+   }
+
+   inline void *operator new( size_t inSize, hx::NewObjectType inType,  const char *inName=0 )
+   {
+      if (inType==NewObjConst)
+         return InternalCreateConstBuffer(0,(int)inSize);
+      return operator new(inSize, inType==NewObjContainer, inName);
+   }
+
+   void operator delete( void *, bool) { }
+   void operator delete( void *, bool, const char * ) { }
+   void operator delete( void *, int ) { }
+   void operator delete( void *, hx::NewObjectType) { }
+   void operator delete( void *, hx::NewObjectType, const char * ) { }
+
+   #if (HXCPP_API_LEVEL>=332)
+   virtual bool _hx_isInstanceOf(int inClassId);
+   #endif
+
+   //virtual void *__root();
+   virtual void __Mark(hx::MarkContext *__inCtx) { }
+   #ifdef HXCPP_VISIT_ALLOCS
+   virtual void __Visit(hx::VisitContext *__inCtx) { }
+   #endif
+
+   // helpers...
+   inline bool __IsArray() const { return __GetType()==vtArray; }
+
+   virtual int __GetType() const { return vtClass; }
+   virtual void *__GetHandle() const { return 0; }
+
+
+   virtual hx::FieldRef __FieldRef(const String &inString);
+
+   virtual String __ToString() const;
+
+   virtual int __ToInt() const { return 0; }
+#if defined(KORE_LINUX) && __cplusplus < 201103L
+   virtual double __ToDouble() const { return NAN; }
+#else
+   virtual double __ToDouble() const { return std::numeric_limits<double>::quiet_NaN(); }
+#endif
+   virtual cpp::Int64 __ToInt64() const { return (cpp::Int64)(0); }
+   virtual const char * __CStr() const;
+   virtual String toString();
+   virtual bool __HasField(const String &inString);
+   virtual hx::Val __Field(const String &inString, hx::PropertyAccess inCallProp);
+
+   #if (HXCPP_API_LEVEL <= 330)
+   virtual bool __Is(hx::Object *inClass) const { return true; }
+   virtual hx::Object *__GetRealObject() { return this; }
+   bool __Is(Dynamic inClass ) const;
+   #endif
+
+   #if (HXCPP_API_LEVEL >= 330)
+   // Non-virtual
+   Dynamic __IField(int inFieldID);
+   double __INumField(int inFieldID);
+   virtual void *_hx_getInterface(int inId);
+   #else
+   virtual hx::Object *__ToInterface(const hx::type_info &inInterface) { return 0; }
+   virtual Dynamic __IField(int inFieldID);
+   virtual double __INumField(int inFieldID);
+
+   // These have been moved to EnumBase
+   virtual DynamicArray __EnumParams();
+   virtual String __Tag() const;
+   virtual int __Index() const;
+   virtual void __SetSize(int inLen) { }
+   #endif
+
+   virtual hx::Val __SetField(const String &inField,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+
+   virtual void  __SetThis(Dynamic inThis);
+   virtual Dynamic __Run(const Array<Dynamic> &inArgs);
+   virtual Dynamic *__GetFieldMap();
+   virtual void __GetFields(Array<String> &outFields);
+   virtual hx::Class __GetClass() const;
+
+   virtual int __Compare(const hx::Object *inRHS) const;
+
+   virtual int __length() const { return 0; }
+   virtual Dynamic __GetItem(int inIndex) const;
+   virtual Dynamic __SetItem(int inIndex,Dynamic inValue);
+
+
+   typedef const Dynamic &D;
+   virtual Dynamic __run();
+   virtual Dynamic __run(D a);
+   virtual Dynamic __run(D a,D b);
+   virtual Dynamic __run(D a,D b,D c);
+   virtual Dynamic __run(D a,D b,D c,D d);
+   virtual Dynamic __run(D a,D b,D c,D d,D e);
+
+   virtual int __ArgCount() const { return -1; }
+
+   #ifdef HXCPP_SCRIPTABLE
+   virtual void **__GetScriptVTable() { return 0; }
+   virtual hx::ScriptCallable *__GetScriptCallable() { return 0; }
+   static hx::ScriptFunction __script_construct;
+   #endif
+
+   #if (HXCPP_API_LEVEL>=331)
+   inline bool __compare( hx::Object *inRHS ) { return this!=inRHS; }
+   #else
+   inline bool __compare( hx::Object *inRHS )
+      { return __GetRealObject()!=inRHS->__GetRealObject(); }
+   #endif
+
+   static hx::Class &__SGetClass();
+   static void __boot();
+};
+
+// --- hx::ObjectPtr ---------------------------------------------------------------
+//
+// This class simply provides syntax so that pointers can be written as objects,
+//  and overloaded operators can be used
+
+template<typename OBJ_>
+class ObjectPtr
+{
+protected:
+   inline bool SetPtr(OBJ_ *inPtr)
+   {
+      mPtr = inPtr;
+      return true;
+   }
+   inline bool SetPtr(...) { return false; }
+
+   inline void CastPtr(hx::Object *inPtr,bool inThrowOnInvalid)
+   {
+      if (inPtr)
+      {
+         #if (HXCPP_API_LEVEL>=332)
+            mPtr = inPtr->_hx_isInstanceOf(OBJ_::_hx_ClassId) ? reinterpret_cast<OBJ_ *>(inPtr) : 0;
+         #elif (HXCPP_API_LEVEL>=331)
+            mPtr = dynamic_cast<OBJ_ *>(inPtr);
+         #else
+            mPtr = dynamic_cast<OBJ_ *>(inPtr->__GetRealObject());
+            #if (HXCPP_API_LEVEL < 330)
+            if (!mPtr)
+               mPtr = (Ptr)inPtr->__ToInterface(typeid(Obj));
+            #endif
+         #endif
+         if (inThrowOnInvalid && !mPtr)
+            ::hx::BadCast();
+      }
+      else
+         mPtr = 0;
+   }
+
+public:
+   typedef OBJ_ Obj;
+   typedef OBJ_ *Ptr;
+
+   inline ObjectPtr() : mPtr(0) { }
+   inline ObjectPtr(OBJ_ *inObj) : mPtr(inObj) { }
+   inline ObjectPtr(const null &inNull) : mPtr(0) { }
+   inline ObjectPtr(const ObjectPtr<OBJ_> &inOther) : mPtr( inOther.mPtr ) {  }
+   template<typename T>
+   inline ObjectPtr(const hx::Native<T> &inNative) : mPtr( dynamic_cast<T>(inNative.ptr) ) {  }
+
+   template<typename SOURCE_>
+   inline ObjectPtr(const ObjectPtr<SOURCE_> &inObjectPtr)
+   {
+      if (!SetPtr(inObjectPtr.mPtr))
+         CastPtr(inObjectPtr.mPtr,false);
+   }
+
+
+   inline ObjectPtr(const ::cpp::Variant &inVariant)
+   {
+      hx::Object *object = inVariant.asObject();
+      if (!SetPtr(object))
+         CastPtr(object,false);
+   }
+
+   template<typename SOURCE_>
+   inline ObjectPtr(const SOURCE_ *inPtr,bool inCheckCast=true)
+   {
+      if (!SetPtr(const_cast<SOURCE_ *>(inPtr)))
+         CastPtr(const_cast<SOURCE_ *>(inPtr),inCheckCast);
+   }
+
+   inline ObjectPtr &operator=(const null &inNull) { mPtr = 0; return *this; }
+   inline ObjectPtr &operator=(Ptr inRHS) { mPtr = inRHS; return *this; }
+   inline ObjectPtr &operator=(const ObjectPtr &inRHS) { mPtr = inRHS.mPtr; return *this; }
+   template<typename InterfaceImpl>
+   inline ObjectPtr &operator=(InterfaceImpl *inRHS)
+   {
+      mPtr = inRHS->operator Ptr();
+      return *this;
+   }
+
+   inline OBJ_ *GetPtr() const { return mPtr; }
+   inline OBJ_ *operator->()
+   {
+      #ifdef HXCPP_CHECK_POINTER
+      if (!mPtr) NullReference("Object", true);
+      // The handler might have fixed up the null value
+      if (!mPtr) NullReference("Object", false);
+      #ifdef HXCPP_GC_CHECK_POINTER
+         GCCheckPointer(mPtr);
+      #endif
+      #endif
+      return mPtr;
+   }
+   inline const OBJ_ *operator->() const
+   {
+      #ifdef HXCPP_CHECK_POINTER
+      if (!mPtr) NullReference("Object", true);
+      // The handler might have fixed up the null value
+      if (!mPtr) NullReference("Object", false);
+      #ifdef HXCPP_GC_CHECK_POINTER
+         GCCheckPointer(mPtr);
+      #endif
+      #endif
+      return mPtr;
+   }
+
+   template<typename T>
+   inline bool operator==(const T &inTRHS) const
+   {
+      ObjectPtr inRHS(inTRHS.mPtr,false);
+      if (mPtr==inRHS.mPtr) return true;
+      if (!mPtr || !inRHS.mPtr) return false;
+      return !mPtr->__compare(inRHS.mPtr);
+   }
+   inline bool operator==(const cpp::Variant &inRHS) const;
+   inline bool operator!=(const cpp::Variant &inRHS) const;
+
+   template<typename T>
+   inline bool operator!=(const T &inTRHS) const
+   {
+      ObjectPtr inRHS(inTRHS.mPtr,false);
+      if (mPtr==inRHS.mPtr) return false;
+      if (!mPtr || !inRHS.mPtr) return true;
+      return mPtr->__compare(inRHS.mPtr);
+   }
+
+   template<typename T>
+   operator hx::Native<T> () { return hx::Native<T>( mPtr ); }
+
+   inline bool operator==(const null &inRHS) const { return mPtr==0; }
+   inline bool operator!=(const null &inRHS) const { return mPtr!=0; }
+
+   //inline bool operator==(const Dynamic &inRHS) const { return inRHS==*this; }
+   //inline bool operator!=(const Dynamic &inRHS) const { return inRHS!=*this; }
+
+
+   // This is defined in the "FieldRef" class...
+   inline class hx::FieldRef FieldRef(const String &inString);
+   inline class hx::IndexRef IndexRef(int inString);
+   inline static hx::Class &__SGetClass() { return OBJ_::__SGetClass(); }
+
+   OBJ_ *mPtr;
+};
+
+
+} // end namespace hx
+
+
+
+#endif

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Operators.h

@@ -0,0 +1,448 @@
+#ifndef HX_OPERATORS_H
+#define HX_OPERATORS_H
+
+
+
+template<typename T> bool null::operator == (const hx::ObjectPtr<T> &O) const { return !O.mPtr; }
+template<typename T> inline bool null::operator != (const hx::ObjectPtr<T> &O) const { return O.mPtr; }
+
+template<typename T> inline bool null::operator == (const Array<T> &O) const { return !O.mPtr; }
+template<typename T> inline bool null::operator != (const Array<T> &O) const { return O.mPtr; }
+inline bool null::operator == (const hx::FieldRef &O) const { return !O.HasPointer(); }
+inline bool null::operator != (const hx::FieldRef &O) const { return O.HasPointer(); }
+inline bool null::operator == (const hx::IndexRef &O) const { return !O.HasPointer(); }
+inline bool null::operator != (const hx::IndexRef &O) const { return O.HasPointer(); }
+
+inline bool null::operator == (const Dynamic &O) const { return !O.mPtr; }
+inline bool null::operator != (const Dynamic &O) const { return O.mPtr; }
+
+inline bool null::operator == (const String &O) const { return !O.raw_ptr(); }
+inline bool null::operator != (const String &O) const { return O.raw_ptr(); }
+
+namespace hx {
+template<typename T> Null<T>::operator Dynamic() { if (isNull) return Dynamic(); return value; }
+}
+
+HX_COMPARE_NULL_MOST_OPS(String)
+HX_COMPARE_NULL_MOST_OPS(Dynamic)
+HX_COMPARE_NULL_MOST_OPS(hx::FieldRef)
+HX_COMPARE_NULL_MOST_OPS(hx::IndexRef)
+
+//HX_NULL_DEFINE_COMPARE_MOST_OPS(String)
+//HX_NULL_DEFINE_COMPARE_MOST_OPS(Dynamic)
+//HX_NULL_DEFINE_COMPARE_MOST_OPS(hx::FieldRef)
+//HX_NULL_DEFINE_COMPARE_MOST_OPS(hx::IndexRef)
+
+
+// Operators for mixing various types ....
+
+
+inline String operator+(const cpp::UInt64 &i,const String &s) { return String(i) + s; }
+inline String operator+(const cpp::Int64 &i,const String &s) { return String(i) + s; }
+inline String operator+(const int &i,const String &s) { return String(i) + s; }
+inline String operator+(const unsigned int &i,const String &s) { return String(i) + s; }
+inline String operator+(const double &d,const String &s) { return String(d) + s; }
+inline String operator+(const float &d,const String &s) { return String(d) + s; }
+inline String operator+(const bool &b,const String &s) { return String(b) + s; }
+inline String operator+(const unsigned char c,const String &s) { return String(c) + s; }
+inline String operator+(const signed char c,const String &s) { return String(c) + s; }
+inline String operator+(const unsigned short c,const String &s) { return String(c) + s; }
+inline String operator+(const signed short c,const String &s) { return String(c) + s; }
+inline String operator+(const null &n,const String &s) { return String(n) + s; }
+inline String operator+(const cpp::CppInt32__ &i,const String &s) { return String(i) + s; }
+
+template<typename T_>
+   inline String operator+(const hx::ObjectPtr<T_> &inLHS,const String &s)
+   { return (inLHS.mPtr ? const_cast<hx::ObjectPtr<T_> & >(inLHS)->toString() : HX_CSTRING("null") ) + s; }
+
+/*
+template<typename LHS_>
+   inline Dynamic operator+(LHS_ inLHS, const hx::FieldRef &inField)
+   { return inLHS + inField.operator Dynamic(); }
+
+template<typename LHS_>
+   inline Dynamic operator+(LHS_ inLHS,const hx::IndexRef &inIndexRef)
+   { return inLHS + inIndexRef.operator Dynamic(); }
+*/
+
+// += -= *= /= %= &= |= ^= <<= >>= >>>=
+
+namespace hx
+{
+
+template<typename T> inline double ToDouble(T inT) { return 0; }
+template<typename T> inline double ToDouble(hx::ObjectPtr<T> inObj)
+{
+   return inObj.mPtr ? inObj.mPtr->__ToDouble() : 0.0;
+}
+template<> inline double ToDouble(String inValue) { return __hxcpp_parse_float(inValue); }
+template<> inline double ToDouble(double inValue) { return inValue; }
+template<> inline double ToDouble(int inValue) { return inValue; }
+template<> inline double ToDouble(bool inValue) { return inValue; }
+template<> inline double ToDouble(float inValue) { return inValue; }
+template<> inline double ToDouble(cpp::UInt64 inValue) { return inValue; }
+template<> inline double ToDouble(cpp::Int64 inValue) { return inValue; }
+template<> inline double ToDouble(null inValue) { return 0; }
+
+
+
+inline int UShr(int inData,int inShift)
+{
+   return ((unsigned int)inData) >> inShift;
+}
+
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES double DoubleMod(double inLHS,double inRHS);
+
+template<typename TL,typename TR>
+double Mod(TL inLHS,TR inRHS) { return hx::DoubleMod(inLHS,inRHS); }
+
+double DivByZero(double d);
+
+#if !defined(_MSC_VER) || _MSC_VER > 1399
+inline int Mod(int inLHS,int inRHS)
+{
+   if (!inRHS)
+      hx::Throw(HX_CSTRING("Mod by 0 Error."));
+   return inLHS % inRHS;
+}
+#endif
+
+
+template<typename L, typename R>
+inline L& AddEq(L &inLHS, R inRHS) { inLHS = inLHS + inRHS; return inLHS; }
+template<typename L, typename R>
+inline L& MultEq(L &inLHS, R inRHS) { inLHS = inLHS * inRHS; return inLHS; }
+template<typename L, typename R>
+inline L& DivEq(L &inLHS, R inRHS) { inLHS = (double)inLHS / (double)inRHS; return inLHS; }
+template<typename L, typename R>
+inline L& SubEq(L &inLHS, R inRHS) { inLHS = inLHS - inRHS; return inLHS; }
+template<typename L, typename R>
+inline L& AndEq(L &inLHS, R inRHS) { inLHS = (int)inLHS & (int)inRHS; return inLHS; }
+template<typename L, typename R>
+inline L& OrEq(L &inLHS, R inRHS) { inLHS = (int)inLHS | (int)inRHS; return inLHS; }
+template<typename L, typename R>
+inline L& XorEq(L &inLHS, R inRHS) { inLHS = (int)inLHS ^ (int)inRHS; return inLHS; }
+template<typename L, typename R>
+inline L& ShlEq(L &inLHS, R inRHS) { inLHS = (int)inLHS << (int)inRHS; return inLHS; }
+template<typename L, typename R>
+inline L& ShrEq(L &inLHS, R inRHS) { inLHS = (int)inLHS >> (int)inRHS; return inLHS; }
+template<typename L, typename R>
+inline L& UShrEq(L &inLHS, R inRHS) { inLHS = hx::UShr(inLHS,inRHS); return inLHS; }
+template<typename L, typename R>
+inline L& ModEq(L &inLHS, R inRHS) { inLHS = DoubleMod(inLHS,inRHS); return inLHS; }
+
+#if defined(__GNUC__) || defined(__SNC__)
+template<typename R>
+inline hx::FieldRef AddEq(hx::FieldRef inLHS, R inRHS) { inLHS = inLHS + inRHS; return inLHS; }
+template<typename R>
+inline hx::FieldRef MultEq(hx::FieldRef inLHS, R inRHS) { inLHS = inLHS * inRHS; return inLHS; }
+template<typename R>
+inline hx::FieldRef DivEq(hx::FieldRef inLHS, R inRHS) { inLHS = (double)inLHS / (double)inRHS; return inLHS; }
+template<typename R>
+inline hx::FieldRef SubEq(hx::FieldRef inLHS, R inRHS) { inLHS = inLHS - inRHS; return inLHS; }
+template<typename R>
+inline hx::FieldRef AndEq(hx::FieldRef inLHS, R inRHS) { inLHS = (int)inLHS & (int)inRHS; return inLHS; }
+template<typename R>
+inline hx::FieldRef OrEq(hx::FieldRef inLHS, R inRHS) { inLHS = (int)inLHS | (int)inRHS; return inLHS; }
+template<typename R>
+inline hx::FieldRef XorEq(hx::FieldRef inLHS, R inRHS) { inLHS = (int)inLHS ^ (int)inRHS; return inLHS; }
+template<typename R>
+inline hx::FieldRef ShlEq(hx::FieldRef inLHS, R inRHS) { inLHS = (int)inLHS << (int)inRHS; return inLHS; }
+template<typename R>
+inline hx::FieldRef ShrEq(hx::FieldRef inLHS, R inRHS) { inLHS = (int)inLHS >> (int)inRHS; return inLHS; }
+template<typename R>
+inline hx::FieldRef UShrEq(hx::FieldRef inLHS, R inRHS) { inLHS = hx::UShr(inLHS,inRHS); return inLHS; }
+template<typename R>
+inline hx::FieldRef ModEq(hx::FieldRef inLHS, R inRHS) { inLHS = DoubleMod(inLHS,inRHS); return inLHS; }
+
+
+template<typename R>
+inline hx::IndexRef AddEq(hx::IndexRef inLHS, R inRHS) { inLHS = inLHS + inRHS; return inLHS; }
+template<typename R>
+inline hx::IndexRef MultEq(hx::IndexRef inLHS, R inRHS) { inLHS = (double)inLHS * (double)inRHS; return inLHS; }
+template<typename R>
+inline hx::IndexRef DivEq(hx::IndexRef inLHS, R inRHS) { inLHS = (double)inLHS / (double)inRHS; return inLHS; }
+template<typename R>
+inline hx::IndexRef SubEq(hx::IndexRef inLHS, R inRHS) { inLHS = (double)inLHS - (double)inRHS; return inLHS; }
+template<typename R>
+inline hx::IndexRef AndEq(hx::IndexRef inLHS, R inRHS) { inLHS = (int)inLHS & (int)inRHS; return inLHS; }
+template<typename R>
+inline hx::IndexRef OrEq(hx::IndexRef inLHS, R inRHS) { inLHS = (int)inLHS | (int)inRHS; return inLHS; }
+template<typename R>
+inline hx::IndexRef XorEq(hx::IndexRef inLHS, R inRHS) { inLHS = (int)inLHS ^ (int)inRHS; return inLHS; }
+template<typename R>
+inline hx::IndexRef ShlEq(hx::IndexRef inLHS, R inRHS) { inLHS = (int)inLHS << (int)inRHS; return inLHS; }
+template<typename R>
+inline hx::IndexRef ShrEq(hx::IndexRef inLHS, R inRHS) { inLHS = (int)inLHS >> (int)inRHS; return inLHS; }
+template<typename R>
+inline hx::IndexRef UShrEq(hx::IndexRef inLHS, R inRHS) { inLHS = hx::UShr(inLHS,inRHS); return inLHS; }
+template<typename R>
+inline hx::IndexRef ModEq(hx::IndexRef inLHS, R inRHS) { inLHS = DoubleMod(inLHS,inRHS); return inLHS; }
+
+
+
+#endif // __GNUC__ || __SNC__
+
+template<typename R,typename T>
+inline hx::__TArrayImplRef<T> AddEq(hx::__TArrayImplRef<T> ref, R inRHS)
+   { ref.mObject->__set(ref.mIndex, ref.mObject->__get(ref.mIndex) + inRHS); return ref;}
+
+template<typename R,typename T>
+inline hx::__TArrayImplRef<T> MultEq(hx::__TArrayImplRef<T> ref, R inRHS)
+   { ref.mObject->__set(ref.mIndex, ref.mObject->__get(ref.mIndex) * inRHS); return ref;}
+
+template<typename R,typename T>
+inline hx::__TArrayImplRef<T> DivEq(hx::__TArrayImplRef<T> ref, R inRHS)
+   { ref.mObject->__set(ref.mIndex, ref.mObject->__get(ref.mIndex) / inRHS); return ref;}
+
+template<typename R,typename T>
+inline hx::__TArrayImplRef<T> SubEq(hx::__TArrayImplRef<T> ref, R inRHS)
+   { ref.mObject->__set(ref.mIndex, ref.mObject->__get(ref.mIndex) - inRHS); return ref;}
+
+template<typename T>
+inline hx::__TArrayImplRef<T> AndEq(hx::__TArrayImplRef<T> ref, int inRHS)
+   { ref.mObject->__set(ref.mIndex, (int)ref.mObject->__get(ref.mIndex) & inRHS); return ref;}
+
+template<typename T>
+inline hx::__TArrayImplRef<T> OrEq(hx::__TArrayImplRef<T> ref, int inRHS)
+   { ref.mObject->__set(ref.mIndex, (int)ref.mObject->__get(ref.mIndex) | inRHS); return ref;}
+
+template<typename T>
+inline hx::__TArrayImplRef<T> XorEq(hx::__TArrayImplRef<T> ref, int inRHS)
+   { ref.mObject->__set(ref.mIndex, (int)ref.mObject->__get(ref.mIndex) ^ inRHS); return ref;}
+
+template<typename T>
+inline hx::__TArrayImplRef<T> ShlEq(hx::__TArrayImplRef<T> ref, int inRHS)
+   { ref.mObject->__set(ref.mIndex, (int)ref.mObject->__get(ref.mIndex) << inRHS); return ref;}
+
+template<typename T>
+inline hx::__TArrayImplRef<T> ShrEq(hx::__TArrayImplRef<T> ref, int inRHS)
+   { ref.mObject->__set(ref.mIndex, (int)ref.mObject->__get(ref.mIndex) >> inRHS); return ref;}
+
+template<typename T>
+inline hx::__TArrayImplRef<T> UShrEq(hx::__TArrayImplRef<T> ref, int inRHS)
+   { ref.mObject->__set(ref.mIndex, hx::UShr(ref.mObject->__get(ref.mIndex),inRHS)); return ref;}
+
+template<typename T>
+inline hx::__TArrayImplRef<T> UShrEq(hx::__TArrayImplRef<T> ref, double inRHS)
+   { ref.mObject->__set(ref.mIndex, DoubleMod(ref.mObject->__get(ref.mIndex),inRHS)); return ref;}
+
+
+
+
+
+
+
+template<typename T> inline T TCastObject(hx::Object *inObj) { return hx::BadCast(); }
+template<> inline bool TCastObject<bool>(hx::Object *inObj)
+{
+   if (!inObj) return false;
+   if (inObj->__GetType()!=::vtBool) return hx::BadCast();
+   return inObj?inObj->__ToInt():0;
+}
+template<> inline int TCastObject<int>(hx::Object *inObj)
+{
+   if (!inObj) return 0;
+   if (!(inObj->__GetType()==::vtInt ||
+        ((inObj->__GetType()==::vtFloat || inObj->__GetType()==::vtInt64) && inObj->__ToDouble()==inObj->__ToInt()) ) ) return hx::BadCast();
+   return inObj->__ToInt();
+}
+template<> inline double TCastObject<double>(hx::Object *inObj)
+{
+   if (!inObj) return 0.0;
+   if ((inObj->__GetType()!=::vtFloat && inObj->__GetType()!=::vtInt64 && inObj->__GetType()!=::vtInt))
+      return hx::BadCast();
+   return inObj->__ToDouble();
+}
+template<> inline float TCastObject<float>(hx::Object *inObj)
+{
+   if (!inObj || (inObj->__GetType()!=::vtFloat && inObj->__GetType()!=::vtInt64 && inObj->__GetType()!=::vtInt))
+      return hx::BadCast();
+   return inObj->__ToDouble();
+}
+
+template<> inline String TCastObject<String>(hx::Object *inObj)
+{
+   if (!inObj) return String();
+   if (inObj->__GetType()!=::vtString)
+      return hx::BadCast();
+   return inObj->__ToString();
+}
+
+template<> inline null TCastObject<null>(hx::Object *inObj) { return null(); }
+
+// Cast to scalar
+template<typename T> struct TCast
+{
+   template<typename VAL> static inline T cast(VAL inVal ) {
+      T result =  TCastObject<T>(Dynamic(inVal).GetPtr());
+      //null string from null is ok...
+      //if (result==null()) hx::BadCast();
+      return result;
+   }
+
+   template<typename INOBJ>
+   static inline T cast(ObjectPtr<INOBJ> inObj )
+   {
+      T result =  TCastObject<T>(inObj.GetPtr());
+      if (result==null()) hx::BadCast();
+      return result;
+   }
+
+   template<typename INOBJ>
+   static inline T cast(Array<INOBJ> inObj ) { return hx::BadCast(); }
+
+};
+
+// Cast to object
+template<typename T> struct TCast< ObjectPtr<T> >
+{
+   template<typename VAL> static inline ObjectPtr<T> cast(VAL inVal ) {
+      ObjectPtr<T> result = Dynamic(inVal);
+      if (result==null() && inVal!=null()) BadCast();
+      return result;
+   }
+
+   template<typename INOBJ>
+   static inline ObjectPtr<T> cast(ObjectPtr<INOBJ> inObj )
+   {
+      ObjectPtr<T> result = ObjectPtr<T>(inObj);
+      if (result==null() && inObj!=null()) hx::BadCast();
+      return result;
+   }
+};
+
+#if (HXCPP_API_LEVEL >= 330)
+template< > struct TCast< cpp::VirtualArray >
+{
+   template<typename VAL> static inline cpp::VirtualArray cast(VAL inVal ) {
+      return  cpp::VirtualArray(inVal);
+   }
+};
+#endif
+
+
+// Cast to struct
+template<typename T,typename H> struct TCast< cpp::Struct<T,H> >
+{
+   static inline cpp::Struct<T,H> cast( const cpp::Struct<T,H> &inObj ) { return inObj; }
+};
+
+
+inline Array<Dynamic> TCastToArray(Dynamic inVal)
+{
+   Dynamic result = inVal;
+   if (result==null() && inVal!=null()) hx::BadCast();
+   return inVal;
+}
+
+template<typename PTRTYPE> struct DynamicConvertType { enum { Convert = aciNotArray }; };
+
+// Always convert ...
+template<> struct DynamicConvertType< hx::Interface * > { enum { Convert = aciAlwaysConvert }; };
+template<> struct DynamicConvertType< Array_obj<Dynamic> * > { enum { Convert = aciObjectArray }; };
+template<> struct DynamicConvertType< Array_obj< ::String> * > { enum { Convert = aciStringArray }; };
+template<typename T> struct DynamicConvertType< Array_obj<T> * > { enum { Convert = sizeof(T) }; };
+#if (HXCPP_API_LEVEL >= 330)
+template<> struct DynamicConvertType< cpp::VirtualArray_obj * > { enum { Convert = aciVirtualArray }; };
+#endif
+
+}
+
+
+
+template<typename RESULT>
+inline RESULT Dynamic::StaticCast() const
+{
+   typedef typename RESULT::Ptr type;
+
+   const int convertId = (int)hx::DynamicConvertType<type>::Convert;
+   if (convertId!=hx::aciNotArray && mPtr && convertId!=((hx::ArrayCommon *)mPtr)->getArrayConvertId())
+   {
+      // Constructing the result from the Dynamic value will check for a conversion
+      //  using something like dynamic_cast
+      return *this;
+   }
+   else
+   {
+      // Simple reinterpret_cast
+      return (typename RESULT::Ptr)mPtr;
+   }
+}
+
+namespace hx
+{
+inline bool IsInterfacePtr(...) { return false; }
+inline bool IsInterfacePtr(const hx::Interface *) { return true; }
+}
+  
+template<typename VALUE>
+inline void __hxcpp_unsafe_set(hx::ObjectPtr<VALUE> &outForced, const Dynamic &inD)
+{
+   if (hx::IsInterfacePtr(outForced.mPtr))
+   {
+      hx::Throw(HX_CSTRING("unsafe set of interfaces not supported yet."));
+      outForced.mPtr = (VALUE *)(inD.mPtr);
+   }
+   else
+   {
+      #if (HXCPP_API_LEVEL >= 331)
+      outForced.mPtr = (VALUE *)(inD.mPtr);
+      #else
+      outForced.mPtr = (VALUE *)(inD.mPtr ? inD.mPtr->__GetRealObject() : 0);
+      #endif
+   }
+}
+
+namespace hx
+{
+class HXCPP_EXTERN_CLASS_ATTRIBUTES StringValueIterator : public cpp::StringIterator<int>
+{
+public:
+   StringValueIterator(const String &inValue) : StringIterator(inValue) { }
+
+   int next() { return value.cca(pos++); }
+};
+
+class HXCPP_EXTERN_CLASS_ATTRIBUTES StringKeyValueIterator : public cpp::StringIterator<Dynamic>
+{
+public:
+   StringKeyValueIterator(const String &inValue) : StringIterator(inValue) { }
+
+   Dynamic next() {
+      int p = pos;
+      return
+        hx::AnonStruct2_obj< int,int >::Create(HX_("key",9f,89,51,00),p,
+                                               HX_("value",71,7f,b8,31), value.cca(pos++) );
+   }
+};
+}
+
+
+Dynamic String::iterator()
+{
+   return new hx::StringValueIterator(*this);
+}
+
+
+Dynamic String::keyValueIterator()
+{
+   return new hx::StringKeyValueIterator(*this);
+}
+
+namespace hx
+{
+template<typename FROM, typename TO> Dynamic hx::ArrayKeyValueIterator<FROM, TO>::next()
+{
+   int p = mIdx++;
+   return
+     hx::AnonStruct2_obj< int,TO >::Create(HX_("key",9f,89,51,00),p,
+                                           HX_("value",71,7f,b8,31), toTo(mArray->__get(p)) );
+}
+}
+
+
+
+
+#endif

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/QuickVec.h

@@ -0,0 +1,204 @@
+#ifndef HX_QUICKVEC_INCLUDED
+#define HX_QUICKVEC_INCLUDED
+
+#include <stdlib.h>
+#include <algorithm>
+
+namespace hx
+{
+
+template<typename T>
+struct QuickVec
+{
+   int mAlloc;
+   int mSize;
+   T *mPtr;
+
+   QuickVec() : mPtr(0), mAlloc(0), mSize(0) { } 
+   ~QuickVec()
+   {
+      if (mPtr)
+         free(mPtr);
+   }
+
+   inline void push(const T &inT)
+   {
+      if (mSize+1>mAlloc)
+      {
+         mAlloc = 10 + (mSize*3/2);
+         mPtr = (T *)realloc(mPtr,sizeof(T)*mAlloc);
+      }
+      mPtr[mSize]=inT;
+      mSize++;
+   }
+   void swap(QuickVec<T> &inOther)
+   {
+      std::swap(mAlloc, inOther.mAlloc);
+      std::swap(mSize, inOther.mSize);
+      std::swap(mPtr, inOther.mPtr);
+   }
+   T *setSize(int inSize)
+   {
+      if (inSize>mAlloc)
+      {
+         mAlloc = inSize;
+         mPtr = (T *)realloc(mPtr,sizeof(T)*mAlloc);
+      }
+      mSize = inSize;
+      return mPtr;
+   }
+   // Can push this many without realloc
+   bool hasExtraCapacity(int inN)
+   {
+      return mSize+inN<=mAlloc;
+   }
+
+   bool safeReserveExtra(int inN)
+   {
+      int want = mSize + inN;
+      if (want>mAlloc)
+      {
+         int wantAlloc = 10 + (mSize*3/2);
+         if (wantAlloc<want)
+            wantAlloc = want;
+         T *newBuffer = (T *)malloc( sizeof(T)*wantAlloc );
+         if (!newBuffer)
+            return false;
+         mAlloc = wantAlloc;
+         if (mPtr)
+         {
+            memcpy(newBuffer, mPtr, mSize*sizeof(T));
+            free(mPtr);
+         }
+         mPtr = newBuffer;
+      }
+      return true;
+   }
+   inline void pop_back() { --mSize; }
+   inline T &back() { return mPtr[mSize-1]; }
+   inline T pop()
+   {
+      return mPtr[--mSize];
+   }
+   inline void qerase(int inPos)
+   {
+      --mSize;
+      mPtr[inPos] = mPtr[mSize];
+   }
+   inline void erase(int inPos)
+   {
+      --mSize;
+      if (mSize>inPos)
+         memmove(mPtr+inPos, mPtr+inPos+1, (mSize-inPos)*sizeof(T));
+   }
+   void zero() { memset(mPtr,0,mSize*sizeof(T) ); }
+
+   inline bool qerase_val(T inVal)
+   {
+      for(int i=0;i<mSize;i++)
+         if (mPtr[i]==inVal)
+         {
+            --mSize;
+            mPtr[i] = mPtr[mSize];
+            return true;
+         }
+      return false;
+   }
+
+   inline bool some_left() { return mSize; }
+   inline bool empty() const { return !mSize; }
+   inline void clear() { mSize = 0; }
+   inline int next()
+   {
+      if (mSize+1>=mAlloc)
+      {
+         mAlloc = 10 + (mSize*3/2);
+         mPtr = (T *)realloc(mPtr,sizeof(T)*mAlloc);
+      }
+      return mSize++;
+   }
+   inline int size() const { return mSize; }
+   inline T &operator[](int inIndex) { return mPtr[inIndex]; }
+   inline const T &operator[](int inIndex) const { return mPtr[inIndex]; }
+
+private:
+   QuickVec(const QuickVec<T> &);
+   void operator =(const QuickVec<T> &);
+};
+
+
+template<typename T>
+class QuickDeque
+{
+    struct Slab
+    {
+       T mElems[1024];
+    };
+
+    QuickVec<Slab *> mSpare;
+    QuickVec<Slab *> mActive;
+
+    int  mHeadPos;
+    int  mTailPos;
+    Slab *mHead;
+    Slab *mTail;
+
+public:
+
+   QuickDeque()
+   {
+      mHead = mTail = 0;
+      mHeadPos = 1024;
+      mTailPos = 1024;
+   }
+   ~QuickDeque()
+   {
+      for(int i=0;i<mSpare.size();i++)
+         delete mSpare[i];
+      for(int i=0;i<mActive.size();i++)
+         delete mActive[i];
+      delete mHead;
+      if (mTail!=mHead)
+         delete mTail;
+   }
+   inline void push(T inObj)
+   {
+      if (mHeadPos<1024)
+      {
+         mHead->mElems[mHeadPos++] = inObj;
+         return;
+      }
+      if (mHead != mTail)
+         mActive.push(mHead);
+      mHead = mSpare.empty() ? new Slab : mSpare.pop();
+      mHead->mElems[0] = inObj;
+      mHeadPos = 1;
+   }
+   inline bool some_left() { return mHead!=mTail || mHeadPos!=mTailPos; }
+   inline T pop()
+   {
+      if (mTailPos<1024)
+         return mTail->mElems[mTailPos++];
+      if (mTail)
+         mSpare.push(mTail);
+      if (mActive.empty())
+      {
+         mTail = mHead;
+      }
+      else
+      {
+         mTail = mActive[0];
+         mActive.erase(0);
+      }
+      mTailPos = 1;
+      return mTail->mElems[0];
+   }
+
+private:
+   QuickDeque(const QuickDeque<T> &);
+   void operator=(const QuickDeque<T> &);
+};
+
+} // end namespace hx
+
+#endif

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Scriptable.h

@@ -0,0 +1,289 @@
+#ifndef INCLUDED_HX_SCRIPTABLE
+#define INCLUDED_HX_SCRIPTABLE
+
+#include <typeinfo>
+#ifdef __clang__
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#endif
+
+
+namespace hx
+{
+
+extern bool gEnableJit;
+inline void EnableJit(bool inEnable) { gEnableJit = inEnable; }
+
+#define HXCPP_CPPIA_SUPER_ARG(x) , (x)
+
+struct ScriptNamedFunction : public ScriptFunction
+{
+   ScriptNamedFunction(const ScriptFunction &s) : ScriptFunction(s), name(0), isStatic(false), superExecute(0) { }
+
+   ScriptNamedFunction(const char *inName=0,StackExecute inExe=0,const char *inSig=0, bool inIsStatic=false, StackExecute superExecute=0)
+      : ScriptFunction(inExe, inSig), name(inName), isStatic(inIsStatic), superExecute(superExecute)  { }
+
+   const char *name;
+   bool isStatic;
+   StackExecute superExecute;
+};
+
+
+inline void SetFloatAligned(void *inPtr, const Float &inValue)
+{
+   #ifdef HXCPP_ALIGN_FLOAT
+   int *dest = (int *)inPtr;
+   const int *src = (const int *)&inValue;
+   dest[1] = src[1];
+   #else
+   *(Float *)inPtr = inValue;
+   #endif
+}
+
+
+inline Float GetFloatAligned(const void *inPtr)
+{
+   #ifdef HXCPP_ALIGN_FLOAT
+   Float result;
+   int *dest = (int *)&result;
+   const int *src = (const int *)inPtr;
+   dest[0] = src[0];
+   dest[1] = src[1];
+   return result;
+   #else
+   return *(Float *)inPtr;
+   #endif
+}
+
+
+inline void StackContext::pushFloat(Float f)
+{
+   SetFloatAligned(pointer, f);
+   pointer += sizeof(Float);
+}
+inline void StackContext::pushString(const String &s)
+{
+   *(String *)pointer = s;
+   pointer += sizeof(String);
+}
+
+inline void StackContext::pushObject(Dynamic d)
+{
+   *(hx::Object **)pointer = d.mPtr;
+   pointer += sizeof(hx::Object *);
+}
+
+inline void StackContext::returnFloat(Float f)
+{
+   SetFloatAligned(frame, f);
+}
+inline void StackContext::returnString(const String &s)
+{
+   *(String *)frame = s;
+}
+inline void StackContext::returnObject(Dynamic d)
+{
+   *(hx::Object **)frame = d.mPtr;
+}
+
+inline hx::Object *StackContext::getThis(bool inCheckPtr)
+{
+   #ifdef HXCPP_CHECK_POINTER
+      if (inCheckPtr)
+      {
+         if (!*(hx::Object **)frame) NullReference("This", false);
+         #ifdef HXCPP_GC_CHECK_POINTER
+         GCCheckPointer(*(hx::Object **)frame);
+         #endif
+      }
+   #endif
+   return *(hx::Object **)frame;
+}
+
+
+inline Float StackContext::getFloat(int inPos)
+{
+   return GetFloatAligned(frame+inPos);
+}
+inline String StackContext::getString(int inPos)
+{
+   return *(String *)(frame+inPos);
+}
+inline Dynamic StackContext::getObject(int inPos)
+{
+   return *(hx::Object **)(frame+inPos);
+}
+
+
+enum SignatureChar
+{
+   sigVoid = 'v',
+   sigBool = 'b',
+   sigInt = 'i',
+   sigFloat = 'f',
+   sigString = 's',
+   sigObject = 'o',
+};
+
+
+
+struct AutoStack
+{
+   CppiaCtx *ctx;
+   unsigned char *pointer;
+   unsigned char *frame;
+
+   AutoStack(CppiaCtx *inCtx) : ctx(inCtx)
+   {
+      frame = ctx->frame;
+      pointer = ctx->pointer;
+      ctx->frame = pointer;
+   }
+   AutoStack(CppiaCtx *inCtx,unsigned char *inPointer) : ctx(inCtx)
+   {
+      frame = ctx->frame;
+      pointer = inPointer;
+      ctx->frame = pointer;
+   }
+
+   ~AutoStack()
+   {
+      ctx->pointer = pointer;
+      ctx->frame = frame;
+   }
+};
+
+
+
+
+
+typedef hx::Object * (*ScriptableClassFactory)(void **inVTable,int inDataSize);
+typedef hx::Object * (*ScriptableInterfaceFactory)(void **inVTable,::hx::Object *);
+
+void ScriptableRegisterClass( String inName, int inBaseSize, ScriptNamedFunction *inFunctions, ScriptableClassFactory inFactory, ScriptFunction inConstruct);
+
+
+#if (HXCPP_API_LEVEL >= 330)
+void ScriptableRegisterInterface( String inName, ScriptNamedFunction *inFunctions, void *inInterfacePointers);
+void ScriptableRegisterNameSlots(const char *inNames[], int inLength);
+
+#else
+void ScriptableRegisterInterface( String inName, ScriptNamedFunction *inFunctions,const hx::type_info *inType, ScriptableInterfaceFactory inFactory);
+#endif
+
+::String ScriptableToString(void *);
+hx::Class ScriptableGetClass(void *);
+int ScriptableGetType(void *);
+void ScriptableMark(void *, hx::Object *, HX_MARK_PARAMS);
+void ScriptableVisit(void *, hx::Object *, HX_VISIT_PARAMS);
+bool ScriptableField(hx::Object *, const ::String &,hx::PropertyAccess inCallProp,Dynamic &outResult);
+bool ScriptableField(hx::Object *, int inName,hx::PropertyAccess inCallProp,Float &outResult);
+bool ScriptableField(hx::Object *, int inName,hx::PropertyAccess inCallProp,Dynamic &outResult);
+void ScriptableGetFields(hx::Object *inObject, Array< ::String> &outFields);
+bool ScriptableSetField(hx::Object *, const ::String &, Dynamic inValue,hx::PropertyAccess inCallProp, Dynamic &outValue);
+
+
+class CppiaLoadedModule_obj : public ::hx::Object
+{
+public:
+   virtual void run() = 0;
+   virtual void boot() = 0;
+   virtual ::hx::Class resolveClass( ::String inName) = 0;
+};
+typedef ::hx::ObjectPtr<CppiaLoadedModule_obj> CppiaLoadedModule;
+
+
+
+} // End namespace hx
+
+void __scriptable_load_neko(String inName);
+void __scriptable_load_cppia(String inCode);
+::hx::CppiaLoadedModule __scriptable_cppia_from_string(String inCode);
+::hx::CppiaLoadedModule __scriptable_cppia_from_data(Array<unsigned char> inBytes);
+void __scriptable_load_neko_bytes(Array<unsigned char> inBytes);
+void __scriptable_load_abc(Array<unsigned char> inBytes);
+
+#if (HXCPP_API_LEVEL >= 330)
+
+#define HX_SCRIPTABLE_REGISTER_INTERFACE(name,class) \
+    hx::ScriptableRegisterInterface( HX_CSTRING(name), __scriptableFunctions, & class##_scriptable )
+
+#else
+
+#define HX_SCRIPTABLE_REGISTER_INTERFACE(name,class) \
+    hx::ScriptableRegisterInterface( HX_CSTRING(name), __scriptableFunctions, &typeid(class), class##__scriptable::__script_create )
+
+#endif
+
+#define HX_SCRIPTABLE_REGISTER_CLASS(name,class) \
+   hx::ScriptableRegisterClass( HX_CSTRING(name), (int)offsetof(class##__scriptable,__scriptVTable) + sizeof(void *), __scriptableFunctions, class##__scriptable::__script_create, class##__scriptable::__script_construct )
+
+
+#ifdef HXCPP_VISIT_ALLOCS
+#define SCRIPTABLE_VISIT_FUNCTION \
+void __Visit(HX_VISIT_PARAMS) { super::__Visit(HX_VISIT_ARG); hx::ScriptableVisit(__scriptVTable[-1],this,HX_VISIT_ARG); }
+#else
+#define SCRIPTABLE_VISIT_FUNCTION
+#endif
+
+
+#define HX_DEFINE_SCRIPTABLE(ARG_LIST) \
+   inline void *operator new( size_t inSize, int inExtraDataSize ) \
+   { \
+      return hx::InternalNew(inSize + inExtraDataSize,true); \
+   } \
+   inline void operator delete(void *,int) {} \
+   public: \
+   void **__scriptVTable; \
+   static hx::Object *__script_create(void **inVTable, int inExtra) { \
+    __ME *result = new (inExtra) __ME(); \
+    result->__scriptVTable = inVTable; \
+   return result; } \
+   void ** __GetScriptVTable() { return __scriptVTable; } \
+   ::String toString() {  if (__scriptVTable[0] ) \
+     { hx::CppiaCtx *ctx = hx::CppiaCtx::getCurrent(); hx::AutoStack a(ctx); ctx->pushObject(this); return ctx->runString(__scriptVTable[0]); } \
+      else return __superString::toString(); } \
+   ::String __ToString() const { return hx::ScriptableToString(__scriptVTable[-1]); } \
+   hx::Class __GetClass() const { return hx::ScriptableGetClass(__scriptVTable[-1]); } \
+   int __GetType() const { return hx::ScriptableGetType(__scriptVTable[-1]); } \
+   void __Mark(HX_MARK_PARAMS) { super::__Mark(HX_MARK_ARG); hx::ScriptableMark(__scriptVTable[-1],this,HX_MARK_ARG); } \
+   SCRIPTABLE_VISIT_FUNCTION
+
+
+
+#define HX_DEFINE_SCRIPTABLE_INTERFACE \
+   void **__scriptVTable; \
+   Dynamic mDelegate; \
+   hx::Object *__GetRealObject() { return mDelegate.mPtr; } \
+   SCRIPTABLE_VISIT_FUNCTION \
+   void ** __GetScriptVTable() { return __scriptVTable; } \
+   public: \
+   static hx::Object *__script_create(void **inVTable,hx::Object *inDelegate) { \
+    __ME *result = new __ME(); \
+    result->__scriptVTable = inVTable; \
+    result->mDelegate = inDelegate; \
+    return result; }
+
+
+
+#define HX_DEFINE_SCRIPTABLE_DYNAMIC \
+ \
+	hx::Val __Field(const ::String &inName,hx::PropertyAccess inCallProp) \
+      { Dynamic result; if (hx::ScriptableField(this,inName,inCallProp,result)) return result; return super::__Field(inName,inCallProp); } \
+	Float __INumField(int inFieldID) \
+		{ Float result; if (hx::ScriptableField(this,inFieldID,hx::paccAlways,result)) return result; return super::__INumField(inFieldID); } \
+	Dynamic __IField(int inFieldID) \
+		{ Dynamic result; if (hx::ScriptableField(this,inFieldID,hx::paccAlways,result)) return result; return super::__IField(inFieldID); } \
+   hx::Val __SetField(const ::String &inName,const hx::Val &inValue,hx::PropertyAccess inCallProp) \
+   { \
+      Dynamic value; \
+      if (hx::ScriptableSetField(this, inName, inValue,inCallProp,value)) \
+         return value; \
+		return super::__SetField(inName,inValue,inCallProp); \
+   } \
+	void __GetFields(Array< ::String> &outFields) \
+		{ super::__GetFields(outFields); hx::ScriptableGetFields(this,outFields); }
+
+
+
+
+#endif

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/StackContext.h

@@ -0,0 +1,752 @@
+#ifndef HX_STACK_CONTEXT_H
+#define HX_STACK_CONTEXT_H
+
+#include "QuickVec.h"
+
+#ifdef HXCPP_SINGLE_THREADED_APP
+  #define HX_CTX_GET ::hx::gMainThreadContext
+#else
+  #define HX_CTX_GET ((::hx::StackContext *)::hx::tlsStackContext)
+#endif
+
+// Set:
+// HXCPP_STACK_LINE if stack line numbers need to be tracked
+// HXCPP_STACK_TRACE if stack frames need to be tracked
+
+// Keep track of lines - more accurate stack traces for exceptions, also
+// needed for the debugger
+#if (defined(HXCPP_DEBUG) || defined(HXCPP_DEBUGGER)) && !defined(HXCPP_STACK_LINE)
+#define HXCPP_STACK_LINE
+#endif
+
+// Do we need to keep a stack trace - for basic exception handelling, also needed for the debugger
+// At a minimum, you can track the functions calls and nothing else
+#if (defined(HXCPP_STACK_LINE) || defined(HXCPP_TELEMETRY) || defined(HXCPP_PROFILER) || defined(HXCPP_DEBUG)) && !defined(HXCPP_STACK_TRACE)
+   #define HXCPP_STACK_TRACE
+#endif
+
+#if defined(HXCPP_STACK_TRACE) && defined(HXCPP_SCRIPTABLE)
+#define HXCPP_STACK_SCRIPTABLE
+#endif
+// HXCPP_DEBUG_HASH == HXCPP_DEBUGGER
+// HXCPP_STACK_VARS == HXCPP_DEBUGGER
+
+
+// HX_STACKFRAME(pos)    - tracks position according to define.  May be optimized away.
+// HX_GC_STACKFRAME(pos) - tracks position according to define, but is never optimized away
+// HX_JUST_GC_STACKFRAME - never tracks position, never optimized away
+
+// Setup the _hx_stackframe variable
+#ifdef HXCPP_STACK_TRACE
+   // Setup the 'HX_DEFINE_STACK_FRAME' 'HX_LOCAL_STACK_FRAME' macro.
+   // This will be empty, just track functions(release), track functions and lines(debug) or track everything (debugger)
+   #define HX_DECLARE_STACK_FRAME(name) extern ::hx::StackPosition name;
+
+   #ifdef HXCPP_STACK_LINE
+
+      #ifdef HXCPP_DEBUGGER
+         #define HX_DEFINE_STACK_FRAME(varName, className, functionName, classFunctionHash, fullName,fileName,     \
+                             lineNumber, fileHash ) \
+          ::hx::StackPosition varName(className, functionName, fullName, fileName, lineNumber, \
+                                            classFunctionHash, fileHash);
+      #else
+         #define HX_DEFINE_STACK_FRAME(varName, className, functionName, classFunctionHash, fullName,fileName,     \
+                          lineNumber, fileHash ) \
+          ::hx::StackPosition varName(className, functionName, fullName, fileName, lineNumber);
+      #endif
+   #else
+
+      #define HX_DEFINE_STACK_FRAME(varName, className, functionName, classFunctionHash, fullName,fileName,     \
+                          lineNumber, fileHash ) \
+      ::hx::StackPosition varName(className, functionName, fullName, fileName);
+
+   #endif
+
+   #define HX_LOCAL_STACK_FRAME(a,b,c,d,e,f,g,h) static HX_DEFINE_STACK_FRAME(a,b,c,d,e,f,g,h)
+
+   // Haxe < 330 does not create position pointers, and we must use a local one.
+   // This code will hst the 'HX_STACK_FRAME' macro
+   #define HX_STACK_FRAME(className, functionName, classFunctionHash, fullName,fileName, lineNumber, fileHash ) \
+      HX_DEFINE_STACK_FRAME(__stackPosition, className, functionName, classFunctionHash, fullName,fileName, lineNumber, fileHash ) \
+      ::hx::StackFrame _hx_stackframe(&__stackPosition);
+
+   // Newer code will use the HX_STACKFRAME macro
+   #define HX_STACKFRAME(pos) ::hx::StackFrame _hx_stackframe(pos);
+   #define HX_GC_STACKFRAME(pos) ::hx::StackFrame _hx_stackframe(pos);
+
+   // Must record the stack state at the catch
+   #define HX_STACK_BEGIN_CATCH __hxcpp_stack_begin_catch();
+   #define HX_JUST_GC_STACKFRAME ::hx::JustGcStackFrame _hx_stackframe;
+   #define HX_CTX _hx_stackframe.ctx
+#else
+   // No need to track frame
+   #define HX_DECLARE_STACK_FRAME(name)
+   #define HX_STACK_BEGIN_CATCH
+   #define HX_DEFINE_STACK_FRAME(__stackPosition, className, functionName, classFunctionHash, fullName,fileName, lineNumber, fileHash )
+   #define HX_LOCAL_STACK_FRAME(a,b,c,d,e,f,g,h)
+   #define HX_STACK_FRAME(className, functionName, classFunctionHash, fullName,fileName, lineNumber, fileHash )
+   #define HX_STACKFRAME(pos)
+   #define HX_JUST_GC_STACKFRAME ::hx::StackContext *_hx_ctx = HX_CTX_GET;
+   #define HX_GC_STACKFRAME(pos) HX_JUST_GC_STACKFRAME
+   #define HX_CTX _hx_ctx
+#endif
+
+#define HX_GC_CTX HX_CTX
+
+
+// Setup debugger catchable and variable macros...
+#ifdef HXCPP_DEBUGGER
+
+   // Emitted at the beginning of every instance fuction.  ptr is "this".
+   // Only if stack variables are to be tracked
+   #define HX_STACK_THIS(ptr) ::hx::StackThis __stackthis(_hx_stackframe.variables, ptr);
+
+   // Emitted at the beginning of every function that takes arguments.
+   // name is the name of the argument.
+   // For the lifetime of this object, the argument will be in the [arguments]
+   // list of the stack frame in which the arg was declared
+   // Only if stack variables are to be tracked
+   #define HX_STACK_ARG(cpp_var, haxe_name) \
+       ::hx::StackVariable __stackargument_##cpp_var(_hx_stackframe.variables, true, haxe_name, &cpp_var);
+
+   // Emitted whenever a Haxe value is pushed on the stack.  cpp_var is the local
+   // cpp variable, haxe_name is the name that was used in haxe for it
+   // Only if stack variables are to be tracked
+   #define HX_STACK_VAR(cpp_var, haxe_name)                                \
+       ::hx::StackVariable __stackvariable_##cpp_var(_hx_stackframe.variables, false, haxe_name, &cpp_var);
+
+   #define HX_STACK_CATCHABLE(T, n)                                        \
+       hx::StackCatchable __stackcatchable_##n                             \
+           (_hx_stackframe, reinterpret_cast<T *>(&_hx_stackframe));
+
+   // If HXCPP_DEBUGGER is enabled, then a throw is checked to see if it
+   // can be caught and if not, the debugger is entered.  Otherwise, the
+   // throw proceeds as normal.
+   #define HX_STACK_DO_THROW(e) __hxcpp_dbg_checkedThrow(e)
+   #define HX_STACK_DO_RETHROW(e) __hxcpp_dbg_checkedRethrow(e)
+
+
+   #define HX_VAR(type,name) type name; HX_STACK_VAR(name, #name)
+   #define HX_VARI(type,name) type name; HX_STACK_VAR(name, #name) name
+   #define HX_VAR_NAME(type,name,dbgName) type name; HX_STACK_VAR(name, dbgName)
+   #define HX_VARI_NAME(type,name,dbgName) type name; HX_STACK_VAR(name, dbgName) name
+
+#else // Non-debugger versions.  Just stub-out.
+
+   #define HX_STACK_THIS(ptr)
+   #define HX_STACK_ARG(cpp_var, haxe_name)
+   #define HX_STACK_VAR(cpp_var, haxe_name)
+   #define HX_STACK_CATCHABLE(T, n)
+
+   #define HX_VAR(type,name) type name
+   #define HX_VARI(type,name) type name
+   #define HX_VAR_NAME(type,name,dbgName) type name
+   #define HX_VARI_NAME(type,name,dbgName) type name
+
+   // Just throw - move to hx::Throw function?
+   #define HX_STACK_DO_THROW(e) ::hx::Throw(e)
+   #define HX_STACK_DO_RETHROW(e) ::hx::Rethrow(e)
+#endif // HXCPP_STACK_VARS
+
+
+
+
+// Emitted after every Haxe line.  number is the original Haxe line number.
+// Only if stack lines are to be tracked
+#ifdef HXCPP_STACK_LINE
+   // If the debugger is enabled, must check for a breakpoint at every line.
+   #ifdef HXCPP_DEBUGGER
+      #define HX_STACK_LINE(number)                                           \
+          _hx_stackframe.lineNumber = number;                                   \
+          /* This is incorrect - a read memory barrier is needed here. */     \
+          /* For now, just live with the exceedingly rare cases where */      \
+          /* breakpoints are missed */                                        \
+          if (::hx::gShouldCallHandleBreakpoints) {                             \
+              __hxcpp_on_line_changed(_hx_stackframe.ctx);                    \
+         }
+      #define HX_STACK_LINE_QUICK(number) _hx_stackframe.lineNumber = number;
+   #else
+      // Just set it
+      #define HX_STACK_LINE(number) _hx_stackframe.lineNumber = number;
+      #define HX_STACK_LINE_QUICK(number) _hx_stackframe.lineNumber = number;
+   #endif
+#else
+   #define HX_STACK_LINE(number)
+   #define HX_STACK_LINE_QUICK(number)
+#endif
+
+
+// For tidier generated code
+#define HXLINE(number) HX_STACK_LINE(number)
+#define HXDLIN(number)
+
+
+// To support older versions of the haxe compiler that emit HX_STACK_PUSH
+// instead of HX_STACK_FRAME.  If the old haxe compiler is used with this
+// new debugger implementation, className.functionName breakpoints will
+// not work, and stack reporting will be a little weird.  If you want to
+// use debugging, you really should upgrade to a newer haxe compiler.
+
+#undef HX_STACK_PUSH
+#define HX_STACK_PUSH(fullName, fileName, lineNumber)                  \
+    HX_STACK_FRAME("", fullName, 0, fullName, fileName, lineNumber, 0)
+
+#if defined(HXCPP_STACK_TRACE) || defined(HXCPP_TELEMETRY)
+   #define HXCPP_STACK_IDS
+#endif
+
+
+namespace hx
+{
+
+
+class StackFrame;
+struct StackContext;
+
+class Profiler;
+void profDestroy(Profiler *);
+void profAttach(Profiler *, StackContext *);
+void profDetach(Profiler *, StackContext *);
+void profSample(Profiler *, StackContext *inContext);
+
+
+class Telemetry;
+Telemetry *tlmCreate(StackContext *);
+void tlmDestroy(Telemetry *);
+void tlmAttach(Telemetry *, StackContext *);
+void tlmDetach(Telemetry *);
+void tlmSampleEnter(Telemetry *, StackFrame *inFrame);
+void tlmSampleExit(Telemetry *);
+
+
+class DebuggerContext;
+DebuggerContext *dbgCtxCreate(StackContext *);
+void dbgCtxDestroy(DebuggerContext *);
+void dbgCtxAttach(DebuggerContext *, StackContext *);
+void dbgCtxDetach(DebuggerContext *);
+void dbgCtxEnable(DebuggerContext *, bool inEnable);
+
+
+struct scriptCallable;
+class StackVariable;
+class StackCatchable;
+
+template<typename T> struct Hash;
+struct TWeakStringSet;
+typedef Hash<TWeakStringSet> WeakStringSet;
+
+extern const char* EXTERN_CLASS_NAME;
+
+
+#ifdef HXCPP_DEBUGGER
+extern volatile bool gShouldCallHandleBreakpoints;
+
+
+// These must match the values present in cpp.vm.Debugger
+enum DebugStatus
+{
+    DBG_STATUS_INVALID = 0, // Not present or needed in cpp.vm.Debugger
+    DBG_STATUS_RUNNING = 1,
+    DBG_STATUS_STOPPED_BREAK_IMMEDIATE = 2,
+    DBG_STATUS_STOPPED_BREAKPOINT = 3,
+    DBG_STATUS_STOPPED_UNCAUGHT_EXCEPTION = 4,
+    DBG_STATUS_STOPPED_CRITICAL_ERROR = 5
+};
+
+enum ExecutionTrace
+{
+   exeTraceOff = 0,
+   exeTraceFuncs = 1,
+   exeTraceLines = 2,
+};
+
+extern ExecutionTrace sExecutionTrace;
+
+#endif
+
+
+
+
+
+class StackPosition
+{
+public:
+    // These are constant during the lifetime of the stack frame
+    const char *className;
+    const char *functionName;
+    const char *fullName; // this is className.functionName - used for profiler
+    const char *fileName;
+    int firstLineNumber;
+
+    #if defined(HXCPP_STACK_SCRIPTABLE)
+    // Information about the current cppia function
+    struct ScriptCallable *scriptCallable;
+    #endif
+
+    // These are only used if HXCPP_DEBUGGER is defined
+    #ifdef HXCPP_DEBUGGER
+    int fileHash;
+    int classFuncHash;
+    #else
+    enum { fileHash = 0, classFuncHash=0 };
+    #endif
+
+    inline StackPosition() { }
+
+    // The constructor automatically adds the StackFrame to the list of
+    // stack frames for the current thread
+    inline StackPosition(const char *inClassName, const char *inFunctionName,
+                         const char *inFullName, const char *inFileName
+                         #ifdef HXCPP_STACK_LINE
+                         , int inLineNumber
+                         #endif
+                         #ifdef HXCPP_DEBUGGER
+                         ,int inClassFunctionHash, int inFileHash
+                         #endif
+                  )
+
+       : className(inClassName), functionName(inFunctionName)
+         ,fullName(inFullName), fileName(inFileName)
+         #ifdef HXCPP_DEBUGGER
+         ,classFuncHash(inClassFunctionHash)
+         ,fileHash(inFileHash)
+         #endif
+         #ifdef HXCPP_STACK_LINE
+         ,firstLineNumber(inLineNumber)
+         #endif
+    {
+       #if defined(HXCPP_STACK_SCRIPTABLE)
+       // Information about the current cppia function
+       scriptCallable = 0;
+       #endif
+    }
+
+};
+
+
+
+
+
+
+#ifdef HXCPP_STACK_TRACE
+struct ExceptionStackFrame
+{
+   #ifdef HXCPP_STACK_LINE
+   int line;
+   #endif
+
+   #if HXCPP_API_LEVEL > 330
+   const hx::StackPosition *position;
+   #else
+   const char *className;
+   const char *functionName;
+   const char *fileName;
+   #endif
+
+   ExceptionStackFrame(const StackFrame &inFrame);
+   ::String format(bool inForDisplay);
+   ::String toDisplay();
+   ::String toString();
+};
+#endif
+
+
+#ifdef HXCPP_SCRIPTABLE
+enum
+{
+   bcrBreak    = 0x01,
+   bcrContinue = 0x02,
+   bcrReturn   = 0x04,
+
+   bcrLoop     = (bcrBreak | bcrContinue),
+};
+
+
+
+#endif
+
+
+struct MarkChunk
+{
+   enum { SIZE = 62 };
+   enum { OBJ_ARRAY_JOB = -1 };
+
+   inline MarkChunk() : count(0), next(0) { }
+
+   int        count;
+
+   union
+   {
+      hx::Object *stack[SIZE];
+      struct
+      {
+         hx::Object **arrayBase;
+         int        arrayElements;
+      };
+   };
+   MarkChunk  *next;
+
+   inline void push(Object *inObj)
+   {
+      stack[count++] = inObj;
+   }
+   inline hx::Object *pop()
+   {
+      if (count)
+         return stack[--count];
+      return 0;
+   }
+   MarkChunk *swapForNew();
+};
+
+
+
+struct StackContext : public hx::ImmixAllocator
+{
+   #ifdef HXCPP_STACK_IDS
+      int  mThreadId;
+   #endif
+
+   #ifdef HXCPP_STACK_TRACE
+      hx::QuickVec<StackFrame *> mStackFrames;
+      hx::QuickVec<hx::ExceptionStackFrame> mExceptionStack;
+      // Updated only when a thrown exception unwinds the stack
+      bool mIsUnwindingException;
+
+      #ifdef HXCPP_STACK_SCRIPTABLE
+         // TODO - combine CppaCtx and StackContext
+      #endif
+
+      #ifdef HXCPP_DEBUGGER
+         DebuggerContext  *mDebugger;
+      #endif
+
+      #ifdef HXCPP_PROFILER
+         // Profiling support
+         Profiler *mProfiler;
+      #endif
+
+   #endif
+
+   #ifdef HXCPP_TELEMETRY
+      // Telemetry support
+      Telemetry *mTelemetry;
+   #endif
+
+   #ifdef HXCPP_COMBINE_STRINGS
+   WeakStringSet *stringSet;
+   #endif
+
+   #ifdef HXCPP_GC_GENERATIONAL
+   MarkChunk *mOldReferrers;
+   inline void pushReferrer(hx::Object *inObj)
+   {
+      // If collector is running on non-generational mode, mOldReferrers will be null
+      if (mOldReferrers)
+      {
+         mOldReferrers->push(inObj);
+         if (mOldReferrers->count==MarkChunk::SIZE)
+            mOldReferrers = mOldReferrers->swapForNew();
+      }
+   }
+   #endif
+
+   #ifdef HXCPP_CATCH_SEGV
+      #ifdef _MSC_VER
+      _se_translator_function mOldSignalFunc;
+      #else
+      void (*mOldSignalFunc)(int);
+      #endif
+   #endif
+
+   StackContext();
+   ~StackContext();
+   void onThreadAttach();
+   void onThreadDetach();
+
+
+   #ifdef HXCPP_STACK_TRACE // {
+   void tracePosition();
+
+   // Note that the stack frames are manipulated without holding any locks.
+   // This is because the manipulation of stack frames can only be done by
+   // the thread that "owns" that stack frame.  The only other contention on
+   // the call stack is from calls to GetThreadInfo() and GetThreadInfos(),
+   // and these should only be called when the thread for which the call
+   // stack is being acquired is stopped in a breakpoint anyway, thus there
+   // can be no contention on the contents of the CallStack in that case
+   // either.
+
+   inline void pushFrame(StackFrame *inFrame)
+   {
+      #ifdef HXCPP_PROFILER
+      if (mProfiler)
+         profSample(mProfiler,this);
+      #endif
+
+      #ifdef HXCPP_TELEMETRY
+      if (mTelemetry)
+         tlmSampleEnter(mTelemetry,inFrame);
+      #endif
+
+      mIsUnwindingException = false;
+      mStackFrames.push(inFrame);
+
+      #ifdef HXCPP_DEBUGGER
+      if (sExecutionTrace!=exeTraceOff)
+         tracePosition();
+      #endif
+   }
+
+   inline void popFrame(StackFrame *inFrame)
+   {
+      #ifdef HXCPP_TELEMETRY
+      if (mTelemetry)
+         tlmSampleExit(mTelemetry);
+      #endif
+
+      if (mIsUnwindingException)
+      {
+         // Use default operator=
+         mExceptionStack.push( *inFrame );
+      }
+
+      mStackFrames.pop_back();
+   }
+
+   void getCurrentCallStackAsStrings(Array<String> result, bool skipLast);
+   void getCurrentExceptionStackAsStrings(Array<String> result);
+   StackFrame *getCurrentStackFrame() { return mStackFrames.back(); }
+   StackFrame *getStackFrame(int inIndex) { return mStackFrames[inIndex]; }
+   int getDepth() const { return mStackFrames.size(); }
+   inline const char *getFullNameAtDepth(int depth) const;
+   void  dumpExceptionStack();
+
+   // Called when a throw occurs
+   void setLastException();
+   void pushLastException();
+    // Called when a catch block begins to be executed.  hxcpp wants to track
+    // the stack back through the catches so that it can be dumped if
+    // uncaught.  If inAll is true, the entire stack is captured immediately.
+    // If inAll is false, only the last stack frame is captured.
+    void beginCatch(bool inAll);
+
+   #endif // } HXCPP_STACK_TRACE
+
+   #ifdef HXCPP_DEBUGGER
+   void enableCurrentThreadDebugging(bool inEnable)
+   {
+      dbgCtxEnable(mDebugger,inEnable);
+   }
+   #endif
+
+   static inline StackContext *getCurrent()
+   {
+      return HX_CTX_GET;
+   }
+
+   #ifdef HXCPP_STACK_IDS
+   static void getAllStackIds( QuickVec<int> &outIds );
+   static StackContext *getStackForId(int id);
+   #endif
+
+
+   #ifdef HXCPP_SCRIPTABLE
+   unsigned char *stack;
+   unsigned char *pointer;
+   unsigned char *frame;
+   class Object  *exception;
+
+   unsigned int breakContReturn;
+   int  byteMarkId;
+
+   template<typename T>
+   void push(T inValue)
+   {
+      *(T *)pointer = inValue;
+      pointer += sizeof(T);
+   }
+   unsigned char *stackAlloc(int inSize)
+   {
+      unsigned char *p = pointer;
+      pointer += inSize;
+      return p;
+   }
+   void stackFree(int inSize)
+   {
+      pointer -= inSize;
+   }
+
+   int getFrameSize() const { return pointer-frame; }
+
+   int runInt(void *vtable);
+   Float runFloat(void *vtable);
+   String runString(void *vtable);
+   void runVoid(void *vtable);
+   Dynamic runObject(void *vtable);
+   hx::Object *runObjectPtr(void *vtable);
+
+   void push(bool &inValue) { *(int *)pointer = inValue; pointer += sizeof(int); }
+   inline void pushBool(bool b) { *(int *)pointer = b; pointer += sizeof(int); }
+   inline void pushInt(int i) { *(int *)pointer = i; pointer += sizeof(int); }
+
+   inline void pushFloat(Float f);
+   inline void pushString(const String &s);
+   inline void pushObject(Dynamic d);
+   inline void returnFloat(Float f);
+   inline void returnString(const String &s);
+   inline void returnObject(Dynamic d);
+   inline hx::Object *getThis(bool inCheckPtr=true);
+
+   inline void returnBool(bool b) { *(int *)frame = b; }
+   inline void returnInt(int i) { *(int *)frame = i; }
+   inline bool getBool(int inPos=0) { return *(bool *)(frame+inPos); }
+   inline int getInt(int inPos=0) { return *(int *)(frame+inPos); }
+
+   inline Float getFloat(int inPos=0);
+   inline String getString(int inPos=0);
+   inline Dynamic getObject(int inPos=0);
+   inline hx::Object *getObjectPtr(int inPos=0) { return *(hx::Object **)(frame+inPos); }
+
+
+   void breakFlag() { breakContReturn |= bcrBreak; }
+   void continueFlag() { breakContReturn |= bcrContinue; }
+   void returnFlag() { breakContReturn |= bcrReturn; }
+
+   #endif
+
+};
+
+
+typedef StackContext CppiaCtx;
+
+
+
+class StackFrame
+{
+public:
+   StackContext        *ctx;
+
+   #ifdef HXCPP_STACK_TRACE // {
+   const StackPosition *position;
+
+      #ifdef HXCPP_STACK_LINE
+         // Current line number, changes during the lifetime of the stack frame.
+         // Only updated if HXCPP_STACK_LINE is defined.
+         int lineNumber;
+
+         #ifdef HXCPP_DEBUGGER
+         // Function arguments and local variables in reverse order of their
+         // declaration.  If a variable name is in here twice, the first version is
+         // the most recently scoped one and should be used.  Only updated if
+         // HXCPP_DEBUGGER is defined.
+         StackVariable *variables;
+
+         // The list of types that can be currently caught in the stack frame.
+         StackCatchable *catchables;
+         #endif
+      #endif
+
+       // The constructor automatically adds the StackFrame to the list of
+       // stack frames for the current thread
+       inline StackFrame(const StackPosition *inPosition
+              ) : position(inPosition)
+       {
+          #ifdef HXCPP_STACK_LINE
+             lineNumber = inPosition->firstLineNumber;
+             #ifdef HXCPP_DEBUGGER
+             variables = 0;
+             catchables = 0;
+             #endif
+          #endif
+
+
+          ctx =  HX_CTX_GET;
+          ctx->pushFrame(this);
+       }
+
+
+       // The destructor automatically removes the StackFrame from the list of
+       // stack frames for the current thread
+       ~StackFrame()
+       {
+          ctx->popFrame(this);
+       }
+
+       ::String toString();
+       ::String toDisplay();
+   #else // }  !HXCPP_STACK_TRACE {
+
+       // Release version only has ctx
+       inline StackFrame()
+       {
+          ctx =  HX_CTX_GET;
+       }
+
+   #endif // }
+
+};
+
+#ifdef HXCPP_STACK_TRACE
+const char *StackContext::getFullNameAtDepth(int depth) const
+{
+   return mStackFrames[depth]->position->fullName;
+}
+#endif
+
+class JustGcStackFrame
+{
+public:
+   StackContext        *ctx;
+   inline JustGcStackFrame() : ctx(HX_CTX_GET) { }
+};
+
+
+
+
+} // end namespace hx
+
+
+
+// Some functions used by AdvancedDebug.cpp
+// Returns the thread number of the calling thread
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+int __hxcpp_GetCurrentThreadNumber();
+
+// Called by the main function when an uncaught exception occurs to dump
+// the stack leading to the exception
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+void __hx_dump_stack();
+
+// The macro HX_STACK_BEGIN_CATCH, which is emitted at the beginning of every
+// catch block, calls this in debug mode to let the debugging system know that
+// a catch block has been entered
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+void __hxcpp_stack_begin_catch();
+
+// Last chance to throw an exception for null-pointer access
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+void __hxcpp_set_critical_error_handler(Dynamic inHandler);
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+void __hxcpp_execution_trace(int inLevel);
+
+// Used by debug breakpoints and execution trace
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+void __hxcpp_set_stack_frame_line(int);
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+void __hxcpp_on_line_changed(hx::StackContext *);
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+void __hxcpp_set_debugger_info(const char **inAllClasses, const char **inFullPaths);
+
+
+void __hxcpp_dbg_getScriptableVariables(hx::StackFrame *stackFrame, ::Array< ::Dynamic> outNames);
+bool __hxcpp_dbg_getScriptableValue(hx::StackFrame *stackFrame, String inName, ::Dynamic &outValue);
+bool __hxcpp_dbg_setScriptableValue(hx::StackFrame *StackFrame, String inName, ::Dynamic inValue);
+
+
+
+
+#endif // HX_STACK_CTX_H

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/StdLibs.h

@@ -0,0 +1,932 @@
+#ifndef HX_STDLIBS_H
+#define HX_STDLIBS_H
+
+// --- Resource -------------------------------------------------------------
+
+namespace haxe {
+	namespace ds {
+		class HXCPP_CLASS_ATTRIBUTES StringMap_obj;
+	}
+}
+
+namespace hx
+{
+struct Resource
+{
+   String        mName;
+   int           mDataLength;
+   unsigned char *mData;
+
+   bool operator<(const Resource &inRHS) const { return mName < inRHS.mName; }
+};
+
+Resource *GetResources();
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+void RegisterResources(hx::Resource *inResources);
+
+
+struct AnyCast
+{
+   template<typename T>
+   explicit AnyCast(T* inPtr) : mPtr((void *)inPtr) { }
+
+   template<typename T>
+   operator T*() const { return (T*)mPtr; }
+
+   void *mPtr;
+};
+
+} // end namespace hx
+
+Array<String>        __hxcpp_resource_names();
+String               __hxcpp_resource_string(String inName);
+Array<unsigned char> __hxcpp_resource_bytes(String inName);
+
+
+
+
+// System access
+Array<String>  __get_args();
+double         __time_stamp();
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_print_string(const String &inV);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_println_string(const String &inV);
+
+template<typename T> inline void __hxcpp_println(T inV)
+{
+   Dynamic d(inV);
+   __hxcpp_println_string(d);
+}
+// Specialization that does not need dynamic boxing
+template<> inline void __hxcpp_println(String inV)
+{
+   __hxcpp_println_string(inV);
+}
+
+template<typename T> inline void __hxcpp_print(T inV)
+{
+   Dynamic d(inV);
+   __hxcpp_print_string(d);
+}
+// Specialization that does not need dynamic boxing
+template<> inline void __hxcpp_print(String inV)
+{
+   __hxcpp_print_string(inV);
+}
+
+
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES void __trace(Dynamic inPtr, Dynamic inData);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_exit(int inExitCode);
+void           __hxcpp_stdlibs_boot();
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES int hxcpp_alloc_kind();
+
+// --- Maths ---------------------------------------------------------
+double __hxcpp_drand();
+HXCPP_EXTERN_CLASS_ATTRIBUTES int __hxcpp_irand(int inMax);
+
+// --- Casting/Converting ---------------------------------------------------------
+HXCPP_EXTERN_CLASS_ATTRIBUTES bool  __instanceof(const Dynamic &inValue, const Dynamic &inType);
+HXCPP_EXTERN_CLASS_ATTRIBUTES int   __int__(double x);
+HXCPP_EXTERN_CLASS_ATTRIBUTES bool  __hxcpp_same_closure(Dynamic &inF1,Dynamic &inF2);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic __hxcpp_parse_int(const String &inString);
+HXCPP_EXTERN_CLASS_ATTRIBUTES double __hxcpp_parse_float(const String &inString);
+HXCPP_EXTERN_CLASS_ATTRIBUTES double __hxcpp_parse_substr_float(const String &inString, int start, int len);
+HXCPP_EXTERN_CLASS_ATTRIBUTES int __hxcpp_parse_substr_int(const String &inString, int start=0, int len=-1);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic __hxcpp_create_var_args(Dynamic &inArrayFunc);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_set_float_format(String inFormat);
+
+inline int _hx_idiv(int inNum,int inDenom) { return inNum/inDenom; }
+inline int _hx_imod(int inNum,int inDenom) { return inNum%inDenom; }
+inline int _hx_cast_int(int inX) { return inX; }
+inline int _hx_fast_floor(double inX) {
+   union Cast
+   {
+      double d;
+      long l;
+   };
+   Cast c;
+   c.d = (inX-0.5) + 6755399441055744.0;
+   return c.l;
+}
+
+
+
+// --- CFFI helpers ------------------------------------------------------------------
+
+// Used for accessing object fields by integer ID, rather than string ID.
+// Used mainly for neko ndll interaction.
+HXCPP_EXTERN_CLASS_ATTRIBUTES int           __hxcpp_field_to_id( const char *inField );
+HXCPP_EXTERN_CLASS_ATTRIBUTES const String &__hxcpp_field_from_id( int f );
+HXCPP_EXTERN_CLASS_ATTRIBUTES int           __hxcpp_register_prim(const HX_CHAR *inName,void *inFunc);
+
+// Get function pointer from dll file
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic __loadprim(String inLib, String inPrim,int inArgCount);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void *__hxcpp_get_proc_address(String inLib, String inPrim,bool inNdll, bool inQuietFail=false);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_run_dll(String inLib, String inPrim);
+// Can assign to function pointer without error
+inline hx::AnyCast __hxcpp_cast_get_proc_address(String inLib, String inPrim,bool inQuietFail=false)
+{
+   return hx::AnyCast(__hxcpp_get_proc_address(inLib,inPrim,false,inQuietFail));
+}
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES int __hxcpp_unload_all_libraries();
+HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_push_dll_path(String inPath);
+HXCPP_EXTERN_CLASS_ATTRIBUTES String __hxcpp_get_dll_extension();
+HXCPP_EXTERN_CLASS_ATTRIBUTES String __hxcpp_get_bin_dir();
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES String __hxcpp_get_kind(Dynamic inObject);
+
+
+// Loading functions via name (dummy return value)
+
+
+
+// --- haxe.io.BytesData ----------------------------------------------------------------
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_bytes_of_string(Array<unsigned char> &outBytes,const String &inString);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_string_of_bytes(Array<unsigned char> &inBytes,String &outString,int pos,int len,bool inCopyPointer=false);
+// UTF8 processing
+HXCPP_EXTERN_CLASS_ATTRIBUTES String __hxcpp_char_array_to_utf8_string(Array<int> &inChars,int inFirst=0, int inLen=-1);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Array<int> __hxcpp_utf8_string_to_char_array(String &inString);
+HXCPP_EXTERN_CLASS_ATTRIBUTES String __hxcpp_char_bytes_to_utf8_string(String &inBytes);
+HXCPP_EXTERN_CLASS_ATTRIBUTES String __hxcpp_utf8_string_to_char_bytes(String &inUTF8);
+
+
+#ifdef HXCPP_GC_GENERATIONAL
+   #define HX_MAP_THIS this, h
+   #define HX_MAP_THIS_ this,
+   #define HX_MAP_THIS_ARG hx::Object *owner, Dynamic &ioHash
+#else
+   #define HX_MAP_THIS h
+   #define HX_MAP_THIS_ 
+   #define HX_MAP_THIS_ARG Dynamic &ioHash
+#endif
+
+// --- HashRoot ---------------------------------------------------------------------
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES int           __root_hash_size(Dynamic *rtHash);
+
+// --- IntHash ----------------------------------------------------------------------
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES inline hx::Object   *__int_hash_create() { return 0; }
+HXCPP_EXTERN_CLASS_ATTRIBUTES void          __int_hash_set(HX_MAP_THIS_ARG,int inKey,const Dynamic &value);
+HXCPP_EXTERN_CLASS_ATTRIBUTES bool          __int_hash_exists(Dynamic &hash,int inKey);
+HXCPP_EXTERN_CLASS_ATTRIBUTES bool          __int_hash_remove(Dynamic &hash,int inKey);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Array<int>    __int_hash_keys(Dynamic &hash);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic       __int_hash_values(Dynamic &hash);
+// Typed IntHash access...
+HXCPP_EXTERN_CLASS_ATTRIBUTES void          __int_hash_set_int(HX_MAP_THIS_ARG,int inKey,int inValue);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void          __int_hash_set_string(HX_MAP_THIS_ARG,int inKey,::String inValue);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void          __int_hash_set_float(HX_MAP_THIS_ARG,int inKey,Float inValue);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void          __int_hash_set_int64(HX_MAP_THIS_ARG,int inKey,cpp::Int64 inValue);
+HXCPP_EXTERN_CLASS_ATTRIBUTES ::String      __int_hash_to_string(Dynamic &hash);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void          __int_hash_clear(Dynamic &hash);
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic       __int_hash_get(Dynamic inHash,int inKey);
+HXCPP_EXTERN_CLASS_ATTRIBUTES int           __int_hash_get_int(Dynamic inHash,int inKey);
+HXCPP_EXTERN_CLASS_ATTRIBUTES ::String      __int_hash_get_string(Dynamic inHash,int inKey);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Float         __int_hash_get_float(Dynamic inHash,int inKey);
+HXCPP_EXTERN_CLASS_ATTRIBUTES cpp::Int64    __int_hash_get_int64(Dynamic inHash,int inKey);
+inline  bool   __int_hash_get_bool(Dynamic inHash,int inKey) { return __int_hash_get_int(inHash,inKey); }
+
+// --- Int64Hash -----------------------------------------------------------------------
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES inline hx::Object   *__int64_hash_create() { return 0; }
+HXCPP_EXTERN_CLASS_ATTRIBUTES void              __int64_hash_set(HX_MAP_THIS_ARG,cpp::Int64 inKey,const Dynamic &value);
+HXCPP_EXTERN_CLASS_ATTRIBUTES bool              __int64_hash_exists(Dynamic &hash,cpp::Int64 inKey);
+HXCPP_EXTERN_CLASS_ATTRIBUTES bool              __int64_hash_remove(Dynamic &hash,cpp::Int64 inKey);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Array<cpp::Int64> __int64_hash_keys(Dynamic &hash);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic           __int64_hash_values(Dynamic &hash);
+// Typed IntHash access...
+HXCPP_EXTERN_CLASS_ATTRIBUTES void          __int64_hash_set_int(HX_MAP_THIS_ARG,cpp::Int64 inKey,int inValue);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void          __int64_hash_set_string(HX_MAP_THIS_ARG,cpp::Int64 inKey,::String inValue);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void          __int64_hash_set_float(HX_MAP_THIS_ARG,cpp::Int64 inKey,Float inValue);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void          __int64_hash_set_int64(HX_MAP_THIS_ARG,cpp::Int64 inKey,cpp::Int64 inValue);
+HXCPP_EXTERN_CLASS_ATTRIBUTES ::String      __int64_hash_to_string(Dynamic &hash);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void          __int64_hash_clear(Dynamic &hash);
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic       __int64_hash_get(Dynamic inHash,cpp::Int64 inKey);
+HXCPP_EXTERN_CLASS_ATTRIBUTES int           __int64_hash_get_int(Dynamic inHash,cpp::Int64 inKey);
+HXCPP_EXTERN_CLASS_ATTRIBUTES ::String      __int64_hash_get_string(Dynamic inHash,cpp::Int64 inKey);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Float         __int64_hash_get_float(Dynamic inHash,cpp::Int64 inKey);
+HXCPP_EXTERN_CLASS_ATTRIBUTES cpp::Int64    __int64_hash_get_int64(Dynamic inHash,cpp::Int64 inKey);
+inline  bool   __int64_hash_get_bool(Dynamic inHash,cpp::Int64 inKey) { return __int64_hash_get_int(inHash,inKey); }
+
+// --- StringHash ----------------------------------------------------------------------
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES void          __string_hash_set(HX_MAP_THIS_ARG,String inKey,const Dynamic &value,bool inForceDynamic=false);
+HXCPP_EXTERN_CLASS_ATTRIBUTES bool          __string_hash_exists(Dynamic &hash,String inKey);
+HXCPP_EXTERN_CLASS_ATTRIBUTES bool          __string_hash_remove(Dynamic &hash,String inKey);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Array< ::String> __string_hash_keys(Dynamic &hash);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic       __string_hash_values(Dynamic &hash);
+// Typed StringHash access...
+HXCPP_EXTERN_CLASS_ATTRIBUTES void          __string_hash_set_int(HX_MAP_THIS_ARG,String inKey,int inValue);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void          __string_hash_set_string(HX_MAP_THIS_ARG,String inKey,::String inValue);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void          __string_hash_set_float(HX_MAP_THIS_ARG,String inKey,Float inValue);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void          __string_hash_set_int64(HX_MAP_THIS_ARG,String inKey,cpp::Int64 inValue);
+HXCPP_EXTERN_CLASS_ATTRIBUTES ::String      __string_hash_map_substr(HX_MAP_THIS_ARG,String inKey,int inStart, int inLength);
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES ::String      __string_hash_to_string(Dynamic &hash);
+HXCPP_EXTERN_CLASS_ATTRIBUTES ::String      __string_hash_to_string_raw(Dynamic &hash);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void          __string_hash_clear(Dynamic &hash);
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic       __string_hash_get(Dynamic inHash,String inKey);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic       __string_hash_get2(haxe::ds::StringMap_obj* map,String* inKey);
+HXCPP_EXTERN_CLASS_ATTRIBUTES int           __string_hash_get_int(Dynamic inHash,String inKey);
+HXCPP_EXTERN_CLASS_ATTRIBUTES ::String      __string_hash_get_string(Dynamic inHash,String inKey);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Float         __string_hash_get_float(Dynamic inHash,String inKey);
+HXCPP_EXTERN_CLASS_ATTRIBUTES cpp::Int64    __string_hash_get_int64(Dynamic inHash,String inKey);
+inline  bool __string_hash_get_bool(Dynamic inHash,String inKey) { return __string_hash_get_int(inHash,inKey); }
+
+// --- ObjectHash ----------------------------------------------------------------------
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES void          __object_hash_set(HX_MAP_THIS_ARG,Dynamic inKey,const Dynamic &value,bool inWeakKey=false);
+HXCPP_EXTERN_CLASS_ATTRIBUTES bool          __object_hash_exists(Dynamic &hash,Dynamic inKey);
+HXCPP_EXTERN_CLASS_ATTRIBUTES bool          __object_hash_remove(Dynamic &hash,Dynamic inKey);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Array< ::Dynamic> __object_hash_keys(Dynamic &hash);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic       __object_hash_values(Dynamic &hash);
+// Typed ObjectHash access...
+HXCPP_EXTERN_CLASS_ATTRIBUTES void          __object_hash_set_int(HX_MAP_THIS_ARG,Dynamic inKey,int inValue,bool inWeakKey=false);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void          __object_hash_set_string(HX_MAP_THIS_ARG,Dynamic inKey,::String inValue,bool inWeakKey=false);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void          __object_hash_set_float(HX_MAP_THIS_ARG,Dynamic inKey,Float inValue,bool inWeakKey=false);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void          __object_hash_set_int64(HX_MAP_THIS_ARG,Dynamic inKey,cpp::Int64 inValue,bool inWeakKey=false);
+HXCPP_EXTERN_CLASS_ATTRIBUTES ::String      __object_hash_to_string(Dynamic &hash);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void          __object_hash_clear(Dynamic &hash);
+
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic       __object_hash_get(Dynamic inHash,Dynamic inKey);
+HXCPP_EXTERN_CLASS_ATTRIBUTES int           __object_hash_get_int(Dynamic inHash,Dynamic inKey);
+HXCPP_EXTERN_CLASS_ATTRIBUTES ::String      __object_hash_get_string(Dynamic inHash,Dynamic inKey);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Float         __object_hash_get_float(Dynamic inHash,Dynamic inKey);
+HXCPP_EXTERN_CLASS_ATTRIBUTES cpp::Int64    __object_hash_get_int64(Dynamic inHash,Dynamic inKey);
+inline bool  __object_hash_get_bool(Dynamic inHash,Dynamic inKey) { return __object_hash_get_int(inHash,inKey); }
+
+// --- Date --------------------------------------------------------------------------
+
+// returns Epoch UTC timestamp (in seconds); assumes that input date parts are considered to be in local timezone date/time representation
+double __hxcpp_new_date(int inYear,int inMonth,int inDay,int inHour, int inMin, int inSeconds,int inMilliseconds = 0);
+
+double __hxcpp_utc_date(int inYear,int inMonth,int inDay,int inHour, int inMin, int inSeconds);
+int    __hxcpp_get_hours(double inSeconds);
+int    __hxcpp_get_minutes(double inSeconds);
+int    __hxcpp_get_seconds(double inSeconds);
+int    __hxcpp_get_year(double inSeconds);
+int    __hxcpp_get_month(double inSeconds);
+int    __hxcpp_get_date(double inSeconds);
+int    __hxcpp_get_day(double inSeconds);
+String __hxcpp_to_string(double inSeconds);
+double __hxcpp_date_now();
+
+
+int    __hxcpp_get_utc_hours(double inSeconds); /* returns hour part of UTC date/time representation of input time (Epoch, in seconds), 0-23 */
+int    __hxcpp_get_utc_minutes(double inSeconds); /* returns minutes part of UTC date/time representation of input time (Epoch, in seconds), 0-59 */
+int    __hxcpp_get_utc_seconds(double inSeconds); /* returns seconds part of UTC date/time representation of input time (Epoch, in seconds), 0-59 */
+int    __hxcpp_get_utc_year(double inSeconds); /* returns year part of UTC date/time representation of input time (Epoch, in seconds) */
+int    __hxcpp_get_utc_month(double inSeconds); /* returns month part of UTC date/time representation of input time (Epoch, in seconds), 0-January...11-December */
+int    __hxcpp_get_utc_date(double inSeconds); /* returns day of the month part of UTC date/time representation of input time (Epoch, in seconds), 1-31 */
+int    __hxcpp_get_utc_day(double inSeconds); /* returns day of the week part of UTC date/time representation of input time (Epoch, in seconds), 0-Sunday...6-Saturday */
+String __hxcpp_to_utc_string(double inSeconds); /* same as __hxcpp_to_string but in corresponding UTC format */
+
+int    __hxcpp_is_dst(double inSeconds); /* is input time (Epoch UTC timestamp, in seconds)'s local time in DST ? 1 for true, 0 for false */
+double __hxcpp_timezone_offset(double inSeconds); /* input time (Epoch UTC timestamp, in seconds)'s local time zone offset from UTC, in seconds */
+double __hxcpp_from_utc(int inYear,int inMonth,int inDay,int inHour, int inMin, int inSeconds, int inMilliSeconds); /* returns Epoch timestamp (in seconds); assumes that input date parts are considered to be in UTC date/time representation */ 
+
+
+
+double __hxcpp_time_stamp();
+
+// --- vm/threading --------------------------------------------------------------------
+
+Dynamic __hxcpp_thread_create(Dynamic inFunc);
+Dynamic __hxcpp_thread_current();
+void    __hxcpp_thread_send(Dynamic inThread, Dynamic inMessage);
+Dynamic __hxcpp_thread_read_message(bool inBlocked);
+bool __hxcpp_is_current_thread(hx::Object *inThread);
+
+Dynamic __hxcpp_mutex_create();
+void    __hxcpp_mutex_acquire(Dynamic);
+bool    __hxcpp_mutex_try(Dynamic);
+void    __hxcpp_mutex_release(Dynamic);
+
+Dynamic __hxcpp_semaphore_create(int);
+void __hxcpp_semaphore_acquire(Dynamic);
+bool __hxcpp_semaphore_try_acquire(Dynamic, double timeout);
+void __hxcpp_semaphore_release(Dynamic);
+
+Dynamic __hxcpp_condition_create(void);
+void __hxcpp_condition_acquire(Dynamic);
+bool __hxcpp_condition_try_acquire(Dynamic);
+void __hxcpp_condition_release(Dynamic);
+void __hxcpp_condition_wait(Dynamic);
+bool __hxcpp_condition_timed_wait(Dynamic,double);
+void __hxcpp_condition_signal(Dynamic);
+void __hxcpp_condition_broadcast(Dynamic);
+
+Dynamic __hxcpp_lock_create();
+bool    __hxcpp_lock_wait(Dynamic inlock,double inTime);
+void    __hxcpp_lock_release(Dynamic inlock);
+
+Dynamic __hxcpp_deque_create();
+void    __hxcpp_deque_add(Dynamic q,Dynamic inVal);
+void    __hxcpp_deque_push(Dynamic q,Dynamic inVal);
+Dynamic __hxcpp_deque_pop(Dynamic q,bool block);
+
+Dynamic __hxcpp_tls_get(int inID);
+void    __hxcpp_tls_set(int inID,Dynamic inVal);
+
+bool _hx_atomic_exchange_if(::cpp::Pointer<cpp::AtomicInt> inPtr, int test, int newVal  );
+int _hx_atomic_inc(::cpp::Pointer<cpp::AtomicInt> inPtr );
+int _hx_atomic_dec(::cpp::Pointer<cpp::AtomicInt> inPtr );
+
+// Assumptions made:
+//    People are not using 8 year old versions of GCC.
+
+#if defined(__GNUC__) || defined(__clang__)
+#define HX_GCC_ATOMICS
+#define HX_HAS_ATOMIC 1
+#elif defined(_MSC_VER)
+#define HX_MSVC_ATOMICS
+#define HX_HAS_ATOMIC 1
+#include <intrin.h>
+#else
+#define HX_HAS_ATOMIC 0
+#endif
+
+inline int _hx_atomic_add(volatile int *a, int b) {
+#if defined(HX_GCC_ATOMICS)
+  return __atomic_fetch_add(a, b, __ATOMIC_SEQ_CST);
+#elif defined(HX_MSVC_ATOMICS)
+  return _InterlockedExchangeAdd((long volatile *)a, b);
+#else
+   int old = *a;
+   *a += b;
+   return old;
+#endif
+}
+
+inline int _hx_atomic_sub(volatile int *a, int b) {
+#if defined(HX_GCC_ATOMICS)
+  return __atomic_fetch_sub(a, b, __ATOMIC_SEQ_CST);
+#elif defined(HX_MSVC_ATOMICS)
+  return _InterlockedExchangeAdd((long volatile *)a, -b);
+#else
+   int old = *a;
+   *a -= b;
+   return old;
+#endif
+}
+
+inline int _hx_atomic_and(volatile int *a, int b) {
+#if defined(HX_GCC_ATOMICS)
+  return __atomic_fetch_and(a, b, __ATOMIC_SEQ_CST);
+#elif defined(HX_MSVC_ATOMICS)
+  return _InterlockedAnd((long volatile *)a, b);
+#else
+   int old = *a;
+   *a &= b;
+   return old;
+#endif
+}
+
+inline int _hx_atomic_or(volatile int *a, int b) {
+#if defined(HX_GCC_ATOMICS)
+  return __atomic_fetch_or(a, b, __ATOMIC_SEQ_CST);
+#elif defined(HX_MSVC_ATOMICS)
+  return _InterlockedOr((long volatile *)a, b);
+#else
+   int old = *a;
+   *a |= b;
+   return old;
+#endif
+}
+
+inline int _hx_atomic_xor(int *a, int b) {
+#if defined(HX_GCC_ATOMICS)
+  return __atomic_fetch_xor(a, b, __ATOMIC_SEQ_CST);
+#elif defined(HX_MSVC_ATOMICS)
+  return _InterlockedXor((long volatile *)a, b);
+#else
+   int old = *a;
+   *a ^= b;
+   return old;
+#endif
+}
+
+inline int _hx_atomic_compare_exchange(volatile int *a, int expected,
+                                       int replacement) {
+#if defined(HX_GCC_ATOMICS)
+   int _expected = expected;
+  __atomic_compare_exchange(a, &_expected, &replacement, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
+  return _expected;
+#elif defined(HX_MSVC_ATOMICS)
+  return _InterlockedCompareExchange((long volatile *)a, replacement, expected);
+#else
+   int old = *a;
+   if(old == expected) {
+      *a = replacement;
+   }
+   return old;
+#endif
+}
+
+inline int _hx_atomic_exchange(volatile int *a, int replacement) {
+#if defined(HX_GCC_ATOMICS)
+   int ret = 0;
+  __atomic_exchange(a, &replacement, &ret, __ATOMIC_SEQ_CST);
+  return ret;
+#elif defined(HX_MSVC_ATOMICS)
+  return _InterlockedExchange((long volatile *)a, replacement);
+#else
+   int old = *a;
+   *a = replacement;
+   return old;
+#endif
+}
+
+inline int _hx_atomic_load(volatile int *a) {
+#if defined(HX_GCC_ATOMICS)
+   int ret = 0;
+  __atomic_load(a, &ret, __ATOMIC_SEQ_CST);
+  return ret;
+#elif defined(HX_MSVC_ATOMICS)
+   return _InterlockedXor((long volatile *)a, 0);
+#else
+   return *a;
+#endif
+}
+
+inline int _hx_atomic_store(volatile int *a, int value) {
+#if defined(HX_GCC_ATOMICS)
+  __atomic_store(a, &value, __ATOMIC_SEQ_CST);
+  return value;
+#elif defined(HX_MSVC_ATOMICS)
+   _InterlockedExchange((long volatile *)a, value);
+   return value;
+#else
+   *a = value;
+   return value;
+#endif
+}
+
+inline void* _hx_atomic_compare_exchange_ptr(volatile void **a, void *expected, void* replacement) {
+#if defined(HX_GCC_ATOMICS)
+   void* _expected = expected;
+  __atomic_compare_exchange(a, (volatile void **)&_expected, (volatile void**)&replacement, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
+  return _expected;
+#elif defined(HX_MSVC_ATOMICS)
+  return _InterlockedCompareExchangePointer((void *volatile *)a, replacement, expected);
+#else
+   void *old = *a;
+   *a = replacement;
+   return old;
+#endif
+}
+
+inline void* _hx_atomic_compare_exchange_cast_ptr(void *a, void *expected, void *replacement) {
+   return _hx_atomic_compare_exchange_ptr((volatile void **)a, expected, replacement);
+}
+
+Array<String> __hxcpp_get_call_stack(bool inSkipLast);
+Array<String> __hxcpp_get_exception_stack();
+#define HXCPP_HAS_CLASSLIST
+Array<String> __hxcpp_get_class_list();
+
+// --- Profile -------------------------------------------------------------------
+
+void __hxcpp_start_profiler(::String inDumpFile);
+void __hxcpp_stop_profiler();
+
+
+// --- Memory --------------------------------------------------------------------------
+
+inline void __hxcpp_align_set_float32( unsigned char *base, int addr, float v)
+{
+   #ifdef HXCPP_ALIGN_FLOAT
+   if (addr & 3)
+   {
+      const unsigned char *src = (const unsigned char *)&v;
+      unsigned char *dest = base + addr;
+      dest[0] = src[0];
+      dest[1] = src[1];
+      dest[2] = src[2];
+      dest[3] = src[3];
+   }
+   else
+   #endif
+   *(float *)(base+addr) = v;
+}
+
+
+inline float __hxcpp_align_get_float32( unsigned char *base, int addr)
+{
+   #ifdef HXCPP_ALIGN_FLOAT
+   if (addr & 3)
+   {
+      float buf;
+      unsigned char *dest = (unsigned char *)&buf;
+      const unsigned char *src = base + addr;
+      dest[0] = src[0];
+      dest[1] = src[1];
+      dest[2] = src[2];
+      dest[3] = src[3];
+      return buf;
+   }
+   #endif
+   return *(float *)(base+addr);
+}
+
+
+inline void __hxcpp_align_set_float64( unsigned char *base, int addr, double v)
+{
+   #ifdef HXCPP_ALIGN_FLOAT
+   if (addr & 3)
+   {
+      unsigned char *dest = base + addr;
+      const unsigned char *src = (const unsigned char *)&v;
+      dest[0] = src[0];
+      dest[1] = src[1];
+      dest[2] = src[2];
+      dest[3] = src[3];
+      dest[4] = src[4];
+      dest[5] = src[5];
+      dest[6] = src[6];
+      dest[7] = src[7];
+   }
+   else
+   #endif
+   *(double *)(base + addr) = v;
+}
+
+
+inline double __hxcpp_align_get_float64( unsigned char *base, int addr)
+{
+   #ifdef HXCPP_ALIGN_FLOAT
+   if (addr & 3)
+   {
+      double buf;
+      unsigned char *dest = (unsigned char *)&buf;
+      const unsigned char *src = base + addr;
+      dest[0] = src[0];
+      dest[1] = src[1];
+      dest[2] = src[2];
+      dest[3] = src[3];
+      dest[4] = src[4];
+      dest[5] = src[5];
+      dest[6] = src[6];
+      dest[7] = src[7];
+      return buf;
+   }
+   #endif
+   return *(double *)(base+addr);
+}
+
+
+
+
+// Threadsafe methods - takes buffer
+HXCPP_EXTERN_CLASS_ATTRIBUTES void  __hxcpp_memory_memset(Array<unsigned char> &inBuffer ,int pos, int len, int value);
+
+inline int __hxcpp_memory_get_byte(Array<unsigned char> inBuffer ,int addr) { return inBuffer->GetBase()[addr]; }
+inline double __hxcpp_memory_get_double(Array<unsigned char> inBuffer ,int addr) {
+   return __hxcpp_align_get_float64((unsigned char *)inBuffer->GetBase(), addr);
+}
+inline float __hxcpp_memory_get_float(Array<unsigned char> inBuffer ,int addr) {
+   return __hxcpp_align_get_float32((unsigned char *)inBuffer->GetBase(), addr);
+}
+inline int __hxcpp_memory_get_i16(Array<unsigned char> inBuffer ,int addr) { return *(short *)(inBuffer->GetBase()+addr); }
+inline int __hxcpp_memory_get_i32(Array<unsigned char> inBuffer ,int addr) { return *(int *)(inBuffer->GetBase()+addr); }
+inline int __hxcpp_memory_get_ui16(Array<unsigned char> inBuffer ,int addr) { return *(unsigned short *)(inBuffer->GetBase()+addr); }
+inline int __hxcpp_memory_get_ui32(Array<unsigned char> inBuffer ,int addr) { return *(unsigned int *)(inBuffer->GetBase()+addr); }
+inline float __hxcpp_memory_get_f32(Array<unsigned char> inBuffer ,int addr) {
+   return __hxcpp_align_get_float32((unsigned char *)inBuffer->GetBase(), addr);
+}
+
+inline void __hxcpp_memory_set_byte(Array<unsigned char> inBuffer ,int addr,int v) { inBuffer->GetBase()[addr] = v; }
+inline void __hxcpp_memory_set_double(Array<unsigned char> inBuffer ,int addr,double v) {
+   return __hxcpp_align_set_float64((unsigned char *)inBuffer->GetBase(), addr,v);
+}
+inline void __hxcpp_memory_set_float(Array<unsigned char> inBuffer ,int addr,float v) {
+   return __hxcpp_align_set_float32((unsigned char *)inBuffer->GetBase(), addr,v);
+}
+inline void __hxcpp_memory_set_i16(Array<unsigned char> inBuffer ,int addr,int v) { *(short *)(inBuffer->GetBase()+addr) = v; }
+inline void __hxcpp_memory_set_i32(Array<unsigned char> inBuffer ,int addr,int v) { *(int *)(inBuffer->GetBase()+addr) = v; }
+inline void __hxcpp_memory_set_ui16(Array<unsigned char> inBuffer ,int addr,int v) { *(unsigned short *)(inBuffer->GetBase()+addr) = v; }
+inline void __hxcpp_memory_set_ui32(Array<unsigned char> inBuffer ,int addr,int v) { *(unsigned int *)(inBuffer->GetBase()+addr) = v; }
+inline void __hxcpp_memory_set_f32(Array<unsigned char> inBuffer ,int addr,float v) {
+   return __hxcpp_align_set_float32((unsigned char *)inBuffer->GetBase(), addr, v);
+}
+
+
+// Uses global pointer...
+extern unsigned char *__hxcpp_memory;
+
+inline void __hxcpp_memory_clear( ) { __hxcpp_memory = 0; }
+inline void __hxcpp_memory_select( Array<unsigned char> inBuffer )
+   { __hxcpp_memory= (unsigned char *)inBuffer->GetBase(); }
+
+inline int __hxcpp_memory_get_byte(int addr) { return __hxcpp_memory[addr]; }
+inline double __hxcpp_memory_get_double(int addr) { return __hxcpp_align_get_float64(__hxcpp_memory,addr); }
+inline float __hxcpp_memory_get_float(int addr) { return __hxcpp_align_get_float32(__hxcpp_memory,addr); }
+inline int __hxcpp_memory_get_i16(int addr) { return *(short *)(__hxcpp_memory+addr); }
+inline int __hxcpp_memory_get_i32(int addr) { return *(int *)(__hxcpp_memory+addr); }
+inline int __hxcpp_memory_get_ui16(int addr) { return *(unsigned short *)(__hxcpp_memory+addr); }
+inline int __hxcpp_memory_get_ui32(int addr) { return *(unsigned int *)(__hxcpp_memory+addr); }
+inline float __hxcpp_memory_get_f32(int addr) { return __hxcpp_align_get_float32(__hxcpp_memory,addr); }
+
+inline void __hxcpp_memory_set_byte(int addr,int v) { __hxcpp_memory[addr] = v; }
+inline void __hxcpp_memory_set_double(int addr,double v) { __hxcpp_align_set_float64(__hxcpp_memory,addr,v); }
+inline void __hxcpp_memory_set_float(int addr,float v) { __hxcpp_align_set_float32(__hxcpp_memory,addr,v); }
+inline void __hxcpp_memory_set_i16(int addr,int v) { *(short *)(__hxcpp_memory+addr) = v; }
+inline void __hxcpp_memory_set_i32(int addr,int v) { *(int *)(__hxcpp_memory+addr) = v; }
+inline void __hxcpp_memory_set_ui16(int addr,int v) { *(unsigned short *)(__hxcpp_memory+addr) = v; }
+inline void __hxcpp_memory_set_ui32(int addr,int v) { *(unsigned int *)(__hxcpp_memory+addr) = v; }
+inline void __hxcpp_memory_set_f32(int addr,float v) { __hxcpp_align_set_float32(__hxcpp_memory,addr,v); }
+
+// FPHelper conversion
+
+inline void __hxcpp_reverse_endian(int &ioData)
+{
+   ioData =   (((ioData>>24) & 0xff )    )|
+              (((ioData>>16) & 0xff )<<8 )|
+              (((ioData>>8 ) & 0xff )<<16 )|
+              (((ioData    ) & 0xff )<<24  );
+}
+
+
+inline float __hxcpp_reinterpret_le_int32_as_float32(int inInt)
+{
+   #ifdef HXCPP_BIG_ENDIAN
+   __hxcpp_reverse_endian(inInt);
+   #endif
+   return *(float*)(&inInt);
+}
+
+
+inline int __hxcpp_reinterpret_float32_as_le_int32(float inFloat)
+{
+   #ifdef HXCPP_BIG_ENDIAN
+   __hxcpp_reverse_endian(*(int *)&inFloat);
+   #endif
+   return *(int*)(&inFloat);
+}
+
+
+inline double __hxcpp_reinterpret_le_int32s_as_float64(int inLow, int inHigh)
+{
+   int vals[2] = {inLow, inHigh};
+   #ifdef HXCPP_BIG_ENDIAN
+   __hxcpp_reverse_endian(vals[0]);
+   __hxcpp_reverse_endian(vals[1]);
+   #endif
+   return *(double*)(vals);
+}
+
+
+inline int __hxcpp_reinterpret_float64_as_le_int32_low(double inValue)
+{
+   int *asInts = (int *)&inValue;
+   #ifdef HXCPP_BIG_ENDIAN
+   __hxcpp_reverse_endian(asInts[0]);
+   #endif
+   return asInts[0];
+}
+
+
+inline int __hxcpp_reinterpret_float64_as_le_int32_high(double inValue)
+{
+   int *asInts = (int *)&inValue;
+   #ifdef HXCPP_BIG_ENDIAN
+   __hxcpp_reverse_endian(asInts[1]);
+   #endif
+   return asInts[1];
+}
+
+#ifdef __OBJC__
+#ifdef HXCPP_OBJC
+
+inline NSData *_hx_bytes_to_nsdata( ::Array<unsigned char> inBytes)
+{
+   if (!inBytes.mPtr)
+     return nil;
+
+   return [NSData dataWithBytes: inBytes->getBase() length:inBytes->length ];
+
+}
+
+inline ::Array<unsigned char> _hx_nsdata_to_bytes(NSData *inData)
+{
+   if (inData==nil)
+      return null();
+
+   return ::Array_obj<unsigned char>::fromData( (const unsigned char *)inData.bytes, inData.length );
+}
+
+#endif
+#endif
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_regexp_new_options(String s, String options);
+
+// EReg.hx -> src/hx/libs/regexp/RegExp.cpp
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_regexp_new_options(String s, String options);
+HXCPP_EXTERN_CLASS_ATTRIBUTES bool    _hx_regexp_match(Dynamic handle, String string, int pos, int len);
+HXCPP_EXTERN_CLASS_ATTRIBUTES String  _hx_regexp_matched(Dynamic handle, int pos);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_regexp_matched_pos(Dynamic handle, int match);
+HXCPP_EXTERN_CLASS_ATTRIBUTES int     _hx_regexp_matched_num(Dynamic handle);
+
+
+// haxe.zip.(Un)Compress.hx -> src/hx/libs/zlib/ZLib.cpp
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_deflate_init(int level);
+HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_deflate_bound(Dynamic handle,int length);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_deflate_buffer(Dynamic handle, Array<unsigned char> src, int srcPos, Array<unsigned char> dest, int destPos);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_deflate_end(Dynamic handle);
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_inflate_init(Dynamic windowBits);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_inflate_buffer(Dynamic handle, Array<unsigned char> src, int srcPos, Array<unsigned char> dest, int destPos);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_inflate_end(Dynamic handle);
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_zip_set_flush_mode(Dynamic handle, String flushMode);
+
+// sys.db.Mysql.hx -> src/hx/libs/regexp/RegExp.cpp
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_mysql_connect(Dynamic params);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void    _hx_mysql_select_db(Dynamic handle,String db);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_mysql_request(Dynamic handle,String req);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_mysql_close(Dynamic handle);
+HXCPP_EXTERN_CLASS_ATTRIBUTES String  _hx_mysql_escape(Dynamic handle,String str);
+HXCPP_EXTERN_CLASS_ATTRIBUTES int     _hx_mysql_result_get_length(Dynamic handle);
+HXCPP_EXTERN_CLASS_ATTRIBUTES int     _hx_mysql_result_get_nfields(Dynamic handle);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_mysql_result_next(Dynamic handle);
+HXCPP_EXTERN_CLASS_ATTRIBUTES String  _hx_mysql_result_get(Dynamic handle,int i);
+HXCPP_EXTERN_CLASS_ATTRIBUTES int     _hx_mysql_result_get_int(Dynamic handle,int i);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Float   _hx_mysql_result_get_float(Dynamic handle,int i);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Array<String> _hx_mysql_result_get_fields_names(Dynamic handle);
+
+namespace cpp { template<typename T> class Function; }
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_mysql_set_conversion(
+      cpp::Function< Dynamic(Dynamic) > inCharsToBytes,
+      cpp::Function< Dynamic(Float) > inTimeToDate );
+
+// sys.db.Sqlite.hx -> src/hx/libs/sqlite/RegExp.cpp
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_sqlite_connect(String filename);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_sqlite_request(Dynamic handle,String req);
+HXCPP_EXTERN_CLASS_ATTRIBUTES void    _hx_sqlite_close(Dynamic handle);
+HXCPP_EXTERN_CLASS_ATTRIBUTES int     _hx_sqlite_last_insert_id(Dynamic handle);
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES int     _hx_sqlite_result_get_length(Dynamic handle);
+HXCPP_EXTERN_CLASS_ATTRIBUTES int     _hx_sqlite_result_get_nfields(Dynamic handle);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_sqlite_result_next(Dynamic handle);
+HXCPP_EXTERN_CLASS_ATTRIBUTES String  _hx_sqlite_result_get(Dynamic handle,int i);
+HXCPP_EXTERN_CLASS_ATTRIBUTES int     _hx_sqlite_result_get_int(Dynamic handle,int i);
+HXCPP_EXTERN_CLASS_ATTRIBUTES Float   _hx_sqlite_result_get_float(Dynamic handle,int i);
+
+// src/hx/libs/std ..
+// File
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_file_open( String fname, String r );
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_file_close( Dynamic handle );
+HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_file_write( Dynamic handle, Array<unsigned char> s, int p, int n );
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_file_write_char( Dynamic handle, int c );
+HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_file_read( Dynamic handle, Array<unsigned char> buf, int p, int n );
+HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_file_read_char( Dynamic handle );
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_file_seek( Dynamic handle, int pos, int kind );
+HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_file_tell( Dynamic handle );
+HXCPP_EXTERN_CLASS_ATTRIBUTES bool _hx_std_file_eof( Dynamic handle );
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_file_flush( Dynamic handle );
+HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_file_contents_string( String name );
+HXCPP_EXTERN_CLASS_ATTRIBUTES Array<unsigned char> _hx_std_file_contents_bytes( String name );
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_file_stdin();
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_file_stdout();
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_file_stderr();
+
+// Process
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_process_run( String cmd, Array<String> vargs, int inShow= 1 /* SHOW_NORMAL */ );
+HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_process_stdout_read( Dynamic handle, Array<unsigned char> buf, int pos, int len );
+HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_process_stderr_read( Dynamic handle, Array<unsigned char> buf, int pos, int len );
+HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_process_stdin_write( Dynamic handle, Array<unsigned char> buf, int pos, int len );
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_process_stdin_close( Dynamic handle );
+#if (HXCPP_API_LEVEL > 420)
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_process_exit( Dynamic handle, bool block );
+#else
+HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_process_exit( Dynamic handle );
+#endif
+HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_process_pid( Dynamic handle );
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_process_kill( Dynamic handle );
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_process_close( Dynamic handle );
+
+// Random
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_random_new();
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_random_set_seed( Dynamic handle, int v );
+HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_random_int( Dynamic handle, int max );
+HXCPP_EXTERN_CLASS_ATTRIBUTES double _hx_std_random_float( Dynamic handle );
+
+// Socket
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_init();
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_socket_new( bool udp, bool ipv6 = false );
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_bind( Dynamic o, int host, int port );
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_bind_ipv6( Dynamic o, Array<unsigned char> host, int port );
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_close( Dynamic handle );
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_send_char( Dynamic o, int c );
+HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_socket_send( Dynamic o, Array<unsigned char> buf, int p, int l );
+HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_socket_recv( Dynamic o, Array<unsigned char> buf, int p, int l );
+HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_socket_recv_char( Dynamic o );
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_write( Dynamic o, Array<unsigned char> buf );
+HXCPP_EXTERN_CLASS_ATTRIBUTES Array<unsigned char> _hx_std_socket_read( Dynamic o );
+HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_host_resolve( String host );
+HXCPP_EXTERN_CLASS_ATTRIBUTES Array<unsigned char> _hx_std_host_resolve_ipv6( String host, bool dummy=true );
+HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_host_to_string( int ip );
+HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_host_to_string_ipv6( Array<unsigned char> ip );
+HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_host_reverse( int host );
+HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_host_reverse_ipv6( Array<unsigned char> host );
+HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_host_local();
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_connect( Dynamic o, int host, int port );
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_connect_ipv6( Dynamic o, Array<unsigned char> host, int port );
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_listen( Dynamic o, int n );
+HXCPP_EXTERN_CLASS_ATTRIBUTES Array<Dynamic> _hx_std_socket_select( Array<Dynamic> rs, Array<Dynamic> ws, Array<Dynamic> es, Dynamic timeout );
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_fast_select( Array<Dynamic> rs, Array<Dynamic> ws, Array<Dynamic> es, Dynamic timeout );
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_socket_accept( Dynamic o );
+HXCPP_EXTERN_CLASS_ATTRIBUTES Array<int> _hx_std_socket_peer( Dynamic o );
+HXCPP_EXTERN_CLASS_ATTRIBUTES Array<int> _hx_std_socket_host( Dynamic o );
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_set_timeout( Dynamic o, Dynamic t );
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_shutdown( Dynamic o, bool r, bool w );
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_set_blocking( Dynamic o, bool b );
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_set_fast_send( Dynamic o, bool b );
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_set_broadcast( Dynamic o, bool b );
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_socket_poll_alloc( int nsocks );
+HXCPP_EXTERN_CLASS_ATTRIBUTES Array<Dynamic> _hx_std_socket_poll_prepare( Dynamic pdata, Array<Dynamic> rsocks, Array<Dynamic> wsocks );
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_poll_events( Dynamic pdata, double timeout );
+HXCPP_EXTERN_CLASS_ATTRIBUTES Array<Dynamic> _hx_std_socket_poll( Array<Dynamic> socks, Dynamic pdata, double timeout );
+HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_socket_send_to( Dynamic o, Array<unsigned char> buf, int p, int l, Dynamic inAddr );
+HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_socket_recv_from( Dynamic o, Array<unsigned char> buf, int p, int l, Dynamic outAddr);
+
+// Sys
+HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_get_env( String v );
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_put_env( String e, String v );
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_sys_sleep( double f );
+HXCPP_EXTERN_CLASS_ATTRIBUTES bool _hx_std_set_time_locale( String l );
+HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_get_cwd();
+HXCPP_EXTERN_CLASS_ATTRIBUTES bool _hx_std_set_cwd( String d );
+HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_sys_string();
+HXCPP_EXTERN_CLASS_ATTRIBUTES bool _hx_std_sys_is64();
+HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_sys_command( String cmd );
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_sys_exit( int code );
+HXCPP_EXTERN_CLASS_ATTRIBUTES bool _hx_std_sys_exists( String path );
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_file_delete( String path );
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_sys_rename( String path, String newname );
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_sys_stat( String path );
+HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_sys_file_type( String path );
+HXCPP_EXTERN_CLASS_ATTRIBUTES bool _hx_std_sys_create_dir( String path, int mode );
+HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_sys_remove_dir( String path );
+HXCPP_EXTERN_CLASS_ATTRIBUTES double _hx_std_sys_time();
+HXCPP_EXTERN_CLASS_ATTRIBUTES double _hx_std_sys_cpu_time();
+HXCPP_EXTERN_CLASS_ATTRIBUTES Array<String> _hx_std_sys_read_dir( String p);
+HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_file_full_path( String path );
+HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_sys_exe_path();
+HXCPP_EXTERN_CLASS_ATTRIBUTES Array<String> _hx_std_sys_env();
+HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_sys_getch( bool b );
+HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_sys_get_pid();
+
+
+// SSL
+void _hx_ssl_init();
+Dynamic _hx_ssl_new( Dynamic hconf );
+void _hx_ssl_close( Dynamic hssl );
+void _hx_ssl_debug_set (int i);
+void _hx_ssl_handshake( Dynamic handle );
+void _hx_ssl_set_socket( Dynamic hssl, Dynamic hsocket );
+void _hx_ssl_set_hostname( Dynamic hssl, String hostname );
+Dynamic _hx_ssl_get_peer_certificate( Dynamic hssl );
+bool _hx_ssl_get_verify_result( Dynamic hssl );
+void _hx_ssl_send_char( Dynamic hssl, int v );
+int _hx_ssl_send( Dynamic hssl, Array<unsigned char> buf, int p, int l );
+void _hx_ssl_write( Dynamic hssl, Array<unsigned char> buf );
+int _hx_ssl_recv_char( Dynamic hssl );
+int _hx_ssl_recv( Dynamic hssl, Array<unsigned char> buf, int p, int l );
+Array<unsigned char> _hx_ssl_read( Dynamic hssl );
+Dynamic _hx_ssl_conf_new( bool server );
+void _hx_ssl_conf_close( Dynamic hconf );
+void _hx_ssl_conf_set_ca( Dynamic hconf, Dynamic hcert );
+void _hx_ssl_conf_set_verify( Dynamic hconf, int mode );
+void _hx_ssl_conf_set_cert( Dynamic hconf, Dynamic hcert, Dynamic hpkey );
+void _hx_ssl_conf_set_servername_callback( Dynamic hconf, Dynamic obj );
+Dynamic _hx_ssl_cert_load_defaults();
+Dynamic _hx_ssl_cert_load_file( String file );
+Dynamic _hx_ssl_cert_load_path( String path );
+String _hx_ssl_cert_get_subject( Dynamic hcert, String objname );
+String _hx_ssl_cert_get_issuer( Dynamic hcert, String objname );
+Array<String> _hx_ssl_cert_get_altnames( Dynamic hcert );
+Array<int> _hx_ssl_cert_get_notbefore( Dynamic hcert );
+Array<int> _hx_ssl_cert_get_notafter( Dynamic hcert );
+Dynamic _hx_ssl_cert_get_next( Dynamic hcert );
+Dynamic _hx_ssl_cert_add_pem( Dynamic hcert, String data );
+Dynamic _hx_ssl_cert_add_der( Dynamic hcert, Array<unsigned char> buf );
+Dynamic _hx_ssl_key_from_der( Array<unsigned char> buf, bool pub );
+Dynamic _hx_ssl_key_from_pem( String data, bool pub, String pass );
+Array<unsigned char> _hx_ssl_dgst_make( Array<unsigned char> buf, String alg );
+Array<unsigned char> _hx_ssl_dgst_sign( Array<unsigned char> buf, Dynamic hpkey, String alg );
+bool _hx_ssl_dgst_verify( Array<unsigned char> buf, Array<unsigned char> sign, Dynamic hpkey, String alg );
+
+
+#endif

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/StdString.h

@@ -0,0 +1,30 @@
+#ifndef HX_STD_STRING_INCLUDEDED
+#define HX_STD_STRING_INCLUDEDED
+
+#include <string>
+
+namespace hx
+{
+   class StdString : public std::string
+   {
+      public:
+         StdString() : std::string() { }
+         StdString(const char *inPtr) : std::string(inPtr) { }
+         StdString(const char *inPtr, int inLen) : std::string(inPtr, inLen) { }
+         StdString(const std::string &inS) : std::string(inS) { }
+         StdString(const StdString &inS) : std::string(inS) { }
+
+         #if (HXCPP_API_LEVEL>1)
+         StdString(const Dynamic &inS) : std::string(inS.mPtr ? inS.mPtr->toString().utf8_str() : "null") { }
+         StdString(const String &inS) : std::string(inS.utf8_str()) { }
+         String toString() const { return String(c_str(),size()).dup(); }
+         String toString() { return String(c_str(),size()).dup(); }
+         operator Dynamic() const { return const_cast<StdString*>(this)->toString(); }
+         #endif
+
+         inline const StdString &toStdString() const { return *this; }
+
+   };
+}
+
+#endif

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/StringAlloc.h

@@ -0,0 +1,53 @@
+#ifndef HX_STRING_ALLOC
+#define HX_STRING_ALLOC
+
+#include <stdlib.h>
+#include <stdint.h>
+
+namespace hx
+{
+
+class IStringAlloc
+{
+   public:
+      virtual void *allocBytes(size_t inBytes) = 0;
+
+   protected:
+      ~IStringAlloc(){};
+};
+
+template<int STACK>
+class StringAlloc : public IStringAlloc
+{
+   char buffer[STACK];
+   size_t alloced;
+   char   *heap;
+
+   public:
+      inline StringAlloc() : alloced(0), heap(0) { }
+      ~StringAlloc()
+      {
+         if (heap)
+            free(heap);
+      }
+      void *allocBytes(size_t inBytes)
+      {
+         if (inBytes<=STACK)
+            return buffer;
+         if (inBytes>alloced)
+         {
+            alloced = inBytes;
+            heap = (char *)realloc(heap, alloced);
+         }
+         return heap;
+      }
+   private:
+      StringAlloc(const StringAlloc &);
+      void operator=(const StringAlloc &);
+};
+
+typedef StringAlloc<100> strbuf;
+
+} // end namespace hx
+
+#endif

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Telemetry.h

@@ -0,0 +1,35 @@
+#ifndef HX_TELEMETRY_H
+#define HX_TELEMETRY_H
+
+#define HX_TELEMETRY_VERSION 1
+
+#include <hxcpp.h>
+#include <vector>
+
+struct TelemetryFrame
+{
+  // microseconds, always valid
+  int gctime;
+  int gcoverhead;
+
+  // Valid only if profiler is enabled
+  std::vector<int> *samples;
+  std::vector<const char*> *names;
+
+  // Valid only if allocations (and profiler) are enabled
+  std::vector<int> *allocation_data;
+  std::vector<int> *stacks;
+};
+
+// --- Telemetry -----------------------------------------------------------------
+
+int __hxcpp_hxt_start_telemetry(bool profiler, bool allocations);
+void __hxcpp_hxt_stash_telemetry();
+TelemetryFrame* __hxcpp_hxt_dump_telemetry(int thread_num);
+void __hxcpp_hxt_ignore_allocs(int delta);
+
+// expose these from GCInternal
+int __hxcpp_gc_reserved_bytes();
+int __hxcpp_gc_used_bytes();
+
+#endif

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Thread.h

@@ -0,0 +1,458 @@
+#ifdef HX_THREAD_H_OVERRIDE
+// Users can define their own header to use here, but there is no API
+// compatibility gaurantee for future changes.
+#include HX_THREAD_H_OVERRIDE
+#else
+
+#ifndef HX_THREAD_H
+#define HX_THREAD_H
+
+#ifndef HXCPP_HEADER_VERSION
+#include "hx/HeaderVersion.h"
+#endif
+
+#if defined(KORE)
+
+#include <kinc/threads/atomic.h>
+#include <kinc/threads/event.h>
+#include <kinc/threads/mutex.h>
+#include <kinc/threads/thread.h>
+
+#elif defined(HX_WINRT)
+
+#include <windows.h>
+#include <process.h>
+#include <mutex>
+
+#elif defined(_WIN32)
+
+#ifdef HXCPP_WINXP_COMPAT
+#undef _WIN32_WINNT
+#define _WIN32_WINNT 0x0400
+#else
+#undef _WIN32_WINNT
+#define _WIN32_WINNT 0x0600
+#endif
+
+#include <windows.h>
+#include <process.h>
+#else
+#include <errno.h>
+#include <pthread.h>
+#include <sys/time.h>
+#include <stdio.h>
+#define HXCPP_PTHREADS
+#endif
+
+#ifdef RegisterClass
+#undef RegisterClass
+#endif
+
+#if defined(KORE)
+
+struct HxMutex {
+	HxMutex() {
+        kinc_mutex_init(&mutex);
+	}
+
+	~HxMutex() {
+		kinc_mutex_destroy(&mutex);
+	}
+
+	void Lock() {
+		kinc_mutex_lock(&mutex);
+	}
+
+	void Unlock() {
+		kinc_mutex_unlock(&mutex);
+	}
+
+	bool TryLock() {
+		return kinc_mutex_try_to_lock(&mutex);
+	}
+
+	void Clean() {
+		kinc_mutex_destroy(&mutex);
+	}
+private:
+	kinc_mutex_t mutex;
+};
+
+#define THREAD_FUNC_TYPE void
+#define THREAD_FUNC_RET return;
+
+inline bool HxCreateDetachedThread(void (*func)(void *), void *param)
+{
+    kinc_thread_t thread;
+    kinc_thread_init(&thread, func, param);
+	return true;
+}
+
+#elif defined(HX_WINDOWS)
+
+
+struct HxMutex
+{
+   HxMutex()
+   {
+      mValid = true;
+      #ifdef HX_WINRT
+      InitializeCriticalSectionEx(&mCritSec,4000,0);
+      #else
+      InitializeCriticalSection(&mCritSec);
+      #endif
+   }
+   ~HxMutex() { if (mValid) DeleteCriticalSection(&mCritSec); }
+   void Lock() { EnterCriticalSection(&mCritSec); }
+   void Unlock() { LeaveCriticalSection(&mCritSec); }
+   bool TryLock() { return TryEnterCriticalSection(&mCritSec); }
+   bool IsValid() { return mValid; }
+   void Clean()
+   {
+      if (mValid)
+      {
+         DeleteCriticalSection(&mCritSec);
+         mValid = false;
+      }
+   }
+
+   bool             mValid;
+   CRITICAL_SECTION mCritSec;
+};
+
+
+#define THREAD_FUNC_TYPE DWORD WINAPI
+#define THREAD_FUNC_RET return 0;
+
+inline bool HxCreateDetachedThread(DWORD (WINAPI *func)(void *), void *param)
+{
+	return (CreateThread(NULL, 0, func, param, 0, 0) != 0);
+}
+
+#else
+
+struct HxMutex
+{
+   HxMutex()
+   {
+      pthread_mutexattr_t mta;
+      pthread_mutexattr_init(&mta);
+      pthread_mutexattr_settype(&mta, PTHREAD_MUTEX_RECURSIVE);
+      mValid = pthread_mutex_init(&mMutex,&mta) ==0;
+   }
+   ~HxMutex() { if (mValid) pthread_mutex_destroy(&mMutex); }
+   void Lock() { pthread_mutex_lock(&mMutex); }
+   void Unlock() { pthread_mutex_unlock(&mMutex); }
+   bool TryLock() { return !pthread_mutex_trylock(&mMutex); }
+   bool IsValid() { return mValid; }
+   void Clean()
+   {
+      if (mValid)
+         pthread_mutex_destroy(&mMutex);
+      mValid = 0;
+   }
+
+   bool mValid;
+   pthread_mutex_t mMutex;
+};
+
+#define THREAD_FUNC_TYPE void *
+#define THREAD_FUNC_RET return 0;
+
+inline bool HxCreateDetachedThread(void *(*func)(void *), void *param)
+{
+	pthread_t t;
+	pthread_attr_t attr;
+	if (pthread_attr_init(&attr) != 0)
+		return false;
+#ifdef PTHREAD_CREATE_DETACHED
+	if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0)
+		return false;
+#endif
+	if (pthread_create(&t, &attr, func, param) != 0 )
+		return false;
+	if (pthread_attr_destroy(&attr) != 0)
+		return false;
+	return true;
+}
+
+#endif
+
+
+
+
+template<typename LOCKABLE>
+struct TAutoLock
+{
+   TAutoLock(LOCKABLE &inMutex) : mMutex(inMutex) { mMutex.Lock(); }
+   ~TAutoLock() { mMutex.Unlock(); }
+   void Lock() { mMutex.Lock(); }
+   void Unlock() { mMutex.Unlock(); }
+
+   LOCKABLE &mMutex;
+};
+
+typedef TAutoLock<HxMutex> AutoLock;
+
+#if defined(KORE)
+
+struct HxSemaphore {
+	HxSemaphore() {
+		kinc_event_init(&event, true);
+	}
+
+	~HxSemaphore() {
+		kinc_event_destroy(&event);
+	}
+
+	void Set() {
+		kinc_event_signal(&event);
+	}
+
+	void Wait() {
+		kinc_event_wait(&event);
+	}
+
+	bool WaitSeconds(double inSeconds) {
+		return kinc_event_try_to_wait(&event, inSeconds);
+	}
+
+	void Reset() {
+		kinc_event_reset(&event);
+	}
+
+	void Clean() {
+		kinc_event_destroy(&event);
+	}
+private:
+	kinc_event_t event;
+};
+
+struct ThreadPoolSignal {
+	ThreadPoolSignal() {
+		kinc_event_init(&event, true);
+	}
+
+	~ThreadPoolSignal() {
+
+	}
+
+	void Set() {
+		kinc_event_signal(&event);
+	}
+
+	void Wait() {
+		kinc_event_wait(&event);
+	}
+
+	bool WaitSeconds(double inSeconds) {
+		return kinc_event_try_to_wait(&event, inSeconds);
+	}
+
+	void Reset() {
+		kinc_event_reset(&event);
+	}
+
+	void Clean() {
+		kinc_event_destroy(&event);
+	}
+private:
+	kinc_event_t event;
+};
+
+#elif defined(HX_WINDOWS)
+
+struct HxSemaphore
+{
+   HxSemaphore()
+   {
+      #ifdef HX_WINRT
+      mSemaphore = CreateEventEx(nullptr,nullptr,0,EVENT_ALL_ACCESS);
+      #else
+      mSemaphore = CreateEvent(0,0,0,0);
+      #endif
+   }
+   ~HxSemaphore() { if (mSemaphore) CloseHandle(mSemaphore); }
+   void Set() { SetEvent(mSemaphore); }
+   void Wait()
+   {
+      #ifdef HX_WINRT
+      WaitForSingleObjectEx(mSemaphore,INFINITE,false);
+      #else
+      WaitForSingleObject(mSemaphore,INFINITE);
+      #endif
+   }
+    // Returns true on success, false on timeout
+   bool WaitSeconds(double inSeconds)
+   {
+      #ifdef HX_WINRT
+      return WaitForSingleObjectEx(mSemaphore,inSeconds*1000.0,false) != WAIT_TIMEOUT;
+      #else
+      return WaitForSingleObject(mSemaphore,inSeconds*1000.0) != WAIT_TIMEOUT;
+      #endif
+   }
+   void Reset() { ResetEvent(mSemaphore); }
+   void Clean() { if (mSemaphore) CloseHandle(mSemaphore); mSemaphore = 0; }
+
+   HANDLE mSemaphore;
+};
+
+#else
+
+
+#define HX_THREAD_SEMAPHORE_LOCKABLE
+
+struct HxSemaphore
+{
+   HxSemaphore()
+   {
+      mSet = false;
+      mValid = true;
+      pthread_cond_init(&mCondition,0);
+   }
+   ~HxSemaphore()
+   {
+      if (mValid)
+      {
+         pthread_cond_destroy(&mCondition);
+      }
+   }
+   // For autolock
+   inline operator HxMutex &() { return mMutex; }
+   void Set()
+   {
+      AutoLock lock(mMutex);
+      if (!mSet)
+      {
+         mSet = true;
+         pthread_cond_signal( &mCondition );
+      }
+   }
+   void QSet()
+   {
+      mSet = true;
+      pthread_cond_signal( &mCondition );
+   }
+   void Reset()
+   {
+      AutoLock lock(mMutex);
+      mSet = false;
+   }
+   void QReset() { mSet = false; }
+   void Wait()
+   {
+      AutoLock lock(mMutex);
+      while( !mSet )
+         pthread_cond_wait( &mCondition, &mMutex.mMutex );
+      mSet = false;
+   }
+   // when we already hold the mMutex lock ...
+   void QWait()
+   {
+      while( !mSet )
+         pthread_cond_wait( &mCondition, &mMutex.mMutex );
+      mSet = false;
+   }
+   // Returns true if the wait was success, false on timeout.
+   bool WaitSeconds(double inSeconds)
+   {
+      struct timeval tv;
+      gettimeofday(&tv, 0);
+
+      int isec = (int)inSeconds;
+      int usec = (int)((inSeconds-isec)*1000000.0);
+      timespec spec;
+      spec.tv_nsec = (tv.tv_usec + usec) * 1000;
+      if (spec.tv_nsec>1000000000)
+      {
+         spec.tv_nsec-=1000000000;
+         isec++;
+      }
+      spec.tv_sec = tv.tv_sec + isec;
+
+      AutoLock lock(mMutex);
+
+      int result = 0;
+      // Wait for set to be true...
+      while( !mSet &&  (result=pthread_cond_timedwait( &mCondition, &mMutex.mMutex, &spec )) != ETIMEDOUT)
+      {
+         if (result!=0)
+         {
+            // Error - something's gone wrong...
+            /*
+            if (result==EINVAL) 
+               printf("ERROR: Condition EINVAL\n");
+            else if (result==EPERM)
+               printf("ERROR: Condition EPERM\n");
+            else
+               printf("ERROR: Condition unknown error\n");
+            */
+            break;
+         }
+         // Condition signalled - but try mSet again ...
+      }
+
+      bool wasSet = mSet;
+      mSet = false;
+      return wasSet;
+   }
+   void Clean()
+   {
+      mMutex.Clean();
+      if (mValid)
+      {
+         mValid = false;
+         pthread_cond_destroy(&mCondition);
+      }
+   }
+
+
+   HxMutex         mMutex;
+   pthread_cond_t  mCondition;
+   bool            mSet;
+   bool            mValid;
+};
+
+
+#endif
+
+
+#if defined(KORE)
+
+#include <kinc/threads/thread.h>
+
+inline void HxSleep(unsigned int ms)
+{
+	kinc_thread_sleep(ms);
+}
+
+#elif defined HX_WINRT
+
+inline void HxSleep(unsigned int ms)
+{
+	::Sleep(ms);
+}
+
+#elif defined HX_WINDOWS
+
+inline void HxSleep(unsigned int ms)
+{
+	::Sleep(ms);
+}
+
+#else
+
+inline void HxSleep(unsigned int ms)
+{
+   struct timespec t;
+   struct timespec tmp;
+   t.tv_sec = 0;
+   t.tv_nsec = ms * 1000000;
+   nanosleep(&t, &tmp);
+}
+
+#endif
+
+
+#endif
+#endif

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Tls.h

@@ -0,0 +1,200 @@
+#ifdef HX_TLS_H_OVERRIDE
+// Users can define their own header to use here, but there is no API
+// compatibility gaurantee for future changes.
+#include HX_TLS_H_OVERRIDE
+#else
+
+#ifndef HX_TLS_INCLUDED
+#define HX_TLS_INCLUDED
+
+#if defined(HX_WINDOWS) || defined(KORE_CONSOLE)
+
+  #if defined(HX_WINRT)
+    // Nothing
+  #elif defined(KORE_CONSOLE)
+
+#include <kinc/threads/threadlocal.h>
+
+namespace hx {
+	template<typename DATA, bool FAST = false> struct TLSData {
+		TLSData() {
+			kinc_thread_local_init(&tls);
+		}
+
+		~TLSData() {
+			kinc_thread_local_destroy(&tls);
+		}
+
+		DATA *Get() {
+			return (DATA*)kinc_thread_local_get(&tls);
+		}
+
+		void Set(DATA *inData) {
+			kinc_thread_local_set(&tls, inData);
+		}
+
+		inline DATA *operator=(DATA *inData) {
+			kinc_thread_local_set(&tls, inData);
+			return inData;
+		}
+
+		inline operator DATA*() {
+			return (DATA*)kinc_thread_local_get(&tls);
+		}
+	private:
+		kinc_thread_local_t tls;
+	};
+}
+
+  #else
+
+   #if ! defined(__GNUC__) && !defined(__BORLANDC__)
+   #include <intrin.h>
+   #endif
+
+   extern "C"
+   {
+      __declspec(dllimport)
+     int __stdcall TlsSetValue(unsigned long  dwTlsIndex, void *lpTlsValue);
+
+     __declspec(dllimport)
+     void * __stdcall TlsGetValue(unsigned long  dwTlsIndex);
+
+     __declspec(dllimport)
+     unsigned long __stdcall TlsAlloc(void);
+   }
+
+
+   namespace hx {
+
+   template<typename DATA,bool FAST=false>
+   struct TLSData
+   {
+      static const size_t kMaxInlineSlots = 64;
+
+      TLSData()
+      {
+         mSlot = TlsAlloc();
+         TlsSetValue(mSlot,0);
+         #ifdef HXCPP_M64
+         mFastOffset = mSlot*sizeof(void *) + 0x1480;
+         #else
+         if (FAST || mSlot < kMaxInlineSlots)
+            mFastOffset = mSlot*sizeof(void *) + 0xE10;
+         else
+            mFastOffset = mSlot - kMaxInlineSlots;
+         #endif
+      }
+      inline DATA *operator=(DATA *inData)
+      {
+         TlsSetValue(mSlot,inData);
+         return inData;
+      }
+
+      inline operator DATA *()
+      {
+         #if !defined(HXCPP_M64) && (_MSC_VER >= 1400)
+         const size_t kTibExtraTlsOffset = 0xF94;
+
+         if (FAST || mSlot < kMaxInlineSlots)
+           return (DATA *)__readfsdword(mFastOffset);
+
+         DATA **extra = (DATA **)(__readfsdword(kTibExtraTlsOffset));
+         return extra[mFastOffset];
+         #elif (_MSC_VER >= 1400) & !defined(HXCPP_DEBUG) && !defined(HXCPP_ARM64)// 64 bit version...
+         if (mSlot < 64)
+           return (DATA *)__readgsqword(mFastOffset);
+         else
+           return (DATA *)TlsGetValue(mSlot);
+         #else
+         return (DATA *)TlsGetValue(mSlot);
+         #endif
+      }
+
+      int mSlot;
+      int mFastOffset;
+   };
+
+   } // end namespace hx
+
+
+   #define DECLARE_TLS_DATA(TYPE,NAME) \
+      hx::TLSData<TYPE> NAME;
+   #define DECLARE_FAST_TLS_DATA(TYPE,NAME) \
+      hx::TLSData<TYPE,true> NAME;
+   #define EXTERN_TLS_DATA(TYPE,NAME) \
+      extern hx::TLSData<TYPE> NAME;
+   #define EXTERN_FAST_TLS_DATA(TYPE,NAME) \
+      extern hx::TLSData<TYPE,true> NAME;
+
+
+  #endif
+#else // not HX_WINDOWS
+
+#include <pthread.h>
+
+namespace hx
+{
+
+template<typename DATA,bool FAST=false>
+struct TLSData
+{
+   TLSData()
+   {
+      pthread_key_create(&mSlot, 0);
+   }
+   DATA *Get()
+   {
+      return (DATA *)pthread_getspecific(mSlot);
+   }
+   void Set(DATA *inData)
+   {
+      pthread_setspecific(mSlot,inData);
+   }
+   inline DATA *operator=(DATA *inData)
+   {
+      pthread_setspecific(mSlot,inData);
+      return inData;
+   }
+   inline operator DATA *() { return (DATA *)pthread_getspecific(mSlot); }
+
+   pthread_key_t mSlot;
+};
+
+} // end namespace hx
+
+
+#endif
+
+
+
+#ifdef HX_WINRT
+
+#define DECLARE_TLS_DATA(TYPE,NAME) \
+   __declspec(thread) TYPE * NAME = nullptr;
+#define DECLARE_FAST_TLS_DATA(TYPE,NAME) \
+   __declspec(thread) TYPE * NAME = nullptr;
+#define EXTERN_TLS_DATA(TYPE,NAME) \
+   __declspec(thread) extern TYPE * NAME;
+#define EXTERN_FAST_TLS_DATA(TYPE,NAME) \
+   __declspec(thread) extern TYPE * NAME;
+
+#else
+
+#define DECLARE_TLS_DATA(TYPE,NAME) \
+   hx::TLSData<TYPE> NAME;
+#define DECLARE_FAST_TLS_DATA(TYPE,NAME) \
+   hx::TLSData<TYPE,true> NAME;
+#define EXTERN_TLS_DATA(TYPE,NAME) \
+   extern hx::TLSData<TYPE> NAME;
+#define EXTERN_FAST_TLS_DATA(TYPE,NAME) \
+   extern hx::TLSData<TYPE,true> NAME;
+
+#endif
+
+
+
+
+#endif
+
+#endif

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Undefine.h

@@ -0,0 +1,44 @@
+#ifndef HX_UNDEFINE_H
+#define HX_UNDEFINE_H
+
+
+#if (HXCPP_API_LEVEL < 321)
+#undef INT_MIN
+#undef INT_MAX
+#undef INT8_MIN
+#undef INT8_MAX
+#undef UINT8_MAX
+#undef INT16_MIN
+#undef INT16_MAX
+#undef UINT16_MAX
+#undef INT32_MIN
+#undef INT32_MAX
+#undef UINT32_MAX
+#endif
+
+
+#undef TRUE
+#undef FALSE
+#undef BOOLEAN
+#undef ERROR
+#undef NO_ERROR
+#undef DELETE
+#undef OPTIONS
+#undef IN
+#undef OUT
+#undef ALTERNATE
+#undef OPTIONAL
+#undef DOUBLE_CLICK
+#undef DIFFERENCE
+#undef POINT
+#undef RECT
+#undef OVERFLOW
+#undef UNDERFLOW
+#undef DOMAIN
+#undef TRANSPARENT
+#undef CONST
+#undef CopyFile
+#undef COLOR_HIGHLIGHT
+#undef __valid
+
+#endif

Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Unordered.h

@@ -0,0 +1,38 @@
+#ifndef HX_UNORDERED_INCLUDED
+#define HX_UNORDERED_INCLUDED
+
+#if (defined(_MSC_VER) && (_MSC_VER >= 1800)) || ( defined(__GNUC__) && defined(HXCPP_CPP11) )
+#include <unordered_set>
+#include <unordered_map>
+
+namespace hx
+{
+
+template<typename T>
+struct UnorderedSet : public std::unordered_set<T> { };
+
+template<typename KEY, typename VALUE>
+struct UnorderedMap : public std::unordered_map<KEY,VALUE> { };
+
+}
+
+
+#else
+
+#include <set>
+#include <map>
+
+namespace hx
+{
+
+template<typename T>
+struct UnorderedSet : public std::set<T> { };
+
+template<typename KEY, typename VALUE>
+struct UnorderedMap : public std::map<KEY,VALUE> { };
+
+}
+
+#endif
+
+#endif