git » swiftpm » commit de8075e

Initial commit

Initial commit

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..06b9948
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,3 @@
+.build
+.swiftpm
+Package.resolved
diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000..7264edd
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,15 @@
+[submodule "Sources/strophe/libstrophe"]
+	path = Sources/strophe/libstrophe
+	url = https://github.com/strophe/libstrophe
+[submodule "Sources/libpcre2-8/pcre2"]
+	path = Sources/libpcre2-8/pcre2
+	url = https://github.com/PCRE2Project/pcre2
+[submodule "Sources/libpcre2-16/pcre2"]
+	path = Sources/libpcre2-16/pcre2
+	url = https://github.com/PCRE2Project/pcre2
+[submodule "Sources/usrsctp/usrsctp"]
+	path = Sources/usrsctp/usrsctp
+	url = https://github.com/singpolyma/usrsctp
+[submodule "Sources/libdatachannel/libdatachannel"]
+	path = Sources/libdatachannel/libdatachannel
+	url = https://github.com/paullouisageneau/libdatachannel
diff --git a/COPYING b/COPYING
new file mode 100644
index 0000000..64128e7
--- /dev/null
+++ b/COPYING
@@ -0,0 +1,204 @@
+Please check submodules and vendored dependencies for their respective licenses.
+Everything not otherwise marked is:
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/Package.swift b/Package.swift
new file mode 100644
index 0000000..c05ec94
--- /dev/null
+++ b/Package.swift
@@ -0,0 +1,201 @@
+// swift-tools-version: 5.8
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+	name: "Snikket",
+	platforms: [
+		.iOS(.v12),
+		.macOS(.v10_15),
+		.tvOS(.v12),
+	],
+	products: [
+		.library(
+			name: "Snikket",
+			targets: ["Snikket"]),
+	],
+	dependencies: [
+		.package(url: "https://github.com/apple/swift-docc-plugin", branch: "main"),
+		.package(url: "https://github.com/krzyzanowskim/OpenSSL-Package", from: "3.3.3000"),
+		.package(url: "https://github.com/alta/swift-opus", branch: "main"),
+	],
+	targets: [
+		// Targets are the basic building blocks of a package, defining a module or a test suite.
+		// Targets can depend on other targets in this package and products from dependencies.
+		.target(
+			name: "strophe",
+			dependencies: [.product(name: "OpenSSL", package: "OpenSSL-Package")],
+			exclude: [
+				"libstrophe/src/compression_dummy.c",
+				"libstrophe/src/parser_expat.c",
+				"libstrophe/src/tls_gnutls.c",
+				"libstrophe/src/tls_schannel.c",
+				"libstrophe/src/tls_dummy.c"
+			],
+			sources: ["libstrophe/src"],
+			linkerSettings: [
+				.linkedLibrary("resolv")
+			]
+		),
+		.target(
+			name: "usrsctp",
+			dependencies: [],
+			exclude: [
+				"usrsctp/.github",
+				"usrsctp/programs",
+				"usrsctp/fuzzer",
+				"usrsctp/cmake",
+				"usrsctp/usrsctplib/netinet6/meson.build"
+			],
+			cxxSettings: [
+				CXXSetting.headerSearchPath("usrsctp/usrsctplib"),
+				CXXSetting.define("HAVE_NETINET_IP_ICMP_H"), 
+				CXXSetting.define("HAVE_SA_LEN"), 
+				CXXSetting.define("HAVE_SCONN_LEN"), 
+				CXXSetting.define("HAVE_SIN6_LEN"), 
+				CXXSetting.define("HAVE_SIN_LEN"),
+				CXXSetting.define("HAVE_STDATOMIC_H"),
+				CXXSetting.define("HAVE_SYS_QUEUE_H"),
+				CXXSetting.define("INET"),
+				CXXSetting.define("INET6"),
+				CXXSetting.define("SCTP_DEBUG"), 
+				CXXSetting.define("SCTP_PROCESS_LEVEL_LOCKS"),
+				CXXSetting.define("SCTP_SIMPLE_ALLOCATOR"),
+				CXXSetting.define("__APPLE_USE_RFC_2292", .when(platforms: [.iOS, .macOS, .tvOS, .watchOS])),
+				CXXSetting.define("__Userspace__"),
+			]
+		),
+		.target(
+			name: "libdatachannel",
+			dependencies: [.product(name: "OpenSSL", package: "OpenSSL-Package"), "usrsctp"],
+			exclude: [
+				"libdatachannel/test",
+				"libdatachannel/src/websocketserver.cpp",
+				"libdatachannel/src/impl/websocketserver.cpp",
+				"libdatachannel/deps/libsrtp/crypto/test",
+				"libdatachannel/deps/libsrtp/crypto/Makefile.in",
+				"libdatachannel/deps/libsrtp/crypto/hash/hmac.c",
+				"libdatachannel/deps/libsrtp/crypto/hash/hmac_mbedtls.c",
+				"libdatachannel/deps/libsrtp/crypto/hash/hmac_nss.c",
+				"libdatachannel/deps/libsrtp/crypto/cipher/aes.c",
+				"libdatachannel/deps/libsrtp/crypto/cipher/aes_icm.c",
+				"libdatachannel/deps/libsrtp/crypto/cipher/aes_icm_nss.c",
+				"libdatachannel/deps/libsrtp/crypto/cipher/aes_gcm_nss.c",
+				"libdatachannel/deps/libsrtp/crypto/cipher/aes_icm_mbedtls.c",
+				"libdatachannel/deps/libsrtp/crypto/cipher/aes_gcm_mbedtls.c",
+			],
+			sources: ["libdatachannel/src", "libdatachannel/deps/libsrtp/crypto", "libdatachannel/deps/libsrtp/srtp", "libdatachannel/deps/libjuice/src"],
+			cxxSettings: [
+				CXXSetting.headerSearchPath("include/rtc"),
+				CXXSetting.headerSearchPath("libdatachannel/src"),
+				CXXSetting.headerSearchPath("libdatachannel/deps/plog/include"),
+				CXXSetting.headerSearchPath("libdatachannel/deps/libsrtp/include"),
+				CXXSetting.headerSearchPath("libdatachannel/deps/libsrtp"),
+				CXXSetting.headerSearchPath("libdatachannel/deps/libsrtp/crypto/include"),
+				CXXSetting.headerSearchPath("libdatachannel/deps/libjuice/include"),
+				CXXSetting.headerSearchPath("libdatachannel/deps/libjuice/include/juice"),
+				CXXSetting.define("OPENSSL"), 
+				CXXSetting.define("GCM"), 
+				CXXSetting.define("RTC_ENABLE_MEDIA=1"),
+				CXXSetting.define("RTC_ENABLE_WEBSOCKET=0"),
+				CXXSetting.define("RTC_EXPORTS"),
+				CXXSetting.define("HAVE_CONFIG_H"),
+				CXXSetting.define("HAVE_ARPA_INET_H"),
+				CXXSetting.define("HAVE_INTTYPES_H"),
+				CXXSetting.define("HAVE_MACHINE_TYPES_H"),
+				CXXSetting.define("HAVE_NETINET_IN_H"),
+				CXXSetting.define("HAVE_STDINT_H"),
+				CXXSetting.define("HAVE_STDLIB_H"),
+				CXXSetting.define("HAVE_SYS_SOCKET_H"),
+				CXXSetting.define("HAVE_SYS_TYPES_H"),
+				CXXSetting.define("HAVE_UNISTD_H"),
+				CXXSetting.define("HAVE_INET_ATON"),
+				CXXSetting.define("HAVE_INET_PTON"),
+				CXXSetting.define("HAVE_SIGACTION"),
+				CXXSetting.define("HAVE_USLEEP"),
+				CXXSetting.define("HAVE_UINT8_T"),
+				CXXSetting.define("HAVE_UINT16_T"),
+				CXXSetting.define("HAVE_UINT32_T"),
+				CXXSetting.define("HAVE_UINT64_T"),
+				CXXSetting.define("HAVE_INT32_T"),
+				CXXSetting.define("SIZEOF_UNSIGNED_LONG=8"),
+				CXXSetting.define("SIZEOF_UNSIGNED_LONG_LONG=8"),
+				CXXSetting.define("HAVE_INLINE"),
+				CXXSetting.define("PACKAGE_VERSION=\"2.5.0\""),
+				CXXSetting.define("PACKAGE_STRING=\"libsrtp2 2.5.0\""),
+			]
+		),
+		.target(
+			name: "libpcre2-8",
+			exclude: [
+				"pcre2/deps",
+				"pcre2/maint",
+				"pcre2/src/pcre2demo.c",
+				"pcre2/src/pcre2test.c",
+				"pcre2/src/pcre2grep.c",
+				"pcre2/src/pcre2posix.c",
+				"pcre2/src/pcre2_jit_compile.c",
+				"pcre2/src/pcre2_jit_test.c",
+				"pcre2/src/pcre2_dftables.c",
+				"pcre2/src/pcre2test.c",
+				"pcre2/src/pcre2posix_test.c",
+				"pcre2/src/pcre2_jit_test.c",
+				"pcre2/src/pcre2_fuzzsupport.c",
+			],
+			cSettings: [
+				CSetting.headerSearchPath("pcre2/src"),
+				CSetting.define("PCRE2_CODE_UNIT_WIDTH=8"),
+				CSetting.define("SUPPORT_PCRE2_8"),
+				CSetting.define("HAVE_CONFIG_H"),
+				CSetting.define("SUPPORT_UNICODE"),
+			]
+		),
+		.target(
+			name: "libpcre2-16",
+			exclude: [
+				"pcre2/deps",
+				"pcre2/maint",
+				"pcre2/src/pcre2demo.c",
+				"pcre2/src/pcre2test.c",
+				"pcre2/src/pcre2grep.c",
+				"pcre2/src/pcre2posix.c",
+				"pcre2/src/pcre2_dftables.c",
+				"pcre2/src/pcre2test.c",
+				"pcre2/src/pcre2posix_test.c",
+				"pcre2/src/pcre2_jit_test.c",
+				"pcre2/src/pcre2_fuzzsupport.c",
+			],
+			cSettings: [
+				CSetting.headerSearchPath("pcre2/src"),
+				CSetting.define("PCRE2_CODE_UNIT_WIDTH=16"),
+				CSetting.define("SUPPORT_PCRE2_16"),
+				CSetting.define("HAVE_CONFIG_H"),
+				CSetting.define("SUPPORT_UNICODE"),
+			]
+		),
+		.target(
+			name: "mbedtls"
+		),
+		.target(
+			name: "c_snikket",
+			dependencies: ["strophe", "libdatachannel", "libpcre2-8", "libpcre2-16", .product(name: "Copus", package: "swift-opus"), "mbedtls"],
+			cSettings: [
+				CSetting.headerSearchPath("iinclude"),
+				CSetting.define("HX_SMART_STRINGS=1"),
+				CSetting.define("HXCPP_M64"),
+				CSetting.define("HXCPP_VISIT_ALLOCS"),
+				CSetting.define("HXCPP_API_LEVEL=430"),
+				CSetting.define("HXCPP_ALIGN_ALLOC=1"),
+				CSetting.define("SQLITE_NOHAVE_SYSTEM", .when(platforms: [.iOS, .tvOS, .watchOS])),
+				CSetting.define("IPHONE", .when(platforms: [.iOS])),
+				CSetting.define("APPLETV", .when(platforms: [.tvOS])),
+				CSetting.define("HX_APPLEWATCH", .when(platforms: [.watchOS])),
+				CSetting.define("HX_MACOS", .when(platforms: [.macOS])),
+			]
+		),
+		.target(name: "Snikket", dependencies: ["c_snikket"]),
+	],
+	cLanguageStandard: CLanguageStandard.c17,
+	cxxLanguageStandard: CXXLanguageStandard.cxx17
+)
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..d09ea8e
--- /dev/null
+++ b/README.md
@@ -0,0 +1,9 @@
+https://borogove.dev
+
+This repository exists to make adding the Borogove SDK to XCode projects (via "Add Package Dependencies") or SwiftPM easier.
+
+# Installation
+
+[Swift Package Manager](https://swift.org/package-manager/)
+
+    dependencies: [.package(url: "https://borogove.dev/src/r/swiftpm")]
diff --git a/Sources/Snikket/Snikket.swift b/Sources/Snikket/Snikket.swift
new file mode 100644
index 0000000..b6d5076
--- /dev/null
+++ b/Sources/Snikket/Snikket.swift
@@ -0,0 +1,2072 @@
+import c_snikket
+
+public func setup(_ handler: @convention(c) @escaping (UnsafePointer<CChar>?)->Void) {
+	c_snikket.snikket_setup(handler)
+}
+
+public func stop(_ wait: Bool) {
+	c_snikket.snikket_stop(wait)
+}
+
+public protocol SDKObject {
+	var o: UnsafeMutableRawPointer {get}
+}
+
+internal func useString(_ mptr: UnsafePointer<CChar>?) -> String? {
+	if let ptr = mptr {
+		let r = String(cString: ptr)
+		c_snikket.snikket_release(ptr)
+		return r
+	} else {
+		return nil
+	}
+}
+
+internal func useString(_ mptr: UnsafeMutableRawPointer?) -> String? {
+	return useString(UnsafePointer(mptr?.assumingMemoryBound(to: CChar.self)))
+}
+
+public protocol MediaStore: SDKObject {
+}
+
+public class AnyMediaStore: MediaStore {
+	public let o: UnsafeMutableRawPointer
+
+	internal init(_ ptr: UnsafeMutableRawPointer) {
+		o = ptr
+	}
+
+	deinit {
+		c_snikket.snikket_release(o)
+	}
+
+}
+
+public class MediaStoreFS: SDKObject, MediaStore {
+	public let o: UnsafeMutableRawPointer
+
+	internal init(_ ptr: UnsafeMutableRawPointer) {
+		o = ptr
+	}
+
+	public init(path: String) {
+		o = c_snikket.snikket_persistence_media_store_f_s_new(path)
+	}
+
+	public func getMediaPath(uri: String, callback: @escaping (String?)->Void) -> Void {
+		let __callback_ptr = UnsafeMutableRawPointer(Unmanaged.passRetained(callback as AnyObject).toOpaque())
+		c_snikket.snikket_persistence_media_store_f_s_get_media_path(
+			self.o,
+			uri,
+			{ (a0, ctx) in
+				let callback = Unmanaged<AnyObject>.fromOpaque(ctx!).takeUnretainedValue() as! (String?)->Void
+				callback(useString(a0))
+			},
+			__callback_ptr
+		)
+	}
+
+	deinit {
+		c_snikket.snikket_release(o)
+	}
+}
+
+public protocol KeyValueStore: SDKObject {
+}
+
+public class AnyKeyValueStore: KeyValueStore {
+	public let o: UnsafeMutableRawPointer
+
+	internal init(_ ptr: UnsafeMutableRawPointer) {
+		o = ptr
+	}
+
+	deinit {
+		c_snikket.snikket_release(o)
+	}
+
+}
+
+public protocol Persistence: SDKObject {
+}
+
+public class AnyPersistence: Persistence {
+	public let o: UnsafeMutableRawPointer
+
+	internal init(_ ptr: UnsafeMutableRawPointer) {
+		o = ptr
+	}
+
+	deinit {
+		c_snikket.snikket_release(o)
+	}
+
+}
+
+public class Hash: SDKObject {
+	public let o: UnsafeMutableRawPointer
+
+	internal init(_ ptr: UnsafeMutableRawPointer) {
+		o = ptr
+	}
+
+	public static func fromHex(algorithm: String, hash: String) -> Hash? {
+		(c_snikket.snikket_hash_from_hex(
+			algorithm,
+			hash
+		)).map({ Hash($0) })
+	}
+
+	public static func fromUri(uri: String) -> Hash? {
+		(c_snikket.snikket_hash_from_uri(
+			uri
+		)).map({ Hash($0) })
+	}
+
+	public var algorithm: String {
+		get {
+			useString(c_snikket.snikket_hash_algorithm(o))!
+		}
+	}
+
+	public func toUri() -> String {
+		useString(c_snikket.snikket_hash_to_uri(
+			self.o
+		))!
+	}
+
+	public func toHex() -> String {
+		useString(c_snikket.snikket_hash_to_hex(
+			self.o
+		))!
+	}
+
+	public func toBase64() -> String {
+		useString(c_snikket.snikket_hash_to_base_64(
+			self.o
+		))!
+	}
+
+	public func toBase64Url() -> String {
+		useString(c_snikket.snikket_hash_to_base_64_url(
+			self.o
+		))!
+	}
+
+	deinit {
+		c_snikket.snikket_release(o)
+	}
+}
+
+public class ChatAttachment: SDKObject {
+	public let o: UnsafeMutableRawPointer
+
+	internal init(_ ptr: UnsafeMutableRawPointer) {
+		o = ptr
+	}
+
+	public static func create(name: String?, mime: String, size: Int32, uri: String) -> ChatAttachment {
+		ChatAttachment(c_snikket.snikket_chat_attachment_create(
+			name,
+			mime,
+			size,
+			uri
+		)!)
+	}
+
+	public var name: String? {
+		get {
+			useString(c_snikket.snikket_chat_attachment_name(o))
+		}
+	}
+
+	public var mime: String {
+		get {
+			useString(c_snikket.snikket_chat_attachment_mime(o))!
+		}
+	}
+
+	public var size: Int32? {
+		get {
+			c_snikket.snikket_chat_attachment_size(o)
+		}
+	}
+
+	public var uris: Array<String> {
+		get {
+			{var __ret: UnsafeMutablePointer<UnsafePointer<CChar>?>? = nil;let __ret_length = c_snikket.snikket_chat_attachment_uris(o, &__ret);return {let __r = UnsafeMutableBufferPointer<UnsafePointer<CChar>?>(start: __ret, count: __ret_length).map({useString($0)!});c_snikket.snikket_release(__ret);return __r;}();}()
+		}
+	}
+
+	public var hashes: Array<Hash> {
+		get {
+			{var __ret: UnsafeMutablePointer<UnsafeMutableRawPointer?>? = nil;let __ret_length = c_snikket.snikket_chat_attachment_hashes(o, &__ret);return {let __r = UnsafeMutableBufferPointer<UnsafeMutableRawPointer?>(start: __ret, count: __ret_length).map({Hash($0!)});c_snikket.snikket_release(__ret);return __r;}();}()
+		}
+	}
+
+	deinit {
+		c_snikket.snikket_release(o)
+	}
+}
+
+public class ChatMessage: SDKObject {
+	public let o: UnsafeMutableRawPointer
+
+	internal init(_ ptr: UnsafeMutableRawPointer) {
+		o = ptr
+	}
+
+	/**
+	 The ID as set by the creator of this message
+	 */
+	public var localId: String? {
+		get {
+			useString(c_snikket.snikket_chat_message_local_id(o))
+		}
+	}
+
+	/**
+	 The ID as set by the authoritative server
+	 */
+	public var serverId: String? {
+		get {
+			useString(c_snikket.snikket_chat_message_server_id(o))
+		}
+	}
+
+	/**
+	 The ID of the server which set the serverId
+	 */
+	public var serverIdBy: String? {
+		get {
+			useString(c_snikket.snikket_chat_message_server_id_by(o))
+		}
+	}
+
+	/**
+	 The type of this message (Chat, Call, etc)
+	 */
+	public var type: MessageType {
+		get {
+			c_snikket.snikket_chat_message_type(o)
+		}
+	}
+
+	/**
+	 The timestamp of this message, in format YYYY-MM-DDThh:mm:ss[.sss]Z
+	 */
+	public var timestamp: String {
+		get {
+			useString(c_snikket.snikket_chat_message_timestamp(o))!
+		}
+	}
+
+	/**
+	 The ID of the sender of this message
+	 */
+	public var senderId: String {
+		get {
+			useString(c_snikket.snikket_chat_message_sender_id(o))!
+		}
+	}
+
+	/**
+	 Message this one is in reply to, or NULL
+	 */
+	public var replyToMessage: ChatMessage? {
+		get {
+			(c_snikket.snikket_chat_message_reply_to_message(o)).map({ ChatMessage($0) })
+		}
+	}
+
+	/**
+	 ID of the thread this message is in, or NULL
+	 */
+	public var threadId: String? {
+		get {
+			useString(c_snikket.snikket_chat_message_thread_id(o))
+		}
+	}
+
+	/**
+	 Array of attachments to this message
+	 */
+	public var attachments: Array<ChatAttachment> {
+		get {
+			{var __ret: UnsafeMutablePointer<UnsafeMutableRawPointer?>? = nil;let __ret_length = c_snikket.snikket_chat_message_attachments(o, &__ret);return {let __r = UnsafeMutableBufferPointer<UnsafeMutableRawPointer?>(start: __ret, count: __ret_length).map({ChatAttachment($0!)});c_snikket.snikket_release(__ret);return __r;}();}()
+		}
+	}
+
+	/**
+	 Body text of this message or NULL
+	 */
+	public var text: String? {
+		get {
+			useString(c_snikket.snikket_chat_message_text(o))
+		}
+	}
+
+	/**
+	 Language code for the body text
+	 */
+	public var lang: String? {
+		get {
+			useString(c_snikket.snikket_chat_message_lang(o))
+		}
+	}
+
+	/**
+	 Direction of this message
+	 */
+	public var direction: MessageDirection {
+		get {
+			c_snikket.snikket_chat_message_direction(o)
+		}
+	}
+
+	/**
+	 Status of this message
+	 */
+	public var status: MessageStatus {
+		get {
+			c_snikket.snikket_chat_message_status(o)
+		}
+		set {
+			c_snikket.snikket_chat_message_set_status(o, newValue)
+		}
+	}
+
+	/**
+	 Array of past versions of this message, if it has been edited
+	 */
+	public var versions: Array<ChatMessage> {
+		get {
+			{var __ret: UnsafeMutablePointer<UnsafeMutableRawPointer?>? = nil;let __ret_length = c_snikket.snikket_chat_message_versions(o, &__ret);return {let __r = UnsafeMutableBufferPointer<UnsafeMutableRawPointer?>(start: __ret, count: __ret_length).map({ChatMessage($0!)});c_snikket.snikket_release(__ret);return __r;}();}()
+		}
+	}
+
+	/**
+	 Create a new ChatMessage in reply to this one
+	 */
+	public func reply() -> ChatMessageBuilder {
+		ChatMessageBuilder(c_snikket.snikket_chat_message_reply(
+			self.o
+		)!)
+	}
+
+	public func getReplyId() -> String? {
+		useString(c_snikket.snikket_chat_message_get_reply_id(
+			self.o
+		))
+	}
+
+	/**
+	 Get HTML version of the message body
+	 
+	 WARNING: this is possibly untrusted HTML. You must parse or sanitize appropriately!
+	 */
+	public func html() -> String {
+		useString(c_snikket.snikket_chat_message_html(
+			self.o
+		))!
+	}
+
+	/**
+	 The ID of the Chat this message is associated with
+	 */
+	public func chatId() -> String {
+		useString(c_snikket.snikket_chat_message_chat_id(
+			self.o
+		))!
+	}
+
+	/**
+	 The ID of the account associated with this message
+	 */
+	public func account() -> String {
+		useString(c_snikket.snikket_chat_message_account(
+			self.o
+		))!
+	}
+
+	/**
+	 Is this an incoming message?
+	 */
+	public func isIncoming() -> Bool {
+		c_snikket.snikket_chat_message_is_incoming(
+			self.o
+		)
+	}
+
+	/**
+	 The URI of an icon for the thread associated with this message, or NULL
+	 */
+	public func threadIcon() -> String?? {
+		useString(c_snikket.snikket_chat_message_thread_icon(
+			self.o
+		))
+	}
+
+	/**
+	 The last status of the call if this message is related to a call
+	 */
+	public func callStatus() -> String? {
+		useString(c_snikket.snikket_chat_message_call_status(
+			self.o
+		))
+	}
+
+	/**
+	 The session id of the call if this message is related to a call
+	 */
+	public func callSid() -> String? {
+		useString(c_snikket.snikket_chat_message_call_sid(
+			self.o
+		))
+	}
+
+	/**
+	 The duration of the call if this message is related to a call
+	 */
+	public func callDuration() -> String? {
+		useString(c_snikket.snikket_chat_message_call_duration(
+			self.o
+		))
+	}
+
+	deinit {
+		c_snikket.snikket_release(o)
+	}
+}
+
+public class Sqlite: SDKObject, KeyValueStore, Persistence {
+	public let o: UnsafeMutableRawPointer
+
+	internal init(_ ptr: UnsafeMutableRawPointer) {
+		o = ptr
+	}
+
+	/**
+	 Create a basic persistence layer based on sqlite
+	 
+	 @param dbfile path to sqlite database
+	 @params media a MediaStore to use for media
+	 @returns new persistence layer
+	 */
+	public init(dbfile: String, media: MediaStore) {
+		o = c_snikket.snikket_persistence_sqlite_new(dbfile, media.o)
+	}
+
+	public func getMessage(accountId: String, chatId: String, serverId: String?, localId: String?, callback: @escaping (ChatMessage?)->Void) -> Void {
+		let __callback_ptr = UnsafeMutableRawPointer(Unmanaged.passRetained(callback as AnyObject).toOpaque())
+		c_snikket.snikket_persistence_sqlite_get_message(
+			self.o,
+			accountId,
+			chatId,
+			serverId,
+			localId,
+			{ (a0, ctx) in
+				let callback = Unmanaged<AnyObject>.fromOpaque(ctx!).takeUnretainedValue() as! (ChatMessage?)->Void
+				callback((a0).map({ ChatMessage($0) }))
+			},
+			__callback_ptr
+		)
+	}
+
+	public func removeAccount(accountId: String, completely: Bool) -> Void {
+		c_snikket.snikket_persistence_sqlite_remove_account(
+			self.o,
+			accountId,
+			completely
+		)
+	}
+
+	public func listAccounts(callback: @escaping (Array<String>)->Void) -> Void {
+		let __callback_ptr = UnsafeMutableRawPointer(Unmanaged.passRetained(callback as AnyObject).toOpaque())
+		c_snikket.snikket_persistence_sqlite_list_accounts(
+			self.o,
+			{ (a0, a0_length, ctx) in
+				let callback = Unmanaged<AnyObject>.fromOpaque(ctx!).takeUnretainedValue() as! (Array<String>)->Void
+				callback({let __r = UnsafeMutableBufferPointer<UnsafePointer<CChar>?>(start: a0, count: a0_length).map({useString($0)!});c_snikket.snikket_release(a0);return __r;}())
+			},
+			__callback_ptr
+		)
+	}
+
+	deinit {
+		c_snikket.snikket_release(o)
+	}
+}
+
+public class ChatMessageBuilder: SDKObject {
+	public let o: UnsafeMutableRawPointer
+
+	internal init(_ ptr: UnsafeMutableRawPointer) {
+		o = ptr
+	}
+
+	/**
+	 @returns a new blank ChatMessageBuilder
+	 */
+	public init() {
+		o = c_snikket.snikket_chat_message_builder_new()
+	}
+
+	/**
+	 The ID as set by the creator of this message
+	 */
+	public var localId: String? {
+		get {
+			useString(c_snikket.snikket_chat_message_builder_local_id(o))
+		}
+		set {
+			c_snikket.snikket_chat_message_builder_set_local_id(o, newValue)
+		}
+	}
+
+	/**
+	 The ID as set by the authoritative server
+	 */
+	public var serverId: String? {
+		get {
+			useString(c_snikket.snikket_chat_message_builder_server_id(o))
+		}
+		set {
+			c_snikket.snikket_chat_message_builder_set_server_id(o, newValue)
+		}
+	}
+
+	/**
+	 The ID of the server which set the serverId
+	 */
+	public var serverIdBy: String? {
+		get {
+			useString(c_snikket.snikket_chat_message_builder_server_id_by(o))
+		}
+		set {
+			c_snikket.snikket_chat_message_builder_set_server_id_by(o, newValue)
+		}
+	}
+
+	/**
+	 The type of this message (Chat, Call, etc)
+	 */
+	public var type: MessageType {
+		get {
+			c_snikket.snikket_chat_message_builder_type(o)
+		}
+		set {
+			c_snikket.snikket_chat_message_builder_set_type(o, newValue)
+		}
+	}
+
+	/**
+	 The timestamp of this message, in format YYYY-MM-DDThh:mm:ss[.sss]+00:00
+	 */
+	public var timestamp: String? {
+		get {
+			useString(c_snikket.snikket_chat_message_builder_timestamp(o))
+		}
+		set {
+			c_snikket.snikket_chat_message_builder_set_timestamp(o, newValue)
+		}
+	}
+
+	public var senderId: String? {
+		get {
+			useString(c_snikket.snikket_chat_message_builder_sender_id(o))
+		}
+		set {
+			c_snikket.snikket_chat_message_builder_set_sender_id(o, newValue)
+		}
+	}
+
+	/**
+	 Message this one is in reply to, or NULL
+	 */
+	public var replyToMessage: ChatMessage? {
+		get {
+			(c_snikket.snikket_chat_message_builder_reply_to_message(o)).map({ ChatMessage($0) })
+		}
+		set {
+			c_snikket.snikket_chat_message_builder_set_reply_to_message(o, newValue?.o)
+		}
+	}
+
+	/**
+	 ID of the thread this message is in, or NULL
+	 */
+	public var threadId: String? {
+		get {
+			useString(c_snikket.snikket_chat_message_builder_thread_id(o))
+		}
+		set {
+			c_snikket.snikket_chat_message_builder_set_thread_id(o, newValue)
+		}
+	}
+
+	/**
+	 Array of attachments to this message
+	 */
+	public var attachments: Array<ChatAttachment> {
+		get {
+			{var __ret: UnsafeMutablePointer<UnsafeMutableRawPointer?>? = nil;let __ret_length = c_snikket.snikket_chat_message_builder_attachments(o, &__ret);return {let __r = UnsafeMutableBufferPointer<UnsafeMutableRawPointer?>(start: __ret, count: __ret_length).map({ChatAttachment($0!)});c_snikket.snikket_release(__ret);return __r;}();}()
+		}
+	}
+
+	/**
+	 Body text of this message or NULL
+	 */
+	public var text: String? {
+		get {
+			useString(c_snikket.snikket_chat_message_builder_text(o))
+		}
+		set {
+			c_snikket.snikket_chat_message_builder_set_text(o, newValue)
+		}
+	}
+
+	/**
+	 Language code for the body text
+	 */
+	public var lang: String? {
+		get {
+			useString(c_snikket.snikket_chat_message_builder_lang(o))
+		}
+		set {
+			c_snikket.snikket_chat_message_builder_set_lang(o, newValue)
+		}
+	}
+
+	/**
+	 Direction of this message
+	 */
+	public var direction: MessageDirection {
+		get {
+			c_snikket.snikket_chat_message_builder_direction(o)
+		}
+		set {
+			c_snikket.snikket_chat_message_builder_set_direction(o, newValue)
+		}
+	}
+
+	/**
+	 Status of this message
+	 */
+	public var status: MessageStatus {
+		get {
+			c_snikket.snikket_chat_message_builder_status(o)
+		}
+		set {
+			c_snikket.snikket_chat_message_builder_set_status(o, newValue)
+		}
+	}
+
+	/**
+	 Array of past versions of this message, if it has been edited
+	 */
+	public var versions: Array<ChatMessage> {
+		get {
+			{var __ret: UnsafeMutablePointer<UnsafeMutableRawPointer?>? = nil;let __ret_length = c_snikket.snikket_chat_message_builder_versions(o, &__ret);return {let __r = UnsafeMutableBufferPointer<UnsafeMutableRawPointer?>(start: __ret, count: __ret_length).map({ChatMessage($0!)});c_snikket.snikket_release(__ret);return __r;}();}()
+		}
+	}
+
+	public func addAttachment(attachment: ChatAttachment) -> Void {
+		c_snikket.snikket_chat_message_builder_add_attachment(
+			self.o,
+			attachment.o
+		)
+	}
+
+	/**
+	 Set rich text using an HTML string
+	 Also sets the plain text body appropriately
+	 */
+	public func setHtml(html: String) -> Void {
+		c_snikket.snikket_chat_message_builder_set_html(
+			self.o,
+			html
+		)
+	}
+
+	/**
+	 The ID of the Chat this message is associated with
+	 */
+	public func chatId() -> String {
+		useString(c_snikket.snikket_chat_message_builder_chat_id(
+			self.o
+		))!
+	}
+
+	/**
+	 The ID of the sender of this message
+	 */
+	public func get_senderId() -> String {
+		useString(c_snikket.snikket_chat_message_builder_get_sender_id(
+			self.o
+		))!
+	}
+
+	public func isIncoming() -> Bool {
+		c_snikket.snikket_chat_message_builder_is_incoming(
+			self.o
+		)
+	}
+
+	public func build() -> ChatMessage {
+		ChatMessage(c_snikket.snikket_chat_message_builder_build(
+			self.o
+		)!)
+	}
+
+	deinit {
+		c_snikket.snikket_release(o)
+	}
+}
+
+public class Dummy: SDKObject, Persistence {
+	public let o: UnsafeMutableRawPointer
+
+	internal init(_ ptr: UnsafeMutableRawPointer) {
+		o = ptr
+	}
+
+	/**
+	 Create a basic persistence layer that persists nothing
+	 
+	 @returns new persistence layer
+	 */
+	public init() {
+		o = c_snikket.snikket_persistence_dummy_new()
+	}
+
+	deinit {
+		c_snikket.snikket_release(o)
+	}
+}
+
+public class AudioFormat: SDKObject {
+	public let o: UnsafeMutableRawPointer
+
+	internal init(_ ptr: UnsafeMutableRawPointer) {
+		o = ptr
+	}
+
+	public init(format: String, payloadType: UInt8, clockRate: Int32, channels: Int32) {
+		o = c_snikket.snikket_jingle_audio_format_new(format, payloadType, clockRate, channels)
+	}
+
+	public var clockRate: Int32 {
+		get {
+			c_snikket.snikket_jingle_audio_format_clock_rate(o)
+		}
+	}
+
+	public var channels: Int32 {
+		get {
+			c_snikket.snikket_jingle_audio_format_channels(o)
+		}
+	}
+
+	deinit {
+		c_snikket.snikket_release(o)
+	}
+}
+
+public class MediaStreamTrack: SDKObject {
+	public let o: UnsafeMutableRawPointer
+
+	internal init(_ ptr: UnsafeMutableRawPointer) {
+		o = ptr
+	}
+
+	public var id: String {
+		get {
+			useString(c_snikket.snikket_jingle_media_stream_track_id(o))!
+		}
+	}
+
+	public var muted: Bool {
+		get {
+			c_snikket.snikket_jingle_media_stream_track_muted(o)
+		}
+	}
+
+	public var kind: String {
+		get {
+			useString(c_snikket.snikket_jingle_media_stream_track_kind(o))!
+		}
+	}
+
+	public var supportedAudioFormats: Array<AudioFormat> {
+		get {
+			{var __ret: UnsafeMutablePointer<UnsafeMutableRawPointer?>? = nil;let __ret_length = c_snikket.snikket_jingle_media_stream_track_supported_audio_formats(o, &__ret);return {let __r = UnsafeMutableBufferPointer<UnsafeMutableRawPointer?>(start: __ret, count: __ret_length).map({AudioFormat($0!)});c_snikket.snikket_release(__ret);return __r;}();}()
+		}
+	}
+
+	/**
+	 Event fired for new inbound audio frame
+	 
+	 @param callback takes three arguments, the Signed 16-bit PCM data, the clock rate, and the number of channels
+	 */
+	public func addPCMListener(callback: @escaping (Array<Int16>, Int32, Int32)->Void) -> Void {
+		let __callback_ptr = UnsafeMutableRawPointer(Unmanaged.passRetained(callback as AnyObject).toOpaque())
+		c_snikket.snikket_jingle_media_stream_track_add_pcm_listener(
+			self.o,
+			{ (a0, a0_length, a1, a2, ctx) in
+				let callback = Unmanaged<AnyObject>.fromOpaque(ctx!).takeUnretainedValue() as! (Array<Int16>, Int32, Int32)->Void
+				callback({let __r = UnsafeMutableBufferPointer<Int16>(start: a0, count: a0_length).map({$0});c_snikket.snikket_release(a0);return __r;}(), a1, a2)
+			},
+			__callback_ptr
+		)
+	}
+
+	/**
+	 Event fired when ready for next outbound audio frame
+	 
+	 @param callback
+	 */
+	public func addReadyForPCMListener(callback: @escaping ()->Void) -> Void {
+		let __callback_ptr = UnsafeMutableRawPointer(Unmanaged.passRetained(callback as AnyObject).toOpaque())
+		c_snikket.snikket_jingle_media_stream_track_add_ready_for_pcm_listener(
+			self.o,
+			{ (ctx) in
+				let callback = Unmanaged<AnyObject>.fromOpaque(ctx!).takeUnretainedValue() as! ()->Void
+				callback()
+			},
+			__callback_ptr
+		)
+	}
+
+	/**
+	 Send new audio to this track
+	 
+	 @param pcm 16-bit signed linear PCM data (interleaved)
+	 @param clockRate the sampling rate of the data
+	 @param channels the number of audio channels
+	 */
+	public func writePCM(pcm: Array<Int16>, clockRate: Int32, channels: Int32) -> Void {
+		c_snikket.snikket_jingle_media_stream_track_write_pcm(
+			self.o,
+			pcm, pcm.count,
+			clockRate,
+			channels
+		)
+	}
+
+	public func stop() -> Void {
+		c_snikket.snikket_jingle_media_stream_track_stop(
+			self.o
+		)
+	}
+
+	deinit {
+		c_snikket.snikket_release(o)
+	}
+}
+
+public class Chat: SDKObject {
+	public let o: UnsafeMutableRawPointer
+
+	internal init(_ ptr: UnsafeMutableRawPointer) {
+		o = ptr
+	}
+
+	/**
+	 ID of this Chat
+	 */
+	public var chatId: String {
+		get {
+			useString(c_snikket.snikket_chat_chat_id(o))!
+		}
+	}
+
+	/**
+	 Current state of this chat
+	 */
+	public var uiState: UiState {
+		get {
+			c_snikket.snikket_chat_ui_state(o)
+		}
+	}
+
+	public var isBlocked: Bool {
+		get {
+			c_snikket.snikket_chat_is_blocked(o)
+		}
+	}
+
+	/**
+	 Fetch a page of messages before some point
+	 
+	 @param beforeId id of the message to look before
+	 @param beforeTime timestamp of the message to look before,
+	        String in format YYYY-MM-DDThh:mm:ss[.sss]+00:00
+	 @param handler takes one argument, an array of ChatMessage that are found
+	 */
+	public func getMessagesBefore(beforeId: String?, beforeTime: String?, handler: @escaping (Array<ChatMessage>)->Void) -> Void {
+		let __handler_ptr = UnsafeMutableRawPointer(Unmanaged.passRetained(handler as AnyObject).toOpaque())
+		c_snikket.snikket_chat_get_messages_before(
+			self.o,
+			beforeId,
+			beforeTime,
+			{ (a0, a0_length, ctx) in
+				let handler = Unmanaged<AnyObject>.fromOpaque(ctx!).takeUnretainedValue() as! (Array<ChatMessage>)->Void
+				handler({let __r = UnsafeMutableBufferPointer<UnsafeMutableRawPointer?>(start: a0, count: a0_length).map({ChatMessage($0!)});c_snikket.snikket_release(a0);return __r;}())
+			},
+			__handler_ptr
+		)
+	}
+
+	/**
+	 Fetch a page of messages after some point
+	 
+	 @param afterId id of the message to look after
+	 @param afterTime timestamp of the message to look after,
+	        String in format YYYY-MM-DDThh:mm:ss[.sss]+00:00
+	 @param handler takes one argument, an array of ChatMessage that are found
+	 */
+	public func getMessagesAfter(afterId: String?, afterTime: String?, handler: @escaping (Array<ChatMessage>)->Void) -> Void {
+		let __handler_ptr = UnsafeMutableRawPointer(Unmanaged.passRetained(handler as AnyObject).toOpaque())
+		c_snikket.snikket_chat_get_messages_after(
+			self.o,
+			afterId,
+			afterTime,
+			{ (a0, a0_length, ctx) in
+				let handler = Unmanaged<AnyObject>.fromOpaque(ctx!).takeUnretainedValue() as! (Array<ChatMessage>)->Void
+				handler({let __r = UnsafeMutableBufferPointer<UnsafeMutableRawPointer?>(start: a0, count: a0_length).map({ChatMessage($0!)});c_snikket.snikket_release(a0);return __r;}())
+			},
+			__handler_ptr
+		)
+	}
+
+	/**
+	 Fetch a page of messages around (before, including, and after) some point
+	 
+	 @param aroundId id of the message to look around
+	 @param aroundTime timestamp of the message to look around,
+	        String in format YYYY-MM-DDThh:mm:ss[.sss]+00:00
+	 @param handler takes one argument, an array of ChatMessage that are found
+	 */
+	public func getMessagesAround(aroundId: String?, aroundTime: String?, handler: @escaping (Array<ChatMessage>)->Void) -> Void {
+		let __handler_ptr = UnsafeMutableRawPointer(Unmanaged.passRetained(handler as AnyObject).toOpaque())
+		c_snikket.snikket_chat_get_messages_around(
+			self.o,
+			aroundId,
+			aroundTime,
+			{ (a0, a0_length, ctx) in
+				let handler = Unmanaged<AnyObject>.fromOpaque(ctx!).takeUnretainedValue() as! (Array<ChatMessage>)->Void
+				handler({let __r = UnsafeMutableBufferPointer<UnsafeMutableRawPointer?>(start: a0, count: a0_length).map({ChatMessage($0!)});c_snikket.snikket_release(a0);return __r;}())
+			},
+			__handler_ptr
+		)
+	}
+
+	/**
+	 Send a ChatMessage to this Chat
+	 
+	 @param message the ChatMessage to send
+	 */
+	public func sendMessage(message: ChatMessageBuilder) -> Void {
+		c_snikket.snikket_chat_send_message(
+			self.o,
+			message.o
+		)
+	}
+
+	/**
+	 Signals that all messages up to and including this one have probably
+	 been displayed to the user
+	 
+	 @param message the ChatMessage most recently displayed
+	 */
+	public func markReadUpTo(message: ChatMessage) -> Void {
+		c_snikket.snikket_chat_mark_read_up_to(
+			self.o,
+			message.o
+		)
+	}
+
+	/**
+	 Save this Chat on the server
+	 */
+	public func bookmark() -> Void {
+		c_snikket.snikket_chat_bookmark(
+			self.o
+		)
+	}
+
+	/**
+	 Get the list of IDs of participants in this Chat
+	 
+	 @returns array of IDs
+	 */
+	public func getParticipants() -> Array<String> {
+		{var __ret: UnsafeMutablePointer<UnsafePointer<CChar>?>? = nil;let __ret_length = c_snikket.snikket_chat_get_participants(
+			self.o
+		, &__ret);return {let __r = UnsafeMutableBufferPointer<UnsafePointer<CChar>?>(start: __ret, count: __ret_length).map({useString($0)!});c_snikket.snikket_release(__ret);return __r;}();}()
+	}
+
+	/**
+	 Get the details for one participant in this Chat
+	 
+	 @param participantId the ID of the participant to look up
+	 */
+	public func getParticipantDetails(participantId: String) -> Participant {
+		Participant(c_snikket.snikket_chat_get_participant_details(
+			self.o,
+			participantId
+		)!)
+	}
+
+	/**
+	 Correct an already-send message by replacing it with a new one
+	 
+	 @param localId the localId of the message to correct
+	        must be the localId of the first version ever sent, not a subsequent correction
+	 @param message the new ChatMessage to replace it with
+	 */
+	public func correctMessage(localId: String, message: ChatMessageBuilder) -> Void {
+		c_snikket.snikket_chat_correct_message(
+			self.o,
+			localId,
+			message.o
+		)
+	}
+
+	/**
+	 Add new reaction to a message in this Chat
+	 
+	 @param m ChatMessage to react to
+	 @param reaction emoji of the reaction
+	 */
+	public func addReaction(m: ChatMessage, reaction: Reaction) -> Void {
+		c_snikket.snikket_chat_add_reaction(
+			self.o,
+			m.o,
+			reaction.o
+		)
+	}
+
+	/**
+	 Remove an already-sent reaction from a message
+	 
+	 @param m ChatMessage to remove the reaction from
+	 @param reaction the emoji to remove
+	 */
+	public func removeReaction(m: ChatMessage, reaction: Reaction) -> Void {
+		c_snikket.snikket_chat_remove_reaction(
+			self.o,
+			m.o,
+			reaction.o
+		)
+	}
+
+	/**
+	 Call this whenever the user is typing, can call on every keystroke
+	 
+	 @param threadId optional, what thread the user has selected if any
+	 @param content optional, what the user has typed so far
+	 */
+	public func typing(threadId: String?, content: String?) -> Void {
+		c_snikket.snikket_chat_typing(
+			self.o,
+			threadId,
+			content
+		)
+	}
+
+	/**
+	 Call this whenever the user makes a chat or thread "active" in your UX
+	 If you call this with true you MUST later call it will false
+	 
+	 @param active true if the chat is "active", false otherwise
+	 @param threadId optional, what thread the user has selected if any
+	 */
+	public func setActive(active: Bool, threadId: String?) -> Void {
+		c_snikket.snikket_chat_set_active(
+			self.o,
+			active,
+			threadId
+		)
+	}
+
+	/**
+	 Archive this chat
+	 */
+	public func close() -> Void {
+		c_snikket.snikket_chat_close(
+			self.o
+		)
+	}
+
+	/**
+	 Pin or unpin this chat
+	 */
+	public func togglePinned() -> Void {
+		c_snikket.snikket_chat_toggle_pinned(
+			self.o
+		)
+	}
+
+	/**
+	 Block this chat so it will not re-open
+	 */
+	public func block(reportSpam: ChatMessage?, onServer: Bool) -> Void {
+		c_snikket.snikket_chat_block(
+			self.o,
+			reportSpam?.o,
+			onServer
+		)
+	}
+
+	/**
+	 Unblock this chat so it will open again
+	 */
+	public func unblock(onServer: Bool) -> Void {
+		c_snikket.snikket_chat_unblock(
+			self.o,
+			onServer
+		)
+	}
+
+	/**
+	 Update notification preferences
+	 */
+	public func setNotifications(filtered: Bool, mention: Bool, reply: Bool) -> Void {
+		c_snikket.snikket_chat_set_notifications(
+			self.o,
+			filtered,
+			mention,
+			reply
+		)
+	}
+
+	/**
+	 Should notifications be filtered?
+	 */
+	public func notificationsFiltered() -> Bool {
+		c_snikket.snikket_chat_notifications_filtered(
+			self.o
+		)
+	}
+
+	/**
+	 Should a mention produce a notification?
+	 */
+	public func notifyMention() -> Bool {
+		c_snikket.snikket_chat_notify_mention(
+			self.o
+		)
+	}
+
+	/**
+	 Should a reply produce a notification?
+	 */
+	public func notifyReply() -> Bool {
+		c_snikket.snikket_chat_notify_reply(
+			self.o
+		)
+	}
+
+	/**
+	 An ID of the most recent message in this chat
+	 */
+	public func lastMessageId() -> String? {
+		useString(c_snikket.snikket_chat_last_message_id(
+			self.o
+		))
+	}
+
+	/**
+	 The timestamp of the most recent message in this chat
+	 */
+	public func lastMessageTimestamp() -> String? {
+		useString(c_snikket.snikket_chat_last_message_timestamp(
+			self.o
+		))
+	}
+
+	/**
+	 Get the URI image to represent this Chat, or null
+	 */
+	public func getPhoto() -> String? {
+		useString(c_snikket.snikket_chat_get_photo(
+			self.o
+		))
+	}
+
+	/**
+	 Get the URI to a placeholder image to represent this Chat
+	 */
+	public func getPlaceholder() -> String {
+		useString(c_snikket.snikket_chat_get_placeholder(
+			self.o
+		))!
+	}
+
+	/**
+	 An ID of the last message displayed to the user
+	 */
+	public func readUpTo() -> String? {
+		useString(c_snikket.snikket_chat_read_up_to(
+			self.o
+		))
+	}
+
+	/**
+	 The number of message that have not yet been displayed to the user
+	 */
+	public func unreadCount() -> Int32 {
+		c_snikket.snikket_chat_unread_count(
+			self.o
+		)
+	}
+
+	/**
+	 A preview of the chat, such as the most recent message body
+	 */
+	public func preview() -> String {
+		useString(c_snikket.snikket_chat_preview(
+			self.o
+		))!
+	}
+
+	public func setDisplayName(fn: String) -> Void {
+		c_snikket.snikket_chat_set_display_name(
+			self.o,
+			fn
+		)
+	}
+
+	/**
+	 The display name of this Chat
+	 */
+	public func getDisplayName() -> String {
+		useString(c_snikket.snikket_chat_get_display_name(
+			self.o
+		))!
+	}
+
+	public func setTrusted(trusted: Bool) -> Void {
+		c_snikket.snikket_chat_set_trusted(
+			self.o,
+			trusted
+		)
+	}
+
+	/**
+	 Is this a chat with an entity we trust to see our online status?
+	 */
+	public func isTrusted() -> Bool {
+		c_snikket.snikket_chat_is_trusted(
+			self.o
+		)
+	}
+
+	public func syncing() -> Bool {
+		c_snikket.snikket_chat_syncing(
+			self.o
+		)
+	}
+
+	/**
+	 Can audio calls be started in this Chat?
+	 */
+	public func canAudioCall() -> Bool {
+		c_snikket.snikket_chat_can_audio_call(
+			self.o
+		)
+	}
+
+	/**
+	 Can video calls be started in this Chat?
+	 */
+	public func canVideoCall() -> Bool {
+		c_snikket.snikket_chat_can_video_call(
+			self.o
+		)
+	}
+
+	/**
+	 Start a new call in this Chat
+	 
+	 @param audio do we want audio in this call
+	 @param video do we want video in this call
+	 */
+	public func startCall(audio: Bool, video: Bool) -> Void {
+		c_snikket.snikket_chat_start_call(
+			self.o,
+			audio,
+			video
+		)
+	}
+
+	/**
+	 Accept any incoming calls in this Chat
+	 */
+	public func acceptCall() -> Void {
+		c_snikket.snikket_chat_accept_call(
+			self.o
+		)
+	}
+
+	/**
+	 Hangup or reject any calls in this chat
+	 */
+	public func hangup() -> Void {
+		c_snikket.snikket_chat_hangup(
+			self.o
+		)
+	}
+
+	/**
+	 The current status of a call in this chat
+	 */
+	public func callStatus() -> String {
+		useString(c_snikket.snikket_chat_call_status(
+			self.o
+		))!
+	}
+
+	/**
+	 A DTMFSender for a call in this chat, or NULL
+	 */
+	public func dtmf() -> DTMFSender? {
+		(c_snikket.snikket_chat_dtmf(
+			self.o
+		)).map({ DTMFSender($0) })
+	}
+
+	/**
+	 All video tracks in all active calls in this chat
+	 */
+	public func videoTracks() -> Array<MediaStreamTrack> {
+		{var __ret: UnsafeMutablePointer<UnsafeMutableRawPointer?>? = nil;let __ret_length = c_snikket.snikket_chat_video_tracks(
+			self.o
+		, &__ret);return {let __r = UnsafeMutableBufferPointer<UnsafeMutableRawPointer?>(start: __ret, count: __ret_length).map({MediaStreamTrack($0!)});c_snikket.snikket_release(__ret);return __r;}();}()
+	}
+
+	deinit {
+		c_snikket.snikket_release(o)
+	}
+}
+
+public class AvailableChat: SDKObject {
+	public let o: UnsafeMutableRawPointer
+
+	internal init(_ ptr: UnsafeMutableRawPointer) {
+		o = ptr
+	}
+
+	/**
+	 The ID of the Chat this search result represents
+	 */
+	public var chatId: String {
+		get {
+			useString(c_snikket.snikket_available_chat_chat_id(o))!
+		}
+	}
+
+	/**
+	 The display name of this search result
+	 */
+	public var displayName: String? {
+		get {
+			useString(c_snikket.snikket_available_chat_display_name(o))
+		}
+	}
+
+	/**
+	 A human-readable note associated with this search result
+	 */
+	public var note: String {
+		get {
+			useString(c_snikket.snikket_available_chat_note(o))!
+		}
+	}
+
+	/**
+	 Is this search result a channel?
+	 */
+	public func isChannel() -> Bool {
+		c_snikket.snikket_available_chat_is_channel(
+			self.o
+		)
+	}
+
+	deinit {
+		c_snikket.snikket_release(o)
+	}
+}
+
+public protocol Session: SDKObject {
+}
+
+public class AnySession: Session {
+	public let o: UnsafeMutableRawPointer
+
+	internal init(_ ptr: UnsafeMutableRawPointer) {
+		o = ptr
+	}
+
+	deinit {
+		c_snikket.snikket_release(o)
+	}
+
+}
+
+public class MediaStream: SDKObject {
+	public let o: UnsafeMutableRawPointer
+
+	internal init(_ ptr: UnsafeMutableRawPointer) {
+		o = ptr
+	}
+
+	public init() {
+		o = c_snikket.snikket_jingle_media_stream_new()
+	}
+
+	/**
+	 Create default bidirectional audio track
+	 */
+	public static func makeAudio() -> MediaStream {
+		MediaStream(c_snikket.snikket_jingle_media_stream_make_audio(
+		)!)
+	}
+
+	public func addTrack(track: MediaStreamTrack) -> Void {
+		c_snikket.snikket_jingle_media_stream_add_track(
+			self.o,
+			track.o
+		)
+	}
+
+	public func getTracks() -> Array<MediaStreamTrack> {
+		{var __ret: UnsafeMutablePointer<UnsafeMutableRawPointer?>? = nil;let __ret_length = c_snikket.snikket_jingle_media_stream_get_tracks(
+			self.o
+		, &__ret);return {let __r = UnsafeMutableBufferPointer<UnsafeMutableRawPointer?>(start: __ret, count: __ret_length).map({MediaStreamTrack($0!)});c_snikket.snikket_release(__ret);return __r;}();}()
+	}
+
+	deinit {
+		c_snikket.snikket_release(o)
+	}
+}
+
+public class InitiatedSession: SDKObject, Session {
+	public let o: UnsafeMutableRawPointer
+
+	internal init(_ ptr: UnsafeMutableRawPointer) {
+		o = ptr
+	}
+
+	public var sid: String {
+		get {
+			useString(c_snikket.snikket_jingle_initiated_session_sid(o))!
+		}
+	}
+
+	public func accept() -> Void {
+		c_snikket.snikket_jingle_initiated_session_accept(
+			self.o
+		)
+	}
+
+	public func hangup() -> Void {
+		c_snikket.snikket_jingle_initiated_session_hangup(
+			self.o
+		)
+	}
+
+	public func addMedia(streams: Array<MediaStream>) -> Void {
+		c_snikket.snikket_jingle_initiated_session_add_media(
+			self.o,
+			streams.map { $0.o }, streams.count
+		)
+	}
+
+	public func callStatus() -> String {
+		useString(c_snikket.snikket_jingle_initiated_session_call_status(
+			self.o
+		))!
+	}
+
+	public func videoTracks() -> Array<MediaStreamTrack> {
+		{var __ret: UnsafeMutablePointer<UnsafeMutableRawPointer?>? = nil;let __ret_length = c_snikket.snikket_jingle_initiated_session_video_tracks(
+			self.o
+		, &__ret);return {let __r = UnsafeMutableBufferPointer<UnsafeMutableRawPointer?>(start: __ret, count: __ret_length).map({MediaStreamTrack($0!)});c_snikket.snikket_release(__ret);return __r;}();}()
+	}
+
+	public func dtmf() -> DTMFSender? {
+		(c_snikket.snikket_jingle_initiated_session_dtmf(
+			self.o
+		)).map({ DTMFSender($0) })
+	}
+
+	public func supplyMedia(streams: Array<MediaStream>) -> Void {
+		c_snikket.snikket_jingle_initiated_session_supply_media(
+			self.o,
+			streams.map { $0.o }, streams.count
+		)
+	}
+
+	deinit {
+		c_snikket.snikket_release(o)
+	}
+}
+
+public class Client: SDKObject {
+	public let o: UnsafeMutableRawPointer
+
+	internal init(_ ptr: UnsafeMutableRawPointer) {
+		o = ptr
+	}
+
+	/**
+	 Create a new Client to connect to a particular account
+	 
+	 @param address the account to connect to
+	 @param persistence the persistence layer to use for storage
+	 */
+	public init(address: String, persistence: Persistence) {
+		o = c_snikket.snikket_client_new(address, persistence.o)
+	}
+
+	/**
+	 Start this client running and trying to connect to the server
+	 */
+	public func start() -> Void {
+		c_snikket.snikket_client_start(
+			self.o
+		)
+	}
+
+	/**
+	 Destroy local data for this account
+	 
+	 @param completely if true chats, messages, etc will be deleted as well
+	 */
+	public func logout(completely: Bool) -> Void {
+		c_snikket.snikket_client_logout(
+			self.o,
+			completely
+		)
+	}
+
+	/**
+	 Sets the password to be used in response to the password needed event
+	 
+	 @param password
+	 */
+	public func usePassword(password: String) -> Void {
+		c_snikket.snikket_client_use_password(
+			self.o,
+			password
+		)
+	}
+
+	/**
+	 Get the account ID for this Client
+	 
+	 @returns account id
+	 */
+	public func accountId() -> String {
+		useString(c_snikket.snikket_client_account_id(
+			self.o
+		))!
+	}
+
+	/**
+	 Get the current display name for this account
+	 
+	 @returns display name
+	 */
+	public func displayName() -> String {
+		useString(c_snikket.snikket_client_display_name(
+			self.o
+		))!
+	}
+
+	/**
+	 Set the current display name for this account on the server
+	 
+	 @param display name to set (ignored if empty or NULL)
+	 */
+	public func setDisplayName(displayName: String) -> Void {
+		c_snikket.snikket_client_set_display_name(
+			self.o,
+			displayName
+		)
+	}
+
+	/**
+	 Turn a file into a ChatAttachment for attaching to a ChatMessage
+	 */
+	public func prepareAttachment(source: AttachmentSource, callback: @escaping (ChatAttachment?)->Void) -> Void {
+		let __callback_ptr = UnsafeMutableRawPointer(Unmanaged.passRetained(callback as AnyObject).toOpaque())
+		c_snikket.snikket_client_prepare_attachment(
+			self.o,
+			source.o,
+			{ (a0, ctx) in
+				let callback = Unmanaged<AnyObject>.fromOpaque(ctx!).takeUnretainedValue() as! (ChatAttachment?)->Void
+				callback((a0).map({ ChatAttachment($0) }))
+			},
+			__callback_ptr
+		)
+	}
+
+	/**
+	 @returns array of open chats, sorted by last activity
+	 */
+	public func getChats() -> Array<Chat> {
+		{var __ret: UnsafeMutablePointer<UnsafeMutableRawPointer?>? = nil;let __ret_length = c_snikket.snikket_client_get_chats(
+			self.o
+		, &__ret);return {let __r = UnsafeMutableBufferPointer<UnsafeMutableRawPointer?>(start: __ret, count: __ret_length).map({Chat($0!)});c_snikket.snikket_release(__ret);return __r;}();}()
+	}
+
+	/**
+	 Search for chats the user can start or join
+	 
+	 @param q the search query to use
+	 @param callback takes two arguments, the query that was used and the array of results
+	 */
+	public func findAvailableChats(q: String, callback: @escaping (String, Array<AvailableChat>)->Void) -> Void {
+		let __callback_ptr = UnsafeMutableRawPointer(Unmanaged.passRetained(callback as AnyObject).toOpaque())
+		c_snikket.snikket_client_find_available_chats(
+			self.o,
+			q,
+			{ (a0, a1, a1_length, ctx) in
+				let callback = Unmanaged<AnyObject>.fromOpaque(ctx!).takeUnretainedValue() as! (String, Array<AvailableChat>)->Void
+				callback(useString(a0)!, {let __r = UnsafeMutableBufferPointer<UnsafeMutableRawPointer?>(start: a1, count: a1_length).map({AvailableChat($0!)});c_snikket.snikket_release(a1);return __r;}())
+			},
+			__callback_ptr
+		)
+	}
+
+	/**
+	 Start or join a chat from the search results
+	 
+	 @returns the chat that was started
+	 */
+	public func startChat(availableChat: AvailableChat) -> Chat {
+		Chat(c_snikket.snikket_client_start_chat(
+			self.o,
+			availableChat.o
+		)!)
+	}
+
+	/**
+	 Find a chat by id
+	 
+	 @returns the chat if known, or NULL
+	 */
+	public func getChat(chatId: String) -> Chat? {
+		(c_snikket.snikket_client_get_chat(
+			self.o,
+			chatId
+		)).map({ Chat($0) })
+	}
+
+	/**
+	 Event fired when client needs a password for authentication
+	 
+	 @param handler takes one argument, the Client that needs a password
+	 */
+	public func addPasswordNeededListener(handler: @escaping (Client)->Void) -> Void {
+		let __handler_ptr = UnsafeMutableRawPointer(Unmanaged.passRetained(handler as AnyObject).toOpaque())
+		c_snikket.snikket_client_add_password_needed_listener(
+			self.o,
+			{ (a0, ctx) in
+				let handler = Unmanaged<AnyObject>.fromOpaque(ctx!).takeUnretainedValue() as! (Client)->Void
+				handler(Client(a0!))
+			},
+			__handler_ptr
+		)
+	}
+
+	/**
+	 Event fired when client is connected and fully synchronized
+	 
+	 @param handler takes no arguments
+	 */
+	public func addStatusOnlineListener(handler: @escaping ()->Void) -> Void {
+		let __handler_ptr = UnsafeMutableRawPointer(Unmanaged.passRetained(handler as AnyObject).toOpaque())
+		c_snikket.snikket_client_add_status_online_listener(
+			self.o,
+			{ (ctx) in
+				let handler = Unmanaged<AnyObject>.fromOpaque(ctx!).takeUnretainedValue() as! ()->Void
+				handler()
+			},
+			__handler_ptr
+		)
+	}
+
+	/**
+	 Event fired when client is disconnected
+	 
+	 @param handler takes no arguments
+	 */
+	public func addStatusOfflineListener(handler: @escaping ()->Void) -> Void {
+		let __handler_ptr = UnsafeMutableRawPointer(Unmanaged.passRetained(handler as AnyObject).toOpaque())
+		c_snikket.snikket_client_add_status_offline_listener(
+			self.o,
+			{ (ctx) in
+				let handler = Unmanaged<AnyObject>.fromOpaque(ctx!).takeUnretainedValue() as! ()->Void
+				handler()
+			},
+			__handler_ptr
+		)
+	}
+
+	/**
+	 Event fired when connection fails with a fatal error and will not be retried
+	 
+	 @param handler takes no arguments
+	 */
+	public func addConnectionFailedListener(handler: @escaping ()->Void) -> Void {
+		let __handler_ptr = UnsafeMutableRawPointer(Unmanaged.passRetained(handler as AnyObject).toOpaque())
+		c_snikket.snikket_client_add_connection_failed_listener(
+			self.o,
+			{ (ctx) in
+				let handler = Unmanaged<AnyObject>.fromOpaque(ctx!).takeUnretainedValue() as! ()->Void
+				handler()
+			},
+			__handler_ptr
+		)
+	}
+
+	/**
+	 Event fired when a new ChatMessage comes in on any Chat
+	 Also fires when status of a ChatMessage changes,
+	 when a ChatMessage is edited, or when a reaction is added
+	 
+	 @param handler takes two arguments, the ChatMessage and ChatMessageEvent enum describing what happened
+	 */
+	public func addChatMessageListener(handler: @escaping (ChatMessage, Int32)->Void) -> Void {
+		let __handler_ptr = UnsafeMutableRawPointer(Unmanaged.passRetained(handler as AnyObject).toOpaque())
+		c_snikket.snikket_client_add_chat_message_listener(
+			self.o,
+			{ (a0, a1, ctx) in
+				let handler = Unmanaged<AnyObject>.fromOpaque(ctx!).takeUnretainedValue() as! (ChatMessage, Int32)->Void
+				handler(ChatMessage(a0!), a1)
+			},
+			__handler_ptr
+		)
+	}
+
+	/**
+	 Event fired when syncing a new ChatMessage that was send when offline.
+	 Normally you don't want this, but it may be useful if you want to notify on app start.
+	 
+	 @param handler takes one argument, the ChatMessage
+	 */
+	public func addSyncMessageListener(handler: @escaping (ChatMessage)->Void) -> Void {
+		let __handler_ptr = UnsafeMutableRawPointer(Unmanaged.passRetained(handler as AnyObject).toOpaque())
+		c_snikket.snikket_client_add_sync_message_listener(
+			self.o,
+			{ (a0, ctx) in
+				let handler = Unmanaged<AnyObject>.fromOpaque(ctx!).takeUnretainedValue() as! (ChatMessage)->Void
+				handler(ChatMessage(a0!))
+			},
+			__handler_ptr
+		)
+	}
+
+	/**
+	 Event fired when a Chat's metadata is updated, or when a new Chat is added
+	 
+	 @param handler takes one argument, an array of Chats that were updated
+	 */
+	public func addChatsUpdatedListener(handler: @escaping (Array<Chat>)->Void) -> Void {
+		let __handler_ptr = UnsafeMutableRawPointer(Unmanaged.passRetained(handler as AnyObject).toOpaque())
+		c_snikket.snikket_client_add_chats_updated_listener(
+			self.o,
+			{ (a0, a0_length, ctx) in
+				let handler = Unmanaged<AnyObject>.fromOpaque(ctx!).takeUnretainedValue() as! (Array<Chat>)->Void
+				handler({let __r = UnsafeMutableBufferPointer<UnsafeMutableRawPointer?>(start: a0, count: a0_length).map({Chat($0!)});c_snikket.snikket_release(a0);return __r;}())
+			},
+			__handler_ptr
+		)
+	}
+
+	/**
+	 Event fired when a new call comes in
+	 
+	 @param handler takes two arguments, the call Session and the associated Chat ID
+	 */
+	public func addCallRingListener(handler: @escaping (Session, String)->Void) -> Void {
+		let __handler_ptr = UnsafeMutableRawPointer(Unmanaged.passRetained(handler as AnyObject).toOpaque())
+		c_snikket.snikket_client_add_call_ring_listener(
+			self.o,
+			{ (a0, a1, ctx) in
+				let handler = Unmanaged<AnyObject>.fromOpaque(ctx!).takeUnretainedValue() as! (Session, String)->Void
+				handler(AnySession(a0!), useString(a1)!)
+			},
+			__handler_ptr
+		)
+	}
+
+	/**
+	 Event fired when a call is retracted or hung up
+	 
+	 @param handler takes one argument, the associated Chat ID
+	 */
+	public func addCallRetractListener(handler: @escaping (String)->Void) -> Void {
+		let __handler_ptr = UnsafeMutableRawPointer(Unmanaged.passRetained(handler as AnyObject).toOpaque())
+		c_snikket.snikket_client_add_call_retract_listener(
+			self.o,
+			{ (a0, ctx) in
+				let handler = Unmanaged<AnyObject>.fromOpaque(ctx!).takeUnretainedValue() as! (String)->Void
+				handler(useString(a0)!)
+			},
+			__handler_ptr
+		)
+	}
+
+	/**
+	 Event fired when an outgoing call starts ringing
+	 
+	 @param handler takes one argument, the associated Chat ID
+	 */
+	public func addCallRingingListener(handler: @escaping (String)->Void) -> Void {
+		let __handler_ptr = UnsafeMutableRawPointer(Unmanaged.passRetained(handler as AnyObject).toOpaque())
+		c_snikket.snikket_client_add_call_ringing_listener(
+			self.o,
+			{ (a0, ctx) in
+				let handler = Unmanaged<AnyObject>.fromOpaque(ctx!).takeUnretainedValue() as! (String)->Void
+				handler(useString(a0)!)
+			},
+			__handler_ptr
+		)
+	}
+
+	/**
+	 Event fired when a call is asking for media to send
+	 
+	 @param handler takes three arguments, the call Session,
+	        a boolean indicating if audio is desired,
+	        and a boolean indicating if video is desired
+	 */
+	public func addCallMediaListener(handler: @escaping (InitiatedSession, Bool, Bool)->Void) -> Void {
+		let __handler_ptr = UnsafeMutableRawPointer(Unmanaged.passRetained(handler as AnyObject).toOpaque())
+		c_snikket.snikket_client_add_call_media_listener(
+			self.o,
+			{ (a0, a1, a2, ctx) in
+				let handler = Unmanaged<AnyObject>.fromOpaque(ctx!).takeUnretainedValue() as! (InitiatedSession, Bool, Bool)->Void
+				handler(InitiatedSession(a0!), a1, a2)
+			},
+			__handler_ptr
+		)
+	}
+
+	/**
+	 Event fired when call has a new MediaStreamTrack to play
+	 
+	 @param handler takes three arguments, the associated Chat ID,
+	        the new MediaStreamTrack, and an array of any associated MediaStreams
+	 */
+	public func addCallTrackListener(handler: @escaping (String, MediaStreamTrack, Array<MediaStream>)->Void) -> Void {
+		let __handler_ptr = UnsafeMutableRawPointer(Unmanaged.passRetained(handler as AnyObject).toOpaque())
+		c_snikket.snikket_client_add_call_track_listener(
+			self.o,
+			{ (a0, a1, a2, a2_length, ctx) in
+				let handler = Unmanaged<AnyObject>.fromOpaque(ctx!).takeUnretainedValue() as! (String, MediaStreamTrack, Array<MediaStream>)->Void
+				handler(useString(a0)!, MediaStreamTrack(a1!), {let __r = UnsafeMutableBufferPointer<UnsafeMutableRawPointer?>(start: a2, count: a2_length).map({MediaStream($0!)});c_snikket.snikket_release(a2);return __r;}())
+			},
+			__handler_ptr
+		)
+	}
+
+	/**
+	 Let the SDK know the UI is in the foreground
+	 */
+	public func setInForeground() -> Void {
+		c_snikket.snikket_client_set_in_foreground(
+			self.o
+		)
+	}
+
+	/**
+	 Let the SDK know the UI is in the foreground
+	 */
+	public func setNotInForeground() -> Void {
+		c_snikket.snikket_client_set_not_in_foreground(
+			self.o
+		)
+	}
+
+	deinit {
+		c_snikket.snikket_release(o)
+	}
+}
+
+public class AttachmentSource: SDKObject {
+	public let o: UnsafeMutableRawPointer
+
+	internal init(_ ptr: UnsafeMutableRawPointer) {
+		o = ptr
+	}
+
+	public init(path: String, mime: String) {
+		o = c_snikket.snikket_attachment_source_new(path, mime)
+	}
+
+	public var path: String {
+		get {
+			useString(c_snikket.snikket_attachment_source_path(o))!
+		}
+	}
+
+	public var type: String {
+		get {
+			useString(c_snikket.snikket_attachment_source_type(o))!
+		}
+	}
+
+	public var name: String {
+		get {
+			useString(c_snikket.snikket_attachment_source_name(o))!
+		}
+	}
+
+	public var size: Int32 {
+		get {
+			c_snikket.snikket_attachment_source_size(o)
+		}
+	}
+
+	deinit {
+		c_snikket.snikket_release(o)
+	}
+}
+
+public class Participant: SDKObject {
+	public let o: UnsafeMutableRawPointer
+
+	internal init(_ ptr: UnsafeMutableRawPointer) {
+		o = ptr
+	}
+
+	public var displayName: String {
+		get {
+			useString(c_snikket.snikket_participant_display_name(o))!
+		}
+	}
+
+	public var photoUri: String? {
+		get {
+			useString(c_snikket.snikket_participant_photo_uri(o))
+		}
+	}
+
+	public var placeholderUri: String {
+		get {
+			useString(c_snikket.snikket_participant_placeholder_uri(o))!
+		}
+	}
+
+	public var isSelf: Bool {
+		get {
+			c_snikket.snikket_participant_is_self(o)
+		}
+	}
+
+	deinit {
+		c_snikket.snikket_release(o)
+	}
+}
+
+public class Channel: Chat {
+	public func isPrivate() -> Bool {
+		c_snikket.snikket_channel_is_private(
+			self.o
+		)
+	}
+
+}
+
+public class DirectChat: Chat {
+}
+
+public class Reaction: SDKObject {
+	public let o: UnsafeMutableRawPointer
+
+	internal init(_ ptr: UnsafeMutableRawPointer) {
+		o = ptr
+	}
+
+	public var senderId: String {
+		get {
+			useString(c_snikket.snikket_reaction_sender_id(o))!
+		}
+	}
+
+	public var timestamp: String {
+		get {
+			useString(c_snikket.snikket_reaction_timestamp(o))!
+		}
+	}
+
+	public var text: String {
+		get {
+			useString(c_snikket.snikket_reaction_text(o))!
+		}
+	}
+
+	public var key: String {
+		get {
+			useString(c_snikket.snikket_reaction_key(o))!
+		}
+	}
+
+	public var envelopeId: String? {
+		get {
+			useString(c_snikket.snikket_reaction_envelope_id(o))
+		}
+	}
+
+	deinit {
+		c_snikket.snikket_release(o)
+	}
+}
+
+public class CustomEmojiReaction: Reaction {
+	public var uri: String {
+		get {
+			useString(c_snikket.snikket_custom_emoji_reaction_uri(o))!
+		}
+	}
+
+}
+
+public class DTMFSender: SDKObject {
+	public let o: UnsafeMutableRawPointer
+
+	internal init(_ ptr: UnsafeMutableRawPointer) {
+		o = ptr
+	}
+
+	/**
+	 Schedule DTMF events to be sent
+	 
+	 @param tones can be any number of 0123456789#*ABCD,
+	 */
+	public func insertDTMF(tones: String) -> Void {
+		c_snikket.snikket_jingle_dtmf_sender_insert_dtmf(
+			self.o,
+			tones
+		)
+	}
+
+	deinit {
+		c_snikket.snikket_release(o)
+	}
+}
+
+public typealias UiState = snikket_ui_state
+
+public typealias MessageType = snikket_message_type
+
+public typealias MessageStatus = snikket_message_status
+
+public typealias MessageDirection = snikket_message_direction
diff --git a/Sources/c_snikket/iinclude/Array.h b/Sources/c_snikket/iinclude/Array.h
new file mode 100644
index 0000000..ed6f738
--- /dev/null
+++ b/Sources/c_snikket/iinclude/Array.h
@@ -0,0 +1,1186 @@
+#ifndef HX_ARRAY_H
+#define HX_ARRAY_H
+#include <cpp/FastIterator.h>
+
+// --- hx::ReturnNull ------------------------------------------------------
+//
+// Provides an "Null<Object>" of given type.  For types that can't actually be null, Dynamic is used.
+
+namespace hx
+{
+
+enum ArrayStore
+{
+   arrayNull = 0,
+   arrayEmpty,
+   arrayFixed,
+   arrayBool,
+   arrayInt,
+   arrayFloat,
+   arrayString,
+   arrayObject,
+   arrayInt64
+};
+
+enum ArrayConvertId
+{
+   aciAlwaysConvert = -4,
+   aciVirtualArray = -3,
+   aciStringArray  = -2,
+   aciObjectArray  = -1,
+   aciNotArray     = 0,
+   aciPodBase      = 1,
+};
+
+template<typename T>
+struct ReturnNull { typedef T type; };
+template<> struct ReturnNull<int> { typedef Dynamic type; };
+template<> struct ReturnNull<double> { typedef Dynamic type; };
+template<> struct ReturnNull<float> { typedef Dynamic type; };
+template<> struct ReturnNull<bool> { typedef Dynamic type; };
+template<> struct ReturnNull<char> { typedef Dynamic type; };
+template<> struct ReturnNull<signed char> { typedef Dynamic type; };
+template<> struct ReturnNull<unsigned char> { typedef Dynamic type; };
+template<> struct ReturnNull<short> { typedef Dynamic type; };
+template<> struct ReturnNull<unsigned short> { typedef Dynamic type; };
+template<> struct ReturnNull<unsigned int> { typedef Dynamic type; };
+template<> struct ReturnNull< ::cpp::Int64> { typedef Dynamic type; };
+
+template<typename T>
+struct ArrayTraits { enum { StoreType = arrayObject }; };
+template<> struct ArrayTraits<int> { enum { StoreType = arrayInt }; };
+template<> struct ArrayTraits<float> { enum { StoreType = arrayFloat}; };
+template<> struct ArrayTraits<double> { enum { StoreType = arrayFloat}; };
+template<> struct ArrayTraits<Dynamic> { enum { StoreType = arrayObject }; };
+template<> struct ArrayTraits<String> { enum { StoreType = arrayString }; };
+template<> struct ArrayTraits< ::cpp::Int64> { enum { StoreType = arrayInt64 }; };
+
+}
+
+
+
+namespace hx
+{
+
+
+
+// --- ArrayIterator -------------------------------------------
+//
+// An object that conforms to the standard iterator interface for arrays
+template<typename FROM,typename TO>
+class ArrayIterator : public cpp::FastIterator_obj<TO>
+{
+public:
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdArrayIterator };
+
+   ArrayIterator(Array<FROM> inArray) : mArray(inArray), mIdx(0) { }
+
+   // Fast versions ...
+   bool hasNext()  { return mIdx < mArray->length; }
+
+   inline TO toTo(const Dynamic &inD) { return inD.StaticCast<TO>(); }
+
+   template<typename T>
+   inline TO toTo(T inT) { return inT; }
+
+   TO next() { return toTo(mArray->__get(mIdx++)); }
+
+   void __Mark(hx::MarkContext *__inCtx) { HX_MARK_MEMBER_NAME(mArray,"mArray"); }
+   #ifdef HXCPP_VISIT_ALLOCS
+   void __Visit(hx::VisitContext *__inCtx) { HX_VISIT_MEMBER_NAME(mArray,"mArray"); }
+   #endif
+
+   int      mIdx;
+   Array<FROM> mArray;
+};
+
+// --- ArrayKeyValueIterator -------------------------------------------
+template<typename FROM,typename TO>
+class ArrayKeyValueIterator : public cpp::FastIterator_obj<Dynamic>
+{
+public:
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdArrayIterator };
+
+   ArrayKeyValueIterator(Array<FROM> inArray) : mArray(inArray), mIdx(0) { }
+
+   bool hasNext()  { return mIdx < mArray->length; }
+
+   inline TO toTo(const Dynamic &inD) { return inD.StaticCast<TO>(); }
+
+   template<typename T>
+   inline TO toTo(T inT) { return inT; }
+
+
+   Dynamic next();
+
+   void __Mark(hx::MarkContext *__inCtx) { HX_MARK_MEMBER_NAME(mArray,"mArray"); }
+   #ifdef HXCPP_VISIT_ALLOCS
+   void __Visit(hx::VisitContext *__inCtx) { HX_VISIT_MEMBER_NAME(mArray,"mArray"); }
+   #endif
+
+   int      mIdx;
+   Array<FROM> mArray;
+};
+
+}
+
+namespace hx
+{
+
+// Also used by cpp::VirtualArray
+class HXCPP_EXTERN_CLASS_ATTRIBUTES ArrayCommon : public hx::Object
+{
+   protected:
+      int mArrayConvertId;
+   public:
+      // Plain old data element size - or 0 if not plain-old-data
+      int getArrayConvertId() const { return mArrayConvertId; }
+
+      virtual hx::Object *__GetRealObject() { return this; }
+};
+
+// --- hx::ArrayBase ----------------------------------------------------
+//
+// Base class that treats array contents as a slab of bytes.
+// The derived "Array_obj" adds strong typing to the "[]" operator
+
+class HXCPP_EXTERN_CLASS_ATTRIBUTES ArrayBase : public ArrayCommon
+{
+public:
+   ArrayBase(int inSize,int inReserve,int inElementSize,bool inAtomic);
+
+   // Defined later so we can use "Array"
+   static Array<Dynamic> __new(int inSize=0,int inReserve=0);
+
+
+   static void __boot();
+
+   typedef hx::Object super;
+
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdArrayBase };
+
+   // Used by cpp.ArrayBase
+   inline int getElementSize() const { return GetElementSize(); }
+   inline int getByteCount() const { return GetElementSize()*length; }
+   inline char * getBase() const { return mBase; }
+
+
+   hx::Val __SetField(const String &inString,const hx::Val &inValue ,hx::PropertyAccess inCallProp) { return null(); }
+
+   static hx::Class __mClass;
+   static hx::Class &__SGetClass() { return __mClass; }
+   hx::Class __GetClass() const { return __mClass; }
+   String toString();
+   String __ToString() const;
+   int __Compare(const hx::Object *inRHS) const;
+
+
+   void setData(void *inData, int inElements)
+   {
+      mBase = (char *)inData;
+      length = inElements;
+      mAlloc = inElements;
+      HX_OBJ_WB_PESSIMISTIC_GET(this);
+   }
+
+   void setUnmanagedData(void *inData, int inElements)
+   {
+      mBase = (char *)inData;
+      length = inElements;
+      mAlloc = -1;
+   }
+
+
+   int __GetType() const { return vtArray; }
+
+   inline size_t size() const { return length; }
+   inline int __length() const { return (int)length; }
+
+   virtual String ItemString(int inI)  = 0;
+
+   const char * __CStr() const { return mBase; }
+   inline const char *GetBase() const { return mBase; }
+   inline char *GetBase() { return mBase; }
+
+   virtual int GetElementSize() const = 0;
+
+   inline void resize(int inSize)
+   {
+      if (inSize<length)
+      {
+         int s = GetElementSize();
+         memset(mBase + inSize*s, 0, (length-inSize)*s);
+         length = inSize;
+      }
+      else if (inSize>length)
+      {
+         EnsureSize(inSize);
+         length = inSize;
+      }
+   }
+   inline void __SetSize(int inLen) { resize(inLen); }
+
+   void __SetSizeExact(int inLen=0);
+   
+   Dynamic __unsafe_get(const Dynamic &i);
+   Dynamic __unsafe_set(const Dynamic &i, const Dynamic &val);
+
+   void safeSort(Dynamic sorter, bool isString);
+
+   inline void __unsafeStringReference(String inString)
+   {
+      mBase = (char *)inString.raw_ptr();
+      length = inString.length / GetElementSize();
+      mAlloc = length;
+      HX_OBJ_WB_PESSIMISTIC_GET(this);
+   }
+
+   
+   virtual hx::ArrayStore getStoreType() const = 0;
+
+
+   // Dynamic interface
+   hx::Val __Field(const String &inString ,hx::PropertyAccess inCallProp);
+
+   inline void ____SetSize(int len)  { resize(len); } 
+   inline void ____SetSizeExact(int len)  { __SetSizeExact(len); } 
+   inline Dynamic ____unsafe_set(const Dynamic &i, const Dynamic &val)  { return __SetItem(i,val); } 
+   inline Dynamic ____unsafe_get(const Dynamic &i)  { return __GetItem(i); } 
+
+   virtual hx::ArrayBase *__concat(const cpp::VirtualArray &a0) = 0;
+   virtual hx::ArrayBase *__copy() = 0;
+   virtual void __insert(int inIndex,const Dynamic &a1) = 0;
+   virtual Dynamic __iterator() = 0;
+   virtual Dynamic __keyValueIterator() = 0;
+   virtual ::String __join(::String a0) = 0;
+   virtual Dynamic __pop() = 0;
+   virtual int __push(const Dynamic &a0) = 0;
+   virtual bool __contains(const Dynamic &a0) = 0;
+   virtual bool __remove(const Dynamic &a0) = 0;
+   virtual bool __removeAt(int inIndex) = 0;
+   virtual int __indexOf(const Dynamic &a0,const Dynamic &a1) = 0;
+   virtual int __lastIndexOf(const Dynamic &a0,const Dynamic &a1) = 0;
+   virtual void __reverse() = 0;
+   virtual Dynamic __shift() = 0;
+   virtual hx::ArrayBase *__slice(const Dynamic &a0,const Dynamic &a1) = 0;
+   virtual hx::ArrayBase *__splice(const Dynamic &a0,const Dynamic &a1) = 0;
+   virtual void __sort(const Dynamic &a0) = 0;
+   virtual ::String __toString() = 0;
+   virtual void  __unshift(const Dynamic &a0) = 0;
+   virtual cpp::VirtualArray_obj *__map(const Dynamic &func) = 0;
+   virtual hx::ArrayBase *__filter(const Dynamic &func) = 0;
+   virtual void __blit(int inDestElement,const cpp::VirtualArray &inSourceArray,int inSourceElement,int inElementCount) = 0;
+   virtual int __memcmp(const cpp::VirtualArray &a0) = 0;
+   inline void __zero(const Dynamic &a0,const Dynamic &a1)  { zero(a0,a1); }
+   virtual void __qsort(Dynamic inCompare) = 0;
+   virtual void __resize(int inLen) = 0;
+
+   virtual void set(int inIdx, const cpp::Variant &inValue) = 0;
+   virtual void setUnsafe(int inIdx, const cpp::Variant &inValue) = 0;
+
+   Dynamic concat_dyn();
+   Dynamic copy_dyn();
+   Dynamic insert_dyn();
+   Dynamic iterator_dyn();
+   Dynamic keyValueIterator_dyn();
+   Dynamic join_dyn();
+   Dynamic pop_dyn();
+   Dynamic push_dyn();
+   Dynamic contains_dyn();
+   Dynamic remove_dyn();
+   Dynamic removeAt_dyn();
+   Dynamic indexOf_dyn();
+   Dynamic lastIndexOf_dyn();
+   Dynamic reverse_dyn();
+   Dynamic shift_dyn();
+   Dynamic slice_dyn();
+   Dynamic splice_dyn();
+   Dynamic sort_dyn();
+   Dynamic toString_dyn();
+   Dynamic unshift_dyn();
+   Dynamic map_dyn();
+   Dynamic filter_dyn();
+   Dynamic __SetSize_dyn();
+   Dynamic __SetSizeExact_dyn();
+   Dynamic __unsafe_get_dyn();
+   Dynamic __unsafe_set_dyn();
+   Dynamic blit_dyn();
+   Dynamic zero_dyn();
+   Dynamic memcmp_dyn();
+   Dynamic resize_dyn();
+
+   void Realloc(int inLen) const;
+
+   inline void EnsureSize(int inLen) const
+   {
+      if (inLen>length)
+      {
+         if (inLen>mAlloc)
+            Realloc(inLen);
+         length = inLen;
+      }
+   }
+
+   void RemoveElement(int inIndex);
+
+
+   void Insert(int inPos);
+
+   void Splice(hx::ArrayBase *outResult,int inPos,int inLen);
+
+   void Slice(hx::ArrayBase *outResult,int inPos,int inEnd);
+
+   void Concat(hx::ArrayBase *outResult,const char *inEnd, int inLen);
+
+
+   void reserve(int inN) const;
+
+   inline int capacity() const { return mAlloc; }
+
+   // Set numeric values to 0, pointers to null, bools to false
+   void zero(Dynamic inFirst, Dynamic inCount);
+
+   int Memcmp(ArrayBase *inArray);
+
+   // Copy section of other array.
+   void Blit(int inDestElement, ArrayBase *inSourceArray, int inSourceElement, int inElementCount);
+
+   static String joinArray(hx::ArrayBase *inBase, String inSeparator);
+   static String joinArray(Array_obj<String> *inArray, String inSeparator);
+
+   virtual bool AllocAtomic() const { return false; }
+
+   inline bool IsByteArray() const { return getStoreType()==arrayBool; }
+
+
+   inline Dynamic __get(int inIndex) const { return __GetItem(inIndex); }
+
+   // Plain old data element size - or 0 if not plain-old-data
+   int getArrayConvertId() const { return mArrayConvertId; }
+
+   mutable int length;
+
+   static inline int baseOffset() { return (int)offsetof(ArrayBase,mBase); }
+   static inline int allocOffset() { return (int)offsetof(ArrayBase,mAlloc); }
+   static inline int lengthOffset() { return (int)offsetof(ArrayBase,length); }
+
+protected:
+   mutable int mAlloc;
+   mutable char  *mBase;
+};
+
+} // end namespace hx for ArrayBase
+
+namespace cpp
+{
+   typedef hx::ArrayBase ArrayBase_obj;
+
+   // Use by cpp.ArrayBase extern
+   typedef hx::ObjectPtr<ArrayBase_obj> ArrayBase;
+}
+
+
+#include "cpp/VirtualArray.h"
+
+
+
+
+// --- Array_obj ------------------------------------------------------------------
+//
+// The Array_obj specialises the ArrayBase, adding typing where required
+
+
+namespace hx
+{
+// This is to determine is we need to include our slab of bytes in garbage collection
+template<typename T>
+inline bool TypeContainsPointers(T *) { return true; }
+template<> inline bool TypeContainsPointers(bool *) { return false; }
+template<> inline bool TypeContainsPointers(int *) { return false; }
+template<> inline bool TypeContainsPointers(double *) { return false; }
+template<> inline bool TypeContainsPointers(float *) { return false; }
+template<> inline bool TypeContainsPointers(short *) { return false; }
+template<> inline bool TypeContainsPointers(unsigned char *) { return false; }
+template<> inline bool TypeContainsPointers(::cpp::Int64 *) { return false; }
+
+template<typename TYPE> inline bool ContainsPointers()
+{
+   return TypeContainsPointers( (TYPE *)0 );
+}
+
+
+
+// For returning "null" when out of bounds ...
+template<typename TYPE>
+inline TYPE *NewNull() { Dynamic d; return (TYPE *)hx::NewGCBytes(&d,sizeof(d)); }
+
+template<> inline int *NewNull<int>() { int i=0; return (int *)hx::NewGCPrivate(&i,sizeof(i)); }
+template<> inline bool *NewNull<bool>() { bool b=0; return (bool *)hx::NewGCPrivate(&b,sizeof(b)); }
+template<> inline double *NewNull<double>() { double d=0.0; return (double *)hx::NewGCPrivate(&d,sizeof(d)); }
+template<> inline float *NewNull<float>() { float d=0.0f; return (float *)hx::NewGCPrivate(&d,sizeof(d)); }
+template<> inline unsigned char *NewNull<unsigned char>() { unsigned char u=0; return (unsigned char *)hx::NewGCPrivate(&u,sizeof(u)); }
+template<> inline ::cpp::Int64 *NewNull< ::cpp::Int64>() { ::cpp::Int64 i=0; return (::cpp::Int64 *)hx::NewGCPrivate(&i,sizeof(i)); }
+
+
+bool DynamicEq(const Dynamic &a, const Dynamic &b);
+
+}
+
+template<typename T> struct ArrayClassId { enum { id=hx::clsIdArrayObject }; };
+template<> struct ArrayClassId<unsigned char> { enum { id=hx::clsIdArrayByte }; };
+template<> struct ArrayClassId<signed char> { enum { id=hx::clsIdArrayByte }; };
+template<> struct ArrayClassId<unsigned short> { enum { id=hx::clsIdArrayShort }; };
+template<> struct ArrayClassId<signed short> { enum { id=hx::clsIdArrayShort }; };
+template<> struct ArrayClassId<unsigned int> { enum { id=hx::clsIdArrayInt }; };
+template<> struct ArrayClassId<signed int> { enum { id=hx::clsIdArrayInt }; };
+template<> struct ArrayClassId<float> { enum { id=hx::clsIdArrayFloat32 }; };
+template<> struct ArrayClassId<double> { enum { id=hx::clsIdArrayFloat64 }; };
+template<> struct ArrayClassId<String> { enum { id=hx::clsIdArrayString }; };
+template<> struct ArrayClassId< ::cpp::Int64> { enum { id=hx::clsIdArrayInt64 }; };
+
+// sort...
+#include <algorithm>
+
+namespace hx
+{
+template<typename T>
+inline bool arrayElemEq(const T &a, const T &b) { return a==b; }
+
+template<>
+inline bool arrayElemEq<Dynamic>(const Dynamic &a, const Dynamic &b) {
+   return hx::DynamicEq(a,b);
+}
+}
+
+
+template<typename ELEM_>
+class Array_obj : public hx::ArrayBase
+{
+   typedef ELEM_ Elem;
+   typedef hx::ObjectPtr< Array_obj<ELEM_> > ObjPtr;
+   typedef typename hx::ReturnNull<ELEM_>::type NullType;
+
+public:
+   enum { _hx_ClassId = ArrayClassId<ELEM_>::id };
+
+
+   Array_obj(int inSize,int inReserve) :
+        hx::ArrayBase(inSize,inReserve,sizeof(ELEM_),!hx::ContainsPointers<ELEM_>()) { }
+
+
+   // Defined later so we can use "Array"
+   static Array<ELEM_> __new(int inSize=0,int inReserve=0);
+   static Array<ELEM_> __newConstWrapper(ELEM_ *inData,int inSize);
+   static Array<ELEM_> fromData(const ELEM_ *inData,int inCount);
+
+   bool _hx_isInstanceOf(int inClassId)
+   {
+      return inClassId==1 || inClassId==(int)hx::clsIdArrayBase || inClassId==(int)_hx_ClassId;
+   }
+
+   virtual bool AllocAtomic() const { return !hx::ContainsPointers<ELEM_>(); }
+
+   virtual Dynamic __GetItem(int inIndex) const { return __get(inIndex); }
+   virtual Dynamic __SetItem(int inIndex,Dynamic inValue)
+   {
+      ELEM_ &elem = Item(inIndex);
+      elem = inValue;
+      if (hx::ContainsPointers<ELEM_>()) { HX_OBJ_WB_GET(this,hx::PointerOf(elem)); }
+      return inValue;
+   }
+
+   inline ELEM_ *Pointer() { return (ELEM_ *)mBase; }
+
+   inline ELEM_ &Item(int inIndex)
+   {
+      if (inIndex>=(int)length) EnsureSize(inIndex+1);
+      else if (inIndex<0) { return * hx::NewNull<ELEM_>(); }
+      return * (ELEM_ *)(mBase + inIndex*sizeof(ELEM_));
+   }
+   inline ELEM_ __get(int inIndex) const
+   {
+      if ((unsigned int)inIndex>=(unsigned int)length ) return null();
+      return * (ELEM_ *)(mBase + inIndex*sizeof(ELEM_));
+   }
+
+   // Does not check for size valid - use with care
+   inline ELEM_ &__unsafe_get(int inIndex) { return * (ELEM_ *)(mBase + inIndex*sizeof(ELEM_)); }
+
+
+   inline ELEM_ & __unsafe_set(int inIndex, ELEM_ inValue)
+   {
+      ELEM_ &elem = *(ELEM_*)(mBase + inIndex*sizeof(ELEM_));
+      elem = inValue;
+      if (hx::ContainsPointers<ELEM_>()) { HX_OBJ_WB_GET(this, hx::PointerOf(elem)); }
+      return elem;
+   }
+
+
+   inline int memcmp(Array<ELEM_> inOther)
+   {
+      return ArrayBase::Memcmp(inOther.GetPtr());
+   }
+
+
+   inline void memcpy(int inStart, const ELEM_ *inData, int inElements)
+   {
+      EnsureSize(inStart+inElements);
+      int s = GetElementSize();
+      ::memcpy(mBase + s*inStart, inData, s*inElements);
+      if (hx::ContainsPointers<ELEM_>())
+      {
+         HX_OBJ_WB_PESSIMISTIC_GET(this);
+      }
+   }
+
+
+   inline void blit(int inDestElement,  Array<ELEM_> inSourceArray,
+                    int inSourceElement, int inElementCount)
+   {
+      ArrayBase::Blit(inDestElement, inSourceArray.GetPtr(), inSourceElement, inElementCount);
+   }
+
+
+   void __Mark(hx::MarkContext *__inCtx)
+   {
+      if (mAlloc>0) hx::MarkAlloc((void *)mBase, __inCtx );
+      if (length && hx::ContainsPointers<ELEM_>())
+      {
+         ELEM_ *ptr = (ELEM_ *)mBase;
+         HX_MARK_MEMBER_ARRAY(ptr,length);
+      }
+   }
+
+   #ifdef HXCPP_VISIT_ALLOCS
+   void __Visit(hx::VisitContext *__inCtx)
+   {
+      if (mAlloc>0) __inCtx->visitAlloc((void **)&mBase);
+      if (hx::ContainsPointers<ELEM_>())
+      {
+         ELEM_ *ptr = (ELEM_ *)mBase;
+         for(int i=0;i<length;i++)
+         {
+            HX_VISIT_MEMBER(ptr[i]);
+         }
+      }
+   }
+   #endif
+
+   inline Array<ELEM_> __SetSizeExact(int inLen);
+
+   int GetElementSize() const { return sizeof(ELEM_); }
+
+   String ItemString(int inI)
+   {
+      String result(__get(inI));
+      if (result==null()) return HX_CSTRING("null");
+      return result;
+   }
+
+   Array_obj<ELEM_> *Add(const ELEM_ &inItem) { push(inItem); return this; }
+
+   Array<ELEM_> init(int inIndex, ELEM_ inValue)
+   {
+      * (ELEM_ *)(mBase + inIndex*sizeof(ELEM_)) = inValue;
+      #ifdef HXCPP_GC_GENERATIONAL
+      if (hx::ContainsPointers<ELEM_>())
+         { HX_OBJ_WB_GET(this, hx::PointerOf(inValue)); }
+      #endif
+      return this;
+   }
+
+
+   #ifdef HXCPP_GC_GENERATIONAL
+   inline int pushCtx(hx::StackContext *_hx_ctx, ELEM_ inVal )
+   {
+      int l = length;
+      EnsureSize((int)l+1);
+      * (ELEM_ *)(mBase + l*sizeof(ELEM_)) = inVal;
+      if (hx::ContainsPointers<ELEM_>()) { HX_ARRAY_WB(this,inIdx, hx::PointerOf(inVal) ); }
+      return length;
+   }
+   #endif
+
+
+   // Haxe API
+   inline int push( ELEM_ inVal )
+   {
+      #ifdef HXCPP_GC_GENERATIONAL
+      if (hx::ContainsPointers<ELEM_>())
+         return pushCtx(HX_CTX_GET,inVal);
+      #endif
+      int l = length;
+      EnsureSize((int)l+1);
+      * (ELEM_ *)(mBase + l*sizeof(ELEM_)) = inVal;
+      return length;
+   }
+   inline NullType pop( )
+   {
+      if (!length) return null();
+      ELEM_ result = __get((int)length-1);
+      resize((int)length-1);
+      return result;
+   }
+
+
+
+   int Find(ELEM_ inValue)
+   {
+      ELEM_ *e = (ELEM_ *)mBase;
+      for(int i=0;i<length;i++)
+         if (hx::arrayElemEq(e[i],inValue))
+            return i;
+      return -1;
+   }
+
+   bool contains(ELEM_ inValue)
+   {
+      ELEM_ *e = (ELEM_ *)mBase;
+      for(int i=0;i<length;i++)
+      {
+         if (hx::arrayElemEq(e[i],inValue))
+            return true;
+      }
+      return false;
+   }
+
+   bool remove(ELEM_ inValue)
+   {
+      ELEM_ *e = (ELEM_ *)mBase;
+      for(int i=0;i<length;i++)
+      {
+         if (hx::arrayElemEq(e[i],inValue))
+         {
+            RemoveElement((int)i);
+            return true;
+         }
+      }
+      return false;
+   }
+
+   bool removeAt( int idx )
+   { 
+      if( idx < 0 ) idx += length; 
+      if (idx>=length || idx<0) return false; 
+      RemoveElement(idx); 
+      return true; 
+   }
+
+
+   int indexOf(ELEM_ inValue, Dynamic fromIndex = null())
+   {
+      int len = length;
+      int i = fromIndex==null() ? 0 : fromIndex->__ToInt();
+      ELEM_ *e = (ELEM_ *)mBase;
+      if (i < 0)
+      {
+         i += len;
+         if (i < 0) i = 0;
+      }
+      while(i<len)
+      {
+         if (hx::arrayElemEq(e[i],inValue))
+            return i;
+         i++;
+      }
+      return -1;
+   }
+
+   int lastIndexOf(ELEM_ inValue, Dynamic fromIndex = null())
+   {
+      int len = length;
+      int i = fromIndex==null() ? len-1 : fromIndex->__ToInt();
+      ELEM_ *e = (ELEM_ *)mBase;
+      if (i >= len)
+         i = len - 1;
+      else if (i < 0)
+         i += len;
+      while(i>=0)
+      {
+         if (hx::arrayElemEq(e[i],inValue))
+            return i;
+         i--;
+      }
+      return -1;
+   }
+
+   NullType shift()
+   {
+      if (length==0) return null();
+      ELEM_ result = __get(0);
+      RemoveElement(0);
+      return result;
+   }
+
+   String join(String inSeparator) { return ArrayBase::joinArray(this, inSeparator); }
+
+   Array<ELEM_> concat( Array<ELEM_> inTail );
+   Array<ELEM_> copy( );
+   Array<ELEM_> slice(int inPos, Dynamic end = null());
+   Array<ELEM_> splice(int inPos, int len);
+   inline void removeRange(int inPos, int len)
+   {
+      hx::ArrayBase::Splice(0,inPos,len);
+   }
+
+   cpp::VirtualArray map(Dynamic inFunc);
+   Array<ELEM_> filter(Dynamic inFunc);
+
+   void insert(int inPos, ELEM_ inValue)
+   {
+		if (inPos<0)
+		{
+			inPos+=length;
+			if (inPos<0) inPos = 0;
+		}
+		else if (inPos>length)
+			inPos = length;
+		hx::ArrayBase::Insert(inPos);
+      Item(inPos) = inValue;
+      #ifdef HXCPP_GC_GENERATIONAL
+      if (hx::ContainsPointers<ELEM_>())
+         { HX_OBJ_WB_GET(this,hx::PointerOf(inValue)); }
+      #endif
+   }
+
+   void unshift(ELEM_ inValue)
+   {
+      insert(0,inValue);
+   }
+
+   void reverse()
+   {
+      int half = length/2;
+      ELEM_ *e = (ELEM_ *)mBase;
+      for(int i=0;i<half;i++)
+      {
+         ELEM_ tmp = e[length-i-1];
+         e[length-i-1] = e[i];
+         e[i] = tmp;
+      }
+   }
+
+   // Will do random pointer sorting for object pointers
+   inline void sortAscending()
+   {
+      ELEM_ *e = (ELEM_ *)mBase;
+      std::sort(e, e+length);
+   }
+   static inline bool greaterThan(const ELEM_ &inA, const ELEM_ &inB) { return inB < inA; }
+   inline void sortDescending()
+   {
+      ELEM_ *e = (ELEM_ *)mBase;
+      std::sort(e, e+length, greaterThan);
+   }
+
+
+   struct Sorter
+   {
+      Sorter(Dynamic inFunc) : mFunc(inFunc) { }
+
+      bool operator()(const ELEM_ &inA, const ELEM_ &inB)
+      {
+         return mFunc( Dynamic(inA), Dynamic(inB))->__ToInt() < 0;
+      }
+
+      Dynamic mFunc;
+   };
+
+   inline void qsort(Dynamic inSorter)
+   {
+      ELEM_ *e = (ELEM_ *)mBase;
+      std::sort(e, e+length, Sorter(inSorter) );
+   }
+
+   void sort(Dynamic inSorter)
+   {
+      if ( (int)hx::ArrayTraits<ELEM_>::StoreType==(int)hx::arrayObject ||
+          (int)hx::ArrayTraits<ELEM_>::StoreType==(int)hx::arrayString)
+      {
+         // Keep references from being hidden inside sorters buffers
+         safeSort(inSorter, (int)hx::ArrayTraits<ELEM_>::StoreType==(int)hx::arrayString);
+      }
+      else
+      {
+         ELEM_ *e = (ELEM_ *)mBase;
+         std::stable_sort(e, e+length, Sorter(inSorter) );
+      }
+   }
+
+   Dynamic iterator() { return new hx::ArrayIterator<ELEM_,ELEM_>(this); }
+   Dynamic keyValueIterator() { return new hx::ArrayKeyValueIterator<ELEM_,ELEM_>(this); }
+
+   template<typename TO>
+   Dynamic iteratorFast() { return new hx::ArrayIterator<ELEM_,TO>(this); }
+
+   template<typename TO>
+   Dynamic keyValueIteratorFast() { return new hx::ArrayKeyValueIterator<ELEM_,TO>(this); }
+   
+   virtual hx::ArrayStore getStoreType() const
+   {
+      return (hx::ArrayStore) hx::ArrayTraits<ELEM_>::StoreType;
+   }
+
+   inline ELEM_ &setCtx(hx::StackContext *_hx_ctx, int inIdx, ELEM_ inValue)
+   {
+      ELEM_ &elem = Item(inIdx);
+      HX_ARRAY_WB(this,inIdx, hx::PointerOf(inValue) );
+      return elem = inValue;
+   }
+
+
+   // Dynamic interface
+   virtual hx::ArrayBase *__concat(const cpp::VirtualArray &a0) { return concat(a0).mPtr; }
+   virtual hx::ArrayBase *__copy() { return copy().mPtr; }
+   virtual void __insert(int inIndex,const Dynamic &a1) { insert(inIndex,a1);}
+   virtual Dynamic __iterator() { return iterator(); }
+   virtual Dynamic __keyValueIterator() { return keyValueIterator(); }
+   virtual ::String __join(::String a0) { return join(a0); }
+   virtual Dynamic __pop() { return pop(); }
+   virtual int __push(const Dynamic &a0) { return push(a0);}
+   virtual bool __contains(const Dynamic &a0) { return contains(a0); }
+   virtual bool __remove(const Dynamic &a0) { return remove(a0); }
+   virtual bool __removeAt(int inIndex) { return removeAt(inIndex); }
+   virtual int __indexOf(const Dynamic &a0,const Dynamic &a1) { return indexOf(a0, a1); }
+   virtual int __lastIndexOf(const Dynamic &a0,const Dynamic &a1) { return lastIndexOf(a0, a1); }
+   virtual void __reverse() { reverse(); }
+   virtual Dynamic __shift() { return shift(); }
+   virtual hx::ArrayBase *__slice(const Dynamic &a0,const Dynamic &a1) { return slice(a0,a1).mPtr; }
+   virtual hx::ArrayBase *__splice(const Dynamic &a0,const Dynamic &a1) { return splice(a0,a1).mPtr; }
+   virtual void __sort(const Dynamic &a0) { sort(a0); }
+   virtual ::String __toString() { return toString(); }
+   virtual void  __unshift(const Dynamic &a0) { unshift(a0); }
+   virtual cpp::VirtualArray_obj *__map(const Dynamic &func) { return map(func).mPtr; }
+   virtual void __resize(int inLen) { resize(inLen); }
+
+   virtual hx::ArrayBase *__filter(const Dynamic &func) { return filter(func).mPtr; }
+   virtual void __blit(int inDestElement,const cpp::VirtualArray &inSourceArray,int inSourceElement,int inElementCount)
+   {
+      blit(inDestElement,inSourceArray,inSourceElement,inElementCount);
+   }
+   virtual int __memcmp(const cpp::VirtualArray &a0) { return memcmp(a0); }
+   virtual void __qsort(Dynamic inCompare) { this->qsort(inCompare); };
+
+   virtual void set(int inIndex, const cpp::Variant &inValue) {
+      ELEM_ &elem = Item(inIndex);
+      elem = ELEM_(inValue);
+      if (hx::ContainsPointers<ELEM_>()) {
+         HX_OBJ_WB_GET(this, hx::PointerOf(elem));
+      }
+   }
+   virtual void setUnsafe(int inIndex, const cpp::Variant &inValue) {
+      ELEM_ &elem = *(ELEM_ *)(mBase + inIndex*sizeof(ELEM_));
+      elem = ELEM_(inValue);
+      if (hx::ContainsPointers<ELEM_>()) { HX_OBJ_WB_GET(this,hx::PointerOf(elem)); }
+   }
+};
+
+
+// --- Array ---------------------------------------------------------------
+//
+// The array class adds object syntax to the Array_obj pointer
+
+template<typename ELEM_>
+class Array : public hx::ObjectPtr< Array_obj<ELEM_> >
+{
+   typedef hx::ObjectPtr< Array_obj<ELEM_> > super;
+   typedef Array_obj<ELEM_> OBJ_;
+
+public:
+   typedef ELEM_ Elem;
+   typedef Array_obj<ELEM_> *Ptr;
+   using super::mPtr;
+   using super::GetPtr;
+
+   Array() { }
+   Array(int inSize,int inReserve) : super( OBJ_::__new(inSize,inReserve) ) { }
+   Array(const null &inNull) : super(0) { }
+   Array(Ptr inPtr) : super(inPtr) { }
+
+   #ifdef HXCPP_CHECK_POINTER
+   inline OBJ_ *CheckGetPtr() const
+   {
+      if (!mPtr) hx::NullReference("Array", true);
+      // The handler might have fixed up the null value
+      if (!mPtr) hx::NullReference("Array", false);
+      return mPtr;
+   }
+   #else
+   inline OBJ_ *CheckGetPtr() const { return mPtr; }
+   #endif
+
+   // Construct from our type ...
+   Array ( const hx::ObjectPtr< OBJ_  > &inArray )
+        :  hx::ObjectPtr< OBJ_ >(inArray) { }
+
+   Array(const Array<ELEM_> &inArray) : super(inArray.GetPtr()) { }
+
+   // Build dynamic array from foreign array
+   template<typename SOURCE_>
+   Array( const Array<SOURCE_> &inRHS ) : super(0)
+   {
+      Array_obj<SOURCE_> *ptr = inRHS.GetPtr(); 
+      if (ptr)
+      {
+         OBJ_ *arr = dynamic_cast<OBJ_ *>(ptr);
+         if (!arr)
+         {
+            // Non-identical type (syntactically, should be creating from Array<Dynamic>)
+            // Copy elements one-by-one
+            // Not quite right, but is the best we can do...
+            int n = ptr->__length();
+            *this = Array_obj<ELEM_>::__new(n);
+            for(int i=0;i<n;i++)
+               mPtr->__unsafe_set(i,ptr->__GetItem(i));
+         }
+         else
+            mPtr = arr;
+      }
+   }
+
+   #ifdef HX_VARRAY_DEFINED
+   // From VirtualArray
+   Array( const cpp::VirtualArray &inVArray) { fromVArray(inVArray.mPtr); }
+
+   void fromVArray(cpp::VirtualArray_obj *inVArray)
+   {
+      if (!inVArray || inVArray->store==hx::arrayNull)
+      {
+         mPtr = 0;
+         return;
+      }
+      inVArray->fixType<ELEM_>();
+      // Switch on type?
+      setDynamic(inVArray->base,true);
+   }
+
+   Array &operator=( const cpp::VirtualArray &inRHS )
+   {
+      fromVArray(inRHS.mPtr);
+      return *this;
+   }
+
+   #endif
+
+   inline void setDynamic( const Dynamic &inRHS, bool inIgnoreVirtualArray=false )
+   {
+      hx::Object *ptr = inRHS.GetPtr(); 
+      if (ptr)
+      {
+         OBJ_ *arr = dynamic_cast<OBJ_ *>(ptr);
+         if (!arr && ptr->__GetClass().mPtr == super::__SGetClass().mPtr )
+         {
+            #ifdef HX_VARRAY_DEFINED
+            cpp::VirtualArray_obj *varray = inIgnoreVirtualArray ? 0 :
+                                            dynamic_cast<cpp::VirtualArray_obj *>(ptr);
+            if (varray)
+               fromVArray(varray);
+            else
+            #endif
+            {
+               // Non-identical type.
+               // Copy elements one-by-one
+               // Not quite right, but is the best we can do...
+               int n = ptr->__length();
+               *this = Array_obj<ELEM_>::__new(n);
+               for(int i=0;i<n;i++)
+                  mPtr->__unsafe_set(i,ptr->__GetItem(i));
+            }
+         }
+         else
+            mPtr = arr;
+      }
+   }
+
+   Array( const Dynamic &inRHS ) : super(0) { setDynamic(inRHS); }
+   Array( const cpp::ArrayBase &inRHS ) : super(0) { setDynamic(inRHS); }
+   inline Array(const ::cpp::Variant &inVariant) : super(0)
+   {
+      setDynamic(inVariant.asObject());
+   }
+
+   // operator= exact match...
+   Array &operator=( Array<ELEM_> inRHS )
+   {
+      mPtr = inRHS.GetPtr();
+      return *this;
+   }
+
+   // Foreign array
+   template<typename OTHER>
+   Array &operator=( const Array<OTHER> &inRHS )
+   {
+      *this = Array(inRHS);
+      return *this;
+   }
+
+   Array &operator=( const Dynamic &inRHS )
+   {
+      setDynamic(inRHS);
+      return *this;
+   }
+
+   Array &operator=( const cpp::ArrayBase &inRHS )
+   {
+      setDynamic(inRHS);
+      return *this;
+   }
+
+
+   Array &operator=( const cpp::Variant &inRHS )
+   {
+      if (inRHS.type!=cpp::Variant::typeObject)
+         setDynamic( null() );
+      else
+         setDynamic(inRHS.valObject);
+      return *this;
+   }
+
+
+   Array &operator=( const null &inNull )
+   {
+      mPtr = 0;
+      return *this;
+   }
+
+   inline bool operator==(const cpp::VirtualArray &varray) const { return varray==*this; }
+   inline bool operator!=(const cpp::VirtualArray &varray) const { return varray!=*this; }
+
+   inline ELEM_ &operator[](int inIdx) { return CheckGetPtr()->Item(inIdx); }
+   inline ELEM_ operator[](int inIdx) const { return CheckGetPtr()->__get(inIdx); }
+   //inline ELEM_ __get(int inIdx) const { return CheckGetPtr()->__get(inIdx); }
+   inline int __length() const { return CheckGetPtr()->__length(); }
+   inline Array<ELEM_> &Add(const ELEM_ &inElem) { CheckGetPtr()->Add(inElem); return *this; }
+   inline Array<ELEM_> & operator<<(const ELEM_ &inElem) { CheckGetPtr()->Add(inElem); return *this; }
+};
+
+
+// Now that the "Array" object is defined, we can implement this function ....
+
+template<typename ELEM_>
+Array<ELEM_> Array_obj<ELEM_>::__new(int inSize,int inReserve)
+ { return  Array<ELEM_>(new Array_obj(inSize,inReserve)); }
+
+
+template<typename ELEM_>
+Array<ELEM_> Array_obj<ELEM_>::__newConstWrapper(ELEM_ *inData,int inSize)
+{
+   Array_obj<ELEM_> temp(0,0);
+   Array_obj<ELEM_> *result = (Array_obj<ELEM_> *)hx::InternalCreateConstBuffer(&temp,sizeof(temp));
+   result->setUnmanagedData(inData, inSize);
+   return result;
+}
+
+
+template<typename ELEM_>
+Array<ELEM_> Array_obj<ELEM_>::fromData(const ELEM_ *inData,int inCount)
+{
+   Array<ELEM_> result = new Array_obj(inCount,inCount);
+   if (inCount)
+       result->memcpy(0, inData, inCount);
+   return result;
+}
+
+
+
+template<>
+inline bool Dynamic::IsClass<Array<Dynamic> >()
+   { return mPtr && mPtr->__GetClass()== hx::ArrayBase::__mClass; }
+
+
+template<typename ELEM_>
+Array<ELEM_> Array_obj<ELEM_>::concat( Array<ELEM_> inTail )
+{
+   Array_obj *result = new Array_obj(inTail->__length()+(int)length,0);
+   hx::ArrayBase::Concat(result,inTail->GetBase(),inTail->__length());
+   return result;
+}
+
+template<typename ELEM_>
+Array<ELEM_> Array_obj<ELEM_>::copy( )
+{
+   Array_obj *result = new Array_obj((int)length,0);
+   ::memcpy(result->GetBase(),GetBase(),length*sizeof(ELEM_));
+   return result;
+}
+
+// Copies the range of the array starting at pos up to, but not including, end.
+// Both pos and end can be negative to count from the end: -1 is the last item in the array.
+template<typename ELEM_>
+Array<ELEM_> Array_obj<ELEM_>::slice(int inPos, Dynamic end)
+{
+   int e = end==null() ? length : end->__ToInt();
+   Array_obj *result = new Array_obj(0,0);
+   hx::ArrayBase::Slice(result,inPos,(int)e);
+   return result;
+}
+
+template<typename ELEM_>
+Array<ELEM_> Array_obj<ELEM_>::splice(int inPos, int len)
+{
+   Array_obj * result = new Array_obj(0,0);
+   hx::ArrayBase::Splice(result,inPos,len);
+   return result;
+}
+
+
+template<typename ELEM_>
+Array<ELEM_> Array_obj<ELEM_>::filter(Dynamic inFunc)
+{
+   Array_obj *result = new Array_obj(0,0);
+   for(int i=0;i<length;i++)
+      if (inFunc(__unsafe_get(i)))
+         result->push(__unsafe_get(i));
+   return result;
+}
+
+template<typename ELEM_>
+Array<ELEM_> Array_obj<ELEM_>::__SetSizeExact(int inLen)
+{
+   ArrayBase::__SetSizeExact(inLen);
+   return this;
+}
+
+// Static externs 
+template<typename ARRAY>
+inline ARRAY _hx_array_set_size_exact(ARRAY inArray, int inLen)
+{
+   return inArray->__SetSizeExact(inLen);
+}
+
+template<typename ARRAY1,typename ARRAY2>
+inline int _hx_array_memcmp(ARRAY1 inArray1, ARRAY2 inArray2)
+{
+   return inArray1->memcmp(inArray2);
+}
+
+template<typename ARRAY,typename VALUE>
+inline typename ARRAY::Elem _hx_array_unsafe_set(ARRAY inArray, int inIndex, VALUE inValue)
+{
+   return inArray->__unsafe_set(inIndex, inValue);
+}
+
+
+template<typename ARRAY>
+inline typename ARRAY::Elem _hx_array_unsafe_get(ARRAY inArray, int inIndex)
+{
+   return inArray->__unsafe_get(inIndex);
+}
+
+
+
+// Include again, for functions that required Array definition
+#ifdef HX_VARRAY_DEFINED
+#include "cpp/VirtualArray.h"
+#endif
+
+template<typename ELEM_>
+cpp::VirtualArray Array_obj<ELEM_>::map(Dynamic inFunc)
+{
+   cpp::VirtualArray result = cpp::VirtualArray_obj::__new(length,0);
+   for(int i=0;i<length;i++)
+      result->__unsafe_set(i,inFunc(__unsafe_get(i)));
+   return result;
+}
+
+#endif
\ No newline at end of file
diff --git a/Sources/c_snikket/iinclude/Date.h b/Sources/c_snikket/iinclude/Date.h
new file mode 100644
index 0000000..370b920
--- /dev/null
+++ b/Sources/c_snikket/iinclude/Date.h
@@ -0,0 +1,95 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_Date
+#define INCLUDED_Date
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_8e4589df03e4f3cc_26_new)
+HX_DECLARE_CLASS0(Date)
+
+
+
+class HXCPP_CLASS_ATTRIBUTES Date_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Date_obj OBJ_;
+		Date_obj();
+
+	public:
+		enum { _hx_ClassId = 0x018f7872 };
+
+		void __construct(int year,int month,int day,int hour,int min,int sec);
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="Date")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"Date"); }
+
+		inline static ::hx::ObjectPtr< Date_obj > __new(int year,int month,int day,int hour,int min,int sec) {
+			::hx::ObjectPtr< Date_obj > __this = new Date_obj();
+			__this->__construct(year,month,day,hour,min,sec);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Date_obj > __alloc(::hx::Ctx *_hx_ctx,int year,int month,int day,int hour,int min,int sec) {
+			Date_obj *__this = (Date_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Date_obj), false, "Date"));
+			*(void **)__this = Date_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_8e4589df03e4f3cc_26_new)
+HXDLIN(  26)		( ( ::Date)(__this) )->mSeconds =  ::__hxcpp_new_date(year,month,day,hour,min,sec);
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Date_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Date",4e,82,3c,2d); }
+
+		static  ::Date now();
+		static ::Dynamic now_dyn();
+
+		static  ::Date fromTime(Float t);
+		static ::Dynamic fromTime_dyn();
+
+		Float mSeconds;
+		Float getTime();
+		::Dynamic getTime_dyn();
+
+		int getUTCHours();
+		::Dynamic getUTCHours_dyn();
+
+		int getUTCMinutes();
+		::Dynamic getUTCMinutes_dyn();
+
+		int getUTCSeconds();
+		::Dynamic getUTCSeconds_dyn();
+
+		int getUTCFullYear();
+		::Dynamic getUTCFullYear_dyn();
+
+		int getUTCMonth();
+		::Dynamic getUTCMonth_dyn();
+
+		int getUTCDate();
+		::Dynamic getUTCDate_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+
+#endif /* INCLUDED_Date */ 
diff --git a/Sources/c_snikket/iinclude/Dynamic.h b/Sources/c_snikket/iinclude/Dynamic.h
new file mode 100644
index 0000000..391b949
--- /dev/null
+++ b/Sources/c_snikket/iinclude/Dynamic.h
@@ -0,0 +1,477 @@
+#ifndef HX_DYNAMIC_H
+#define HX_DYNAMIC_H
+
+// --- Dynamic ---------------------------------------------------------------
+//
+// The Dynamic class views all classes through the hx::Object interface, and
+//  provides generic access to its pointer.
+// It uses dynamic_cast to provide strongly-typed access to the real class.
+
+namespace hx { class Interface; }
+
+
+
+class HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic : public hx::ObjectPtr<hx::Object>
+{
+   typedef  hx::ObjectPtr<hx::Object> super;
+
+public:
+
+   Dynamic() {};
+   Dynamic(int inVal);
+   Dynamic(short inVal);
+   Dynamic(unsigned int inVal);
+   Dynamic(unsigned short inVal);
+   Dynamic(unsigned char inVal);
+   Dynamic(signed char inVal);
+   Dynamic(const cpp::CppInt32__ &inVal);
+   Dynamic(bool inVal);
+   Dynamic(double inVal);
+   Dynamic(float inVal);
+   Dynamic(cpp::Int64 inVal);
+   Dynamic(cpp::UInt64 inVal);
+   Dynamic(unsigned long inVal);
+   Dynamic(hx::Object *inObj) : super(inObj) { }
+   Dynamic(const String &inString);
+   Dynamic(const null &inNull) : super(0) { }
+   Dynamic(const Dynamic &inRHS) : super(inRHS.mPtr) { }
+   explicit Dynamic(const HX_CHAR *inStr);
+   Dynamic(const cpp::Variant &inRHS) : super(inRHS.asDynamic()) { }
+   template<typename T>
+   Dynamic(const hx::Native<T *> &inInterface):super(inInterface.ptr ? inInterface->__GetRealObject() : (hx::Object *)0 ) { }
+   #if !defined(__GNUC__) || defined(__MINGW32__) || (defined(__WORDSIZE) && (__WORDSIZE != 64))
+   Dynamic(long inVal);
+   Dynamic(unsigned long inVal);
+   #endif
+#ifdef __OBJC__
+#ifdef HXCPP_OBJC
+   Dynamic(const id inObjc);
+#endif
+#endif
+
+   template<typename T,typename S>
+   explicit Dynamic(const cpp::Struct<T,S> &inRHS) { *this = inRHS; }
+   template<typename T>
+   explicit Dynamic(const cpp::Pointer<T> &inRHS) { *this = inRHS; }
+
+
+    void Set(bool inVal);
+    void Set(int inVal);
+    void Set(double inVal);
+    void Set(float inVal);
+
+
+   template<typename RESULT> RESULT StaticCast() const;
+
+   inline operator double () const { return mPtr ? mPtr->__ToDouble() : 0.0; }
+   inline operator float () const { return mPtr ? (float)mPtr->__ToDouble() : 0.0f; }
+   inline operator int () const { return mPtr ? mPtr->__ToInt() : 0; }
+   inline operator unsigned int () const { return mPtr ? mPtr->__ToInt() : 0; }
+   inline operator short () const { return mPtr ? mPtr->__ToInt() : 0; }
+   inline operator unsigned short () const { return mPtr ? mPtr->__ToInt() : 0; }
+   inline operator unsigned char () const { return mPtr ? mPtr->__ToInt() : 0; }
+   inline operator char () const { return mPtr ? mPtr->__ToInt() : 0; }
+   inline operator signed char () const { return mPtr ? mPtr->__ToInt() : 0; }
+   inline operator bool() const { return mPtr && mPtr->__ToInt(); }
+   inline operator cpp::Int64() const { return mPtr ? mPtr->__ToInt64() : 0; }
+   inline operator cpp::UInt64() const { return mPtr ? mPtr->__ToInt64() : 0; }
+   inline operator unsigned long() const { return mPtr ? mPtr->__ToInt64() : 0; }
+
+   // Conversion to generic pointer requires you to tag the class with a typedef
+   template<typename T>
+   inline operator typename hx::Native<T *> () const {
+      return hx::Native<T *>(dynamic_cast<T *>(mPtr));
+   }
+
+
+   //inline operator cpp::Variant() const { return cpp::Variant(mPtr); }
+#ifdef __OBJC__
+#ifdef HXCPP_OBJC
+   #ifdef OBJC_ARC
+   inline operator id() const { return mPtr ? (__bridge id)mPtr->__GetHandle() : 0; }
+   #else
+   inline operator id() const { return mPtr ? (id)mPtr->__GetHandle() : 0; }
+   #endif
+#endif
+#endif
+   inline bool operator !() const { return !mPtr || !mPtr->__ToInt(); }
+
+   hx::IndexRef operator[](int inIndex);
+   inline Dynamic __get(int inIndex) const { return mPtr->__GetItem(inIndex); }
+
+   template<typename SOURCE_>
+   Dynamic(const hx::ObjectPtr<SOURCE_> &inObjectPtr) :
+          hx::ObjectPtr<hx::Object>(inObjectPtr.mPtr) { }
+
+   Dynamic Default(const Dynamic &inDef) { return mPtr ? *this : inDef; }
+
+   template<typename RETURN_>
+   RETURN_ Cast() const { return RETURN_(*this); }
+
+   template<typename CLASS_>
+   bool IsClass() { return CLASS_(mPtr,false).mPtr; }
+
+	static void __boot();
+
+	inline bool IsNumeric() const
+	{
+		if (!mPtr) return false;
+		int t = mPtr->__GetType();
+		return t==vtInt || t==vtFloat;
+	}
+
+	inline bool IsBool() const
+	{
+		if (!mPtr) return false;
+		int t = mPtr->__GetType();
+		return t==vtBool;
+	}
+
+
+   int Compare(const Dynamic &inRHS) const
+   {
+      if (mPtr==0) return inRHS.mPtr==0 ? 0 : -1;
+      if (inRHS.mPtr==0) return -1;
+      return mPtr->__Compare(inRHS.mPtr);
+   }
+
+   bool operator==(const null &inRHS) const { return mPtr==0; }
+   bool operator!=(const null &inRHS) const { return mPtr!=0; }
+
+   bool operator == (const Dynamic &inRHS) const
+   {
+      // Comparing pointers fails in the case on Nan==Nan
+      //if (mPtr==inRHS.mPtr) return true;
+      if (!mPtr && !inRHS.mPtr) return true;
+      if (!mPtr || !inRHS.mPtr) return false;
+      return mPtr->__Compare(inRHS.mPtr)==0;
+   }
+
+   bool operator != (const Dynamic &inRHS) const
+   {
+      // Comparing pointers fails in the case on Nan==Nan
+      //if (mPtr==inRHS.mPtr) return true;
+      if (!mPtr && !inRHS.mPtr) return false;
+      if (!mPtr || !inRHS.mPtr) return true;
+      return mPtr->__Compare(inRHS.mPtr)!=0;
+   }
+
+
+   bool operator == (const cpp::Variant &inRHS) const { return (*this) == Dynamic(inRHS); }
+   bool operator != (const cpp::Variant &inRHS) const { return (*this) != Dynamic(inRHS); }
+
+
+   #define DYNAMIC_COMPARE_OP( op ) \
+      bool operator op (const String &inRHS)  const { return mPtr && ((String)(*this) op inRHS); } \
+      bool operator op (double inRHS)  const { return IsNumeric() && ((double)(*this) op inRHS); } \
+      bool operator op (cpp::Int64 inRHS)  const { return IsNumeric() && ((cpp::Int64)(*this) op inRHS); } \
+      bool operator op (cpp::UInt64 inRHS)  const { return IsNumeric() && ((cpp::Int64)(*this) op inRHS); } \
+      bool operator op (float inRHS)  const { return IsNumeric() && ((double)(*this) op inRHS); } \
+      bool operator op (int inRHS)  const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
+      bool operator op (unsigned int inRHS)  const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
+      bool operator op (short inRHS)  const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
+      bool operator op (unsigned short inRHS)  const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
+      bool operator op (signed char inRHS)  const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
+      bool operator op (unsigned char inRHS)  const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
+      bool operator op (bool inRHS)  const { return IsBool() && ((double)(*this) op (double)inRHS); } \
+
+   bool operator != (const String &inRHS)  const { return !mPtr || ((String)(*this) != inRHS); }
+   bool operator != (double inRHS)  const { return !IsNumeric() || ((double)(*this) != inRHS); }
+   bool operator != (cpp::Int64 inRHS)  const { return !IsNumeric() || ((cpp::Int64)(*this) != inRHS); }
+   bool operator != (cpp::UInt64 inRHS)  const { return !IsNumeric() || ((cpp::Int64)(*this) != inRHS); }
+   bool operator != (float inRHS)  const { return !IsNumeric() || ((double)(*this) != inRHS); }
+   bool operator != (int inRHS)  const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
+   bool operator != (unsigned int inRHS)  const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
+   bool operator != (short inRHS)  const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
+   bool operator != (unsigned short inRHS)  const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
+   bool operator != (signed char inRHS)  const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
+   bool operator != (unsigned char inRHS)  const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
+   bool operator != (bool inRHS)  const { return !IsBool() || ((double)(*this) != (double)inRHS); }
+
+
+
+   #define DYNAMIC_COMPARE_OP_ALL( op ) \
+      bool operator op (const Dynamic &inRHS) const { return mPtr && (Compare(inRHS) op 0); } \
+      bool operator op (const cpp::Variant &inRHS) const { return *this op Dynamic(inRHS); } \
+      DYNAMIC_COMPARE_OP(op)
+
+
+   DYNAMIC_COMPARE_OP( == )
+   DYNAMIC_COMPARE_OP_ALL( < )
+   DYNAMIC_COMPARE_OP_ALL( <= )
+   DYNAMIC_COMPARE_OP_ALL( >= )
+   DYNAMIC_COMPARE_OP_ALL( >  )
+
+   template<typename T_>
+   bool operator==(const hx::ObjectPtr<T_> &inRHS) const
+   {
+      if (mPtr==inRHS.mPtr) return true;
+      if (!mPtr || !inRHS.mPtr) return false;
+      return mPtr == inRHS.mPtr;
+   }
+
+   template<typename T_>
+   bool operator!=(const hx::ObjectPtr<T_> &inRHS) const
+   {
+      if (mPtr==inRHS.mPtr) return false;
+      if (!mPtr || !inRHS.mPtr) return true;
+      return mPtr != inRHS.mPtr;
+   }
+
+
+   // Operator + is different, since it must consider strings too...
+    Dynamic operator+(const Dynamic &inRHS) const;
+   inline String operator+(const String &s) const;
+
+    Dynamic operator+(const cpp::UInt64 &i) const;
+    Dynamic operator+(const cpp::Int64 &i) const;
+    Dynamic operator+(const int &i) const;
+    Dynamic operator+(const unsigned int &i) const;
+    Dynamic operator+(const short &i) const;
+    Dynamic operator+(const unsigned short &i) const;
+    Dynamic operator+(const signed char &i) const;
+    Dynamic operator+(const unsigned char &i) const;
+    Dynamic operator+(const double &d) const;
+    Dynamic operator+(const float &d) const;
+    Dynamic operator+(const cpp::Variant &d) const;
+
+   double operator%(const Dynamic &inRHS) const;
+   double operator-() const { return mPtr ? - mPtr->__ToDouble() : 0.0; }
+   double operator++() { double val = mPtr->__ToDouble() + 1; *this = val; return val; }
+   double operator++(int) {double val = mPtr->__ToDouble(); *this = val+1; return val; }
+   double operator--() { double val = mPtr->__ToDouble() - 1; *this = val; return val; }
+   double operator--(int) {double val = mPtr->__ToDouble(); *this = val-1; return val; }
+
+
+   double operator / (const cpp::Variant &inRHS) const { return (double)(*this) / (double)inRHS; } \
+   double operator / (const Dynamic &inRHS) const { return (double)(*this) / (double)inRHS; } \
+   double operator / (const double &inRHS) const { return (double)(*this) / (double)inRHS; } \
+   double operator / (const float &inRHS) const { return (double)(*this) / (double)inRHS; } \
+   double operator / (const int &inRHS) const { return (double)(*this) / (double)inRHS; }
+
+   #define DYNAMIC_ARITH( op ) \
+      Dynamic operator op (const cpp::Variant &inRHS) const \
+        { return mPtr->__GetType()==vtInt && inRHS.isInt() ? \
+              Dynamic((int)(*this) op (int)inRHS) : \
+              Dynamic( (double)(*this) op (double)inRHS); } \
+      Dynamic operator op (const Dynamic &inRHS) const \
+        { return mPtr->__GetType()==vtInt && inRHS.mPtr->__GetType()==vtInt ? \
+              Dynamic((int)(*this) op (int)inRHS) : \
+              Dynamic( (double)(*this) op (double)inRHS); } \
+      double operator op (const double &inRHS) const { return (double)(*this) op (double)inRHS; } \
+      double operator op (const float &inRHS) const { return (double)(*this) op (double)inRHS; } \
+      Dynamic operator op (const int &inRHS) const \
+        { return mPtr->__GetType()==vtInt ?  Dynamic((int)(*this) op inRHS) : Dynamic((double)(*this) op inRHS); } \
+      Dynamic operator op (const unsigned int &inRHS) const \
+        { return mPtr->__GetType()==vtInt ?  Dynamic((int)(*this) op inRHS) : Dynamic((double)(*this) op inRHS); } \
+      Dynamic operator op (const short &inRHS) const \
+        { return mPtr->__GetType()==vtInt ?  Dynamic((int)(*this) op inRHS) : Dynamic((double)(*this) op inRHS); } \
+      Dynamic operator op (const unsigned short &inRHS) const \
+        { return mPtr->__GetType()==vtInt ?  Dynamic((int)(*this) op inRHS) : Dynamic((double)(*this) op inRHS); } \
+      Dynamic operator op (const signed char &inRHS) const \
+        { return mPtr->__GetType()==vtInt ?  Dynamic((int)(*this) op inRHS) : Dynamic((double)(*this) op inRHS); } \
+      Dynamic operator op (const unsigned char &inRHS) const \
+        { return mPtr->__GetType()==vtInt ?  Dynamic((int)(*this) op inRHS) : Dynamic((double)(*this) op inRHS); } \
+      Dynamic operator op (const cpp::Int64 &inRHS) const \
+        { return Dynamic((double)(*this) op inRHS); } \
+      Dynamic operator op (const cpp::UInt64 &inRHS) const \
+        { return Dynamic((double)(*this) op inRHS); } \
+
+   DYNAMIC_ARITH( - )
+   DYNAMIC_ARITH( * )
+
+   static void ThrowBadFunctionError();
+   inline void CheckFPtr() { if (!mPtr) ThrowBadFunctionError(); }
+
+   inline  ::Dynamic operator()() { CheckFPtr(); return mPtr->__run(); }
+   inline  ::Dynamic operator()(const Dynamic &inArg0) { CheckFPtr(); return mPtr->__run(inArg0); }
+   inline  ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1) { CheckFPtr(); return mPtr->__run(inArg0,inArg1); }
+   inline  ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2) { CheckFPtr(); return mPtr->__run(inArg0,inArg1,inArg2); }
+   inline  ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3) { CheckFPtr(); return mPtr->__run(inArg0,inArg1,inArg2,inArg3); }
+   inline  ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4) { CheckFPtr(); return mPtr->__run(inArg0,inArg1,inArg2,inArg3,inArg4); }
+
+   HX_DECLARE_DYNAMIC_FUNCTIONS;
+
+
+   typedef const Dynamic &D;
+};
+
+
+
+namespace hx
+{
+
+inline hx::Object *DynamicPtr(Dynamic inVal) { return inVal.mPtr; }
+
+typedef Dynamic (*MemberFunction0)(hx::Object *inObj);
+typedef Dynamic (*MemberFunction1)(hx::Object *inObj,const Dynamic &inArg0);
+typedef Dynamic (*MemberFunction2)(hx::Object *inObj,const Dynamic &inArg0,const Dynamic &inArg1);
+typedef Dynamic (*MemberFunction3)(hx::Object *inObj,const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2);
+typedef Dynamic (*MemberFunction4)(hx::Object *inObj,const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3);
+typedef Dynamic (*MemberFunction5)(hx::Object *inObj,const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4);
+typedef Dynamic (*MemberFunctionVar)(hx::Object *inObj,const Array<Dynamic> &inArgs);
+
+typedef Dynamic (*StaticFunction0)();
+typedef Dynamic (*StaticFunction1)(const Dynamic &inArg0);
+typedef Dynamic (*StaticFunction2)(const Dynamic &inArg0,const Dynamic &inArg1);
+typedef Dynamic (*StaticFunction3)(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2);
+typedef Dynamic (*StaticFunction4)(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3);
+typedef Dynamic (*StaticFunction5)(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4);
+typedef Dynamic (*StaticFunctionVar)(const Array<Dynamic> &inArgs);
+
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateMemberFunction0(const char *,hx::Object *, MemberFunction0);
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateMemberFunction1(const char *,hx::Object *, MemberFunction1);
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateMemberFunction2(const char *,hx::Object *, MemberFunction2);
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateMemberFunction3(const char *,hx::Object *, MemberFunction3);
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateMemberFunction4(const char *,hx::Object *, MemberFunction4);
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateMemberFunction5(const char *,hx::Object *, MemberFunction5);
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateMemberFunctionVar(const char *,hx::Object *, MemberFunctionVar,int inN);
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateStaticFunction0(const char *,StaticFunction0);
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateStaticFunction1(const char *,StaticFunction1);
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateStaticFunction2(const char *,StaticFunction2);
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateStaticFunction3(const char *,StaticFunction3);
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateStaticFunction4(const char *,StaticFunction4);
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateStaticFunction5(const char *,StaticFunction5);
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateStaticFunctionVar(const char *,StaticFunctionVar,int inN);
+
+
+}
+
+
+
+
+
+
+
+template<>
+inline int Dynamic::Cast<int>() const { return mPtr ? mPtr->__ToInt() : 0; }
+template<>
+inline bool Dynamic::Cast<bool>() const { return mPtr ? mPtr->__ToInt() : 0; }
+template<>
+inline double Dynamic::Cast<double>() const { return mPtr ? mPtr->__ToDouble() : 0; }
+template<>
+inline float Dynamic::Cast<float>() const { return mPtr ? mPtr->__ToDouble() : 0; }
+template<>
+inline String Dynamic::Cast<String>() const { return mPtr ? mPtr->toString() : String(null()); }
+
+
+
+//
+// Gets the class definition that relates to a specific type.
+// Most classes have their own class data, by the standard types (non-classes)
+//  use the template traits to get the class
+
+namespace hx
+{
+HXCPP_EXTERN_CLASS_ATTRIBUTES hx::Class &GetIntClass();
+HXCPP_EXTERN_CLASS_ATTRIBUTES hx::Class &GetFloatClass();
+HXCPP_EXTERN_CLASS_ATTRIBUTES hx::Class &GetBoolClass();
+HXCPP_EXTERN_CLASS_ATTRIBUTES hx::Class &GetVoidClass();
+HXCPP_EXTERN_CLASS_ATTRIBUTES hx::Class &GetStringClass();
+HXCPP_EXTERN_CLASS_ATTRIBUTES hx::Class &GetInt64Class();
+}
+
+template<>
+inline bool Dynamic::IsClass<int>() { return mPtr && mPtr->__GetClass()==hx::GetIntClass(); }
+template<>
+inline bool Dynamic::IsClass<double>() { return mPtr &&
+   ( mPtr->__GetClass()==hx::GetIntClass() || mPtr->__GetClass()==hx::GetFloatClass()) ; }
+template<>
+inline bool Dynamic::IsClass<float>() { return mPtr && mPtr->__GetClass()==hx::GetFloatClass(); }
+template<>
+inline bool Dynamic::IsClass<bool>() { return mPtr && mPtr->__GetClass()==hx::GetBoolClass(); }
+template<>
+inline bool Dynamic::IsClass<null>() { return !mPtr; }
+template<>
+inline bool Dynamic::IsClass<String>() { return mPtr && mPtr->__GetClass()==hx::GetStringClass(); }
+template<>
+inline bool Dynamic::IsClass<Dynamic>() { return true; }
+template<>
+inline bool Dynamic::IsClass< ::cpp::Int64>() { return mPtr && mPtr->__GetClass()==hx::GetInt64Class(); }
+
+inline String Dynamic::operator+(const String &s) const { return Cast<String>() + s; }
+
+#define HX_DYNAMIC_OP_ISEQ(T) \
+inline bool operator == (const T &inLHS,const Dynamic &inRHS) { return inRHS==inLHS; } \
+inline bool operator != (const T &inLHS,const Dynamic &inRHS) { return inRHS!=inLHS; }
+
+HX_DYNAMIC_OP_ISEQ(String)
+HX_DYNAMIC_OP_ISEQ(double)
+HX_DYNAMIC_OP_ISEQ(float)
+HX_DYNAMIC_OP_ISEQ(int)
+HX_DYNAMIC_OP_ISEQ(bool)
+
+inline bool operator < (bool inLHS,const Dynamic &inRHS) { return false; }
+inline bool operator <= (bool inLHS,const Dynamic &inRHS) { return false; }
+inline bool operator >= (bool inLHS,const Dynamic &inRHS) { return false; }
+inline bool operator > (bool inLHS,const Dynamic &inRHS) { return false; }
+
+#if defined(HX_WINRT) && defined(__cplusplus_winrt)
+// Try to avoid the compiler using injected Box::operator int and Dynamic(null) when doing ==
+template<typename T>
+bool operator==(Platform::Box<T> ^inPtr, nullptr_t)
+{
+    void* ptr = (void*) reinterpret_cast<void*>(inPtr);
+   return ptr==nullptr;
+}
+#endif
+
+
+
+#define COMPARE_DYNAMIC_OP( op ) \
+   inline bool operator op (double inLHS,const ::Dynamic &inRHS) \
+      { return inRHS.IsNumeric() && (inLHS op (double)inRHS); } \
+   inline bool operator op (float inLHS,const ::Dynamic &inRHS) \
+      { return inRHS.IsNumeric() && ((double)inLHS op (double)inRHS); } \
+   inline bool operator op (int inLHS,const ::Dynamic &inRHS) \
+      { return inRHS.IsNumeric() && (inLHS op (double)inRHS); }
+
+COMPARE_DYNAMIC_OP( < )
+COMPARE_DYNAMIC_OP( <= )
+COMPARE_DYNAMIC_OP( >= )
+COMPARE_DYNAMIC_OP( >  )
+
+
+#define ARITH_DYNAMIC( op ) \
+   inline double operator op (const cpp::Int64 &inLHS,const Dynamic &inRHS) { return inLHS op (cpp::Int64)inRHS;} \
+   inline double operator op (const cpp::UInt64 &inLHS,const Dynamic &inRHS) { return inLHS op (cpp::UInt64)inRHS;} \
+   inline double operator op (const double &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS;} \
+   inline double operator op (const float &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS;} \
+   inline double operator op (const int &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
+   inline double operator op (const unsigned int &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
+   inline double operator op (const short &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
+   inline double operator op (const unsigned short &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
+   inline double operator op (const signed char &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
+   inline double operator op (const unsigned char &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
+
+ARITH_DYNAMIC( - )
+ARITH_DYNAMIC( + )
+ARITH_DYNAMIC( / )
+ARITH_DYNAMIC( * )
+
+double operator%(const int &inLHS,const Dynamic &inRHS);
+double operator%(const double &inLHS,const Dynamic &inRHS);
+double operator%(const float &inLHS,const Dynamic &inRHS);
+
+template<typename T,typename H> String::String(const cpp::Struct<T,H> &inRHS) { *this = (String)inRHS; }
+template<typename OBJ> String::String(const hx::ObjectPtr<OBJ> &inRHS) { *this = Dynamic(inRHS); }
+
+
+
+#endif
diff --git a/Sources/c_snikket/iinclude/EReg.h b/Sources/c_snikket/iinclude/EReg.h
new file mode 100644
index 0000000..9cf6865
--- /dev/null
+++ b/Sources/c_snikket/iinclude/EReg.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_EReg
+#define INCLUDED_EReg
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(EReg)
+
+
+
+class HXCPP_CLASS_ATTRIBUTES EReg_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef EReg_obj OBJ_;
+		EReg_obj();
+
+	public:
+		enum { _hx_ClassId = 0x022d4033 };
+
+		void __construct(::String r,::String opt);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="EReg")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"EReg"); }
+		static ::hx::ObjectPtr< EReg_obj > __new(::String r,::String opt);
+		static ::hx::ObjectPtr< EReg_obj > __alloc(::hx::Ctx *_hx_ctx,::String r,::String opt);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~EReg_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("EReg",0f,4a,da,2d); }
+
+		 ::Dynamic r;
+		::String last;
+		bool global;
+		bool match(::String s);
+		::Dynamic match_dyn();
+
+		::String matched(int n);
+		::Dynamic matched_dyn();
+
+		 ::Dynamic matchedPos();
+		::Dynamic matchedPos_dyn();
+
+		bool matchSub(::String s,int pos,::hx::Null< int >  len);
+		::Dynamic matchSub_dyn();
+
+		::String replace(::String s,::String by);
+		::Dynamic replace_dyn();
+
+		::String map(::String s, ::Dynamic f);
+		::Dynamic map_dyn();
+
+};
+
+
+#endif /* INCLUDED_EReg */ 
diff --git a/Sources/c_snikket/iinclude/Enum.h b/Sources/c_snikket/iinclude/Enum.h
new file mode 100644
index 0000000..fed5b22
--- /dev/null
+++ b/Sources/c_snikket/iinclude/Enum.h
@@ -0,0 +1,158 @@
+#ifndef HX_ENUM_H
+#define HX_ENUM_H
+
+
+
+// Enum (ie enum object class def)  is the same as Class.
+typedef hx::Class Enum;
+
+
+namespace hx
+{
+
+// --- hx::EnumBase_obj ----------------------------------------------------------
+//
+// Base class for Enums.
+// Specializations of this class don't actually add more data, just extra constructors
+//  and type information.
+
+class HXCPP_EXTERN_CLASS_ATTRIBUTES EnumBase_obj : public hx::Object
+{
+   typedef hx::Object super;
+   typedef EnumBase_obj OBJ_;
+
+
+   protected:
+      String  _hx_tag;
+      int     mFixedFields;
+      #ifdef HXCPP_SCRIPTABLE
+      struct CppiaClassInfo *classInfo; 
+      #endif
+   public:
+      HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdEnum };
+
+      int          index;
+
+   public:
+      inline void *operator new( size_t inSize, int inExtra=0)
+      {
+         return hx::Object::operator new(inSize+inExtra, true, 0);
+      }
+      inline void operator delete(void *, int inExtra ) { }
+      inline void operator delete(void *, size_t inSize ) { }
+      inline void operator delete(void *, size_t inSize, int inExtra ) { }
+
+
+      HX_DO_ENUM_RTTI_INTERNAL;
+      static hx::ObjectPtr<hx::Class_obj> &__SGetClass();
+
+
+      String toString();
+
+      EnumBase_obj() : index(-1) { }
+      EnumBase_obj(const null &inNull) : index(-1) { }
+      int __GetType() const { return vtEnum; }
+      static Dynamic __CreateEmpty();
+      static Dynamic __Create(DynamicArray inArgs);
+      static void __boot();
+
+      void __Mark(hx::MarkContext *__inCtx);
+      #ifdef HXCPP_VISIT_ALLOCS
+      void __Visit(hx::VisitContext *__inCtx);
+      #endif
+
+      static hx::ObjectPtr<EnumBase_obj> Resolve(String inName);
+      inline static bool __GetStatic(const ::String &inName, Dynamic &outValue, hx::PropertyAccess inCallProp) { return false; }
+
+      inline cpp::Variant *_hx_getFixed() { return (cpp::Variant *)(this + 1); }
+      inline const cpp::Variant *_hx_getFixed() const { return (cpp::Variant *)(this + 1); }
+      inline ::Dynamic __Param(int inID) { return _hx_getFixed()[inID]; }
+      template<typename T>
+      inline EnumBase_obj *_hx_init(int inIndex,const T &inValue)
+      {
+         #ifdef HXCPP_GC_GENERATIONAL
+         cpp::Variant &v = _hx_getFixed()[inIndex];
+         v = inValue;
+         if (v.type<=cpp::Variant::typeString)
+             HX_OBJ_WB_GET(this, v.valObject);
+         #else
+         _hx_getFixed()[inIndex] = inValue;
+         #endif
+         return this;
+      }
+      inline void _hx_setIdentity(const String &inTag, int inIndex,int inFixedFields)
+      {
+         _hx_tag = inTag;
+         HX_OBJ_WB_GET(this, _hx_tag.__s);
+         index = inIndex;
+         mFixedFields = inFixedFields;
+      }
+      DynamicArray _hx_getParameters();
+
+      inline ::Dynamic _hx_getObject(int inId) { return _hx_getFixed()[inId].asDynamic(); }
+      inline int _hx_getInt(int inId) { return _hx_getFixed()[inId]; }
+      inline ::cpp::Int64 _hx_getInt64(int inId) { return _hx_getFixed()[inId].asInt64(); }
+      inline Float _hx_getFloat(int inId) { return _hx_getFixed()[inId]; }
+      inline bool _hx_getBool(int inId) { return _hx_getFixed()[inId]; }
+      inline ::String _hx_getString(int inId) { return _hx_getFixed()[inId].asString(); }
+      inline ::Dynamic _hx_getParamI(int inId) { return _hx_getFixed()[inId]; }
+      inline int _hx_getParamCount() { return mFixedFields; }
+      // Alias for _hx_getParamI
+      Dynamic __GetItem(int inIndex) const;
+
+      // For legacy
+      inline String __Tag() const { return _hx_tag; }
+
+
+      String _hx_getTag() const { return _hx_tag; }
+      int _hx_getIndex() const { return index; }
+
+
+      int __Compare(const hx::Object *inRHS) const;
+
+      virtual String GetEnumName( ) const { return HX_CSTRING("Enum"); }
+};
+
+
+typedef hx::ObjectPtr<EnumBase_obj> EnumBase;
+
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES bool __hxcpp_enum_eq( ::hx::EnumBase a,  ::hx::EnumBase b);
+
+// --- CreateEnum -------------------------------------------------------------
+//
+// Template function to return a strongly-typed version fo the Enum.
+// Most of the common stuff is in "Set".
+
+template<typename ENUM>
+ENUM *CreateEnum(const String &inName,int inIndex, int inFields)
+{
+   ENUM *result = new (inFields*sizeof(cpp::Variant)) ENUM;
+   result->_hx_setIdentity(inName,inIndex,inFields);
+   return result;
+}
+
+template<typename ENUM>
+ENUM *CreateConstEnum(const String &inName,int inIndex)
+{
+   ENUM vtable;
+   ENUM *result = (ENUM *)hx::InternalCreateConstBuffer(&vtable,sizeof(ENUM));
+   result->_hx_setIdentity(inName,inIndex,0);
+   return result;
+}
+
+} // end namespace hx
+
+inline int _hx_getEnumValueIndex(hx::EnumBase inEnum)
+{
+   return inEnum->_hx_getIndex();
+}
+
+inline void __hxcpp_enum_force(hx::EnumBase inEnum,String inForceName, int inIndex)
+{
+   inEnum->_hx_setIdentity(inForceName, inIndex,0);
+}
+
+
+
+#endif
diff --git a/Sources/c_snikket/iinclude/HaxeCBridge.h b/Sources/c_snikket/iinclude/HaxeCBridge.h
new file mode 100644
index 0000000..6c32ea0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/HaxeCBridge.h
@@ -0,0 +1,44 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_HaxeCBridge
+#define INCLUDED_HaxeCBridge
+
+#ifndef HXCPP_H
+#ifdef HXCPP_API_LEVEL
+#include <hxcpp.h>
+#else
+#include <hx/Native.h>
+#endif
+#endif
+
+#ifndef INCLUDED_cbce7ceea2d0df24
+#define INCLUDED_cbce7ceea2d0df24
+#include "HaxeCBridge.h"
+#endif
+
+
+
+class HXCPP_CLASS_ATTRIBUTES HaxeCBridge
+{
+	public:
+		static void mainThreadInit(::cpp::Function< bool  () > isMainThreadCb);
+
+		static void mainThreadRun(::cpp::Function< void  () > processNativeCalls,::cpp::Function< void  (const char*) > onUnhandledException);
+
+		static void** retainHaxeArray(::cpp::VirtualArray haxeArray);
+
+		static void* retainHaxeObject( ::Dynamic haxeObject);
+
+		static const char* retainHaxeString(::String haxeString);
+
+		static void releaseHaxePtr(void * haxePtr);
+
+		static bool isMainThread();
+
+		static void endMainThread(bool waitOnScheduledEvents);
+
+		static void wakeMainThread();
+
+};
+
+
+#endif /* INCLUDED_HaxeCBridge */ 
diff --git a/Sources/c_snikket/iinclude/Lambda.h b/Sources/c_snikket/iinclude/Lambda.h
new file mode 100644
index 0000000..43b4ef0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/Lambda.h
@@ -0,0 +1,76 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_Lambda
+#define INCLUDED_Lambda
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(Lambda)
+
+
+
+class HXCPP_CLASS_ATTRIBUTES Lambda_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Lambda_obj OBJ_;
+		Lambda_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4cec6e4b };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="Lambda")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"Lambda"); }
+
+		inline static ::hx::ObjectPtr< Lambda_obj > __new() {
+			::hx::ObjectPtr< Lambda_obj > __this = new Lambda_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Lambda_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Lambda_obj *__this = (Lambda_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Lambda_obj), false, "Lambda"));
+			*(void **)__this = Lambda_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Lambda_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Lambda",27,a7,54,85); }
+
+		static ::cpp::VirtualArray array( ::Dynamic it);
+		static ::Dynamic array_dyn();
+
+		static bool exists( ::Dynamic it, ::Dynamic f);
+		static ::Dynamic exists_dyn();
+
+		static ::cpp::VirtualArray filter( ::Dynamic it, ::Dynamic f);
+		static ::Dynamic filter_dyn();
+
+		static  ::Dynamic fold( ::Dynamic it, ::Dynamic f, ::Dynamic first);
+		static ::Dynamic fold_dyn();
+
+		static bool empty( ::Dynamic it);
+		static ::Dynamic empty_dyn();
+
+		static  ::Dynamic find( ::Dynamic it, ::Dynamic f);
+		static ::Dynamic find_dyn();
+
+		static int findIndex( ::Dynamic it, ::Dynamic f);
+		static ::Dynamic findIndex_dyn();
+
+};
+
+
+#endif /* INCLUDED_Lambda */ 
diff --git a/Sources/c_snikket/iinclude/Reflect.h b/Sources/c_snikket/iinclude/Reflect.h
new file mode 100644
index 0000000..87d8d52
--- /dev/null
+++ b/Sources/c_snikket/iinclude/Reflect.h
@@ -0,0 +1,91 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_Reflect
+#define INCLUDED_Reflect
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(Reflect)
+
+
+
+class HXCPP_CLASS_ATTRIBUTES Reflect_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Reflect_obj OBJ_;
+		Reflect_obj();
+
+	public:
+		enum { _hx_ClassId = 0x769a515d };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="Reflect")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"Reflect"); }
+
+		inline static ::hx::ObjectPtr< Reflect_obj > __new() {
+			::hx::ObjectPtr< Reflect_obj > __this = new Reflect_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Reflect_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Reflect_obj *__this = (Reflect_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Reflect_obj), false, "Reflect"));
+			*(void **)__this = Reflect_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Reflect_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Reflect",1d,ac,7a,b6); }
+
+		static bool hasField( ::Dynamic o,::String field);
+		static ::Dynamic hasField_dyn();
+
+		static  ::Dynamic field( ::Dynamic o,::String field);
+		static ::Dynamic field_dyn();
+
+		static void setField( ::Dynamic o,::String field, ::Dynamic value);
+		static ::Dynamic setField_dyn();
+
+		static  ::Dynamic getProperty( ::Dynamic o,::String field);
+		static ::Dynamic getProperty_dyn();
+
+		static  ::Dynamic callMethod( ::Dynamic o, ::Dynamic func,::cpp::VirtualArray args);
+		static ::Dynamic callMethod_dyn();
+
+		static ::Array< ::String > fields( ::Dynamic o);
+		static ::Dynamic fields_dyn();
+
+		static bool isFunction( ::Dynamic f);
+		static ::Dynamic isFunction_dyn();
+
+		static int compare( ::Dynamic a, ::Dynamic b);
+		static ::Dynamic compare_dyn();
+
+		static bool compareMethods( ::Dynamic f1, ::Dynamic f2);
+		static ::Dynamic compareMethods_dyn();
+
+		static bool isObject( ::Dynamic v);
+		static ::Dynamic isObject_dyn();
+
+		static bool isEnumValue( ::Dynamic v);
+		static ::Dynamic isEnumValue_dyn();
+
+		static  ::Dynamic copy( ::Dynamic o);
+		static ::Dynamic copy_dyn();
+
+};
+
+
+#endif /* INCLUDED_Reflect */ 
diff --git a/Sources/c_snikket/iinclude/Std.h b/Sources/c_snikket/iinclude/Std.h
new file mode 100644
index 0000000..c837022
--- /dev/null
+++ b/Sources/c_snikket/iinclude/Std.h
@@ -0,0 +1,83 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_Std
+#define INCLUDED_Std
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(Std)
+
+
+
+class HXCPP_CLASS_ATTRIBUTES Std_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Std_obj OBJ_;
+		Std_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7ee3a517 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="Std")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"Std"); }
+
+		inline static ::hx::ObjectPtr< Std_obj > __new() {
+			::hx::ObjectPtr< Std_obj > __this = new Std_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Std_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Std_obj *__this = (Std_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Std_obj), false, "Std"));
+			*(void **)__this = Std_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Std_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Std",83,60,3f,00); }
+
+		static bool is( ::Dynamic v, ::Dynamic t);
+		static ::Dynamic is_dyn();
+
+		static bool isOfType( ::Dynamic v, ::Dynamic t);
+		static ::Dynamic isOfType_dyn();
+
+		static  ::Dynamic downcast( ::Dynamic value,::hx::Class c);
+		static ::Dynamic downcast_dyn();
+
+		static  ::Dynamic instance( ::Dynamic value,::hx::Class c);
+		static ::Dynamic instance_dyn();
+
+		static ::String string( ::Dynamic s);
+		static ::Dynamic string_dyn();
+
+		static int _hx_int(Float x);
+		static ::Dynamic _hx_int_dyn();
+
+		static  ::Dynamic parseInt(::String x);
+		static ::Dynamic parseInt_dyn();
+
+		static Float parseFloat(::String x);
+		static ::Dynamic parseFloat_dyn();
+
+		static int random(int x);
+		static ::Dynamic random_dyn();
+
+		static inline String string(String &s) { return s; }
+};
+
+
+#endif /* INCLUDED_Std */ 
diff --git a/Sources/c_snikket/iinclude/StringBuf.h b/Sources/c_snikket/iinclude/StringBuf.h
new file mode 100644
index 0000000..575e391
--- /dev/null
+++ b/Sources/c_snikket/iinclude/StringBuf.h
@@ -0,0 +1,78 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_StringBuf
+#define INCLUDED_StringBuf
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_8b63e6eaf513c097_35_new)
+HX_DECLARE_CLASS0(StringBuf)
+
+
+
+class HXCPP_CLASS_ATTRIBUTES StringBuf_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef StringBuf_obj OBJ_;
+		StringBuf_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2cc74002 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="StringBuf")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"StringBuf"); }
+
+		inline static ::hx::ObjectPtr< StringBuf_obj > __new() {
+			::hx::ObjectPtr< StringBuf_obj > __this = new StringBuf_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< StringBuf_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			StringBuf_obj *__this = (StringBuf_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(StringBuf_obj), true, "StringBuf"));
+			*(void **)__this = StringBuf_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_8b63e6eaf513c097_35_new)
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~StringBuf_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("StringBuf",c2,ca,83,69); }
+
+		::Array< ::String > b;
+		::Array< char > charBuf;
+		::String charBufAsString();
+		::Dynamic charBufAsString_dyn();
+
+		void flush();
+		::Dynamic flush_dyn();
+
+		int get_length();
+		::Dynamic get_length_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+
+#endif /* INCLUDED_StringBuf */ 
diff --git a/Sources/c_snikket/iinclude/StringTools.h b/Sources/c_snikket/iinclude/StringTools.h
new file mode 100644
index 0000000..039cb8b
--- /dev/null
+++ b/Sources/c_snikket/iinclude/StringTools.h
@@ -0,0 +1,88 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_StringTools
+#define INCLUDED_StringTools
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(StringTools)
+
+
+
+class HXCPP_CLASS_ATTRIBUTES StringTools_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef StringTools_obj OBJ_;
+		StringTools_obj();
+
+	public:
+		enum { _hx_ClassId = 0x084f186e };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="StringTools")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"StringTools"); }
+
+		inline static ::hx::ObjectPtr< StringTools_obj > __new() {
+			::hx::ObjectPtr< StringTools_obj > __this = new StringTools_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< StringTools_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			StringTools_obj *__this = (StringTools_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(StringTools_obj), false, "StringTools"));
+			*(void **)__this = StringTools_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~StringTools_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("StringTools",6a,db,63,03); }
+
+		static ::String urlEncode(::String s);
+		static ::Dynamic urlEncode_dyn();
+
+		static ::String htmlEscape(::String s, ::Dynamic quotes);
+		static ::Dynamic htmlEscape_dyn();
+
+		static bool startsWith(::String s,::String start);
+		static ::Dynamic startsWith_dyn();
+
+		static bool endsWith(::String s,::String end);
+		static ::Dynamic endsWith_dyn();
+
+		static bool isSpace(::String s,int pos);
+		static ::Dynamic isSpace_dyn();
+
+		static ::String ltrim(::String s);
+		static ::Dynamic ltrim_dyn();
+
+		static ::String rtrim(::String s);
+		static ::Dynamic rtrim_dyn();
+
+		static ::String trim(::String s);
+		static ::Dynamic trim_dyn();
+
+		static ::String lpad(::String s,::String c,int l);
+		static ::Dynamic lpad_dyn();
+
+		static ::String replace(::String s,::String sub,::String by);
+		static ::Dynamic replace_dyn();
+
+		static ::String hex(int n, ::Dynamic digits);
+		static ::Dynamic hex_dyn();
+
+};
+
+
+#endif /* INCLUDED_StringTools */ 
diff --git a/Sources/c_snikket/iinclude/Sys.h b/Sources/c_snikket/iinclude/Sys.h
new file mode 100644
index 0000000..4834a8a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/Sys.h
@@ -0,0 +1,67 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_Sys
+#define INCLUDED_Sys
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(Sys)
+
+
+
+class HXCPP_CLASS_ATTRIBUTES Sys_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Sys_obj OBJ_;
+		Sys_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7ee3a981 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="Sys")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"Sys"); }
+
+		inline static ::hx::ObjectPtr< Sys_obj > __new() {
+			::hx::ObjectPtr< Sys_obj > __this = new Sys_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Sys_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Sys_obj *__this = (Sys_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Sys_obj), false, "Sys"));
+			*(void **)__this = Sys_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Sys_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Sys",ed,64,3f,00); }
+
+		static ::String getEnv(::String s);
+		static ::Dynamic getEnv_dyn();
+
+		static ::String getCwd();
+		static ::Dynamic getCwd_dyn();
+
+		static ::String systemName();
+		static ::Dynamic systemName_dyn();
+
+		static Float time();
+		static ::Dynamic time_dyn();
+
+};
+
+
+#endif /* INCLUDED_Sys */ 
diff --git a/Sources/c_snikket/iinclude/Type.h b/Sources/c_snikket/iinclude/Type.h
new file mode 100644
index 0000000..4c1fe40
--- /dev/null
+++ b/Sources/c_snikket/iinclude/Type.h
@@ -0,0 +1,71 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_Type
+#define INCLUDED_Type
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(Type)
+HX_DECLARE_CLASS0(ValueType)
+
+
+
+class HXCPP_CLASS_ATTRIBUTES Type_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Type_obj OBJ_;
+		Type_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0c3514fe };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="Type")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"Type"); }
+
+		inline static ::hx::ObjectPtr< Type_obj > __new() {
+			::hx::ObjectPtr< Type_obj > __this = new Type_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Type_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Type_obj *__this = (Type_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Type_obj), false, "Type"));
+			*(void **)__this = Type_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Type_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Type",da,1e,e2,37); }
+
+		static ::hx::Class getClass( ::Dynamic o);
+		static ::Dynamic getClass_dyn();
+
+		static ::String getClassName(::hx::Class c);
+		static ::Dynamic getClassName_dyn();
+
+		static ::Array< ::String > getInstanceFields(::hx::Class c);
+		static ::Dynamic getInstanceFields_dyn();
+
+		static  ::ValueType _hx_typeof( ::Dynamic v);
+		static ::Dynamic _hx_typeof_dyn();
+
+		static ::cpp::VirtualArray enumParameters( ::Dynamic e);
+		static ::Dynamic enumParameters_dyn();
+
+};
+
+
+#endif /* INCLUDED_Type */ 
diff --git a/Sources/c_snikket/iinclude/ValueType.h b/Sources/c_snikket/iinclude/ValueType.h
new file mode 100644
index 0000000..ce988c6
--- /dev/null
+++ b/Sources/c_snikket/iinclude/ValueType.h
@@ -0,0 +1,47 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_ValueType
+#define INCLUDED_ValueType
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(ValueType)
+
+
+class ValueType_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef ValueType_obj OBJ_;
+
+	public:
+		ValueType_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("ValueType",ab,8a,60,3b); }
+		::String __ToString() const { return HX_("ValueType.",23,cb,18,b9) + _hx_tag; }
+
+		static ::ValueType TBool;
+		static inline ::ValueType TBool_dyn() { return TBool; }
+		static ::ValueType TClass(::hx::Class c);
+		static ::Dynamic TClass_dyn();
+		static ::ValueType TEnum(::hx::Class e);
+		static ::Dynamic TEnum_dyn();
+		static ::ValueType TFloat;
+		static inline ::ValueType TFloat_dyn() { return TFloat; }
+		static ::ValueType TFunction;
+		static inline ::ValueType TFunction_dyn() { return TFunction; }
+		static ::ValueType TInt;
+		static inline ::ValueType TInt_dyn() { return TInt; }
+		static ::ValueType TNull;
+		static inline ::ValueType TNull_dyn() { return TNull; }
+		static ::ValueType TObject;
+		static inline ::ValueType TObject_dyn() { return TObject; }
+		static ::ValueType TUnknown;
+		static inline ::ValueType TUnknown_dyn() { return TUnknown; }
+};
+
+
+#endif /* INCLUDED_ValueType */ 
diff --git a/Sources/c_snikket/iinclude/Xml.h b/Sources/c_snikket/iinclude/Xml.h
new file mode 100644
index 0000000..2b2f152
--- /dev/null
+++ b/Sources/c_snikket/iinclude/Xml.h
@@ -0,0 +1,114 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_Xml
+#define INCLUDED_Xml
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(Xml)
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+
+
+
+class HXCPP_CLASS_ATTRIBUTES Xml_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Xml_obj OBJ_;
+		Xml_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7ee76a4b };
+
+		void __construct(int nodeType);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="Xml")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"Xml"); }
+		static ::hx::ObjectPtr< Xml_obj > __new(int nodeType);
+		static ::hx::ObjectPtr< Xml_obj > __alloc(::hx::Ctx *_hx_ctx,int nodeType);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Xml_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Xml",b7,25,43,00); }
+
+		static void __boot();
+		static int Element;
+		static int PCData;
+		static int CData;
+		static int Comment;
+		static int DocType;
+		static int ProcessingInstruction;
+		static int Document;
+		static  ::Xml parse(::String str);
+		static ::Dynamic parse_dyn();
+
+		static  ::Xml createElement(::String name);
+		static ::Dynamic createElement_dyn();
+
+		static  ::Xml createPCData(::String data);
+		static ::Dynamic createPCData_dyn();
+
+		static  ::Xml createCData(::String data);
+		static ::Dynamic createCData_dyn();
+
+		static  ::Xml createComment(::String data);
+		static ::Dynamic createComment_dyn();
+
+		static  ::Xml createDocType(::String data);
+		static ::Dynamic createDocType_dyn();
+
+		static  ::Xml createProcessingInstruction(::String data);
+		static ::Dynamic createProcessingInstruction_dyn();
+
+		static  ::Xml createDocument();
+		static ::Dynamic createDocument_dyn();
+
+		int nodeType;
+		::String nodeName;
+		::String nodeValue;
+		 ::Xml parent;
+		::Array< ::Dynamic> children;
+		 ::haxe::ds::StringMap attributeMap;
+		::String get(::String att);
+		::Dynamic get_dyn();
+
+		void set(::String att,::String value);
+		::Dynamic set_dyn();
+
+		bool exists(::String att);
+		::Dynamic exists_dyn();
+
+		 ::Dynamic attributes();
+		::Dynamic attributes_dyn();
+
+		 ::Xml firstElement();
+		::Dynamic firstElement_dyn();
+
+		void addChild( ::Xml x);
+		::Dynamic addChild_dyn();
+
+		bool removeChild( ::Xml x);
+		::Dynamic removeChild_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+
+#endif /* INCLUDED_Xml */ 
diff --git a/Sources/c_snikket/iinclude/_HaxeCBridge/Int64Map_Impl_.h b/Sources/c_snikket/iinclude/_HaxeCBridge/Int64Map_Impl_.h
new file mode 100644
index 0000000..cf001a9
--- /dev/null
+++ b/Sources/c_snikket/iinclude/_HaxeCBridge/Int64Map_Impl_.h
@@ -0,0 +1,62 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED__HaxeCBridge_Int64Map_Impl_
+#define INCLUDED__HaxeCBridge_Int64Map_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(_HaxeCBridge,Int64Map_Impl_)
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,IntMap)
+
+namespace _HaxeCBridge{
+
+
+class HXCPP_CLASS_ATTRIBUTES Int64Map_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Int64Map_Impl__obj OBJ_;
+		Int64Map_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x09ceba9e };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="_HaxeCBridge.Int64Map_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"_HaxeCBridge.Int64Map_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Int64Map_Impl__obj > __new() {
+			::hx::ObjectPtr< Int64Map_Impl__obj > __this = new Int64Map_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Int64Map_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Int64Map_Impl__obj *__this = (Int64Map_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Int64Map_Impl__obj), false, "_HaxeCBridge.Int64Map_Impl_"));
+			*(void **)__this = Int64Map_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Int64Map_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Int64Map_Impl_",af,5c,92,21); }
+
+		static  ::haxe::ds::IntMap _new();
+		static ::Dynamic _new_dyn();
+
+};
+
+} // end namespace _HaxeCBridge
+
+#endif /* INCLUDED__HaxeCBridge_Int64Map_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/_HaxeCBridge/Internal.h b/Sources/c_snikket/iinclude/_HaxeCBridge/Internal.h
new file mode 100644
index 0000000..a2a1fae
--- /dev/null
+++ b/Sources/c_snikket/iinclude/_HaxeCBridge/Internal.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED__HaxeCBridge_Internal
+#define INCLUDED__HaxeCBridge_Internal
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(_HaxeCBridge,Internal)
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,IntMap)
+HX_DECLARE_CLASS2(sys,thread,Lock)
+
+namespace _HaxeCBridge{
+
+
+class HXCPP_CLASS_ATTRIBUTES Internal_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Internal_obj OBJ_;
+		Internal_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0f2147a8 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="_HaxeCBridge.Internal")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"_HaxeCBridge.Internal"); }
+
+		inline static ::hx::ObjectPtr< Internal_obj > __new() {
+			::hx::ObjectPtr< Internal_obj > __this = new Internal_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Internal_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Internal_obj *__this = (Internal_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Internal_obj), false, "_HaxeCBridge.Internal"));
+			*(void **)__this = Internal_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Internal_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Internal",5d,23,28,02); }
+
+		static void __boot();
+		static ::cpp::Function< bool  () > isMainThreadCb;
+		static Dynamic isMainThreadCb_dyn() { return isMainThreadCb;}
+		static  ::sys::thread::Lock mainThreadWaitLock;
+		static bool mainThreadLoopActive;
+		static bool mainThreadEndIfNoPending;
+		static  ::haxe::ds::IntMap gcRetainMap;
+};
+
+} // end namespace _HaxeCBridge
+
+#endif /* INCLUDED__HaxeCBridge_Internal */ 
diff --git a/Sources/c_snikket/iinclude/_UnicodeString/UnicodeString_Impl_.h b/Sources/c_snikket/iinclude/_UnicodeString/UnicodeString_Impl_.h
new file mode 100644
index 0000000..eb2190b
--- /dev/null
+++ b/Sources/c_snikket/iinclude/_UnicodeString/UnicodeString_Impl_.h
@@ -0,0 +1,66 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED__UnicodeString_UnicodeString_Impl_
+#define INCLUDED__UnicodeString_UnicodeString_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(_UnicodeString,UnicodeString_Impl_)
+
+namespace _UnicodeString{
+
+
+class HXCPP_CLASS_ATTRIBUTES UnicodeString_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef UnicodeString_Impl__obj OBJ_;
+		UnicodeString_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x699a1cff };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="_UnicodeString.UnicodeString_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"_UnicodeString.UnicodeString_Impl_"); }
+
+		inline static ::hx::ObjectPtr< UnicodeString_Impl__obj > __new() {
+			::hx::ObjectPtr< UnicodeString_Impl__obj > __this = new UnicodeString_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< UnicodeString_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			UnicodeString_Impl__obj *__this = (UnicodeString_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(UnicodeString_Impl__obj), false, "_UnicodeString.UnicodeString_Impl_"));
+			*(void **)__this = UnicodeString_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~UnicodeString_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("UnicodeString_Impl_",ce,64,09,f3); }
+
+		static ::String charAt(::String this1,int index);
+		static ::Dynamic charAt_dyn();
+
+		static ::String substr(::String this1,int pos, ::Dynamic len);
+		static ::Dynamic substr_dyn();
+
+		static int get_length(::String this1);
+		static ::Dynamic get_length_dyn();
+
+};
+
+} // end namespace _UnicodeString
+
+#endif /* INCLUDED__UnicodeString_UnicodeString_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/_Xml/XmlType_Impl_.h b/Sources/c_snikket/iinclude/_Xml/XmlType_Impl_.h
new file mode 100644
index 0000000..43c8ecc
--- /dev/null
+++ b/Sources/c_snikket/iinclude/_Xml/XmlType_Impl_.h
@@ -0,0 +1,60 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED__Xml_XmlType_Impl_
+#define INCLUDED__Xml_XmlType_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(_Xml,XmlType_Impl_)
+
+namespace _Xml{
+
+
+class HXCPP_CLASS_ATTRIBUTES XmlType_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef XmlType_Impl__obj OBJ_;
+		XmlType_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x29df0a39 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="_Xml.XmlType_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"_Xml.XmlType_Impl_"); }
+
+		inline static ::hx::ObjectPtr< XmlType_Impl__obj > __new() {
+			::hx::ObjectPtr< XmlType_Impl__obj > __this = new XmlType_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< XmlType_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			XmlType_Impl__obj *__this = (XmlType_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(XmlType_Impl__obj), false, "_Xml.XmlType_Impl_"));
+			*(void **)__this = XmlType_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~XmlType_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("XmlType_Impl_",71,0b,9f,dd); }
+
+		static ::String toString(int this1);
+		static ::Dynamic toString_dyn();
+
+};
+
+} // end namespace _Xml
+
+#endif /* INCLUDED__Xml_XmlType_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/cpp/CppInt32__.h b/Sources/c_snikket/iinclude/cpp/CppInt32__.h
new file mode 100644
index 0000000..bd856c0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/cpp/CppInt32__.h
@@ -0,0 +1,92 @@
+#ifndef INCLUDED_haxe_CppInt32__
+#define INCLUDED_haxe_CppInt32__
+
+#include <hxcpp.h>
+
+namespace cpp
+{
+
+#define HX_I32_DEF_FUNC1(Name) \
+   static inline Dynamic __##Name(const Dynamic &a) { return Name(a); } \
+   static inline Dynamic Name##_dyn() { return  hx::CreateStaticFunction1(#Name,&CppInt32__::__##Name); }
+
+#define HX_I32_DEF_FUNC2(Name) \
+   static inline Dynamic __##Name(const Dynamic &a, const Dynamic &b) { return Name(a,b); } \
+   static inline Dynamic Name##_dyn() { return  hx::CreateStaticFunction2(#Name,&CppInt32__::__##Name); }
+
+class CppInt32__
+{
+public:
+   CppInt32__(int inX=0) : mValue(inX) { }
+   CppInt32__(const null &inNull) : mValue(0) { }
+   CppInt32__(const Dynamic &inD);
+   operator int() const { return mValue; }
+   template<typename T>
+   inline CppInt32__ &operator=(T inValue) { mValue = inValue; return *this; }
+
+   static inline CppInt32__ make(int a,int b) { return CppInt32__( (a<<16) | b ); }
+   static inline CppInt32__ ofInt(int a) { return CppInt32__( a ); }
+   static inline int toInt(CppInt32__ a) { __hxcpp_check_overflow(a); return a.mValue; }
+   static inline int toNativeInt(CppInt32__ a) { return a.mValue; }
+   static inline CppInt32__ add(CppInt32__ a,CppInt32__ b) { return CppInt32__( a.mValue + b.mValue  ); }
+   static inline CppInt32__ sub(CppInt32__ a,CppInt32__ b) { return CppInt32__( a.mValue - b.mValue  ); }
+   static inline CppInt32__ mul(CppInt32__ a,CppInt32__ b) { return CppInt32__( a.mValue * b.mValue  ); }
+   static inline CppInt32__ div(CppInt32__ a,CppInt32__ b) { return CppInt32__( a.mValue / b.mValue  ); }
+   static inline CppInt32__ mod(CppInt32__ a,CppInt32__ b) { return CppInt32__( a.mValue % b.mValue  ); }
+   static inline CppInt32__ shl(CppInt32__ a,int b) { return CppInt32__( a.mValue << (b&31)  ); }
+   static inline CppInt32__ shr(CppInt32__ a,int b) { return CppInt32__( a.mValue >> (b&31)  ); }
+   static inline CppInt32__ ushr(CppInt32__ a,int b) { return CppInt32__( ((unsigned int)a.mValue) >> (b&31)  ); }
+   static inline CppInt32__ _and(CppInt32__ a,CppInt32__ b) { return CppInt32__( a.mValue & b.mValue  ); }
+   static inline CppInt32__ _or(CppInt32__ a,CppInt32__ b) { return CppInt32__( a.mValue | b.mValue  ); }
+   static inline CppInt32__ _xor(CppInt32__ a,CppInt32__ b) { return CppInt32__( a.mValue ^ b.mValue  ); }
+   static inline CppInt32__ neg(CppInt32__ a) { return CppInt32__( -a.mValue ); }
+   static inline CppInt32__ complement(CppInt32__ a) { return CppInt32__( ~a.mValue ); }
+   static inline int compare(CppInt32__ a,CppInt32__ b) { return ( a.mValue - b.mValue ); }
+   static inline bool isNeg(CppInt32__ a) { return a.mValue < 0; }
+   static inline bool isZero(CppInt32__ a) { return a.mValue == 0; }
+   static inline int ucompare(CppInt32__ a,CppInt32__ b) { unsigned int am = a.mValue, bm = b.mValue; return (am == bm) ? 0 : ((am > bm) ? 1 : -1); }
+
+
+   inline bool operator==(const CppInt32__ &inRHS) const { return mValue == inRHS.mValue; }
+
+   inline int operator-(CppInt32__ b) { return mValue - b.mValue; }
+   inline int operator+(CppInt32__ b) { return mValue + b.mValue; }
+   inline int operator*(CppInt32__ b) { return mValue * b.mValue; }
+   inline int operator/(CppInt32__ b) { return mValue / b.mValue; }
+   inline int operator%(CppInt32__ b) { return mValue % b.mValue; }
+
+   HX_I32_DEF_FUNC2(make)
+   HX_I32_DEF_FUNC1(ofInt)
+   HX_I32_DEF_FUNC1(toInt)
+   HX_I32_DEF_FUNC1(toNativeInt)
+   HX_I32_DEF_FUNC2(add)
+   HX_I32_DEF_FUNC2(sub)
+   HX_I32_DEF_FUNC2(mul)
+   HX_I32_DEF_FUNC2(div)
+   HX_I32_DEF_FUNC2(mod)
+   HX_I32_DEF_FUNC2(shl)
+   HX_I32_DEF_FUNC2(shr)
+   HX_I32_DEF_FUNC2(ushr)
+   HX_I32_DEF_FUNC2(_and)
+   HX_I32_DEF_FUNC2(_or)
+   HX_I32_DEF_FUNC2(_xor)
+   HX_I32_DEF_FUNC1(neg)
+   HX_I32_DEF_FUNC1(complement)
+   HX_I32_DEF_FUNC2(compare)
+   HX_I32_DEF_FUNC2(ucompare)
+   HX_I32_DEF_FUNC1(isNeg)
+   HX_I32_DEF_FUNC1(isZero)
+
+   int mValue;
+};
+
+typedef CppInt32__ CppInt32___obj;
+}
+
+
+
+
+
+#endif
+
+
diff --git a/Sources/c_snikket/iinclude/cpp/FastIterator.h b/Sources/c_snikket/iinclude/cpp/FastIterator.h
new file mode 100644
index 0000000..37bcf66
--- /dev/null
+++ b/Sources/c_snikket/iinclude/cpp/FastIterator.h
@@ -0,0 +1,108 @@
+#ifndef INCLUDED_cpp_FastIterator
+#define INCLUDED_cpp_FastIterator
+
+namespace cpp
+{
+
+class HXCPP_EXTERN_CLASS_ATTRIBUTES IteratorBase : public hx::Object
+{
+public:
+   hx::Val __Field(const String &inString ,hx::PropertyAccess inCallProp);
+   virtual bool hasNext() = 0;
+   virtual Dynamic _dynamicNext() = 0;
+
+   Dynamic hasNext_dyn( );
+   Dynamic next_dyn( );
+   Dynamic _dynamicNext_dyn( );
+};
+
+
+template<typename T>
+class HXCPP_EXTERN_CLASS_ATTRIBUTES FastIterator_obj : public IteratorBase
+{
+public:
+   virtual bool hasNext() = 0;
+   virtual T next() = 0;
+
+   virtual Dynamic _dynamicNext() { return next(); }
+};
+
+
+
+template<typename T>
+class HXCPP_EXTERN_CLASS_ATTRIBUTES DynamicIterator : public FastIterator_obj<T>
+{
+public:
+   Dynamic mNext;
+   Dynamic mHasNext;
+
+   DynamicIterator(Dynamic inValue)
+   {
+      mNext = inValue->__Field(HX_CSTRING("next"), HX_PROP_ALWAYS);
+      mHasNext = inValue->__Field(HX_CSTRING("hasNext"), HX_PROP_ALWAYS);
+   }
+
+   bool hasNext() { return mHasNext(); }
+   T next() { return mNext(); }
+
+   void __Mark(hx::MarkContext *__inCtx)
+   {
+      HX_MARK_MEMBER_NAME(mNext,"mNext");
+      HX_MARK_MEMBER_NAME(mHasNext,"mHasNext");
+   }
+
+   #ifdef HXCPP_VISIT_ALLOCS
+   void __Visit(hx::VisitContext *__inCtx)
+   {
+      HX_VISIT_MEMBER_NAME(mNext,"mNext");
+      HX_VISIT_MEMBER_NAME(mHasNext,"mHasNext");
+   }
+   #endif
+
+};
+
+
+template<typename T>
+FastIterator_obj<T> *CreateFastIterator(Dynamic inValue)
+{
+   FastIterator_obj<T> *result = dynamic_cast< FastIterator_obj<T> *>(inValue.GetPtr());
+   if (result) return result;
+   return new DynamicIterator<T>(inValue);
+}
+
+template<typename T>
+class HXCPP_EXTERN_CLASS_ATTRIBUTES StringIterator : public cpp::FastIterator_obj<T>
+{
+public:
+   String value;
+   int    pos;
+
+   StringIterator(const String &inValue) : value(inValue), pos(0) { }
+
+   bool hasNext() { return pos<value.length; }
+   void __Mark(hx::MarkContext *__inCtx)
+   {
+      cpp::FastIterator_obj<T>::__Mark(__inCtx);
+      HX_MARK_MEMBER_NAME(value,"value");
+   }
+
+   #ifdef HXCPP_VISIT_ALLOCS
+   void __Visit(hx::VisitContext *__inCtx)
+   {
+      cpp::FastIterator_obj<T>::__Visit(__inCtx);
+      HX_VISIT_MEMBER_NAME(value,"value");
+   }
+   #endif
+};
+
+}
+
+
+
+
+
+
+
+
+
+#endif
diff --git a/Sources/c_snikket/iinclude/cpp/Int64.h b/Sources/c_snikket/iinclude/cpp/Int64.h
new file mode 100644
index 0000000..e8b60db
--- /dev/null
+++ b/Sources/c_snikket/iinclude/cpp/Int64.h
@@ -0,0 +1,148 @@
+#ifndef CPP_INT64_INCLUDED
+#define CPP_INT64_INCLUDED
+
+namespace cpp
+{
+
+class Int64Handler
+{
+   public:
+      static inline const char *getName() { return "cpp.Int64"; }
+      static inline String toString( const void *inValue ) { return String( *(Int64 *)inValue ); }
+      static inline void handler(DynamicHandlerOp op, void *ioValue,int inSize, void *outResult)
+      {
+         if (op==dhoToString)
+            *(String *)outResult = toString(ioValue);
+         else if (op==dhoGetClassName)
+            *(const char **)outResult = getName();
+         else if (op==dhoFromDynamic)
+         {
+            StructHandlerDynamicParams *params = (StructHandlerDynamicParams *)outResult;
+            cpp::Int64 &value = *(cpp::Int64 *)ioValue;
+            params->outProcessed = true;
+            if (!params->inData)
+               value = 0;
+            else
+               value = params->inData->__ToInt64();
+         }
+         else if (op==dhoToDynamic)
+         {
+            Dynamic value =  *(cpp::Int64 *)ioValue;
+            *(hx::Object **)outResult = value.mPtr;
+         }
+         else if (op==dhoIs)
+         {
+            StructHandlerDynamicParams *params = (StructHandlerDynamicParams *)outResult;
+            hx::Object *obj = params->inData;
+            int type = obj->__GetType();
+            params->outProcessed = type==vtInt || type==vtInt64;
+         }
+         else
+            return DefaultStructHandler::handler(op,ioValue,inSize, outResult);
+      }
+};
+
+typedef Struct<Int64,Int64Handler> Int64Struct;
+
+
+}
+
+#if (HXCPP_API_LEVEL >= 420)
+
+inline cpp::Int64 _hx_int64_make(int a, int b) { return (((cpp::Int64)(unsigned int)a)<<32) | (unsigned int)b; }
+inline bool _hx_int64_is_neg(cpp::Int64 a) { return a<0; }
+inline bool _hx_int64_is_zero(cpp::Int64 a) { return a==0; }
+inline bool _hx_int64_eq(cpp::Int64 a, cpp::Int64 b) { return a==b; }
+inline bool _hx_int64_neq(cpp::Int64 a, cpp::Int64 b) { return a!=b; }
+inline int _hx_int64_compare(cpp::Int64 a, cpp::Int64 b)
+{
+   return a==b ? 0 : a<b ? -1 : 1;
+}
+inline int _hx_int64_ucompare(cpp::Int64 a, cpp::Int64 b)
+{
+   return a==b ? 0 : ( ::cpp::UInt64)a<( ::cpp::UInt64)b ? -1 : 1;
+}
+inline String _hx_int64_to_string(cpp::Int64 a) { return a; }
+
+inline cpp::Int64 _hx_int64_neg(cpp::Int64 a) { return -a; }
+inline cpp::Int64 _hx_int64_complement(cpp::Int64 a) { return ~a; }
+
+inline cpp::Int64 _hx_int64_pre_increment(cpp::Int64 &ioVal) {
+   return ++ioVal;
+}
+inline cpp::Int64 _hx_int64_post_increment(cpp::Int64 &ioVal) {
+   return ioVal++;
+}
+inline cpp::Int64 _hx_int64_pre_decrement(cpp::Int64 &ioVal) {
+   return --ioVal;
+}
+inline cpp::Int64 _hx_int64_post_decrement(cpp::Int64 &ioVal) {
+   return ioVal--;
+}
+
+inline cpp::Int64 _hx_int64_sub(cpp::Int64 a, cpp::Int64 b) { return a-b; }
+inline cpp::Int64 _hx_int64_add(cpp::Int64 a, cpp::Int64 b) { return a+b; }
+inline cpp::Int64 _hx_int64_mul(cpp::Int64 a, cpp::Int64 b) { return a*b; }
+inline cpp::Int64 _hx_int64_div(cpp::Int64 a, cpp::Int64 b) { return a/b; }
+inline cpp::Int64 _hx_int64_mod(cpp::Int64 a, cpp::Int64 b) { return a%b; }
+inline cpp::Int64 _hx_int64_and(cpp::Int64 a, cpp::Int64 b) { return a&b; }
+inline cpp::Int64 _hx_int64_or(cpp::Int64 a, cpp::Int64 b) { return a|b; }
+inline cpp::Int64 _hx_int64_xor(cpp::Int64 a, cpp::Int64 b) { return a^b; }
+inline cpp::Int64 _hx_int64_shl(cpp::Int64 a, int b) { return a<<(b&63); }
+inline cpp::Int64 _hx_int64_shr(cpp::Int64 a, int b) { return a>>(b&63); }
+inline cpp::Int64 _hx_int64_ushr(cpp::Int64 a, int b) { return ((cpp::UInt64)a)>>(b&63); }
+inline int _hx_int64_high(cpp::Int64 a) { return (int)( a >> 32 ); }
+inline int _hx_int64_low(cpp::Int64 a) { return (int)( a & 0xffffffff ); }
+
+#else
+
+inline cpp::Int64Struct _hx_int64_make(int a, int b) { return (((cpp::Int64)(unsigned int)a)<<32) | (unsigned int)b; }
+inline bool _hx_int64_is_neg(cpp::Int64 a) { return a<0; }
+inline bool _hx_int64_is_zero(cpp::Int64 a) { return a==0; }
+inline bool _hx_int64_eq(cpp::Int64 a, cpp::Int64 b) { return a==b; }
+inline bool _hx_int64_neq(cpp::Int64 a, cpp::Int64 b) { return a!=b; }
+inline int _hx_int64_compare(cpp::Int64 a, cpp::Int64 b)
+{
+   return a==b ? 0 : a<b ? -1 : 1;
+}
+inline int _hx_int64_ucompare(cpp::Int64 a, cpp::Int64 b)
+{
+   return a==b ? 0 : ( ::cpp::UInt64)a<( ::cpp::UInt64)b ? -1 : 1;
+}
+inline String _hx_int64_to_string(cpp::Int64Struct a) { return a; }
+
+inline cpp::Int64Struct _hx_int64_neg(cpp::Int64 a) { return -a; }
+inline cpp::Int64Struct _hx_int64_complement(cpp::Int64 a) { return ~a; }
+
+inline cpp::Int64Struct _hx_int64_pre_increment(cpp::Int64Struct &ioVal) {
+   return ++ioVal.get();
+}
+inline cpp::Int64Struct _hx_int64_post_increment(cpp::Int64Struct &ioVal) {
+   return ioVal.get()++;
+}
+inline cpp::Int64Struct _hx_int64_pre_decrement(cpp::Int64Struct &ioVal) {
+   return --ioVal.get();
+}
+inline cpp::Int64Struct _hx_int64_post_decrement(cpp::Int64Struct &ioVal) {
+   return ioVal.get()--;
+}
+
+inline cpp::Int64Struct _hx_int64_sub(cpp::Int64 a, cpp::Int64 b) { return a-b; }
+inline cpp::Int64Struct _hx_int64_add(cpp::Int64 a, cpp::Int64 b) { return a+b; }
+inline cpp::Int64Struct _hx_int64_mul(cpp::Int64 a, cpp::Int64 b) { return a*b; }
+inline cpp::Int64Struct _hx_int64_div(cpp::Int64 a, cpp::Int64 b) { return a/b; }
+inline cpp::Int64Struct _hx_int64_mod(cpp::Int64 a, cpp::Int64 b) { return a%b; }
+inline cpp::Int64Struct _hx_int64_and(cpp::Int64 a, cpp::Int64 b) { return a&b; }
+inline cpp::Int64Struct _hx_int64_or(cpp::Int64 a, cpp::Int64 b) { return a|b; }
+inline cpp::Int64Struct _hx_int64_xor(cpp::Int64 a, cpp::Int64 b) { return a^b; }
+inline cpp::Int64Struct _hx_int64_shl(cpp::Int64 a, int b) { return a<<(b&63); }
+inline cpp::Int64Struct _hx_int64_shr(cpp::Int64 a, int b) { return a>>(b&63); }
+inline cpp::Int64Struct _hx_int64_ushr(cpp::Int64 a, int b) { return ((cpp::UInt64)a)>>(b&63); }
+inline int _hx_int64_high(cpp::Int64Struct a) { return (int)( a.get() >>32 ); }
+inline int _hx_int64_low(cpp::Int64Struct a) { return (int)( a.get()  & 0xffffffff ); }
+
+#endif
+
+
+
+#endif
diff --git a/Sources/c_snikket/iinclude/cpp/Lib.h b/Sources/c_snikket/iinclude/cpp/Lib.h
new file mode 100644
index 0000000..38d98b7
--- /dev/null
+++ b/Sources/c_snikket/iinclude/cpp/Lib.h
@@ -0,0 +1,56 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_cpp_Lib
+#define INCLUDED_cpp_Lib
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(cpp,Lib)
+
+namespace cpp{
+
+
+class HXCPP_CLASS_ATTRIBUTES Lib_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Lib_obj OBJ_;
+		Lib_obj();
+
+	public:
+		enum { _hx_ClassId = 0x561f6486 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="cpp.Lib")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"cpp.Lib"); }
+
+		inline static ::hx::ObjectPtr< Lib_obj > __new() {
+			::hx::ObjectPtr< Lib_obj > __this = new Lib_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Lib_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Lib_obj *__this = (Lib_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Lib_obj), false, "cpp.Lib"));
+			*(void **)__this = Lib_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Lib_obj();
+
+		HX_DO_RTTI_ALL;
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Lib",25,07,3a,00); }
+
+};
+
+} // end namespace cpp
+
+#endif /* INCLUDED_cpp_Lib */ 
diff --git a/Sources/c_snikket/iinclude/cpp/Pointer.h b/Sources/c_snikket/iinclude/cpp/Pointer.h
new file mode 100644
index 0000000..25c28b4
--- /dev/null
+++ b/Sources/c_snikket/iinclude/cpp/Pointer.h
@@ -0,0 +1,558 @@
+#ifndef CPP_POINTER_H
+#define CPP_POINTER_H
+
+namespace cpp
+{
+
+struct AutoCast
+{
+   void *value;
+
+   explicit inline AutoCast(void *inValue) : value(inValue) { }
+};
+
+
+struct RawAutoCast
+{
+   void *value;
+
+   explicit inline RawAutoCast(void *inValue) : value(inValue) { }
+
+   template<typename T>
+   operator T*() const { return (T*)value; }
+};
+
+
+Dynamic CreateDynamicPointer(void *inValue);
+
+enum DynamicHandlerOp
+{
+   dhoGetClassName,
+   dhoToString,
+   dhoFromDynamic,
+   dhoToDynamic,
+   dhoIs,
+};
+typedef void (*DynamicHandlerFunc)(DynamicHandlerOp op, void *ioValue, int inSize, void *outResult);
+Dynamic CreateDynamicStruct(const void *inValue, int inSize, DynamicHandlerFunc inFunc);
+
+template<typename T> class Reference;
+
+
+
+struct StructHandlerDynamicParams
+{
+   StructHandlerDynamicParams(hx::Object *data,const char *inName) :
+       outProcessed(false), inName(inName), inData(data) { }
+   bool outProcessed;
+   hx::Object *inData;
+   const char *inName;
+};
+
+
+class DefaultStructHandler
+{
+   public:
+      static inline const char *getName() { return "unknown"; }
+      static inline String toString( const void *inValue ) { return HX_CSTRING("Struct"); }
+      static inline void handler(DynamicHandlerOp op, void *ioValue, int inSize, void *outResult)
+      {
+         if (op==dhoToString)
+            *(String *)outResult = toString(ioValue);
+         else if (op==dhoGetClassName)
+            *(const char **)outResult = getName();
+         else if (op==dhoToDynamic)
+         {
+            // Handle outsize..
+            *(hx::Object **)outResult = 0;
+         }
+         else if (op==dhoFromDynamic)
+         {
+            StructHandlerDynamicParams *params = (StructHandlerDynamicParams *)outResult;
+            hx::Object *ptr= params->inData;
+            void *data = (void *)ptr->__GetHandle();
+            int len = ptr->__length();
+            if (data && len>=inSize && ptr->__CStr()==params->inName)
+            {
+               memcpy(ioValue,data,inSize);
+               params->outProcessed = true;
+            }
+         }
+         else if (op==dhoIs)
+         {
+            StructHandlerDynamicParams *params = (StructHandlerDynamicParams *)outResult;
+            hx::Object *ptr= params->inData;
+            void *data = (void *)ptr->__GetHandle();
+            int len = ptr->__length();
+            params->outProcessed = data && len>=inSize && ptr->__CStr()==params->inName;
+         }
+      }
+};
+
+
+class EnumHandler
+{
+   public:
+      static inline const char *getName() { return "enum"; }
+      static inline String toString( const void *inValue ) {
+         int val = inValue ? *(int *)inValue : 0;
+         return HX_CSTRING("enum(") + String(val) + HX_CSTRING(")");
+      }
+
+      static inline void handler(DynamicHandlerOp op, void *ioValue, int inSize, void *outResult)
+      {
+         if (op==dhoToString)
+            *(String *)outResult = toString(ioValue);
+         else if (op==dhoGetClassName)
+            *(const char **)outResult = getName();
+         else if (op==dhoFromDynamic)
+         {
+            StructHandlerDynamicParams *params = (StructHandlerDynamicParams *)outResult;
+            if (params->inData->__GetType()==vtInt)
+            {
+               *(int *)ioValue =  params->inData->__ToInt();
+               params->outProcessed = true;
+            }
+            else
+               DefaultStructHandler::handler(op,ioValue, inSize, outResult);
+         }
+         else
+            DefaultStructHandler::handler(op,ioValue, inSize, outResult);
+      }
+};
+
+
+
+template<typename T, typename HANDLER = DefaultStructHandler >
+class Struct
+{
+public:
+   T value;
+   // This allows 'StaticCast' to be used from arrays
+   typedef Dynamic Ptr;
+
+   inline Struct( ) {  }
+   inline Struct( const T &inRHS ) : value(inRHS) {  }
+   inline Struct( const null &) { value = T(); }
+   inline Struct( const Reference<T> &);
+   inline Struct( const Dynamic &inRHS) { fromDynamic(inRHS.mPtr); }
+
+   inline Struct<T,HANDLER> &operator=( const T &inRHS ) { value = inRHS; return *this; }
+   inline Struct<T,HANDLER> &operator=( const null & ) { value = T(); return *this; }
+   inline Struct<T,HANDLER> &operator=( const Dynamic &inRHS ) { return *this = Struct<T,HANDLER>(inRHS); }
+
+   operator Dynamic() const
+   {
+      hx::Object *result = 0;
+      HANDLER::handler(dhoToDynamic, (void *)&value, sizeof(T), &result );
+      if (result)
+         return result;
+      return CreateDynamicStruct( &value, sizeof(T), HANDLER::handler);
+   }
+   operator String() const { return HANDLER::toString(&value); }
+
+   inline Struct( const hx::Val &inRHS) { fromDynamic(inRHS.asObject()); }
+   operator hx::Val() const { return operator Dynamic(); }
+
+   bool operator==(const Struct<T,HANDLER> &inRHS) const { return value==inRHS.value; }
+   bool operator==(const null &inRHS) const { return false; }
+   bool operator!=(const null &inRHS) const { return true; }
+
+   // Haxe uses -> notation
+   inline T *operator->() { return &value; }
+
+   T &get() { return value; }
+
+   static inline bool is( const Dynamic &inRHS)
+   {
+      hx::Object *ptr = inRHS.mPtr;
+      if (!ptr)
+         return false;
+      StructHandlerDynamicParams convert(ptr, ptr->__CStr());
+      HANDLER::handler(dhoIs, 0, sizeof(T), &convert );
+      return convert.outProcessed;
+   }
+
+
+   inline void fromDynamic( hx::Object *ptr)
+   {
+      if (!ptr)
+      {
+         value = T();
+         return;
+      }
+      StructHandlerDynamicParams convert(ptr, ptr->__CStr());
+      HANDLER::handler(dhoFromDynamic, &value, sizeof(T), &convert );
+      if (!convert.outProcessed)
+      {
+         hx::NullReference("DynamicData", true);
+         return;
+      }
+   }
+
+   inline operator T& () { return value; }
+};
+
+
+
+
+template<typename T>
+class Pointer
+{
+public:
+   typedef T elementType;
+
+   T *ptr;
+
+   inline Pointer( ) : ptr(0) { }
+   inline Pointer( const Pointer &inRHS ) : ptr(inRHS.ptr) {  }
+   inline Pointer( const Dynamic &inRHS) { ptr = inRHS==null()?0: (T*)inRHS->__GetHandle(); }
+   inline Pointer( const null &inRHS ) : ptr(0) { }
+   inline Pointer( const cpp::Variant &inVariant ) {
+      hx::Object *obj = inVariant.asObject();
+      ptr = obj  ? (T*)inVariant.valObject->__GetHandle() : 0;
+   }
+
+   template<typename O>
+   inline Pointer( const O *inValue ) : ptr( (T*) inValue) { }
+   //inline Pointer( T *inValue ) : ptr(inValue) { }
+   inline Pointer( AutoCast inValue ) : ptr( (T*)inValue.value) { }
+
+   template<typename H>
+   inline Pointer( const Struct<T,H> &structVal ) : ptr( &structVal.value ) { }
+
+   template<typename O>
+   inline void setRaw(const O *inValue ) { ptr =  (T*) inValue; }
+   
+
+   inline Pointer operator=( const Pointer &inRHS ) { return ptr = inRHS.ptr; }
+   inline Dynamic operator=( Dynamic &inValue )
+   {
+      ptr = inValue==null() ? 0 : (T*) inValue->__GetHandle();
+      return inValue;
+   }
+   inline Dynamic operator=( null &inValue ) { ptr=0; return inValue; }
+
+   template<typename O>
+   inline Pointer operator=( const Pointer<O> &inValue ) { ptr = (T*) inValue.ptr; return *this; }
+
+   template<typename O>
+   inline Pointer operator=( const O *inValue ) { ptr = (T*) inValue; return *this; }
+
+   template<typename H>
+   inline Pointer operator=( const Struct<T,H> &structVal ) { ptr = &structVal.value; return *this; }
+
+
+
+   inline AutoCast reinterpret() { return AutoCast(ptr); }
+   inline RawAutoCast rawCast() { return RawAutoCast(ptr); }
+
+   inline bool operator==( const null &inValue ) const { return ptr==0; }
+   inline bool operator!=( const null &inValue ) const { return ptr!=0; }
+
+   // Allow '->' syntax
+   inline Pointer *operator->() { return this; }
+ 	inline Pointer inc() { return ++ptr; }
+	inline Pointer dec() { return --ptr; }
+	inline Pointer add(int inInt) { return ptr+inInt; }
+	inline Pointer sub(int inInt) { return ptr-inInt; }
+ 	inline Pointer incBy(int inDiff) { ptr+=inDiff; return ptr; }
+ 	inline Pointer decBy(int inDiff) { ptr-=inDiff; return ptr; }
+ 	inline T &postIncRef() { return *ptr++; }
+ 	inline T &postIncVal() { return *ptr++; }
+
+   inline T &at(int inIndex) { return ptr[inIndex]; }
+   inline void setAt(int inIndex, const T &test) { ptr[inIndex] = test; }
+
+   inline T &__get(int inIndex) { return ptr[inIndex]; }
+   inline T &__set(int inIndex, const T &inValue) { T *p = ptr+inIndex; *p = inValue; return *p; }
+
+   inline T &get_value() { return *ptr; }
+   inline T &get_ref() { return *ptr; }
+   inline T &set_ref(const T &inValue) { return *ptr = inValue;  }
+
+   operator Dynamic () const { return CreateDynamicPointer((void *)ptr); }
+   operator cpp::Variant () const { return CreateDynamicPointer((void *)ptr); }
+
+   operator T * () { return ptr; }
+   T * get_raw() { return ptr; }
+   const T * get_constRaw() { return ptr; }
+
+   inline void destroy() { delete ptr; }
+   inline void destroyArray() { delete [] ptr; }
+
+   inline bool lt(Pointer inOther) { return ptr < inOther.ptr; }
+   inline bool gt(Pointer inOther) { return ptr > inOther.ptr; }
+   inline bool leq(Pointer inOther) { return ptr <= inOther.ptr; }
+   inline bool geq(Pointer inOther) { return ptr >= inOther.ptr; }
+
+};
+
+
+
+
+
+template<>
+class Pointer<void>
+{
+public:
+   enum { elementSize = 0 };
+
+   void *ptr;
+
+   inline Pointer( ) : ptr(0) { }
+   inline Pointer( const Pointer &inRHS ) : ptr(inRHS.ptr) {  }
+   inline Pointer( const Dynamic &inRHS) { ptr = inRHS==null()?0: (void*)inRHS->__GetHandle(); }
+   inline Pointer( const null &inRHS ) : ptr(0) { }
+
+   template<typename O>
+   inline Pointer( const O *inValue ) : ptr( (void*) inValue) { }
+   //inline Pointer( T *inValue ) : ptr(inValue) { }
+   inline Pointer( AutoCast inValue ) : ptr( (void*)inValue.value) { }
+
+   inline Pointer operator=( const Pointer &inRHS ) { return ptr = inRHS.ptr; }
+   inline Dynamic operator=( Dynamic &inValue )
+   {
+      ptr = inValue==null() ? 0 : (void*) inValue->__GetHandle();
+      return inValue;
+   }
+   inline Dynamic operator=( null &inValue ) { ptr=0; return inValue; }
+   inline AutoCast reinterpret() { return AutoCast(ptr); }
+   inline RawAutoCast rawCast() { return RawAutoCast(ptr); }
+
+   inline bool operator==( const null &inValue ) const { return ptr==0; }
+   inline bool operator!=( const null &inValue ) const { return ptr!=0; }
+
+   // Allow '->' syntax
+   inline Pointer *operator->() { return this; }
+ 	inline Pointer inc() { return ptr; }
+	inline Pointer dec() { return ptr; }
+	inline Pointer add(int inInt) { return ptr; }
+	inline Pointer sub(int inInt) { return ptr; }
+ 	inline Pointer incBy(int inDiff) { return ptr; }
+ 	inline Pointer decBy(int inDiff) { return ptr; }
+ 	inline void postIncRef() {  }
+ 	inline void postIncVal() {  }
+
+   inline void at(int inIndex) {  }
+
+   inline void __get(int inIndex) { }
+
+   template<typename O>
+   inline void __set(int inIndex, O inValue) { }
+
+   inline void get_value() {  }
+   inline void get_ref() {  }
+   template<typename O> inline void set_ref(O val) {  }
+
+   operator Dynamic () const { return CreateDynamicPointer(ptr); }
+   //operator hx::Val () const { return CreateDynamicPointer((void *)ptr); }
+   operator void * () { return ptr; }
+   void * get_raw() { return ptr; }
+   const void * get_constRaw() { return ptr; }
+
+   inline void destroy() {  }
+   inline void destroyArray() {  }
+
+   inline bool lt(Pointer inOther) { return ptr < inOther.ptr; }
+   inline bool gt(Pointer inOther) { return ptr > inOther.ptr; }
+   inline bool leq(Pointer inOther) { return ptr <= inOther.ptr; }
+   inline bool geq(Pointer inOther) { return ptr >= inOther.ptr; }
+
+};
+
+
+
+
+template<typename T>
+inline bool operator == (const null &, Pointer<T> inPtr) { return inPtr.ptr==0; }
+template<typename T>
+inline bool operator != (const null &, Pointer<T> inPtr) { return inPtr.ptr!=0; }
+
+
+
+template<typename T>
+class Reference : public Pointer<T>
+{
+public:
+   using Pointer<T>::ptr;
+
+
+   inline Reference( const T &inRHS ) : Pointer<T>(&inRHS) {  }
+   inline Reference( T &inRHS ) : Pointer<T>(&inRHS) {  }
+
+   inline Reference( ) : Pointer<T>((T*)0) { }
+   inline Reference( const Reference &inRHS ) : Pointer<T>(inRHS.ptr) {  }
+   inline Reference( const Dynamic &inRHS) { ptr = inRHS==null()?0: (T*)inRHS->__GetHandle(); }
+   inline Reference( const null &inRHS ) : Pointer<T>((T*)0) { }
+   inline Reference( const T *inValue ) : Pointer<T>( (T*) inValue) { }
+   //inline Reference( T *inValue ) : Pointer(inValue) { }
+   inline Reference( AutoCast inValue ) : Pointer<T>( (T*)inValue.value) { }
+
+   template<typename OTHER>
+   inline Reference( const Reference<OTHER> &inOther )
+   {
+      // Allow reinterpret or not?
+      ptr = (T*)inOther.ptr;
+   }
+
+   template<typename H>
+   inline Reference( const Struct<T,H> &structVal ) : Pointer<T>( &structVal.value ) { }
+
+   inline Reference operator=( const Reference &inRHS ) { return ptr = inRHS.ptr; }
+
+
+   inline T *operator->() const { return ptr; }
+   
+   inline operator T &() { return *ptr; }
+
+};
+
+template<typename T,typename H>
+Struct<T,H>::Struct( const Reference<T> &ref ) : value(*ref.ptr) { };
+
+
+
+template<typename T>
+class Function
+{
+public:
+   T *call;
+
+   inline Function( ) { }
+   inline Function( const Function &inRHS ) : call(inRHS.call) {  }
+   inline Function( const Dynamic &inRHS) { call = inRHS==null()?0: (T*)inRHS->__GetHandle(); }
+   inline Function( const null &inRHS ) { call = 0; }
+   inline Function( T *inValue ) : call((T*)(inValue)) { }
+   //inline Function( T *inValue ) : call(inValue) { }
+   inline Function( AutoCast inValue ) : call( (T*)inValue.value) { }
+   inline Function( const hx::AnyCast &inValue ) : call( (T*)inValue.mPtr) { }
+
+   template<typename FROM>
+   inline static Function __new(FROM from)
+   {
+      return Function(from);
+   }
+
+   inline Function operator=( const Function &inRHS ) { return call = inRHS.call; }
+   inline Dynamic operator=( Dynamic &inValue )
+   {
+      call = inValue==null() ? 0 : (T*) inValue->__GetHandle();
+      return inValue;
+   }
+   inline Dynamic operator=( null &inValue ) { call=0; return inValue; }
+   inline bool operator==( const null &inValue ) const { return call==0; }
+   inline bool operator!=( const null &inValue ) const { return call!=0; }
+
+
+   operator Dynamic () const { return CreateDynamicPointer((void *)call); }
+   //operator hx::Val () const { return CreateDynamicPointer((void *)call); }
+   operator T * () { return call; }
+   operator void * () { return (void *)call; }
+
+   inline T &get_call() { return *call; }
+
+   inline bool lt(Function inOther) { return call < inOther.call; }
+   inline bool gt(Function inOther) { return call > inOther.call; }
+   inline bool leq(Function inOther) { return call <= inOther.call; }
+   inline bool geq(Function inOther) { return call >= inOther.call; }
+
+};
+
+
+template<typename T>
+inline bool operator == (const null &, Function<T> inPtr) { return inPtr.call==0; }
+template<typename T>
+inline bool operator != (const null &, Function<T> inPtr) { return inPtr.call!=0; }
+
+
+
+class Function_obj
+{
+public:
+
+	inline static AutoCast getProcAddress(String inLib, String inPrim)
+   {
+      return AutoCast(__hxcpp_get_proc_address(inLib, inPrim,false));
+   }
+
+
+   template<typename T>
+	inline static AutoCast fromStaticFunction(T *inFunction)
+   {
+      return AutoCast(inFunction);
+   }
+};
+
+
+class Pointer_obj
+{
+public:
+   template<typename T>
+	inline static AutoCast arrayElem(::Array<T> array, int inIndex)  { return AutoCast(&array[inIndex]); }
+	inline static AutoCast arrayElem(Dynamic inVal, int inIndex)
+   {
+      if (inVal==null() || !inVal->__IsArray())
+         return AutoCast(0);
+      hx::ArrayBase *base = (hx::ArrayBase *)inVal.GetPtr();
+      return AutoCast(base->GetBase() + inIndex*base->GetElementSize());
+   }
+
+   template<typename T>
+	inline static AutoCast ofArray(::Array<T> array)  { return AutoCast(&array[0]); }
+	inline static AutoCast ofArray(Dynamic inVal)
+   {
+      if (inVal==null() || !inVal->__IsArray())
+         return AutoCast(0);
+      hx::ArrayBase *base = (hx::ArrayBase *)inVal.GetPtr();
+      return AutoCast(base->GetBase());
+   }
+
+
+
+   template<typename T>
+	inline static Pointer<T> addressOf(T &value)  { return Pointer<T>(&value); }
+
+   template<typename T>
+	inline static Pointer<void> endOf(hx::ObjectPtr<T> value)  { return (void *)(value.mPtr+1); }
+
+   template<typename T>
+	inline static Pointer<T> fromPointer(T *value)  { return Pointer<T>(value); }
+   template<typename T>
+	inline static Pointer<T> fromPointer(const T *value)  { return Pointer<T>(value); }
+
+   template<typename T>
+	inline static Pointer<T> fromRaw(T *value)  { return Pointer<T>(value); }
+   template<typename T>
+	inline static Pointer<T> fromRaw(const T *value)  { return Pointer<T>(value); }
+	inline static Pointer<void> fromRaw(const AutoCast &inAutoCast)  { return Pointer<void>(inAutoCast.value); }
+	inline static Pointer<void> fromRaw(const RawAutoCast &inAutoCast)  { return Pointer<void>(inAutoCast.value); }
+
+
+   inline static AutoCast fromHandle(Dynamic inValue, String inKind)
+   {
+      if (inValue==null() || (inKind!=null() && inKind!=__hxcpp_get_kind(inValue)))
+         return AutoCast(0);
+      return AutoCast(inValue->__GetHandle());
+   }
+};
+
+
+class Reference_obj
+{
+public:
+
+};
+
+
+
+} // end namespace cpp
+
+namespace hx
+{
+template <typename T>
+T *StarOf(T &x) { return &x; }
+}
+
+
+#endif
diff --git a/Sources/c_snikket/iinclude/cpp/Variant.h b/Sources/c_snikket/iinclude/cpp/Variant.h
new file mode 100644
index 0000000..cf2352f
--- /dev/null
+++ b/Sources/c_snikket/iinclude/cpp/Variant.h
@@ -0,0 +1,674 @@
+#ifndef CPP_VARIANT_TWICE_H
+
+
+namespace cpp
+{
+#ifndef CPP_VARIANT_ONCE_H
+#define CPP_VARIANT_ONCE_H
+
+   template<typename T>
+   inline bool isIntType(const T &inRHS) { return false; }
+   template<> inline bool isIntType(const int &inRHS) { return true; }
+   template<> inline bool isIntType(const Dynamic &inRHS);
+   template<> inline bool isIntType(const cpp::Variant &inRHS);
+
+   template<typename T>
+   inline bool isStringType(const T &inRHS) { return false; }
+   template<> inline bool isStringType(const String &inRHS) { return true; }
+   template<> inline bool isStringType(const Dynamic &inRHS);
+   template<> inline bool isStringType(const cpp::Variant &inRHS);
+
+   struct Variant
+   {
+      enum Type
+      {
+         typeObject = 0,
+         typeString,
+         typeDouble,
+         typeInt,
+         typeInt64,
+         typeBool,
+      };
+
+      union
+      {
+         // Although this is typed as 'char', it might be char16_t in the case of smart strings
+         const char *valStringPtr;
+         hx::Object *valObject;
+         double valDouble;
+         cpp::Int64 valInt64;
+         int valInt;
+         bool valBool;
+      };
+      Type type;
+      unsigned int valStringLen;
+
+
+
+      inline bool isNull() const {
+          return (type==typeObject && !valObject) || (type==typeString && !valStringPtr); }
+      inline bool isNumeric() const;
+      inline bool isBool() const;
+      inline int asInt() const;
+      inline bool isInt() const;
+      inline cpp::Int64 asInt64() const;
+      inline bool isInt64() const;
+      inline bool isString() const;
+      inline double asDouble() const;
+      inline hx::Object *asObject() const { return type==typeObject ? valObject : 0; }
+      inline hx::Object *asDynamic() const{ return type==typeObject ? valObject : toDynamic(); }
+      inline hx::Object *toDynamic() const; // later
+      inline String asString() const;
+      inline String getString() const;
+
+      inline Variant() : valInt64(0), type(typeObject) { }
+      //inline Variant() { copyBuf.b[0] = copyBuf.b[1] = 0; }
+      inline Variant(const null &) : type(typeObject), valObject(0) { }
+      inline Variant(bool inValue) : type(typeBool), valBool(inValue) { }
+      inline Variant(double inValue) : type(typeDouble), valDouble(inValue) { }
+      inline Variant(const ::String &inValue); // later
+
+      inline Variant(cpp::Int64 inValue) : type(typeInt64), valInt64(inValue) { }
+      inline Variant(cpp::UInt64 inValue) : type(typeInt64), valInt64(inValue) { }
+      inline Variant(unsigned long inValue) : type(typeInt64), valInt64(inValue) { }
+      inline Variant(int inValue) : type(typeInt), valInt(inValue) { }
+      inline Variant(cpp::UInt32 inValue) : type(typeInt), valInt(inValue) { }
+      inline Variant(cpp::Int16 inValue) : type(typeInt), valInt(inValue) { }
+      inline Variant(cpp::UInt16 inValue) : type(typeInt), valInt(inValue) { }
+      inline Variant(cpp::Int8 inValue) : type(typeInt), valInt(inValue) { }
+      inline Variant(cpp::UInt8 inValue) : type(typeInt), valInt(inValue) { }
+      #if defined(__OBJC__) && defined(HXCPP_OBJC)
+      inline Variant(const id inObjc);
+      inline operator id() const;
+      #endif
+
+
+      template<typename SOURCE_>
+      Variant(const hx::ObjectPtr<SOURCE_> &inObjectPtr);
+
+      inline Variant(const Dynamic &inRHS); // later
+      inline Variant(hx::Object *inValue) : type(typeObject), valObject(inValue) { }
+
+      template<typename T,typename H>
+      explicit inline Variant(const cpp::Struct<T,H> &inVal);
+      template<typename T>
+      explicit inline Variant(const cpp::Pointer<T> &inRHS) ;
+      template<typename T>
+      explicit inline Variant(const cpp::Function<T> &inRHS) ;
+      template<typename T>
+      explicit inline Variant(const hx::Native<T> &inRHS) ;
+
+      //inline operator Dynamic() const; // later
+      //inline operator String() const;
+      inline operator double() const { return asDouble(); }
+      inline operator int() const { return asInt(); }
+      inline operator bool() const { return asInt(); }
+      inline operator float () const { return asDouble(); }
+      inline operator unsigned int () const { return asInt(); }
+      inline operator short () const { return asInt(); }
+      inline operator unsigned short () const { return asInt(); }
+      inline operator unsigned char () const { return asInt(); }
+      inline operator char () const { return asInt(); }
+      inline operator signed char () const { return asInt(); }
+      inline operator cpp::Int64 () const { return asInt64(); }
+      inline operator cpp::UInt64 () const { return asInt64(); }
+      inline operator unsigned long () const { return asInt64(); }
+      inline bool operator !() const { return !asInt(); }
+
+      inline int Compare(hx::Object *inRHS) const;
+      inline int Compare(const Dynamic &inRHS) const;
+      inline int Compare(const cpp::Variant &inRHS) const;
+
+      inline double set(const double &inValue) { type=typeDouble; return valDouble=inValue; }
+      inline double set(const float &inValue) { type=typeDouble; return valDouble=inValue; }
+
+      inline void mark(hx::MarkContext *__inCtx); // later
+      #ifdef HXCPP_VISIT_ALLOCS
+      inline void visit(hx::VisitContext *__inCtx); // later
+      #endif
+
+
+      //inline Variant &operator=(const Variant &inRhs) { copyBuf = inRhs.copyBuf; return *this; }
+
+      template<typename T>
+      bool operator==(const T &inRHS) const;
+
+      template<typename T>
+      bool operator==(const hx::ObjectPtr<T> &inRHS) const
+         { return Compare(inRHS.mPtr)==0; }
+
+
+      template<typename T>
+      bool operator!=(const hx::ObjectPtr<T> &inRHS) const
+         { return Compare(inRHS.mPtr)!=0; }
+
+
+
+      inline bool operator==(const null &inRHS) const { return isNull(); }
+      inline bool operator==(const String &inRHS) const;
+
+      inline bool operator!=(const null &inRHS) const { return !isNull(); }
+      inline bool operator!=(const Variant &inRHS) const { return !operator==(inRHS); }
+      inline bool operator!=(const String &inRHS)  const;
+
+
+      template<typename RETURN_>
+      RETURN_ Cast() const { return RETURN_(*this); }
+
+      void CheckFPtr();
+      HX_DECLARE_VARIANT_FUNCTIONS
+
+
+    // Operator + is different, since it must consider strings too...
+    inline String operator+(const String &s) const;
+    template<typename T>
+    inline cpp::Variant operator + (const T &inRHS) const;
+
+    inline double operator%(const Dynamic &inRHS) const;
+    inline double operator-() const { return -asDouble(); }
+    inline double operator++() { return set(asDouble()+1); }
+    inline double operator++(int) {double val = asDouble(); set(val+1); return val; }
+    inline double operator--() { return set(asDouble()-1); }
+    inline double operator--(int) {double val = asDouble(); set(val-1); return val; }
+
+    template<typename T>
+    inline double operator / (const T &inRHS) const { return asDouble() / (double)inRHS; } \
+
+    template<typename T>
+    inline cpp::Variant operator - (const T &inRHS) const
+    {
+       if (::cpp::isIntType(inRHS) && isInt() )
+          return asInt() - (int)inRHS;
+       return asDouble() - (double)inRHS;
+    }
+
+    template<typename T>
+    inline cpp::Variant operator * (const T &inRHS) const
+    {
+       if (::cpp::isIntType(inRHS) && isInt())
+          return asInt() * (int)inRHS;
+       return asDouble() * (double)inRHS;
+    }
+
+   inline bool operator < (const String &inRHS) const;
+   inline bool operator <= (const String &inRHS) const;
+   inline bool operator > (const String &inRHS) const;
+   inline bool operator >= (const String &inRHS) const;
+
+
+
+   #define HX_VARIANT_COMPARE_OP( op ) \
+   inline bool operator op (double inRHS)  const { return isNumeric() && (asDouble() op inRHS); } \
+   inline bool operator op (cpp::Int64 inRHS)  const { return isNumeric() && (asInt64() op inRHS); } \
+   inline bool operator op (cpp::UInt64 inRHS)  const { return isNumeric() && ((cpp::UInt64)(asInt64()) op inRHS); } \
+   inline bool operator op (float inRHS)  const { return isNumeric() && (asDouble() op inRHS); } \
+   inline bool operator op (int inRHS)  const { return isNumeric() && (asDouble() op (double)inRHS); } \
+   inline bool operator op (unsigned int inRHS)  const { return isNumeric() && (asDouble() op (double)inRHS); } \
+   inline bool operator op (short inRHS)  const { return isNumeric() && (asDouble() op (double)inRHS); } \
+   inline bool operator op (unsigned short inRHS)  const { return isNumeric() && (asDouble() op (double)inRHS); } \
+   inline bool operator op (signed char inRHS)  const { return isNumeric() && (asDouble() op (double)inRHS); } \
+   inline bool operator op (unsigned char inRHS)  const { return isNumeric() && (asDouble() op (double)inRHS); } \
+   inline bool operator op (bool inRHS)  const { return isBool() && (asDouble() op (double)inRHS); } \
+   inline bool operator op (const Dynamic &inRHS)  const { return Compare(inRHS) op 0; } \
+
+   #define HX_VARIANT_COMPARE_OP_ALL( op ) \
+      inline bool operator op (const null &inRHS)  const { return false; } \
+      inline bool operator op (const cpp::Variant &inRHS)  const { return Compare(inRHS) op 0; } \
+      HX_VARIANT_COMPARE_OP(op)
+
+   HX_VARIANT_COMPARE_OP( == )
+   HX_VARIANT_COMPARE_OP( != )
+   HX_VARIANT_COMPARE_OP_ALL( < )
+   HX_VARIANT_COMPARE_OP_ALL( <= )
+   HX_VARIANT_COMPARE_OP_ALL( >= )
+   HX_VARIANT_COMPARE_OP_ALL( >  )
+
+
+   };
+
+#else // Second time ...
+   #define CPP_VARIANT_TWICE_H
+
+   bool Variant::isInt() const
+   {
+      return type==typeInt || (type==typeObject && valObject && valObject->__GetType()==vtInt);
+   }
+   bool Variant::isInt64() const
+   {
+      return type==typeInt64 || (type==typeObject && valObject && valObject->__GetType()==vtInt64);
+   }
+   bool Variant::isString() const
+   {
+      return type==typeString || (type==typeObject && valObject && valObject->__GetType()==vtString);
+   }
+
+
+   #if defined(__OBJC__) && defined(HXCPP_OBJC)
+   // Variant type neither adds nor releases references counts while holding the value as an id on the stack
+   // The Dynamic created here owns the id, and we refer to the Dynamic and use his reference count to keep the id alive
+   inline Variant::Variant(const id inObjc) { type=typeObject; valObject = Dynamic(inObjc).mPtr; }
+   #ifdef OBJC_ARC
+      inline Variant::operator id () const {  return type==typeObject && valObject ? (__bridge id)valObject->__GetHandle() : 0;  }
+   #else
+      inline Variant::operator id () const {  return type==typeObject && valObject ? (id)valObject->__GetHandle() : 0;  }
+   #endif
+   #endif
+
+
+
+   template<> inline bool isIntType(const Dynamic &inRHS) { return inRHS->__GetType()==vtInt; }
+   template<> inline bool isIntType(const cpp::Variant &inRHS) { return inRHS.isInt(); }
+   template<> inline bool isStringType(const Dynamic &inRHS) { return inRHS.mPtr && inRHS->__GetType()==vtString; }
+   template<> inline bool isStringType(const cpp::Variant &inRHS) { return inRHS.isString(); }
+
+   template<typename T,typename H>
+   Variant::Variant(const cpp::Struct<T,H> &inVal) :
+           type(typeObject), valObject(Dynamic(inVal).mPtr) { }
+
+   template<typename T>
+   Variant::Variant(const cpp::Pointer<T> &inRHS) : type(typeObject), valObject( Dynamic(inRHS).mPtr ) { }
+   template<typename T>
+   Variant::Variant(const cpp::Function<T> &inRHS) : type(typeObject), valObject( Dynamic(inRHS).mPtr ) { }
+   template<typename T>
+   Variant::Variant(const hx::Native<T> &inRHS) : type(typeObject), valObject( CreateDynamicPointer(inRHS.ptr).mPtr ) { }
+
+
+#define HX_ARITH_VARIANT( op ) \
+   inline double operator op (const double &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS;} \
+   inline double operator op (const float &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS;} \
+   inline double operator op (const int &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
+   inline double operator op (const unsigned int &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
+   inline double operator op (const signed char &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
+   inline double operator op (const unsigned char &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
+   inline double operator op (const signed short &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
+   inline double operator op (const unsigned short &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
+   inline double operator op (const cpp::Int64 &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
+   inline double operator op (const cpp::UInt64 &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
+
+   HX_ARITH_VARIANT( - )
+   HX_ARITH_VARIANT( + )
+   HX_ARITH_VARIANT( / )
+   HX_ARITH_VARIANT( * )
+
+   inline bool Variant::operator==(const String &inString) const
+   {
+      if (isNull()) return inString==null();
+      return type==typeString && asString()==inString;
+   }
+   inline bool Variant::operator!=(const String &inString) const
+   {
+      if (isNull()) return inString!=null();
+      return type!=typeString || asString()!=inString;
+   }
+   inline bool Variant::operator < (const String &inRHS)  const { return asString() < inRHS; }
+   inline bool Variant::operator <= (const String &inRHS)  const { return asString() < inRHS; }
+   inline bool Variant::operator > (const String &inRHS)  const { return asString() > inRHS; }
+   inline bool Variant::operator >= (const String &inRHS)  const { return asString() >= inRHS; }
+
+
+
+
+
+   Variant::Variant(const ::String &inValue) :
+      type(typeString), valStringPtr(inValue.raw_ptr()), valStringLen(inValue.length) { }
+
+   Variant::Variant(const Dynamic &inRHS) : type(typeObject), valObject(inRHS.mPtr) { }
+
+   template<typename SOURCE_>
+   Variant::Variant(const hx::ObjectPtr<SOURCE_> &inObjectPtr) :
+       type(typeObject), valObject(inObjectPtr.mPtr) { }
+
+   inline void Variant::CheckFPtr()
+   {
+      if (isNull())  Dynamic::ThrowBadFunctionError();
+   }
+
+   HX_IMPLEMENT_INLINE_VARIANT_FUNCTIONS
+
+
+   int Variant::asInt() const
+   {
+      if (type==typeInt)
+         return valInt;
+
+      switch(type)
+      {
+         case typeDouble: return valDouble;
+         case typeInt64: return (int)valInt64;
+         case typeBool: return valBool;
+         case typeObject: return valObject ? valObject->__ToInt() : 0;
+         default: ;
+      }
+      return 0;
+   }
+
+
+
+   cpp::Int64 Variant::asInt64() const
+   {
+      if (type==typeInt64)
+         return valInt64;
+
+      switch(type)
+      {
+         case typeDouble: return valDouble;
+         case typeInt: return valInt;
+         case typeBool: return valBool;
+         case typeObject: return valObject ? valObject->__ToInt64() : 0;
+         default: ;
+      }
+      return 0;
+   }
+
+   double Variant::asDouble() const
+   {
+      if (type==typeDouble)
+         return valDouble;
+      else if (type==typeInt)
+         return valInt;
+      else if (type==typeBool)
+         return valBool ? 1.0 : 0.0;
+      else if (type==typeInt64)
+         return valInt64;
+      else if (type==typeObject)
+         return valObject ? valObject->__ToDouble() : 0.0;
+      return 0.0;
+   }
+
+
+   inline hx::Object *Variant::toDynamic() const
+   {
+      switch(type)
+      {
+         case typeInt: return Dynamic(valInt).mPtr;
+         case typeDouble: return Dynamic(valDouble).mPtr;
+         case typeBool: return Dynamic(valBool).mPtr;
+         case typeString: return Dynamic(String(valStringPtr, valStringLen)).mPtr;
+         case typeInt64: return Dynamic(valInt64).mPtr;
+         case typeObject: return valObject;
+         default: ;
+      }
+      return 0;
+   }
+
+
+   /*
+   Variant::operator Dynamic() const
+   {
+      switch(type)
+      {
+         case typeInt: return valInt;
+         case typeDouble: return valDouble;
+         case typeBool: return valBool;
+         case typeString: return String(valStringPtr, valStringLen);
+         case typeObject: return valObject;
+         default: ;
+      }
+      return null();
+   }
+   */
+
+
+   bool Variant::isNumeric() const
+   {
+      if (type==typeInt || type==typeDouble || type==typeInt64)
+         return true;
+      if (type!=typeObject || valObject==0)
+         return false;
+
+      int t = valObject->__GetType();
+      return t==vtInt || t==vtFloat;
+   }
+
+   bool Variant::isBool() const
+   {
+      if (type==typeBool)
+         return true;
+      if (type!=typeObject || valObject==0)
+         return false;
+
+      return valObject->__GetType() == vtBool;
+   }
+
+
+   String Variant::getString() const { return String(valStringPtr, valStringLen); }
+   String Variant::asString() const
+   {
+      switch(type)
+      {
+         case typeInt: return String(valInt);
+         case typeDouble: return String(valDouble);
+         case typeBool: return String(valBool);
+         case typeString: return String(valStringPtr, valStringLen);
+         case typeInt64: return String(valInt64);
+         case typeObject: return valObject ? valObject->toString() : String();
+         default: ;
+      }
+      return String();
+   }
+   //Variant::operator String() const { return asString(); }
+
+
+   void Variant::mark(hx::MarkContext *__inCtx)
+   {
+      if (type==typeString)
+      {
+         HX_MARK_STRING(valStringPtr);
+      }
+      else if (type==typeObject)
+      {
+         HX_MARK_OBJECT(valObject);
+      }
+   }
+
+   template<typename T>
+   bool Variant::operator==(const T &inRHS) const
+   {
+      switch(type)
+      {
+         case typeInt: return valInt==(double)inRHS;
+         case typeDouble:return valDouble==(double)inRHS;
+         case typeBool: return valBool==(bool)inRHS;
+         case typeInt64: return valInt64==(cpp::Int64)inRHS;
+         case typeString: return getString()==String(inRHS);
+         case typeObject:
+               if (!valObject)
+                  return inRHS == null();
+               return valObject->__Compare( Dynamic(inRHS).mPtr )==0;
+      }
+      return false;
+   }
+
+
+   int Variant::Compare(hx::Object *inPtr) const
+   {
+      if (!inPtr)
+         return isNull() ? 0 : 1;
+
+      switch(type)
+      {
+         case typeInt:
+           {
+              double diff = valInt - inPtr->__ToDouble();
+              return diff<0 ? -1 : diff==0 ? 0 : 1;
+           }
+         case typeDouble:
+           {
+              double diff = valDouble - inPtr->__ToDouble();
+              return diff<0 ? -1 : diff==0 ? 0 : 1;
+           }
+         case typeInt64:
+           {
+              cpp::Int64 diff = valInt64 - inPtr->__ToInt64();
+              return diff<0 ? -1 : diff==0 ? 0 : 1;
+           }
+         case typeBool:
+            if (!inPtr) return 1;
+            return valBool==(bool)(inPtr->__ToInt()) ? 1 : 0;
+         case typeString:
+            if (!inPtr) return valStringPtr ? 1 : 0;
+            if (inPtr->__GetType()!=vtString)
+               return 1;
+            return String(valStringPtr, valStringLen)==inPtr->toString() ? 1 : 0;
+         case typeObject:
+            return valObject->__Compare( inPtr );
+         default: ;
+
+      }
+      return 0;
+   }
+   int Variant::Compare(const Dynamic &inD) const { return Compare(inD.mPtr); }
+   int Variant::Compare(const cpp::Variant &inVar) const
+   {
+      if (inVar.type==typeObject)
+         return Compare(inVar.valObject);
+
+      switch(type)
+      {
+         case typeInt:
+           {
+              double diff = valInt - inVar.asDouble();
+              return diff<0 ? -1 : diff==0 ? 0 : 1;
+           }
+         case typeDouble:
+           {
+              double diff = valDouble - inVar.asDouble();
+              return diff<0 ? -1 : diff==0 ? 0 : 1;
+           }
+         case typeInt64:
+           {
+              cpp::Int64 diff = valInt64 - inVar.asInt64();
+              return diff<0 ? -1 : diff==0 ? 0 : 1;
+           }
+         case typeBool:
+            return valBool==(bool)(inVar.asInt()) ? 1 : 0;
+         case typeString:
+            if (inVar.type!=typeString)
+               return 1;
+            return String(valStringPtr, valStringLen)==inVar.asString();
+         case typeObject:
+            if (!valObject)
+               return 1;
+            return - inVar.Compare(*this);
+      }
+
+      return 0;
+   }
+
+   String cpp::Variant::operator+(const String &s) const
+   {
+      return asString() + s;
+   }
+   template<typename T>
+   cpp::Variant Variant::operator + (const T &inRHS) const
+   {
+      if (isString() || ::cpp::isStringType(inRHS))
+         return asString() + String(inRHS);
+      return asDouble() + (double)inRHS;
+   }
+
+
+   #ifdef HXCPP_VISIT_ALLOCS
+   void Variant::visit(hx::VisitContext *__inCtx)
+   {
+      if (type==typeString)
+      {
+         HX_VISIT_STRING(valStringPtr);
+      }
+      else if (type==typeObject)
+      {
+         HX_VISIT_OBJECT(valObject);
+      }
+   }
+   #endif // HXCPP_VISIT_ALLOCS
+
+
+
+
+
+#define HX_VARIANT_OP_ISEQ(T) \
+inline bool operator == (const T &inLHS,const cpp::Variant &inRHS) { return inRHS==inLHS; } \
+inline bool operator != (const T &inLHS,const cpp::Variant &inRHS) { return inRHS!=inLHS; }
+
+
+#define HX_VARIANT_OP_ISEQ(T) \
+inline bool operator == (const T &inLHS,const cpp::Variant &inRHS) { return inRHS==inLHS; } \
+inline bool operator != (const T &inLHS,const cpp::Variant &inRHS) { return inRHS!=inLHS; }
+
+HX_VARIANT_OP_ISEQ(String)
+HX_VARIANT_OP_ISEQ(double)
+HX_VARIANT_OP_ISEQ(float)
+HX_VARIANT_OP_ISEQ(cpp::Int64)
+HX_VARIANT_OP_ISEQ(cpp::UInt64)
+HX_VARIANT_OP_ISEQ(int)
+HX_VARIANT_OP_ISEQ(unsigned int)
+HX_VARIANT_OP_ISEQ(short)
+HX_VARIANT_OP_ISEQ(unsigned short)
+HX_VARIANT_OP_ISEQ(signed char)
+HX_VARIANT_OP_ISEQ(unsigned char)
+HX_VARIANT_OP_ISEQ(bool)
+
+inline bool operator < (bool inLHS,const cpp::Variant &inRHS) { return false; }
+inline bool operator <= (bool inLHS,const cpp::Variant &inRHS) { return false; }
+inline bool operator >= (bool inLHS,const cpp::Variant &inRHS) { return false; }
+inline bool operator > (bool inLHS,const cpp::Variant &inRHS) { return false; }
+
+
+#define HX_COMPARE_VARIANT_OP( op ) \
+   inline bool operator op (double inLHS,const ::cpp::Variant &inRHS) \
+      { return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
+   inline bool operator op (float inLHS,const ::cpp::Variant &inRHS) \
+      { return inRHS.isNumeric() && ((double)inLHS op (double)inRHS); } \
+   inline bool operator op (cpp::Int64 inLHS,const ::cpp::Variant &inRHS) \
+      { return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
+   inline bool operator op (cpp::UInt64 inLHS,const ::cpp::Variant &inRHS) \
+      { return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
+   inline bool operator op (int inLHS,const ::cpp::Variant &inRHS) \
+      { return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
+   inline bool operator op (unsigned int inLHS,const ::cpp::Variant &inRHS) \
+      { return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
+   inline bool operator op (short inLHS,const ::cpp::Variant &inRHS) \
+      { return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
+   inline bool operator op (unsigned short inLHS,const ::cpp::Variant &inRHS) \
+      { return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
+   inline bool operator op (signed char inLHS,const ::cpp::Variant &inRHS) \
+      { return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
+   inline bool operator op (unsigned char inLHS,const ::cpp::Variant &inRHS) \
+      { return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
+   inline bool operator op (const null &,const ::cpp::Variant &inRHS) \
+      { return false; } \
+
+HX_COMPARE_VARIANT_OP( < )
+HX_COMPARE_VARIANT_OP( <= )
+HX_COMPARE_VARIANT_OP( >= )
+HX_COMPARE_VARIANT_OP( >  )
+
+
+
+
+
+
+} // close cpp
+namespace hx {
+   template<typename T>
+   bool ObjectPtr<T>::operator==(const cpp::Variant &inRHS) const {
+       return inRHS.Compare(mPtr)==0;
+   }
+   template<typename T>
+   bool ObjectPtr<T>::operator!=(const cpp::Variant &inRHS) const {
+       return inRHS.Compare(mPtr)!=0;
+   }
+
+} // close hx
+namespace cpp {
+
+#endif // not twice
+
+
+
+} // end namespace cpp
+
+
+
+
+#endif // CPP_VARIANT_TWICE_H
diff --git a/Sources/c_snikket/iinclude/cpp/VirtualArray.h b/Sources/c_snikket/iinclude/cpp/VirtualArray.h
new file mode 100644
index 0000000..a95f65f
--- /dev/null
+++ b/Sources/c_snikket/iinclude/cpp/VirtualArray.h
@@ -0,0 +1,724 @@
+namespace cpp
+{
+
+// This file is included twice - either side of the Array definition
+#ifndef HX_VARRAY_DEFINED
+#define HX_VARRAY_DEFINED
+
+
+class VirtualArray : public hx::ObjectPtr<VirtualArray_obj>
+{
+   typedef hx::ObjectPtr<VirtualArray_obj> super;
+public:
+   typedef Dynamic Elem;
+
+   inline VirtualArray() : super(0) { }
+   inline VirtualArray(VirtualArray_obj *inObj) : super(inObj) { }
+   inline VirtualArray(const null &inNull) : super(0) { }
+   inline VirtualArray(const VirtualArray &inOther) : super( inOther.mPtr ) {  }
+
+   // Build from foreign array
+   template<typename SOURCE_> inline VirtualArray( const Array<SOURCE_> &inRHS );
+
+
+   inline VirtualArray( const Dynamic &inRHS ) : super(0) { setDynamic(inRHS); }
+   inline VirtualArray( const cpp::ArrayBase &inRHS ) : super(0) { setDynamic(inRHS); }
+   inline VirtualArray(const ::cpp::Variant &inVariant) { setDynamic(inVariant.asObject()); }
+
+
+
+
+   inline VirtualArray &operator=(const null &inNull) { mPtr = 0; return *this; }
+   inline VirtualArray &operator=(Ptr inRHS) { mPtr = inRHS; return *this; }
+   inline VirtualArray &operator=(const VirtualArray &inRHS) { mPtr = inRHS.mPtr; return *this; }
+
+   inline void setDynamic( const Dynamic &inRHS );
+
+   template<typename T>
+   inline VirtualArray Add(const T &inVal);
+
+
+   inline bool operator==(const Dynamic &value) const { return value==*this; }
+   template<typename SOURCE_> inline bool operator==( const Array<SOURCE_> &inRHS );
+
+   inline bool operator!=(Dynamic value) const { return value!=*this; }
+   template<typename SOURCE_> inline bool operator!=( const Array<SOURCE_> &inRHS ) { return inRHS!=*this; }
+
+};
+
+
+
+
+
+
+class HXCPP_EXTERN_CLASS_ATTRIBUTES VirtualArray_obj : public hx::ArrayCommon
+{
+   typedef hx::ArrayStore ArrayStore;
+   typedef hx::ArrayBase ArrayBase;
+
+public:
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdVirtualArray };
+
+   typedef hx::Object super;
+   ArrayStore  store;
+   ArrayBase   *base;
+
+   VirtualArray_obj(ArrayBase *inBase=0, bool inFixed=false) : base(inBase)
+   {
+      mArrayConvertId = hx::aciVirtualArray;
+      store = inFixed && inBase ? hx::arrayFixed : base ? base->getStoreType() : hx::arrayEmpty;
+      #ifdef HXCPP_GC_GENERATIONAL
+      if (base)
+         HX_OBJ_WB_GET(this,base);
+      #endif
+   }
+
+   VirtualArray_obj(ArrayStore inStore)
+   {
+      mArrayConvertId = hx::aciVirtualArray;
+      store = inStore;
+   }
+
+   hx::Object *__GetRealObject() { return base?(hx::Object *)base:(hx::Object *)this; }
+
+   inline static VirtualArray __new(int inSize=0,int inReserve=0)
+   {
+      VirtualArray result = new VirtualArray_obj(hx::arrayEmpty);
+      if (inSize>0)
+         result->__SetSizeExact(inSize);
+      if (inReserve>0)
+         result->reserve(inReserve);
+      return result;
+   }
+
+   int __Compare(const hx::Object *inRHS) const;
+
+   inline int get_length() const
+   {
+      return base ? base->length : 0;
+   }
+
+   inline void checkBase() const
+   {
+      #ifdef HXCPP_CHECK_POINTER
+      if (store==hx::arrayNull)
+      {
+         hx::NullReference("Array", true);
+         // The handler might have fixed up the null value
+         if (store==hx::arrayNull) hx::NullReference("Array", false);
+      }
+      #endif
+   }
+
+   void EnsureStorage(const Dynamic &inValue)
+   {
+      if (!inValue.mPtr)
+      {
+         EnsureNullStorage();
+      }
+      else switch(inValue->__GetType())
+      {
+         case vtBool: EnsureBoolStorage(); break;
+         case vtInt: EnsureIntStorage(); break;
+         case vtFloat: EnsureFloatStorage(); break;
+         case vtString: EnsureStringStorage(); break;
+         case vtInt64: EnsureInt64Storage(); break;
+         default: EnsureObjectStorage();
+      }
+   }
+
+
+   void EnsureStorage(const cpp::Variant &inValue)
+   {
+      switch(inValue.type)
+      {
+         case Variant::typeObject:
+               if (!inValue.valObject)
+                  EnsureNullStorage();
+               else
+                  EnsureObjectStorage();
+               break;
+         case Variant::typeString: EnsureStringStorage(); break;
+         case Variant::typeDouble: EnsureFloatStorage(); break;
+         case Variant::typeInt: EnsureIntStorage(); break;
+         case Variant::typeBool: EnsureBoolStorage(); break;
+         case Variant::typeInt64: EnsureInt64Storage(); break;
+      }
+   }
+
+
+   void MakeIntArray();
+   void MakeInt64Array();
+   void MakeObjectArray();
+   void MakeFloatArray();
+   void MakeBoolArray();
+   void MakeStringArray();
+
+   void EnsureStorage(const VirtualArray &inValue) { EnsureObjectStorage(); }
+   void EnsureStorage(const unsigned char &inValue) { EnsureIntStorage(); }
+   void EnsureStorage(const bool &inValue) { EnsureBoolStorage(); }
+   void EnsureStorage(const String &inValue) { EnsureStringStorage(); }
+   void EnsureStorage(const double &inValue) { EnsureFloatStorage(); }
+   void EnsureStorage(const float &inValue) { EnsureFloatStorage(); }
+   void EnsureStorage(const int &inValue) { EnsureIntStorage(); }
+   void EnsureStorage(const cpp::Int64 &inValue) { EnsureInt64Storage(); }
+   void EnsureStorage(const cpp::UInt64 &inValue) { EnsureInt64Storage(); }
+   void EnsureStorage(const null &inValue) { EnsureNullStorage(); }
+   template<typename T>
+   void EnsureStorage(const T &inValue) { EnsureObjectStorage(); }
+
+   inline void EnsureBoolStorage()
+   {
+      switch(store)
+      {
+         case hx::arrayNull:
+         case hx::arrayObject:
+         case hx::arrayFixed:
+         case hx::arrayBool:
+            return;
+         case hx::arrayEmpty:
+            MakeBoolArray();
+            break;
+         case hx::arrayInt:
+         case hx::arrayInt64:
+         case hx::arrayFloat:
+         case hx::arrayString:
+            MakeObjectArray();
+            break;
+      }
+   }
+   inline void EnsureStringStorage()
+   {
+      switch(store)
+      {
+         case hx::arrayNull:
+         case hx::arrayObject:
+         case hx::arrayFixed:
+         case hx::arrayString:
+            return;
+         case hx::arrayEmpty:
+            MakeStringArray();
+            break;
+         case hx::arrayInt:
+         case hx::arrayInt64:
+         case hx::arrayFloat:
+         case hx::arrayBool:
+            MakeObjectArray();
+            break;
+      }
+   }
+   inline void EnsureFloatStorage()
+   {
+      switch(store)
+      {
+         case hx::arrayNull:
+         case hx::arrayFloat:
+         case hx::arrayObject:
+         case hx::arrayFixed:
+            return;
+         case hx::arrayInt:
+         case hx::arrayInt64:
+         case hx::arrayEmpty:
+            MakeFloatArray();
+            break;
+         case hx::arrayBool:
+         case hx::arrayString:
+            MakeObjectArray();
+            break;
+      }
+   }
+
+   inline void EnsureIntStorage()
+   {
+      switch(store)
+      {
+         case hx::arrayNull:
+         case hx::arrayInt:
+         case hx::arrayInt64:
+         case hx::arrayFloat:
+         case hx::arrayObject:
+         case hx::arrayFixed:
+            return;
+         case hx::arrayEmpty:
+            MakeIntArray();
+            break;
+         case hx::arrayBool:
+         case hx::arrayString:
+            MakeObjectArray();
+            break;
+      }
+   }
+
+   inline void EnsureInt64Storage()
+   {
+      switch(store)
+      {
+         case hx::arrayNull:
+         case hx::arrayInt64:
+         case hx::arrayFloat:
+         case hx::arrayObject:
+         case hx::arrayFixed:
+            return;
+         case hx::arrayInt:
+         case hx::arrayEmpty:
+            MakeInt64Array();
+            break;
+         case hx::arrayBool:
+         case hx::arrayString:
+            MakeObjectArray();
+            break;
+      }
+   }
+
+   inline void EnsureObjectStorage()
+   {
+      switch(store)
+      {
+         case hx::arrayNull:
+         case hx::arrayObject:
+         case hx::arrayFixed:
+            return;
+         case hx::arrayEmpty:
+         case hx::arrayInt:
+         case hx::arrayInt64:
+         case hx::arrayFloat:
+         case hx::arrayBool:
+         case hx::arrayString:
+            MakeObjectArray();
+            break;
+      }
+   }
+   inline void EnsureNullStorage()
+   {
+      switch(store)
+      {
+         case hx::arrayNull:
+         case hx::arrayObject:
+         case hx::arrayFixed:
+         case hx::arrayString:
+            return;
+         case hx::arrayEmpty:
+         case hx::arrayInt:
+         case hx::arrayInt64:
+         case hx::arrayFloat:
+         case hx::arrayBool:
+            MakeObjectArray();
+            break;
+      }
+   }
+
+   template<typename F> void fixType();
+   template<typename F> F castArray();
+
+   void EnsureBase();
+   void CreateEmptyArray(int inLen);
+
+   void EnsureArrayStorage(ArrayStore inValue);
+   void EnsureArrayStorage(VirtualArray inValue);
+
+   void __Mark(hx::MarkContext *__inCtx)
+   {
+      HX_MARK_OBJECT(base);
+   }
+   #ifdef HXCPP_VISIT_ALLOCS
+   void __Visit(hx::VisitContext *__inCtx)
+   {
+      if (base)
+        __inCtx->visitObject( (hx::Object **)&base);
+   }
+   #endif
+
+
+   // Used by cpp.ArrayBase
+   inline int getElementSize() const { return base ? base->GetElementSize() : 0; }
+   inline int getByteCount() const { return base ? base->getByteCount() : 0; }
+   inline char * getBase() const { return base ? base->GetBase() : 0; }
+   hx::Val __SetField(const String &inString,const hx::Val &inValue ,hx::PropertyAccess inCallProp) { return null(); }
+
+   static hx::Class &__SGetClass() { return hx::ArrayBase::__mClass; }
+   hx::Class __GetClass() const;
+   String toString();
+   String __ToString() const { return const_cast<VirtualArray_obj *>(this)->toString(); }
+
+   void setData(void *inData, int inElements) { EnsureBase(); base->setData(inData, inElements); }
+   void setUnmanagedData(void *inData, int inElements) { EnsureBase(); base->setUnmanagedData(inData, inElements); }
+
+   int __GetType() const { return vtArray; }
+
+   inline size_t size() const { checkBase(); return store==hx::arrayEmpty ? 0 : base->length; }
+   inline int __length() const { checkBase(); return store==hx::arrayEmpty ? 0 : (int)base->length; }
+
+   String ItemString(int inI) { checkBase(); return store==hx::arrayEmpty ? null() : base->ItemString(inI); }
+
+   const char * __CStr() const { return store==hx::arrayEmpty ? "[]" : store==hx::arrayNull ? "null" : base->__CStr(); }
+   inline const char *GetBase() const { return base ? base->GetBase() : 0; }
+   inline char *GetBase() { return base ? base->GetBase() : 0; }
+
+   int GetElementSize() const { checkBase(); return store==hx::arrayEmpty ? 0 : base->GetElementSize(); }
+
+   inline void reserve(int inSize) const
+   {
+      if (base)
+         base->reserve(inSize);
+   }
+
+   inline int capacity()
+   {
+      if (base)
+         return base->capacity();
+      return 0;
+   }
+
+   void resize(int inLen)
+   {
+      if (!base)
+         CreateEmptyArray(inLen);
+      else
+         base->resize(inLen);
+   }
+   void __SetSize(int inLen) { resize(inLen); }
+
+   VirtualArray __SetSizeExact(int inLen=0)
+   {
+      if (!base && inLen)
+         CreateEmptyArray(inLen);
+      else if (base)
+         base->__SetSizeExact(inLen);
+      return this;
+   }
+
+   void safeSort(Dynamic sorter, bool isString) { checkBase(); if (store!=hx::arrayEmpty) base->safeSort(sorter,isString); }
+
+   inline void __unsafeStringReference(String inString) { if (base) base->__unsafeStringReference(inString); }
+
+
+   Dynamic __GetItem(int inIndex) const;
+   Dynamic __SetItem(int inIndex,Dynamic inValue);
+   hx::Val __Field(const String &inString, hx::PropertyAccess inCallProp);
+
+   template<typename T>
+   inline const T &set(int inIdx, const T &inVal)
+   {
+      if (store!=hx::arrayFixed)
+      {
+         if (inIdx>(store==hx::arrayEmpty ? 0 : (int)base->length) )
+            EnsureObjectStorage();
+         else
+            EnsureStorage(inVal);
+      }
+      base->set(inIdx, inVal);
+      return inVal;
+   }
+
+
+   template<typename T>
+   inline int push(const T &inVal)
+   {
+      if (store!=hx::arrayFixed) EnsureStorage(inVal);
+      return base->__push(Dynamic(inVal));
+   }
+
+
+   template<typename T>
+   inline VirtualArray_obj *Add(const T &inVal)
+   {
+      if (store!=hx::arrayFixed) EnsureStorage(inVal);
+      base->__push(Dynamic(inVal));
+      return this;
+   }
+
+   inline Dynamic pop() { checkBase(); return store==hx::arrayEmpty ? null() : base->__pop(); }
+
+   inline bool contains(Dynamic inValue)
+   {
+      checkBase();
+      if (store==hx::arrayEmpty)
+         return false;
+      EnsureStorage(inValue);
+      return base->__contains(inValue);
+   }
+
+   inline bool remove(Dynamic inValue)
+   {
+      checkBase();
+      if (store==hx::arrayEmpty)
+         return false;
+      EnsureStorage(inValue);
+      return base->__remove(inValue);
+   }
+
+   inline bool removeAt(int inIndex) { checkBase(); return (store!=hx::arrayEmpty) && base->__removeAt(inIndex); }
+
+   int indexOf(Dynamic inValue, Dynamic fromIndex = null())
+   {
+      checkBase();
+      if (store==hx::arrayEmpty)
+         return -1;
+      EnsureStorage(inValue);
+      return (int)base->__indexOf(inValue,fromIndex);
+   }
+   int lastIndexOf(Dynamic inValue, Dynamic fromIndex = null())
+   {
+      checkBase();
+      if (store==hx::arrayEmpty)
+         return -1;
+      EnsureStorage(inValue);
+      return (int)base->__lastIndexOf(inValue,fromIndex);
+   }
+
+   Dynamic shift() { checkBase(); return store==hx::arrayEmpty ? null() : base->__shift(); }
+
+   VirtualArray concat( VirtualArray inTail )
+   {
+      inTail->checkBase();
+      EnsureArrayStorage(inTail);
+      if (inTail->__length()<1)
+         return copy();
+      return new VirtualArray_obj( base->__concat(inTail), store==hx::arrayFixed );
+   }
+   VirtualArray copy( )
+   {
+      checkBase();
+      if (store==hx::arrayEmpty)
+         return new VirtualArray_obj(hx::arrayEmpty);
+
+      return new VirtualArray_obj(base->__copy(), store==hx::arrayFixed);
+   }
+   VirtualArray slice(int inPos, Dynamic end = null())
+   {
+      checkBase();
+      if (store==hx::arrayEmpty)
+         return new VirtualArray_obj(hx::arrayEmpty);
+      return new VirtualArray_obj(base->__slice(inPos,end), store==hx::arrayFixed);
+   }
+   VirtualArray splice(int inPos, int len);
+   VirtualArray map(Dynamic inFunc);
+   VirtualArray filter(Dynamic inFunc);
+
+   template<typename T>
+   inline VirtualArray init(int inIndex, const T &inVal)
+   {
+      if (store!=hx::arrayFixed) EnsureStorage(inVal);
+      __SetItem(inIndex,inVal);
+      return this;
+   } 
+
+   inline Dynamic __unsafe_set(int inIndex, const Dynamic &val)  { return __SetItem(inIndex,val); } 
+   inline Dynamic __unsafe_get(int inIndex)  { return __GetItem(inIndex); } 
+
+
+   template<typename T>
+   inline void insert(int inPos, const T &inValue)
+   {
+      if (store!=hx::arrayFixed)
+      {
+         if (inPos>(store==hx::arrayEmpty ? 0 : (int)base->length) )
+            EnsureObjectStorage();
+         else
+            EnsureStorage(inValue);
+      }
+
+      base->__insert(inPos,inValue);
+   }
+
+   template<typename T>
+   inline void unshift(const T& inValue)
+   {
+      if (store!=hx::arrayFixed) EnsureStorage(inValue);
+      base->__unshift(inValue);
+   }
+
+   inline void reverse() { checkBase(); if (store!=hx::arrayEmpty) base->__reverse(); }
+
+   inline void qsort(Dynamic inSorter) { checkBase(); if (base) base->__qsort(inSorter); }
+
+   inline void sort(Dynamic inSorter) { checkBase(); if (base) base->__sort(inSorter); }
+
+   Dynamic iterator() { checkBase(); return  !base ? getEmptyIterator() :  base->__iterator(); }
+   static Dynamic getEmptyIterator();
+
+   Dynamic keyValueIterator() { checkBase(); return  !base ? getEmptyIterator() :  base->__keyValueIterator(); }
+
+   bool IsByteArray() const { checkBase(); return store!=hx::arrayEmpty && base->IsByteArray(); }
+
+   void zero(Dynamic inFirst, Dynamic inCount) { checkBase(); if (store!=hx::arrayEmpty) base->zero(inFirst,inCount); }
+
+   inline int memcmp(VirtualArray inOther)
+   {
+      checkBase();
+      if (store==hx::arrayEmpty)
+         return inOther->__length() == 0;
+      return base->__memcmp(inOther);
+   }
+   inline void blit(int inDestElement,  cpp::VirtualArray inSourceArray, int inSourceElement, int inElementCount)
+   {
+      inSourceArray->checkBase();
+      EnsureArrayStorage(inSourceArray);
+      if (base)
+         base->__blit(inDestElement, inSourceArray, inSourceElement, inElementCount);
+   }
+
+   String join(String inSeparator) { checkBase(); if (!base) return HX_CSTRING(""); return base->__join(inSeparator); }
+
+
+   Dynamic __get(int inIndex) const { checkBase(); if (store==hx::arrayEmpty) return null(); return base->__GetItem(inIndex); }
+
+   Dynamic concat_dyn();
+   Dynamic copy_dyn();
+   Dynamic insert_dyn();
+   Dynamic iterator_dyn();
+   Dynamic keyValueIterator_dyn();
+   Dynamic join_dyn();
+   Dynamic pop_dyn();
+   Dynamic push_dyn();
+   Dynamic contains_dyn();
+   Dynamic remove_dyn();
+   Dynamic removeAt_dyn();
+   Dynamic indexOf_dyn();
+   Dynamic lastIndexOf_dyn();
+   Dynamic reverse_dyn();
+   Dynamic shift_dyn();
+   Dynamic slice_dyn();
+   Dynamic splice_dyn();
+   Dynamic sort_dyn();
+   Dynamic toString_dyn();
+   Dynamic unshift_dyn();
+   Dynamic map_dyn();
+   Dynamic filter_dyn();
+   Dynamic __SetSize_dyn();
+   Dynamic __SetSizeExact_dyn();
+   Dynamic __unsafe_get_dyn();
+   Dynamic __unsafe_set_dyn();
+   Dynamic blit_dyn();
+   Dynamic zero_dyn();
+   Dynamic memcmp_dyn();
+   Dynamic resize_dyn();
+};
+
+
+//typedef hx::ObjectPtr< VirtualArray_obj > VirtualArray;
+
+
+
+#else // !HX_VARRAY_DEFINED
+
+
+// Build dynamic array from foreign array
+template<typename SOURCE_>
+VirtualArray::VirtualArray( const Array<SOURCE_> &inRHS )
+   : super( !inRHS.mPtr ? 0 : new VirtualArray_obj( inRHS.mPtr, true) )
+{
+}
+
+
+template<typename T>
+inline VirtualArray VirtualArray::Add(const T &inVal)
+{
+   mPtr->push(inVal);
+   return *this;
+}
+
+
+inline void VirtualArray::setDynamic( const Dynamic &inRHS )
+{
+   hx::Object *ptr = inRHS.GetPtr(); 
+   if (ptr)
+   {
+      if (ptr->__GetClass().mPtr == super::__SGetClass().mPtr )
+      {
+         cpp::VirtualArray_obj *varray = dynamic_cast<cpp::VirtualArray_obj *>(ptr);
+         if (varray)
+            mPtr = varray;
+         else
+            mPtr = new VirtualArray_obj(dynamic_cast<cpp::ArrayBase_obj *>(ptr), true);
+      }
+   }
+}
+
+
+
+template<typename F>
+void VirtualArray_obj::fixType()
+{
+   if (store==hx::arrayFixed)
+      return;
+
+   store = hx::arrayFixed;
+   if (base && base->length>0)
+   {
+      Array<F> fixedArray = Dynamic(base);
+      base = fixedArray.mPtr;
+   }
+   else
+   {
+      base = new Array_obj<F>(0,0);
+   }
+   #ifdef HXCPP_GC_GENERATIONAL
+   if (base)
+      HX_OBJ_WB_GET(this,base);
+   #endif
+}
+
+template<typename ARRAY >
+ARRAY VirtualArray_obj::castArray()
+{
+   if (store==hx::arrayFixed)
+      return Dynamic(base);
+
+   store = hx::arrayFixed;
+   if (base && base->length>0)
+   {
+      ARRAY fixedArray = Dynamic(base);
+      base = fixedArray.mPtr;
+      #ifdef HXCPP_GC_GENERATIONAL
+      if (base)
+         HX_OBJ_WB_GET(this,base);
+      #endif
+      return fixedArray;
+   }
+   else
+   {
+      ARRAY fixedArray(0,0);
+      base = fixedArray.mPtr;
+      #ifdef HXCPP_GC_GENERATIONAL
+      if (base)
+         HX_OBJ_WB_GET(this,base);
+      #endif
+      return fixedArray;
+   }
+}
+
+template<typename SOURCE_>
+inline bool VirtualArray::operator==( const Array<SOURCE_> &inRHS )
+{
+   if (!mPtr)
+      return inRHS.mPtr;
+   return mPtr->castArray< Array<SOURCE_> >() == inRHS;
+}
+
+} // end namespace cpp
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_reslove_virtual_array(cpp::VirtualArray inArray);
+
+
+
+namespace hx
+{
+// For type inference when marking
+template<> inline void MarkMember(cpp::VirtualArray &outT,hx::MarkContext *__inCtx)
+  { HX_MARK_OBJECT(outT.mPtr); }
+
+#ifdef HXCPP_VISIT_ALLOCS
+template<> inline void VisitMember(cpp::VirtualArray &outT,hx::VisitContext *__inCtx)
+{
+   HX_VISIT_OBJECT(outT.mPtr);
+}
+#endif
+
+} // end namespace hx
+
+namespace cpp
+{
+#endif // HX_VARRAY_DEFINED
+}
+
diff --git a/Sources/c_snikket/iinclude/datetime/_DateTime/DateTime_Impl_.h b/Sources/c_snikket/iinclude/datetime/_DateTime/DateTime_Impl_.h
new file mode 100644
index 0000000..94bc87f
--- /dev/null
+++ b/Sources/c_snikket/iinclude/datetime/_DateTime/DateTime_Impl_.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_datetime__DateTime_DateTime_Impl_
+#define INCLUDED_datetime__DateTime_DateTime_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(datetime,_DateTime,DateTime_Impl_)
+
+namespace datetime{
+namespace _DateTime{
+
+
+class HXCPP_CLASS_ATTRIBUTES DateTime_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef DateTime_Impl__obj OBJ_;
+		DateTime_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x3ae93836 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="datetime._DateTime.DateTime_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"datetime._DateTime.DateTime_Impl_"); }
+
+		inline static ::hx::ObjectPtr< DateTime_Impl__obj > __new() {
+			::hx::ObjectPtr< DateTime_Impl__obj > __this = new DateTime_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< DateTime_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			DateTime_Impl__obj *__this = (DateTime_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(DateTime_Impl__obj), false, "datetime._DateTime.DateTime_Impl_"));
+			*(void **)__this = DateTime_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~DateTime_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DateTime_Impl_",5b,c4,e6,72); }
+
+		static int getYear(Float this1);
+		static ::Dynamic getYear_dyn();
+
+		static Float yearStart(Float this1);
+		static ::Dynamic yearStart_dyn();
+
+		static bool isLeapYear(Float this1);
+		static ::Dynamic isLeapYear_dyn();
+
+};
+
+} // end namespace datetime
+} // end namespace _DateTime
+
+#endif /* INCLUDED_datetime__DateTime_DateTime_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/datetime/_DateTimeInterval/DateTimeInterval_Impl_.h b/Sources/c_snikket/iinclude/datetime/_DateTimeInterval/DateTimeInterval_Impl_.h
new file mode 100644
index 0000000..2d7ed1a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/datetime/_DateTimeInterval/DateTimeInterval_Impl_.h
@@ -0,0 +1,63 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_datetime__DateTimeInterval_DateTimeInterval_Impl_
+#define INCLUDED_datetime__DateTimeInterval_DateTimeInterval_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(datetime,_DateTimeInterval,DateTimeInterval_Impl_)
+HX_DECLARE_CLASS2(datetime,cores,DateTimeIntervalCore)
+
+namespace datetime{
+namespace _DateTimeInterval{
+
+
+class HXCPP_CLASS_ATTRIBUTES DateTimeInterval_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef DateTimeInterval_Impl__obj OBJ_;
+		DateTimeInterval_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x35e51cc0 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="datetime._DateTimeInterval.DateTimeInterval_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"datetime._DateTimeInterval.DateTimeInterval_Impl_"); }
+
+		inline static ::hx::ObjectPtr< DateTimeInterval_Impl__obj > __new() {
+			::hx::ObjectPtr< DateTimeInterval_Impl__obj > __this = new DateTimeInterval_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< DateTimeInterval_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			DateTimeInterval_Impl__obj *__this = (DateTimeInterval_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(DateTimeInterval_Impl__obj), false, "datetime._DateTimeInterval.DateTimeInterval_Impl_"));
+			*(void **)__this = DateTimeInterval_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~DateTimeInterval_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DateTimeInterval_Impl_",80,46,d9,2e); }
+
+		static  ::datetime::cores::DateTimeIntervalCore create(Float begin,Float end);
+		static ::Dynamic create_dyn();
+
+};
+
+} // end namespace datetime
+} // end namespace _DateTimeInterval
+
+#endif /* INCLUDED_datetime__DateTimeInterval_DateTimeInterval_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/datetime/cores/DateTimeIntervalCore.h b/Sources/c_snikket/iinclude/datetime/cores/DateTimeIntervalCore.h
new file mode 100644
index 0000000..8cfdba1
--- /dev/null
+++ b/Sources/c_snikket/iinclude/datetime/cores/DateTimeIntervalCore.h
@@ -0,0 +1,92 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_datetime_cores_DateTimeIntervalCore
+#define INCLUDED_datetime_cores_DateTimeIntervalCore
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(datetime,cores,DateTimeIntervalCore)
+
+namespace datetime{
+namespace cores{
+
+
+class HXCPP_CLASS_ATTRIBUTES DateTimeIntervalCore_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef DateTimeIntervalCore_obj OBJ_;
+		DateTimeIntervalCore_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2dc1c9d4 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="datetime.cores.DateTimeIntervalCore")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"datetime.cores.DateTimeIntervalCore"); }
+		static ::hx::ObjectPtr< DateTimeIntervalCore_obj > __new();
+		static ::hx::ObjectPtr< DateTimeIntervalCore_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~DateTimeIntervalCore_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DateTimeIntervalCore",5f,bb,ed,3d); }
+
+		bool negative;
+		Float begin;
+		Float end;
+		int years;
+		int months;
+		int days;
+		int hours;
+		int minutes;
+		int seconds;
+		int getYears();
+		::Dynamic getYears_dyn();
+
+		int getMonths();
+		::Dynamic getMonths_dyn();
+
+		int getTotalMonths();
+		::Dynamic getTotalMonths_dyn();
+
+		int getDays();
+		::Dynamic getDays_dyn();
+
+		int getTotalDays();
+		::Dynamic getTotalDays_dyn();
+
+		int getHours();
+		::Dynamic getHours_dyn();
+
+		int getTotalHours();
+		::Dynamic getTotalHours_dyn();
+
+		int getMinutes();
+		::Dynamic getMinutes_dyn();
+
+		int getTotalMinutes();
+		::Dynamic getTotalMinutes_dyn();
+
+		int getSeconds();
+		::Dynamic getSeconds_dyn();
+
+		Float getTotalSeconds();
+		::Dynamic getTotalSeconds_dyn();
+
+};
+
+} // end namespace datetime
+} // end namespace cores
+
+#endif /* INCLUDED_datetime_cores_DateTimeIntervalCore */ 
diff --git a/Sources/c_snikket/iinclude/datetime/utils/DateTimeIntervalUtils.h b/Sources/c_snikket/iinclude/datetime/utils/DateTimeIntervalUtils.h
new file mode 100644
index 0000000..f6bc00b
--- /dev/null
+++ b/Sources/c_snikket/iinclude/datetime/utils/DateTimeIntervalUtils.h
@@ -0,0 +1,63 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_datetime_utils_DateTimeIntervalUtils
+#define INCLUDED_datetime_utils_DateTimeIntervalUtils
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(datetime,cores,DateTimeIntervalCore)
+HX_DECLARE_CLASS2(datetime,utils,DateTimeIntervalUtils)
+
+namespace datetime{
+namespace utils{
+
+
+class HXCPP_CLASS_ATTRIBUTES DateTimeIntervalUtils_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef DateTimeIntervalUtils_obj OBJ_;
+		DateTimeIntervalUtils_obj();
+
+	public:
+		enum { _hx_ClassId = 0x144eafbf };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="datetime.utils.DateTimeIntervalUtils")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"datetime.utils.DateTimeIntervalUtils"); }
+
+		inline static ::hx::ObjectPtr< DateTimeIntervalUtils_obj > __new() {
+			::hx::ObjectPtr< DateTimeIntervalUtils_obj > __this = new DateTimeIntervalUtils_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< DateTimeIntervalUtils_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			DateTimeIntervalUtils_obj *__this = (DateTimeIntervalUtils_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(DateTimeIntervalUtils_obj), false, "datetime.utils.DateTimeIntervalUtils"));
+			*(void **)__this = DateTimeIntervalUtils_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~DateTimeIntervalUtils_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DateTimeIntervalUtils",31,ec,93,52); }
+
+		static ::String strftime( ::datetime::cores::DateTimeIntervalCore dti,::String format);
+		static ::Dynamic strftime_dyn();
+
+};
+
+} // end namespace datetime
+} // end namespace utils
+
+#endif /* INCLUDED_datetime_utils_DateTimeIntervalUtils */ 
diff --git a/Sources/c_snikket/iinclude/datetime/utils/DateTimeMonthUtils.h b/Sources/c_snikket/iinclude/datetime/utils/DateTimeMonthUtils.h
new file mode 100644
index 0000000..ab9584a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/datetime/utils/DateTimeMonthUtils.h
@@ -0,0 +1,71 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_datetime_utils_DateTimeMonthUtils
+#define INCLUDED_datetime_utils_DateTimeMonthUtils
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(datetime,utils,DateTimeMonthUtils)
+
+namespace datetime{
+namespace utils{
+
+
+class HXCPP_CLASS_ATTRIBUTES DateTimeMonthUtils_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef DateTimeMonthUtils_obj OBJ_;
+		DateTimeMonthUtils_obj();
+
+	public:
+		enum { _hx_ClassId = 0x250427de };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="datetime.utils.DateTimeMonthUtils")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"datetime.utils.DateTimeMonthUtils"); }
+
+		inline static ::hx::ObjectPtr< DateTimeMonthUtils_obj > __new() {
+			::hx::ObjectPtr< DateTimeMonthUtils_obj > __this = new DateTimeMonthUtils_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< DateTimeMonthUtils_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			DateTimeMonthUtils_obj *__this = (DateTimeMonthUtils_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(DateTimeMonthUtils_obj), false, "datetime.utils.DateTimeMonthUtils"));
+			*(void **)__this = DateTimeMonthUtils_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~DateTimeMonthUtils_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DateTimeMonthUtils",2c,90,be,68); }
+
+		static int days(int month,::hx::Null< bool >  isLeapYear);
+		static ::Dynamic days_dyn();
+
+		static int getMonth(int days,::hx::Null< bool >  isLeapYear);
+		static ::Dynamic getMonth_dyn();
+
+		static int getMonthDay(int days,::hx::Null< bool >  isLeapYear);
+		static ::Dynamic getMonthDay_dyn();
+
+		static int toSeconds(int month,::hx::Null< bool >  isLeapYear);
+		static ::Dynamic toSeconds_dyn();
+
+};
+
+} // end namespace datetime
+} // end namespace utils
+
+#endif /* INCLUDED_datetime_utils_DateTimeMonthUtils */ 
diff --git a/Sources/c_snikket/iinclude/datetime/utils/DateTimeUtils.h b/Sources/c_snikket/iinclude/datetime/utils/DateTimeUtils.h
new file mode 100644
index 0000000..b774eb8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/datetime/utils/DateTimeUtils.h
@@ -0,0 +1,71 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_datetime_utils_DateTimeUtils
+#define INCLUDED_datetime_utils_DateTimeUtils
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(datetime,utils,DateTimeUtils)
+
+namespace datetime{
+namespace utils{
+
+
+class HXCPP_CLASS_ATTRIBUTES DateTimeUtils_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef DateTimeUtils_obj OBJ_;
+		DateTimeUtils_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4dd3c90c };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="datetime.utils.DateTimeUtils")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"datetime.utils.DateTimeUtils"); }
+
+		inline static ::hx::ObjectPtr< DateTimeUtils_obj > __new() {
+			::hx::ObjectPtr< DateTimeUtils_obj > __this = new DateTimeUtils_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< DateTimeUtils_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			DateTimeUtils_obj *__this = (DateTimeUtils_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(DateTimeUtils_obj), false, "datetime.utils.DateTimeUtils"));
+			*(void **)__this = DateTimeUtils_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~DateTimeUtils_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DateTimeUtils",b6,22,76,b4); }
+
+		static Float fromString(::String str);
+		static ::Dynamic fromString_dyn();
+
+		static Float parse(::String str);
+		static ::Dynamic parse_dyn();
+
+		static Float fromIsoString(::String str);
+		static ::Dynamic fromIsoString_dyn();
+
+		static Float yearToStamp(int year);
+		static ::Dynamic yearToStamp_dyn();
+
+};
+
+} // end namespace datetime
+} // end namespace utils
+
+#endif /* INCLUDED_datetime_utils_DateTimeUtils */ 
diff --git a/Sources/c_snikket/iinclude/haxe/EntryPoint.h b/Sources/c_snikket/iinclude/haxe/EntryPoint.h
new file mode 100644
index 0000000..170f0e7
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/EntryPoint.h
@@ -0,0 +1,60 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_EntryPoint
+#define INCLUDED_haxe_EntryPoint
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,EntryPoint)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES EntryPoint_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef EntryPoint_obj OBJ_;
+		EntryPoint_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7dc0c864 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.EntryPoint")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"haxe.EntryPoint"); }
+
+		inline static ::hx::ObjectPtr< EntryPoint_obj > __new() {
+			::hx::ObjectPtr< EntryPoint_obj > __this = new EntryPoint_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< EntryPoint_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			EntryPoint_obj *__this = (EntryPoint_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(EntryPoint_obj), false, "haxe.EntryPoint"));
+			*(void **)__this = EntryPoint_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~EntryPoint_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("EntryPoint",9e,d2,23,a2); }
+
+		static void run();
+		static ::Dynamic run_dyn();
+
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_EntryPoint */ 
diff --git a/Sources/c_snikket/iinclude/haxe/Exception.h b/Sources/c_snikket/iinclude/haxe/Exception.h
new file mode 100644
index 0000000..5e7cabd
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/Exception.h
@@ -0,0 +1,65 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_Exception
+#define INCLUDED_haxe_Exception
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,Exception)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES Exception_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Exception_obj OBJ_;
+		Exception_obj();
+
+	public:
+		enum { _hx_ClassId = 0x677ddc49 };
+
+		void __construct(::String message, ::haxe::Exception previous, ::Dynamic native);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.Exception")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.Exception"); }
+		static ::hx::ObjectPtr< Exception_obj > __new(::String message, ::haxe::Exception previous, ::Dynamic native);
+		static ::hx::ObjectPtr< Exception_obj > __alloc(::hx::Ctx *_hx_ctx,::String message, ::haxe::Exception previous, ::Dynamic native);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Exception_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Exception",2f,f0,6c,eb); }
+
+		static  ::haxe::Exception caught( ::Dynamic value);
+		static ::Dynamic caught_dyn();
+
+		::String _hx___exceptionMessage;
+		::Array< ::String > _hx___nativeStack;
+		int _hx___skipStack;
+		 ::Dynamic _hx___nativeException;
+		 ::haxe::Exception _hx___previousException;
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+		::String get_message();
+		::Dynamic get_message_dyn();
+
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_Exception */ 
diff --git a/Sources/c_snikket/iinclude/haxe/IMap.h b/Sources/c_snikket/iinclude/haxe/IMap.h
new file mode 100644
index 0000000..b3e5b1a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/IMap.h
@@ -0,0 +1,31 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_IMap
+#define INCLUDED_haxe_IMap
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES IMap_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		 ::Dynamic (::hx::Object :: *_hx_get)( ::Dynamic k); 
+		static inline  ::Dynamic get( ::Dynamic _hx_, ::Dynamic k) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::haxe::IMap_obj *>(_hx_.mPtr->_hx_getInterface(0x09c2bd39)))->_hx_get)(k);
+		}
+		 ::Dynamic (::hx::Object :: *_hx_keys)(); 
+		static inline  ::Dynamic keys( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::haxe::IMap_obj *>(_hx_.mPtr->_hx_getInterface(0x09c2bd39)))->_hx_keys)();
+		}
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_IMap */ 
diff --git a/Sources/c_snikket/iinclude/haxe/Log.h b/Sources/c_snikket/iinclude/haxe/Log.h
new file mode 100644
index 0000000..86c3163
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/Log.h
@@ -0,0 +1,62 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_Log
+#define INCLUDED_haxe_Log
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,Log)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES Log_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Log_obj OBJ_;
+		Log_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3c235b1a };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.Log")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"haxe.Log"); }
+
+		inline static ::hx::ObjectPtr< Log_obj > __new() {
+			::hx::ObjectPtr< Log_obj > __this = new Log_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Log_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Log_obj *__this = (Log_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Log_obj), false, "haxe.Log"));
+			*(void **)__this = Log_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Log_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Log",64,0c,3a,00); }
+
+		static void __boot();
+		static ::Dynamic trace;
+		static inline ::Dynamic &trace_dyn() {return trace; }
+
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_Log */ 
diff --git a/Sources/c_snikket/iinclude/haxe/MainEvent.h b/Sources/c_snikket/iinclude/haxe/MainEvent.h
new file mode 100644
index 0000000..472de6e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/MainEvent.h
@@ -0,0 +1,57 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_MainEvent
+#define INCLUDED_haxe_MainEvent
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,MainEvent)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES MainEvent_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef MainEvent_obj OBJ_;
+		MainEvent_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0b5efb53 };
+
+		void __construct( ::Dynamic f,int p);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.MainEvent")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.MainEvent"); }
+		static ::hx::ObjectPtr< MainEvent_obj > __new( ::Dynamic f,int p);
+		static ::hx::ObjectPtr< MainEvent_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic f,int p);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~MainEvent_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("MainEvent",01,71,3b,31); }
+
+		 ::Dynamic f;
+		Dynamic f_dyn() { return f;}
+		 ::haxe::MainEvent prev;
+		 ::haxe::MainEvent next;
+		bool isBlocking;
+		Float nextRun;
+		int priority;
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_MainEvent */ 
diff --git a/Sources/c_snikket/iinclude/haxe/MainLoop.h b/Sources/c_snikket/iinclude/haxe/MainLoop.h
new file mode 100644
index 0000000..d8ad31a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/MainLoop.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_MainLoop
+#define INCLUDED_haxe_MainLoop
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,MainEvent)
+HX_DECLARE_CLASS1(haxe,MainLoop)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES MainLoop_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef MainLoop_obj OBJ_;
+		MainLoop_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0c7b74e7 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.MainLoop")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"haxe.MainLoop"); }
+
+		inline static ::hx::ObjectPtr< MainLoop_obj > __new() {
+			::hx::ObjectPtr< MainLoop_obj > __this = new MainLoop_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< MainLoop_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			MainLoop_obj *__this = (MainLoop_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(MainLoop_obj), false, "haxe.MainLoop"));
+			*(void **)__this = MainLoop_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~MainLoop_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("MainLoop",5d,d7,eb,79); }
+
+		static  ::haxe::MainEvent pending;
+		static bool hasEvents();
+		static ::Dynamic hasEvents_dyn();
+
+		static void sortEvents();
+		static ::Dynamic sortEvents_dyn();
+
+		static Float tick();
+		static ::Dynamic tick_dyn();
+
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_MainLoop */ 
diff --git a/Sources/c_snikket/iinclude/haxe/NativeStackTrace.h b/Sources/c_snikket/iinclude/haxe/NativeStackTrace.h
new file mode 100644
index 0000000..dc1054c
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/NativeStackTrace.h
@@ -0,0 +1,66 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_NativeStackTrace
+#define INCLUDED_haxe_NativeStackTrace
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,NativeStackTrace)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES NativeStackTrace_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef NativeStackTrace_obj OBJ_;
+		NativeStackTrace_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3984963e };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.NativeStackTrace")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"haxe.NativeStackTrace"); }
+
+		inline static ::hx::ObjectPtr< NativeStackTrace_obj > __new() {
+			::hx::ObjectPtr< NativeStackTrace_obj > __this = new NativeStackTrace_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< NativeStackTrace_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			NativeStackTrace_obj *__this = (NativeStackTrace_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(NativeStackTrace_obj), false, "haxe.NativeStackTrace"));
+			*(void **)__this = NativeStackTrace_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~NativeStackTrace_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("NativeStackTrace",b4,5e,6d,3c); }
+
+		static void saveStack( ::Dynamic exception);
+		static ::Dynamic saveStack_dyn();
+
+		static ::Array< ::String > callStack();
+		static ::Dynamic callStack_dyn();
+
+		static ::Array< ::String > exceptionStack();
+		static ::Dynamic exceptionStack_dyn();
+
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_NativeStackTrace */ 
diff --git a/Sources/c_snikket/iinclude/haxe/StackItem.h b/Sources/c_snikket/iinclude/haxe/StackItem.h
new file mode 100644
index 0000000..bf28552
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/StackItem.h
@@ -0,0 +1,41 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_StackItem
+#define INCLUDED_haxe_StackItem
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,StackItem)
+namespace haxe{
+
+
+class StackItem_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef StackItem_obj OBJ_;
+
+	public:
+		StackItem_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("haxe.StackItem",13,26,c7,2d); }
+		::String __ToString() const { return HX_("StackItem.",73,53,dc,cb) + _hx_tag; }
+
+		static ::haxe::StackItem CFunction;
+		static inline ::haxe::StackItem CFunction_dyn() { return CFunction; }
+		static ::haxe::StackItem FilePos( ::haxe::StackItem s,::String file,int line, ::Dynamic column);
+		static ::Dynamic FilePos_dyn();
+		static ::haxe::StackItem LocalFunction( ::Dynamic v);
+		static ::Dynamic LocalFunction_dyn();
+		static ::haxe::StackItem Method(::String classname,::String method);
+		static ::Dynamic Method_dyn();
+		static ::haxe::StackItem Module(::String m);
+		static ::Dynamic Module_dyn();
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_StackItem */ 
diff --git a/Sources/c_snikket/iinclude/haxe/Timer.h b/Sources/c_snikket/iinclude/haxe/Timer.h
new file mode 100644
index 0000000..27ba251
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/Timer.h
@@ -0,0 +1,65 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_Timer
+#define INCLUDED_haxe_Timer
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,Timer)
+HX_DECLARE_CLASS3(sys,thread,_EventLoop,RegularEvent)
+HX_DECLARE_CLASS3(sys,thread,_Thread,HaxeThread)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES Timer_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Timer_obj OBJ_;
+		Timer_obj();
+
+	public:
+		enum { _hx_ClassId = 0x04eaa0bb };
+
+		void __construct(int time_ms);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.Timer")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.Timer"); }
+		static ::hx::ObjectPtr< Timer_obj > __new(int time_ms);
+		static ::hx::ObjectPtr< Timer_obj > __alloc(::hx::Ctx *_hx_ctx,int time_ms);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		static void __alloc_dynamic_functions(::hx::Ctx *_hx_alloc,Timer_obj *_hx_obj);
+		//~Timer_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Timer",a5,2f,63,a3); }
+
+		static  ::haxe::Timer delay( ::Dynamic f,int time_ms);
+		static ::Dynamic delay_dyn();
+
+		 ::sys::thread::_Thread::HaxeThread thread;
+		 ::sys::thread::_EventLoop::RegularEvent eventHandler;
+		void stop();
+		::Dynamic stop_dyn();
+
+		::Dynamic run;
+		inline ::Dynamic &run_dyn() {return run; }
+
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_Timer */ 
diff --git a/Sources/c_snikket/iinclude/haxe/ValueException.h b/Sources/c_snikket/iinclude/haxe/ValueException.h
new file mode 100644
index 0000000..b515757
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/ValueException.h
@@ -0,0 +1,55 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_ValueException
+#define INCLUDED_haxe_ValueException
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_Exception
+#include <haxe/Exception.h>
+#endif
+HX_DECLARE_CLASS1(haxe,Exception)
+HX_DECLARE_CLASS1(haxe,ValueException)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES ValueException_obj : public  ::haxe::Exception_obj
+{
+	public:
+		typedef  ::haxe::Exception_obj super;
+		typedef ValueException_obj OBJ_;
+		ValueException_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0af01d58 };
+
+		void __construct( ::Dynamic value, ::haxe::Exception previous, ::Dynamic native);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.ValueException")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.ValueException"); }
+		static ::hx::ObjectPtr< ValueException_obj > __new( ::Dynamic value, ::haxe::Exception previous, ::Dynamic native);
+		static ::hx::ObjectPtr< ValueException_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic value, ::haxe::Exception previous, ::Dynamic native);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ValueException_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ValueException",be,0e,61,3f); }
+
+		 ::Dynamic value;
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_ValueException */ 
diff --git a/Sources/c_snikket/iinclude/haxe/crypto/Base64.h b/Sources/c_snikket/iinclude/haxe/crypto/Base64.h
new file mode 100644
index 0000000..0f00eaf
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/crypto/Base64.h
@@ -0,0 +1,78 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_crypto_Base64
+#define INCLUDED_haxe_crypto_Base64
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,crypto,Base64)
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+
+namespace haxe{
+namespace crypto{
+
+
+class HXCPP_CLASS_ATTRIBUTES Base64_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Base64_obj OBJ_;
+		Base64_obj();
+
+	public:
+		enum { _hx_ClassId = 0x08b38de6 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.crypto.Base64")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"haxe.crypto.Base64"); }
+
+		inline static ::hx::ObjectPtr< Base64_obj > __new() {
+			::hx::ObjectPtr< Base64_obj > __this = new Base64_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Base64_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Base64_obj *__this = (Base64_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Base64_obj), false, "haxe.crypto.Base64"));
+			*(void **)__this = Base64_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Base64_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Base64",af,71,bc,89); }
+
+		static void __boot();
+		static ::String CHARS;
+		static  ::haxe::io::Bytes BYTES;
+		static ::String URL_CHARS;
+		static  ::haxe::io::Bytes URL_BYTES;
+		static ::String encode( ::haxe::io::Bytes bytes,::hx::Null< bool >  complement);
+		static ::Dynamic encode_dyn();
+
+		static  ::haxe::io::Bytes decode(::String str,::hx::Null< bool >  complement);
+		static ::Dynamic decode_dyn();
+
+		static ::String urlEncode( ::haxe::io::Bytes bytes,::hx::Null< bool >  complement);
+		static ::Dynamic urlEncode_dyn();
+
+		static  ::haxe::io::Bytes urlDecode(::String str,::hx::Null< bool >  complement);
+		static ::Dynamic urlDecode_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace crypto
+
+#endif /* INCLUDED_haxe_crypto_Base64 */ 
diff --git a/Sources/c_snikket/iinclude/haxe/crypto/BaseCode.h b/Sources/c_snikket/iinclude/haxe/crypto/BaseCode.h
new file mode 100644
index 0000000..bd80353
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/crypto/BaseCode.h
@@ -0,0 +1,65 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_crypto_BaseCode
+#define INCLUDED_haxe_crypto_BaseCode
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,crypto,BaseCode)
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+
+namespace haxe{
+namespace crypto{
+
+
+class HXCPP_CLASS_ATTRIBUTES BaseCode_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef BaseCode_obj OBJ_;
+		BaseCode_obj();
+
+	public:
+		enum { _hx_ClassId = 0x34980465 };
+
+		void __construct( ::haxe::io::Bytes base);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.crypto.BaseCode")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.crypto.BaseCode"); }
+		static ::hx::ObjectPtr< BaseCode_obj > __new( ::haxe::io::Bytes base);
+		static ::hx::ObjectPtr< BaseCode_obj > __alloc(::hx::Ctx *_hx_ctx, ::haxe::io::Bytes base);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~BaseCode_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("BaseCode",fe,5d,c4,cf); }
+
+		 ::haxe::io::Bytes base;
+		int nbits;
+		::Array< int > tbl;
+		 ::haxe::io::Bytes encodeBytes( ::haxe::io::Bytes b);
+		::Dynamic encodeBytes_dyn();
+
+		void initTable();
+		::Dynamic initTable_dyn();
+
+		 ::haxe::io::Bytes decodeBytes( ::haxe::io::Bytes b);
+		::Dynamic decodeBytes_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace crypto
+
+#endif /* INCLUDED_haxe_crypto_BaseCode */ 
diff --git a/Sources/c_snikket/iinclude/haxe/crypto/Sha1.h b/Sources/c_snikket/iinclude/haxe/crypto/Sha1.h
new file mode 100644
index 0000000..e2986e1
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/crypto/Sha1.h
@@ -0,0 +1,81 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_crypto_Sha1
+#define INCLUDED_haxe_crypto_Sha1
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_b388adc1457cbfc2_48_new)
+HX_DECLARE_CLASS2(haxe,crypto,Sha1)
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+
+namespace haxe{
+namespace crypto{
+
+
+class HXCPP_CLASS_ATTRIBUTES Sha1_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Sha1_obj OBJ_;
+		Sha1_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3a249b8c };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.crypto.Sha1")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"haxe.crypto.Sha1"); }
+
+		inline static ::hx::ObjectPtr< Sha1_obj > __new() {
+			::hx::ObjectPtr< Sha1_obj > __this = new Sha1_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Sha1_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Sha1_obj *__this = (Sha1_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Sha1_obj), false, "haxe.crypto.Sha1"));
+			*(void **)__this = Sha1_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_b388adc1457cbfc2_48_new)
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Sha1_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Sha1",a5,f4,2b,37); }
+
+		static  ::haxe::io::Bytes make( ::haxe::io::Bytes b);
+		static ::Dynamic make_dyn();
+
+		static ::Array< int > bytes2blks( ::haxe::io::Bytes b);
+		static ::Dynamic bytes2blks_dyn();
+
+		::Array< int > doEncode(::Array< int > x);
+		::Dynamic doEncode_dyn();
+
+		int ft(int t,int b,int c,int d);
+		::Dynamic ft_dyn();
+
+		int kt(int t);
+		::Dynamic kt_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace crypto
+
+#endif /* INCLUDED_haxe_crypto_Sha1 */ 
diff --git a/Sources/c_snikket/iinclude/haxe/crypto/Sha256.h b/Sources/c_snikket/iinclude/haxe/crypto/Sha256.h
new file mode 100644
index 0000000..6851954
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/crypto/Sha256.h
@@ -0,0 +1,75 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_crypto_Sha256
+#define INCLUDED_haxe_crypto_Sha256
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_0a4e95b4276e5057_48_new)
+HX_DECLARE_CLASS2(haxe,crypto,Sha256)
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+
+namespace haxe{
+namespace crypto{
+
+
+class HXCPP_CLASS_ATTRIBUTES Sha256_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Sha256_obj OBJ_;
+		Sha256_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0c0976ea };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.crypto.Sha256")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"haxe.crypto.Sha256"); }
+
+		inline static ::hx::ObjectPtr< Sha256_obj > __new() {
+			::hx::ObjectPtr< Sha256_obj > __this = new Sha256_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Sha256_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Sha256_obj *__this = (Sha256_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Sha256_obj), false, "haxe.crypto.Sha256"));
+			*(void **)__this = Sha256_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_0a4e95b4276e5057_48_new)
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Sha256_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Sha256",87,18,8f,51); }
+
+		static  ::haxe::io::Bytes make( ::haxe::io::Bytes b);
+		static ::Dynamic make_dyn();
+
+		static ::Array< int > bytes2blks( ::haxe::io::Bytes b);
+		static ::Dynamic bytes2blks_dyn();
+
+		::Array< int > doEncode(::Array< int > m,int l);
+		::Dynamic doEncode_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace crypto
+
+#endif /* INCLUDED_haxe_crypto_Sha256 */ 
diff --git a/Sources/c_snikket/iinclude/haxe/ds/BalancedTree.h b/Sources/c_snikket/iinclude/haxe/ds/BalancedTree.h
new file mode 100644
index 0000000..4f5b9e6
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/ds/BalancedTree.h
@@ -0,0 +1,83 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_ds_BalancedTree
+#define INCLUDED_haxe_ds_BalancedTree
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,BalancedTree)
+HX_DECLARE_CLASS2(haxe,ds,TreeNode)
+
+namespace haxe{
+namespace ds{
+
+
+class HXCPP_CLASS_ATTRIBUTES BalancedTree_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef BalancedTree_obj OBJ_;
+		BalancedTree_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4cc9cf7f };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.ds.BalancedTree")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.ds.BalancedTree"); }
+		static ::hx::ObjectPtr< BalancedTree_obj > __new();
+		static ::hx::ObjectPtr< BalancedTree_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~BalancedTree_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("BalancedTree",66,71,f8,aa); }
+
+		 ::haxe::ds::TreeNode root;
+		void set( ::Dynamic key, ::Dynamic value);
+		::Dynamic set_dyn();
+
+		 ::Dynamic get( ::Dynamic key);
+		::Dynamic get_dyn();
+
+		bool exists( ::Dynamic key);
+		::Dynamic exists_dyn();
+
+		 ::Dynamic keys();
+		::Dynamic keys_dyn();
+
+		 ::haxe::ds::TreeNode setLoop( ::Dynamic k, ::Dynamic v, ::haxe::ds::TreeNode node);
+		::Dynamic setLoop_dyn();
+
+		void keysLoop( ::haxe::ds::TreeNode node,::cpp::VirtualArray acc);
+		::Dynamic keysLoop_dyn();
+
+		 ::haxe::ds::TreeNode balance( ::haxe::ds::TreeNode l, ::Dynamic k, ::Dynamic v, ::haxe::ds::TreeNode r);
+		::Dynamic balance_dyn();
+
+		virtual int compare( ::Dynamic k1, ::Dynamic k2);
+		::Dynamic compare_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace ds
+
+#endif /* INCLUDED_haxe_ds_BalancedTree */ 
diff --git a/Sources/c_snikket/iinclude/haxe/ds/Either.h b/Sources/c_snikket/iinclude/haxe/ds/Either.h
new file mode 100644
index 0000000..64e3fd7
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/ds/Either.h
@@ -0,0 +1,37 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_ds_Either
+#define INCLUDED_haxe_ds_Either
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,ds,Either)
+namespace haxe{
+namespace ds{
+
+
+class Either_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef Either_obj OBJ_;
+
+	public:
+		Either_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("haxe.ds.Either",1c,1a,b7,a4); }
+		::String __ToString() const { return HX_("Either.",29,67,48,40) + _hx_tag; }
+
+		static ::haxe::ds::Either Left( ::Dynamic v);
+		static ::Dynamic Left_dyn();
+		static ::haxe::ds::Either Right( ::Dynamic v);
+		static ::Dynamic Right_dyn();
+};
+
+} // end namespace haxe
+} // end namespace ds
+
+#endif /* INCLUDED_haxe_ds_Either */ 
diff --git a/Sources/c_snikket/iinclude/haxe/ds/EnumValueMap.h b/Sources/c_snikket/iinclude/haxe/ds/EnumValueMap.h
new file mode 100644
index 0000000..48f7525
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/ds/EnumValueMap.h
@@ -0,0 +1,65 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_ds_EnumValueMap
+#define INCLUDED_haxe_ds_EnumValueMap
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_ds_BalancedTree
+#include <haxe/ds/BalancedTree.h>
+#endif
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,BalancedTree)
+HX_DECLARE_CLASS2(haxe,ds,EnumValueMap)
+
+namespace haxe{
+namespace ds{
+
+
+class HXCPP_CLASS_ATTRIBUTES EnumValueMap_obj : public  ::haxe::ds::BalancedTree_obj
+{
+	public:
+		typedef  ::haxe::ds::BalancedTree_obj super;
+		typedef EnumValueMap_obj OBJ_;
+		EnumValueMap_obj();
+
+	public:
+		enum { _hx_ClassId = 0x34ccfa05 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.ds.EnumValueMap")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.ds.EnumValueMap"); }
+		static ::hx::ObjectPtr< EnumValueMap_obj > __new();
+		static ::hx::ObjectPtr< EnumValueMap_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~EnumValueMap_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("EnumValueMap",ec,9b,fb,92); }
+
+		int compare( ::Dynamic _tmp_k1, ::Dynamic _tmp_k2);
+
+		int compareArgs(::cpp::VirtualArray a1,::cpp::VirtualArray a2);
+		::Dynamic compareArgs_dyn();
+
+		int compareArg( ::Dynamic v1, ::Dynamic v2);
+		::Dynamic compareArg_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace ds
+
+#endif /* INCLUDED_haxe_ds_EnumValueMap */ 
diff --git a/Sources/c_snikket/iinclude/haxe/ds/IntMap.h b/Sources/c_snikket/iinclude/haxe/ds/IntMap.h
new file mode 100644
index 0000000..c5e3745
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/ds/IntMap.h
@@ -0,0 +1,102 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_ds_IntMap
+#define INCLUDED_haxe_ds_IntMap
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,IntMap)
+
+namespace haxe{
+namespace ds{
+
+
+class HXCPP_CLASS_ATTRIBUTES IntMap_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef IntMap_obj OBJ_;
+		IntMap_obj();
+
+	public:
+		enum { _hx_ClassId = 0x269a1502 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.ds.IntMap")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.ds.IntMap"); }
+		static ::hx::ObjectPtr< IntMap_obj > __new();
+		static ::hx::ObjectPtr< IntMap_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~IntMap_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		 ::Dynamic get_a7a2487a( ::Dynamic k);
+		::String __ToString() const { return HX_("IntMap",0d,a9,08,d3); }
+
+		 ::Dynamic h;
+		void set(int key, ::Dynamic value);
+		::Dynamic set_dyn();
+
+		 ::Dynamic get(int key);
+		::Dynamic get_dyn();
+
+		bool remove(int key);
+		::Dynamic remove_dyn();
+
+		 ::Dynamic keys();
+		::Dynamic keys_dyn();
+
+
+  inline void set(int key, ::null value) { __int_hash_set(HX_MAP_THIS,key,value); }
+  inline void set(int key, bool value) { __int_hash_set(HX_MAP_THIS,key,value); }
+  inline void set(int key, char value) { __int_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(int key, unsigned char value) { __int_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(int key, signed char value) { __int_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(int key, short value) { __int_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(int key, unsigned short value) { __int_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(int key, int value) { __int_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(int key, unsigned int value) { __int_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(int key, float value) { __int_hash_set_float(HX_MAP_THIS,key,value); }
+  inline void set(int key, double value) { __int_hash_set_float(HX_MAP_THIS,key,value); }
+  inline void set(int key, ::String value) { __int_hash_set_string(HX_MAP_THIS,key,value); }
+  inline void set(int key, cpp::Int64 value) { __int_hash_set_int64(HX_MAP_THIS,key,value); }
+
+  template<typename V, typename H>
+  inline void set(int key, const ::cpp::Struct<V,H> &value) {__int_hash_set(HX_MAP_THIS,key,value); }
+  template<typename F>
+  inline void set(int key, const ::cpp::Function<F> &value) {__int_hash_set(HX_MAP_THIS,key,value); }
+  template<typename V>
+  inline void set(int key, const ::cpp::Pointer<V> &value) {__int_hash_set(HX_MAP_THIS,key,(Dynamic)value ); }
+
+  template<typename VALUE>
+  inline void set(Dynamic &key, const VALUE &value) { set( (int)key, value ); }
+
+  inline bool get_bool(int key) { return __int_hash_get_bool(h,key); }
+  inline int get_int(int key) { return __int_hash_get_int(h,key); }
+  inline Float get_float(int key) { return __int_hash_get_float(h,key); }
+  inline String get_string(int key) { return __int_hash_get_string(h,key); }
+  inline cpp::Int64 get_int64(int key) { return __int_hash_get_int64(h,key); }
+
+};
+
+} // end namespace haxe
+} // end namespace ds
+
+#endif /* INCLUDED_haxe_ds_IntMap */ 
diff --git a/Sources/c_snikket/iinclude/haxe/ds/List.h b/Sources/c_snikket/iinclude/haxe/ds/List.h
new file mode 100644
index 0000000..f0559ec
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/ds/List.h
@@ -0,0 +1,62 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_ds_List
+#define INCLUDED_haxe_ds_List
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,ds,List)
+HX_DECLARE_CLASS3(haxe,ds,_List,ListNode)
+
+namespace haxe{
+namespace ds{
+
+
+class HXCPP_CLASS_ATTRIBUTES List_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef List_obj OBJ_;
+		List_obj();
+
+	public:
+		enum { _hx_ClassId = 0x39a75d33 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.ds.List")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.ds.List"); }
+		static ::hx::ObjectPtr< List_obj > __new();
+		static ::hx::ObjectPtr< List_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~List_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("List",7e,48,8c,32); }
+
+		 ::haxe::ds::_List::ListNode h;
+		 ::haxe::ds::_List::ListNode q;
+		int length;
+		void push( ::Dynamic item);
+		::Dynamic push_dyn();
+
+		 ::Dynamic pop();
+		::Dynamic pop_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace ds
+
+#endif /* INCLUDED_haxe_ds_List */ 
diff --git a/Sources/c_snikket/iinclude/haxe/ds/ObjectMap.h b/Sources/c_snikket/iinclude/haxe/ds/ObjectMap.h
new file mode 100644
index 0000000..02cde81
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/ds/ObjectMap.h
@@ -0,0 +1,96 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_ds_ObjectMap
+#define INCLUDED_haxe_ds_ObjectMap
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,ObjectMap)
+
+namespace haxe{
+namespace ds{
+
+
+class HXCPP_CLASS_ATTRIBUTES ObjectMap_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef ObjectMap_obj OBJ_;
+		ObjectMap_obj();
+
+	public:
+		enum { _hx_ClassId = 0x6cba6d44 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.ds.ObjectMap")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.ds.ObjectMap"); }
+		static ::hx::ObjectPtr< ObjectMap_obj > __new();
+		static ::hx::ObjectPtr< ObjectMap_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ObjectMap_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("ObjectMap",fd,a4,50,e5); }
+
+		 ::Dynamic h;
+		void set( ::Dynamic key, ::Dynamic value);
+		::Dynamic set_dyn();
+
+		 ::Dynamic get( ::Dynamic key);
+		::Dynamic get_dyn();
+
+		 ::Dynamic keys();
+		::Dynamic keys_dyn();
+
+
+  inline void set(Dynamic key, ::null value) { __object_hash_set(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, bool value) { __object_hash_set(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, char value) { __object_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, unsigned char value) { __object_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, signed char value) { __object_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, short value) { __object_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, unsigned short value) { __object_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, int value) { __object_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, unsigned int value) { __object_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, float value) { __object_hash_set_float(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, double value) { __object_hash_set_float(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, ::String value) { __object_hash_set_string(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, cpp::Int64 value) { __object_hash_set_int64(HX_MAP_THIS,key,value); }
+
+
+  template<typename V, typename H>
+  inline void set(Dynamic key, const ::cpp::Struct<V,H> &value) {__object_hash_set(HX_MAP_THIS,key,value); }
+  template<typename V>
+  inline void set(Dynamic key, const ::cpp::Function<V> &value) {__object_hash_set(HX_MAP_THIS,key,(Dynamic)value ); }
+  template<typename V>
+  inline void set(Dynamic key, const ::cpp::Pointer<V> &value) {__object_hash_set(HX_MAP_THIS,key,(Dynamic)value ); }
+
+  inline bool get_bool(Dynamic key) { return __object_hash_get_bool(h,key); }
+  inline int get_int(Dynamic key) { return __object_hash_get_int(h,key); }
+  inline Float get_float(Dynamic key) { return __object_hash_get_float(h,key); }
+  inline String get_string(Dynamic key) { return __object_hash_get_string(h,key); }
+  inline cpp::Int64 get_int64(Dynamic key) { return __object_hash_get_int64(h,key); }
+
+};
+
+} // end namespace haxe
+} // end namespace ds
+
+#endif /* INCLUDED_haxe_ds_ObjectMap */ 
diff --git a/Sources/c_snikket/iinclude/haxe/ds/Option.h b/Sources/c_snikket/iinclude/haxe/ds/Option.h
new file mode 100644
index 0000000..f2703eb
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/ds/Option.h
@@ -0,0 +1,37 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_ds_Option
+#define INCLUDED_haxe_ds_Option
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,ds,Option)
+namespace haxe{
+namespace ds{
+
+
+class Option_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef Option_obj OBJ_;
+
+	public:
+		Option_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("haxe.ds.Option",4c,90,17,ac); }
+		::String __ToString() const { return HX_("Option.",f9,5a,4f,ad) + _hx_tag; }
+
+		static ::haxe::ds::Option None;
+		static inline ::haxe::ds::Option None_dyn() { return None; }
+		static ::haxe::ds::Option Some( ::Dynamic v);
+		static ::Dynamic Some_dyn();
+};
+
+} // end namespace haxe
+} // end namespace ds
+
+#endif /* INCLUDED_haxe_ds_Option */ 
diff --git a/Sources/c_snikket/iinclude/haxe/ds/StringMap.h b/Sources/c_snikket/iinclude/haxe/ds/StringMap.h
new file mode 100644
index 0000000..527e7db
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/ds/StringMap.h
@@ -0,0 +1,111 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_ds_StringMap
+#define INCLUDED_haxe_ds_StringMap
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+
+namespace haxe{
+namespace ds{
+
+
+class HXCPP_CLASS_ATTRIBUTES StringMap_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef StringMap_obj OBJ_;
+		StringMap_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4260cd56 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.ds.StringMap")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.ds.StringMap"); }
+		static ::hx::ObjectPtr< StringMap_obj > __new();
+		static ::hx::ObjectPtr< StringMap_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~StringMap_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		 ::Dynamic get_a7a2487a( ::Dynamic k);
+		::String __ToString() const { return HX_("StringMap",2b,12,8c,69); }
+
+		 ::Dynamic h;
+		void set(::String key, ::Dynamic value);
+		::Dynamic set_dyn();
+
+		 ::Dynamic get(::String key);
+		::Dynamic get_dyn();
+
+		bool exists(::String key);
+		::Dynamic exists_dyn();
+
+		bool remove(::String key);
+		::Dynamic remove_dyn();
+
+		 ::Dynamic keys();
+		::Dynamic keys_dyn();
+
+		 ::Dynamic iterator();
+		::Dynamic iterator_dyn();
+
+		void clear();
+		::Dynamic clear_dyn();
+
+
+  inline void set(String key, ::null value) { __string_hash_set(HX_MAP_THIS,key,value); }
+  inline void set(String key, bool value) { __string_hash_set(HX_MAP_THIS,key,value); }
+  inline void set(String key, char value) { __string_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(String key, unsigned char value) { __string_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(String key, signed char value) { __string_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(String key, short value) { __string_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(String key, unsigned short value) { __string_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(String key, int value) { __string_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(String key, unsigned int value) { __string_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(String key, float value) { __string_hash_set_float(HX_MAP_THIS,key,value); }
+  inline void set(String key, double value) { __string_hash_set_float(HX_MAP_THIS,key,value); }
+  inline void set(String key, ::String value) { __string_hash_set_string(HX_MAP_THIS,key,value); }
+  inline void set(String key, cpp::Int64 value) { __string_hash_set_int64(HX_MAP_THIS,key,value); }
+
+  template<typename V, typename H>
+  inline void set(String key, const ::cpp::Struct<V,H> &value) {__string_hash_set(HX_MAP_THIS,key,value); }
+  template<typename V>
+  inline void set(String key, const ::cpp::Function<V> &value) {__string_hash_set(HX_MAP_THIS,key,(Dynamic)value ); }
+  template<typename V>
+  inline void set(String key, const ::cpp::Pointer<V> &value) {__string_hash_set(HX_MAP_THIS,key,(Dynamic)value ); }
+
+  template<typename VALUE>
+  inline void set(Dynamic &key, const VALUE &value) { set( (String)key, value ); }
+
+  inline bool get_bool(String key) { return __string_hash_get_bool(h,key); }
+  inline int get_int(String key) { return __string_hash_get_int(h,key); }
+  inline Float get_float(String key) { return __string_hash_get_float(h,key); }
+  inline String get_string(String key) { return __string_hash_get_string(h,key); }
+  inline cpp::Int64 get_int64(String key) { return __string_hash_get_int64(h,key); }
+
+};
+
+} // end namespace haxe
+} // end namespace ds
+
+#endif /* INCLUDED_haxe_ds_StringMap */ 
diff --git a/Sources/c_snikket/iinclude/haxe/ds/TreeNode.h b/Sources/c_snikket/iinclude/haxe/ds/TreeNode.h
new file mode 100644
index 0000000..9eb45af
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/ds/TreeNode.h
@@ -0,0 +1,119 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_ds_TreeNode
+#define INCLUDED_haxe_ds_TreeNode
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_bd32df1abf02b23a_252_new)
+HX_DECLARE_CLASS2(haxe,ds,TreeNode)
+
+namespace haxe{
+namespace ds{
+
+
+class HXCPP_CLASS_ATTRIBUTES TreeNode_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef TreeNode_obj OBJ_;
+		TreeNode_obj();
+
+	public:
+		enum { _hx_ClassId = 0x723fa5d5 };
+
+		void __construct( ::haxe::ds::TreeNode l, ::Dynamic k, ::Dynamic v, ::haxe::ds::TreeNode r,::hx::Null< int >  __o_h);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.ds.TreeNode")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.ds.TreeNode"); }
+
+		inline static ::hx::ObjectPtr< TreeNode_obj > __new( ::haxe::ds::TreeNode l, ::Dynamic k, ::Dynamic v, ::haxe::ds::TreeNode r,::hx::Null< int >  __o_h) {
+			::hx::ObjectPtr< TreeNode_obj > __this = new TreeNode_obj();
+			__this->__construct(l,k,v,r,__o_h);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< TreeNode_obj > __alloc(::hx::Ctx *_hx_ctx, ::haxe::ds::TreeNode l, ::Dynamic k, ::Dynamic v, ::haxe::ds::TreeNode r,::hx::Null< int >  __o_h) {
+			TreeNode_obj *__this = (TreeNode_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(TreeNode_obj), true, "haxe.ds.TreeNode"));
+			*(void **)__this = TreeNode_obj::_hx_vtable;
+{
+            		int h = __o_h.Default(-1);
+            	HX_STACKFRAME(&_hx_pos_bd32df1abf02b23a_252_new)
+HXLINE( 253)		( ( ::haxe::ds::TreeNode)(__this) )->left = l;
+HXLINE( 254)		( ( ::haxe::ds::TreeNode)(__this) )->key = k;
+HXLINE( 255)		( ( ::haxe::ds::TreeNode)(__this) )->value = v;
+HXLINE( 256)		( ( ::haxe::ds::TreeNode)(__this) )->right = r;
+HXLINE( 257)		if ((h == -1)) {
+HXLINE( 258)			int _hx_tmp;
+HXDLIN( 258)			 ::haxe::ds::TreeNode _this = ( ( ::haxe::ds::TreeNode)(__this) )->left;
+HXDLIN( 258)			int _hx_tmp1;
+HXDLIN( 258)			if (::hx::IsNull( _this )) {
+HXLINE( 258)				_hx_tmp1 = 0;
+            			}
+            			else {
+HXLINE( 258)				_hx_tmp1 = _this->_height;
+            			}
+HXDLIN( 258)			 ::haxe::ds::TreeNode _this1 = ( ( ::haxe::ds::TreeNode)(__this) )->right;
+HXDLIN( 258)			int _hx_tmp2;
+HXDLIN( 258)			if (::hx::IsNull( _this1 )) {
+HXLINE( 258)				_hx_tmp2 = 0;
+            			}
+            			else {
+HXLINE( 258)				_hx_tmp2 = _this1->_height;
+            			}
+HXDLIN( 258)			if ((_hx_tmp1 > _hx_tmp2)) {
+HXLINE( 258)				 ::haxe::ds::TreeNode _this2 = ( ( ::haxe::ds::TreeNode)(__this) )->left;
+HXDLIN( 258)				if (::hx::IsNull( _this2 )) {
+HXLINE( 258)					_hx_tmp = 0;
+            				}
+            				else {
+HXLINE( 258)					_hx_tmp = _this2->_height;
+            				}
+            			}
+            			else {
+HXLINE( 258)				 ::haxe::ds::TreeNode _this3 = ( ( ::haxe::ds::TreeNode)(__this) )->right;
+HXDLIN( 258)				if (::hx::IsNull( _this3 )) {
+HXLINE( 258)					_hx_tmp = 0;
+            				}
+            				else {
+HXLINE( 258)					_hx_tmp = _this3->_height;
+            				}
+            			}
+HXDLIN( 258)			( ( ::haxe::ds::TreeNode)(__this) )->_height = (_hx_tmp + 1);
+            		}
+            		else {
+HXLINE( 260)			( ( ::haxe::ds::TreeNode)(__this) )->_height = h;
+            		}
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~TreeNode_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("TreeNode",a0,92,83,06); }
+
+		 ::haxe::ds::TreeNode left;
+		 ::haxe::ds::TreeNode right;
+		 ::Dynamic key;
+		 ::Dynamic value;
+		int _height;
+};
+
+} // end namespace haxe
+} // end namespace ds
+
+#endif /* INCLUDED_haxe_ds_TreeNode */ 
diff --git a/Sources/c_snikket/iinclude/haxe/ds/_List/ListNode.h b/Sources/c_snikket/iinclude/haxe/ds/_List/ListNode.h
new file mode 100644
index 0000000..c8b20b9
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/ds/_List/ListNode.h
@@ -0,0 +1,74 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_ds__List_ListNode
+#define INCLUDED_haxe_ds__List_ListNode
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_d7fe8fcac3c6136e_266_new)
+HX_DECLARE_CLASS3(haxe,ds,_List,ListNode)
+
+namespace haxe{
+namespace ds{
+namespace _List{
+
+
+class HXCPP_CLASS_ATTRIBUTES ListNode_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef ListNode_obj OBJ_;
+		ListNode_obj();
+
+	public:
+		enum { _hx_ClassId = 0x567ed068 };
+
+		void __construct( ::Dynamic item, ::haxe::ds::_List::ListNode next);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.ds._List.ListNode")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.ds._List.ListNode"); }
+
+		inline static ::hx::ObjectPtr< ListNode_obj > __new( ::Dynamic item, ::haxe::ds::_List::ListNode next) {
+			::hx::ObjectPtr< ListNode_obj > __this = new ListNode_obj();
+			__this->__construct(item,next);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< ListNode_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic item, ::haxe::ds::_List::ListNode next) {
+			ListNode_obj *__this = (ListNode_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(ListNode_obj), true, "haxe.ds._List.ListNode"));
+			*(void **)__this = ListNode_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_d7fe8fcac3c6136e_266_new)
+HXLINE( 267)		( ( ::haxe::ds::_List::ListNode)(__this) )->item = item;
+HXLINE( 268)		( ( ::haxe::ds::_List::ListNode)(__this) )->next = next;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ListNode_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ListNode",a0,95,b0,02); }
+
+		 ::Dynamic item;
+		 ::haxe::ds::_List::ListNode next;
+};
+
+} // end namespace haxe
+} // end namespace ds
+} // end namespace _List
+
+#endif /* INCLUDED_haxe_ds__List_ListNode */ 
diff --git a/Sources/c_snikket/iinclude/haxe/exceptions/NotImplementedException.h b/Sources/c_snikket/iinclude/haxe/exceptions/NotImplementedException.h
new file mode 100644
index 0000000..8af474a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/exceptions/NotImplementedException.h
@@ -0,0 +1,71 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_exceptions_NotImplementedException
+#define INCLUDED_haxe_exceptions_NotImplementedException
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_exceptions_PosException
+#include <haxe/exceptions/PosException.h>
+#endif
+HX_DECLARE_STACK_FRAME(_hx_pos_6becf3ac06fb2a12_8_new)
+HX_DECLARE_CLASS1(haxe,Exception)
+HX_DECLARE_CLASS2(haxe,exceptions,NotImplementedException)
+HX_DECLARE_CLASS2(haxe,exceptions,PosException)
+
+namespace haxe{
+namespace exceptions{
+
+
+class HXCPP_CLASS_ATTRIBUTES NotImplementedException_obj : public  ::haxe::exceptions::PosException_obj
+{
+	public:
+		typedef  ::haxe::exceptions::PosException_obj super;
+		typedef NotImplementedException_obj OBJ_;
+		NotImplementedException_obj();
+
+	public:
+		enum { _hx_ClassId = 0x081bdbd6 };
+
+		void __construct(::String __o_message, ::haxe::Exception previous, ::Dynamic pos);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.exceptions.NotImplementedException")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.exceptions.NotImplementedException"); }
+
+		inline static ::hx::ObjectPtr< NotImplementedException_obj > __new(::String __o_message, ::haxe::Exception previous, ::Dynamic pos) {
+			::hx::ObjectPtr< NotImplementedException_obj > __this = new NotImplementedException_obj();
+			__this->__construct(__o_message,previous,pos);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< NotImplementedException_obj > __alloc(::hx::Ctx *_hx_ctx,::String __o_message, ::haxe::Exception previous, ::Dynamic pos) {
+			NotImplementedException_obj *__this = (NotImplementedException_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(NotImplementedException_obj), true, "haxe.exceptions.NotImplementedException"));
+			*(void **)__this = NotImplementedException_obj::_hx_vtable;
+{
+            		::String message = __o_message;
+            		if (::hx::IsNull(__o_message)) message = HX_("Not implemented",15,1e,32,34);
+            	HX_STACKFRAME(&_hx_pos_6becf3ac06fb2a12_8_new)
+HXDLIN(   8)		__this->super::__construct(message,previous,pos);
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~NotImplementedException_obj();
+
+		HX_DO_RTTI_ALL;
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("NotImplementedException",c0,57,2c,4a); }
+
+};
+
+} // end namespace haxe
+} // end namespace exceptions
+
+#endif /* INCLUDED_haxe_exceptions_NotImplementedException */ 
diff --git a/Sources/c_snikket/iinclude/haxe/exceptions/PosException.h b/Sources/c_snikket/iinclude/haxe/exceptions/PosException.h
new file mode 100644
index 0000000..df1f2b8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/exceptions/PosException.h
@@ -0,0 +1,82 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_exceptions_PosException
+#define INCLUDED_haxe_exceptions_PosException
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_Exception
+#include <haxe/Exception.h>
+#endif
+HX_DECLARE_STACK_FRAME(_hx_pos_9487fa79a58895e3_12_new)
+HX_DECLARE_CLASS1(haxe,Exception)
+HX_DECLARE_CLASS2(haxe,exceptions,PosException)
+
+namespace haxe{
+namespace exceptions{
+
+
+class HXCPP_CLASS_ATTRIBUTES PosException_obj : public  ::haxe::Exception_obj
+{
+	public:
+		typedef  ::haxe::Exception_obj super;
+		typedef PosException_obj OBJ_;
+		PosException_obj();
+
+	public:
+		enum { _hx_ClassId = 0x65f7252d };
+
+		void __construct(::String message, ::haxe::Exception previous, ::Dynamic pos);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.exceptions.PosException")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.exceptions.PosException"); }
+
+		inline static ::hx::ObjectPtr< PosException_obj > __new(::String message, ::haxe::Exception previous, ::Dynamic pos) {
+			::hx::ObjectPtr< PosException_obj > __this = new PosException_obj();
+			__this->__construct(message,previous,pos);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< PosException_obj > __alloc(::hx::Ctx *_hx_ctx,::String message, ::haxe::Exception previous, ::Dynamic pos) {
+			PosException_obj *__this = (PosException_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(PosException_obj), true, "haxe.exceptions.PosException"));
+			*(void **)__this = PosException_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_9487fa79a58895e3_12_new)
+HXLINE(  13)		__this->super::__construct(message,previous,null());
+HXLINE(  14)		if (::hx::IsNull( pos )) {
+HXLINE(  15)			( ( ::haxe::exceptions::PosException)(__this) )->posInfos = ::hx::SourceInfo(HX_("(unknown)",87,5d,fc,5f),0,HX_("(unknown)",87,5d,fc,5f),HX_("(unknown)",87,5d,fc,5f));
+            		}
+            		else {
+HXLINE(  17)			( ( ::haxe::exceptions::PosException)(__this) )->posInfos = pos;
+            		}
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~PosException_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("PosException",3b,8c,23,b9); }
+
+		 ::Dynamic posInfos;
+		virtual ::String toString();
+
+};
+
+} // end namespace haxe
+} // end namespace exceptions
+
+#endif /* INCLUDED_haxe_exceptions_PosException */ 
diff --git a/Sources/c_snikket/iinclude/haxe/format/JsonParser.h b/Sources/c_snikket/iinclude/haxe/format/JsonParser.h
new file mode 100644
index 0000000..be8707a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/format/JsonParser.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_format_JsonParser
+#define INCLUDED_haxe_format_JsonParser
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,format,JsonParser)
+
+namespace haxe{
+namespace format{
+
+
+class HXCPP_CLASS_ATTRIBUTES JsonParser_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef JsonParser_obj OBJ_;
+		JsonParser_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0ae51690 };
+
+		void __construct(::String str);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.format.JsonParser")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.format.JsonParser"); }
+		static ::hx::ObjectPtr< JsonParser_obj > __new(::String str);
+		static ::hx::ObjectPtr< JsonParser_obj > __alloc(::hx::Ctx *_hx_ctx,::String str);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~JsonParser_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("JsonParser",47,65,2e,25); }
+
+		::String str;
+		int pos;
+		 ::Dynamic doParse();
+		::Dynamic doParse_dyn();
+
+		 ::Dynamic parseRec();
+		::Dynamic parseRec_dyn();
+
+		::String parseString();
+		::Dynamic parseString_dyn();
+
+		void invalidChar();
+		::Dynamic invalidChar_dyn();
+
+		void invalidNumber(int start);
+		::Dynamic invalidNumber_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace format
+
+#endif /* INCLUDED_haxe_format_JsonParser */ 
diff --git a/Sources/c_snikket/iinclude/haxe/format/JsonPrinter.h b/Sources/c_snikket/iinclude/haxe/format/JsonPrinter.h
new file mode 100644
index 0000000..4ac12b9
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/format/JsonPrinter.h
@@ -0,0 +1,75 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_format_JsonPrinter
+#define INCLUDED_haxe_format_JsonPrinter
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(StringBuf)
+HX_DECLARE_CLASS2(haxe,format,JsonPrinter)
+
+namespace haxe{
+namespace format{
+
+
+class HXCPP_CLASS_ATTRIBUTES JsonPrinter_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef JsonPrinter_obj OBJ_;
+		JsonPrinter_obj();
+
+	public:
+		enum { _hx_ClassId = 0x385642d1 };
+
+		void __construct( ::Dynamic replacer,::String space);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.format.JsonPrinter")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.format.JsonPrinter"); }
+		static ::hx::ObjectPtr< JsonPrinter_obj > __new( ::Dynamic replacer,::String space);
+		static ::hx::ObjectPtr< JsonPrinter_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic replacer,::String space);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~JsonPrinter_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("JsonPrinter",72,68,9d,fd); }
+
+		static ::String print( ::Dynamic o, ::Dynamic replacer,::String space);
+		static ::Dynamic print_dyn();
+
+		 ::StringBuf buf;
+		 ::Dynamic replacer;
+		Dynamic replacer_dyn() { return replacer;}
+		::String indent;
+		bool pretty;
+		int nind;
+		void write( ::Dynamic k, ::Dynamic v);
+		::Dynamic write_dyn();
+
+		void classString( ::Dynamic v);
+		::Dynamic classString_dyn();
+
+		void fieldsString( ::Dynamic v,::Array< ::String > fields);
+		::Dynamic fieldsString_dyn();
+
+		void quote(::String s);
+		::Dynamic quote_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace format
+
+#endif /* INCLUDED_haxe_format_JsonPrinter */ 
diff --git a/Sources/c_snikket/iinclude/haxe/http/HttpBase.h b/Sources/c_snikket/iinclude/haxe/http/HttpBase.h
new file mode 100644
index 0000000..fb9bfeb
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/http/HttpBase.h
@@ -0,0 +1,90 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_http_HttpBase
+#define INCLUDED_haxe_http_HttpBase
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,http,HttpBase)
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+
+namespace haxe{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES HttpBase_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef HttpBase_obj OBJ_;
+		HttpBase_obj();
+
+	public:
+		enum { _hx_ClassId = 0x10c0921f };
+
+		void __construct(::String url);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.http.HttpBase")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.http.HttpBase"); }
+		static ::hx::ObjectPtr< HttpBase_obj > __new(::String url);
+		static ::hx::ObjectPtr< HttpBase_obj > __alloc(::hx::Ctx *_hx_ctx,::String url);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		static void __alloc_dynamic_functions(::hx::Ctx *_hx_alloc,HttpBase_obj *_hx_obj);
+		//~HttpBase_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HttpBase",d9,cf,1a,f8); }
+
+		::String url;
+		 ::haxe::io::Bytes responseBytes;
+		::String responseAsString;
+		::String postData;
+		 ::haxe::io::Bytes postBytes;
+		::Array< ::Dynamic> headers;
+		::Array< ::Dynamic> params;
+		 ::Dynamic emptyOnData;
+		Dynamic emptyOnData_dyn() { return emptyOnData;}
+		void setHeader(::String name,::String value);
+		::Dynamic setHeader_dyn();
+
+		void setPostData(::String data);
+		::Dynamic setPostData_dyn();
+
+		::Dynamic onData;
+		inline ::Dynamic &onData_dyn() {return onData; }
+
+		::Dynamic onBytes;
+		inline ::Dynamic &onBytes_dyn() {return onBytes; }
+
+		::Dynamic onError;
+		inline ::Dynamic &onError_dyn() {return onError; }
+
+		::Dynamic onStatus;
+		inline ::Dynamic &onStatus_dyn() {return onStatus; }
+
+		bool hasOnData();
+		::Dynamic hasOnData_dyn();
+
+		void success( ::haxe::io::Bytes data);
+		::Dynamic success_dyn();
+
+		::String get_responseData();
+		::Dynamic get_responseData_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace http
+
+#endif /* INCLUDED_haxe_http_HttpBase */ 
diff --git a/Sources/c_snikket/iinclude/haxe/io/Bytes.h b/Sources/c_snikket/iinclude/haxe/io/Bytes.h
new file mode 100644
index 0000000..49850b2
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/io/Bytes.h
@@ -0,0 +1,86 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_io_Bytes
+#define INCLUDED_haxe_io_Bytes
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Encoding)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES Bytes_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Bytes_obj OBJ_;
+		Bytes_obj();
+
+	public:
+		enum { _hx_ClassId = 0x195c64b7 };
+
+		void __construct(int length,::Array< unsigned char > b);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.io.Bytes")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.io.Bytes"); }
+		static ::hx::ObjectPtr< Bytes_obj > __new(int length,::Array< unsigned char > b);
+		static ::hx::ObjectPtr< Bytes_obj > __alloc(::hx::Ctx *_hx_ctx,int length,::Array< unsigned char > b);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Bytes_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Bytes",4b,78,c5,50); }
+
+		static  ::haxe::io::Bytes alloc(int length);
+		static ::Dynamic alloc_dyn();
+
+		static  ::haxe::io::Bytes ofString(::String s, ::haxe::io::Encoding encoding);
+		static ::Dynamic ofString_dyn();
+
+		static  ::haxe::io::Bytes ofData(::Array< unsigned char > b);
+		static ::Dynamic ofData_dyn();
+
+		static  ::haxe::io::Bytes ofHex(::String s);
+		static ::Dynamic ofHex_dyn();
+
+		int length;
+		::Array< unsigned char > b;
+		void blit(int pos, ::haxe::io::Bytes src,int srcpos,int len);
+		::Dynamic blit_dyn();
+
+		void fill(int pos,int len,int value);
+		::Dynamic fill_dyn();
+
+		 ::haxe::io::Bytes sub(int pos,int len);
+		::Dynamic sub_dyn();
+
+		::String getString(int pos,int len, ::haxe::io::Encoding encoding);
+		::Dynamic getString_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+		::String toHex();
+		::Dynamic toHex_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Bytes */ 
diff --git a/Sources/c_snikket/iinclude/haxe/io/BytesBuffer.h b/Sources/c_snikket/iinclude/haxe/io/BytesBuffer.h
new file mode 100644
index 0000000..531cf7a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/io/BytesBuffer.h
@@ -0,0 +1,57 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_io_BytesBuffer
+#define INCLUDED_haxe_io_BytesBuffer
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,BytesBuffer)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES BytesBuffer_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef BytesBuffer_obj OBJ_;
+		BytesBuffer_obj();
+
+	public:
+		enum { _hx_ClassId = 0x183160df };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.io.BytesBuffer")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.io.BytesBuffer"); }
+		static ::hx::ObjectPtr< BytesBuffer_obj > __new();
+		static ::hx::ObjectPtr< BytesBuffer_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~BytesBuffer_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("BytesBuffer",ab,73,22,f6); }
+
+		::Array< unsigned char > b;
+		 ::haxe::io::Bytes getBytes();
+		::Dynamic getBytes_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_BytesBuffer */ 
diff --git a/Sources/c_snikket/iinclude/haxe/io/BytesInput.h b/Sources/c_snikket/iinclude/haxe/io/BytesInput.h
new file mode 100644
index 0000000..4385c8d
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/io/BytesInput.h
@@ -0,0 +1,65 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_io_BytesInput
+#define INCLUDED_haxe_io_BytesInput
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_io_Input
+#include <haxe/io/Input.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,BytesInput)
+HX_DECLARE_CLASS2(haxe,io,Input)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES BytesInput_obj : public  ::haxe::io::Input_obj
+{
+	public:
+		typedef  ::haxe::io::Input_obj super;
+		typedef BytesInput_obj OBJ_;
+		BytesInput_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7e26810b };
+
+		void __construct( ::haxe::io::Bytes b, ::Dynamic pos, ::Dynamic len);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.io.BytesInput")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.io.BytesInput"); }
+		static ::hx::ObjectPtr< BytesInput_obj > __new( ::haxe::io::Bytes b, ::Dynamic pos, ::Dynamic len);
+		static ::hx::ObjectPtr< BytesInput_obj > __alloc(::hx::Ctx *_hx_ctx, ::haxe::io::Bytes b, ::Dynamic pos, ::Dynamic len);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~BytesInput_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("BytesInput",bf,cb,76,e6); }
+
+		::Array< unsigned char > b;
+		int pos;
+		int len;
+		int totlen;
+		int readByte();
+
+		int readBytes( ::haxe::io::Bytes buf,int pos,int len);
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_BytesInput */ 
diff --git a/Sources/c_snikket/iinclude/haxe/io/BytesOutput.h b/Sources/c_snikket/iinclude/haxe/io/BytesOutput.h
new file mode 100644
index 0000000..15fc989
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/io/BytesOutput.h
@@ -0,0 +1,66 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_io_BytesOutput
+#define INCLUDED_haxe_io_BytesOutput
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_io_Output
+#include <haxe/io/Output.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,BytesBuffer)
+HX_DECLARE_CLASS2(haxe,io,BytesOutput)
+HX_DECLARE_CLASS2(haxe,io,Output)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES BytesOutput_obj : public  ::haxe::io::Output_obj
+{
+	public:
+		typedef  ::haxe::io::Output_obj super;
+		typedef BytesOutput_obj OBJ_;
+		BytesOutput_obj();
+
+	public:
+		enum { _hx_ClassId = 0x541db2e0 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.io.BytesOutput")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.io.BytesOutput"); }
+		static ::hx::ObjectPtr< BytesOutput_obj > __new();
+		static ::hx::ObjectPtr< BytesOutput_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~BytesOutput_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("BytesOutput",ac,c5,0e,32); }
+
+		 ::haxe::io::BytesBuffer b;
+		void writeByte(int c);
+
+		int writeBytes( ::haxe::io::Bytes buf,int pos,int len);
+
+		 ::haxe::io::Bytes getBytes();
+		::Dynamic getBytes_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_BytesOutput */ 
diff --git a/Sources/c_snikket/iinclude/haxe/io/Encoding.h b/Sources/c_snikket/iinclude/haxe/io/Encoding.h
new file mode 100644
index 0000000..2103145
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/io/Encoding.h
@@ -0,0 +1,37 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_io_Encoding
+#define INCLUDED_haxe_io_Encoding
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Encoding)
+namespace haxe{
+namespace io{
+
+
+class Encoding_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef Encoding_obj OBJ_;
+
+	public:
+		Encoding_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("haxe.io.Encoding",33,a6,6d,22); }
+		::String __ToString() const { return HX_("Encoding.",db,8b,f5,be) + _hx_tag; }
+
+		static ::haxe::io::Encoding RawNative;
+		static inline ::haxe::io::Encoding RawNative_dyn() { return RawNative; }
+		static ::haxe::io::Encoding UTF8;
+		static inline ::haxe::io::Encoding UTF8_dyn() { return UTF8; }
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Encoding */ 
diff --git a/Sources/c_snikket/iinclude/haxe/io/Eof.h b/Sources/c_snikket/iinclude/haxe/io/Eof.h
new file mode 100644
index 0000000..4daee4e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/io/Eof.h
@@ -0,0 +1,67 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_io_Eof
+#define INCLUDED_haxe_io_Eof
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_c4f7e3feda612c90_29_new)
+HX_DECLARE_CLASS2(haxe,io,Eof)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES Eof_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Eof_obj OBJ_;
+		Eof_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1d7955d0 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.io.Eof")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"haxe.io.Eof"); }
+
+		inline static ::hx::ObjectPtr< Eof_obj > __new() {
+			::hx::ObjectPtr< Eof_obj > __this = new Eof_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Eof_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Eof_obj *__this = (Eof_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Eof_obj), false, "haxe.io.Eof"));
+			*(void **)__this = Eof_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_c4f7e3feda612c90_29_new)
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Eof_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Eof",9c,bc,34,00); }
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Eof */ 
diff --git a/Sources/c_snikket/iinclude/haxe/io/Error.h b/Sources/c_snikket/iinclude/haxe/io/Error.h
new file mode 100644
index 0000000..83aadc4
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/io/Error.h
@@ -0,0 +1,41 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_io_Error
+#define INCLUDED_haxe_io_Error
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Error)
+namespace haxe{
+namespace io{
+
+
+class Error_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef Error_obj OBJ_;
+
+	public:
+		Error_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("haxe.io.Error",68,16,01,55); }
+		::String __ToString() const { return HX_("Error.",86,f7,fc,85) + _hx_tag; }
+
+		static ::haxe::io::Error Blocked;
+		static inline ::haxe::io::Error Blocked_dyn() { return Blocked; }
+		static ::haxe::io::Error Custom( ::Dynamic e);
+		static ::Dynamic Custom_dyn();
+		static ::haxe::io::Error OutsideBounds;
+		static inline ::haxe::io::Error OutsideBounds_dyn() { return OutsideBounds; }
+		static ::haxe::io::Error Overflow;
+		static inline ::haxe::io::Error Overflow_dyn() { return Overflow; }
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Error */ 
diff --git a/Sources/c_snikket/iinclude/haxe/io/Input.h b/Sources/c_snikket/iinclude/haxe/io/Input.h
new file mode 100644
index 0000000..8e88cce
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/io/Input.h
@@ -0,0 +1,81 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_io_Input
+#define INCLUDED_haxe_io_Input
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Input)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES Input_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Input_obj OBJ_;
+		Input_obj();
+
+	public:
+		enum { _hx_ClassId = 0x19e22056 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.io.Input")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"haxe.io.Input"); }
+
+		inline static ::hx::ObjectPtr< Input_obj > __new() {
+			::hx::ObjectPtr< Input_obj > __this = new Input_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Input_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Input_obj *__this = (Input_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Input_obj), false, "haxe.io.Input"));
+			*(void **)__this = Input_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Input_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Input",ea,33,4b,51); }
+
+		bool bigEndian;
+		virtual int readByte();
+		::Dynamic readByte_dyn();
+
+		virtual int readBytes( ::haxe::io::Bytes s,int pos,int len);
+		::Dynamic readBytes_dyn();
+
+		virtual void close();
+		::Dynamic close_dyn();
+
+		bool set_bigEndian(bool b);
+		::Dynamic set_bigEndian_dyn();
+
+		 ::haxe::io::Bytes readAll( ::Dynamic bufsize);
+		::Dynamic readAll_dyn();
+
+		int readInt32();
+		::Dynamic readInt32_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Input */ 
diff --git a/Sources/c_snikket/iinclude/haxe/io/Output.h b/Sources/c_snikket/iinclude/haxe/io/Output.h
new file mode 100644
index 0000000..7fc6dc3
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/io/Output.h
@@ -0,0 +1,82 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_io_Output
+#define INCLUDED_haxe_io_Output
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Encoding)
+HX_DECLARE_CLASS2(haxe,io,Output)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES Output_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Output_obj OBJ_;
+		Output_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0a55a26d };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.io.Output")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"haxe.io.Output"); }
+
+		inline static ::hx::ObjectPtr< Output_obj > __new() {
+			::hx::ObjectPtr< Output_obj > __this = new Output_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Output_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Output_obj *__this = (Output_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Output_obj), false, "haxe.io.Output"));
+			*(void **)__this = Output_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Output_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Output",21,83,15,41); }
+
+		virtual void writeByte(int c);
+		::Dynamic writeByte_dyn();
+
+		virtual int writeBytes( ::haxe::io::Bytes s,int pos,int len);
+		::Dynamic writeBytes_dyn();
+
+		virtual void close();
+		::Dynamic close_dyn();
+
+		void write( ::haxe::io::Bytes s);
+		::Dynamic write_dyn();
+
+		void writeFullBytes( ::haxe::io::Bytes s,int pos,int len);
+		::Dynamic writeFullBytes_dyn();
+
+		void prepare(int nbytes);
+		::Dynamic prepare_dyn();
+
+		void writeString(::String s, ::haxe::io::Encoding encoding);
+		::Dynamic writeString_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Output */ 
diff --git a/Sources/c_snikket/iinclude/haxe/io/Path.h b/Sources/c_snikket/iinclude/haxe/io/Path.h
new file mode 100644
index 0000000..c3b75d8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/io/Path.h
@@ -0,0 +1,78 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_io_Path
+#define INCLUDED_haxe_io_Path
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Path)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES Path_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Path_obj OBJ_;
+		Path_obj();
+
+	public:
+		enum { _hx_ClassId = 0x026896d9 };
+
+		void __construct(::String path);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.io.Path")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.io.Path"); }
+		static ::hx::ObjectPtr< Path_obj > __new(::String path);
+		static ::hx::ObjectPtr< Path_obj > __alloc(::hx::Ctx *_hx_ctx,::String path);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Path_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Path",c5,11,2b,35); }
+
+		static ::String withoutDirectory(::String path);
+		static ::Dynamic withoutDirectory_dyn();
+
+		static ::String join(::Array< ::String > paths);
+		static ::Dynamic join_dyn();
+
+		static ::String normalize(::String path);
+		static ::Dynamic normalize_dyn();
+
+		static ::String addTrailingSlash(::String path);
+		static ::Dynamic addTrailingSlash_dyn();
+
+		static ::String removeTrailingSlashes(::String path);
+		static ::Dynamic removeTrailingSlashes_dyn();
+
+		static bool isAbsolute(::String path);
+		static ::Dynamic isAbsolute_dyn();
+
+		::String dir;
+		::String file;
+		::String ext;
+		bool backslash;
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Path */ 
diff --git a/Sources/c_snikket/iinclude/haxe/iterators/ArrayIterator.h b/Sources/c_snikket/iinclude/haxe/iterators/ArrayIterator.h
new file mode 100644
index 0000000..15325b9
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/iterators/ArrayIterator.h
@@ -0,0 +1,78 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_iterators_ArrayIterator
+#define INCLUDED_haxe_iterators_ArrayIterator
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_44ded26575b0f4de_28_new)
+HX_DECLARE_CLASS2(haxe,iterators,ArrayIterator)
+
+namespace haxe{
+namespace iterators{
+
+
+class HXCPP_CLASS_ATTRIBUTES ArrayIterator_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef ArrayIterator_obj OBJ_;
+		ArrayIterator_obj();
+
+	public:
+		enum { _hx_ClassId = 0x189859c8 };
+
+		void __construct(::cpp::VirtualArray array);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.iterators.ArrayIterator")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.iterators.ArrayIterator"); }
+
+		inline static ::hx::ObjectPtr< ArrayIterator_obj > __new(::cpp::VirtualArray array) {
+			::hx::ObjectPtr< ArrayIterator_obj > __this = new ArrayIterator_obj();
+			__this->__construct(array);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< ArrayIterator_obj > __alloc(::hx::Ctx *_hx_ctx,::cpp::VirtualArray array) {
+			ArrayIterator_obj *__this = (ArrayIterator_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(ArrayIterator_obj), true, "haxe.iterators.ArrayIterator"));
+			*(void **)__this = ArrayIterator_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_44ded26575b0f4de_28_new)
+HXLINE(  30)		( ( ::haxe::iterators::ArrayIterator)(__this) )->current = 0;
+HXLINE(  37)		( ( ::haxe::iterators::ArrayIterator)(__this) )->array = array;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ArrayIterator_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ArrayIterator",87,84,c8,5d); }
+
+		::cpp::VirtualArray array;
+		int current;
+		bool hasNext();
+		::Dynamic hasNext_dyn();
+
+		 ::Dynamic next();
+		::Dynamic next_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace iterators
+
+#endif /* INCLUDED_haxe_iterators_ArrayIterator */ 
diff --git a/Sources/c_snikket/iinclude/haxe/iterators/MapKeyValueIterator.h b/Sources/c_snikket/iinclude/haxe/iterators/MapKeyValueIterator.h
new file mode 100644
index 0000000..22cf306
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/iterators/MapKeyValueIterator.h
@@ -0,0 +1,61 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_iterators_MapKeyValueIterator
+#define INCLUDED_haxe_iterators_MapKeyValueIterator
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,iterators,MapKeyValueIterator)
+
+namespace haxe{
+namespace iterators{
+
+
+class HXCPP_CLASS_ATTRIBUTES MapKeyValueIterator_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef MapKeyValueIterator_obj OBJ_;
+		MapKeyValueIterator_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5732dffd };
+
+		void __construct(::Dynamic map);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.iterators.MapKeyValueIterator")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.iterators.MapKeyValueIterator"); }
+		static ::hx::ObjectPtr< MapKeyValueIterator_obj > __new(::Dynamic map);
+		static ::hx::ObjectPtr< MapKeyValueIterator_obj > __alloc(::hx::Ctx *_hx_ctx,::Dynamic map);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~MapKeyValueIterator_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("MapKeyValueIterator",fc,23,62,2c); }
+
+		::Dynamic map;
+		 ::Dynamic keys;
+		bool hasNext();
+		::Dynamic hasNext_dyn();
+
+		 ::Dynamic next();
+		::Dynamic next_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace iterators
+
+#endif /* INCLUDED_haxe_iterators_MapKeyValueIterator */ 
diff --git a/Sources/c_snikket/iinclude/haxe/xml/Parser.h b/Sources/c_snikket/iinclude/haxe/xml/Parser.h
new file mode 100644
index 0000000..b6ef3d6
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/xml/Parser.h
@@ -0,0 +1,71 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_xml_Parser
+#define INCLUDED_haxe_xml_Parser
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(Xml)
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS2(haxe,xml,Parser)
+
+namespace haxe{
+namespace xml{
+
+
+class HXCPP_CLASS_ATTRIBUTES Parser_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Parser_obj OBJ_;
+		Parser_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1c6f1730 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.xml.Parser")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"haxe.xml.Parser"); }
+
+		inline static ::hx::ObjectPtr< Parser_obj > __new() {
+			::hx::ObjectPtr< Parser_obj > __this = new Parser_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Parser_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Parser_obj *__this = (Parser_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Parser_obj), false, "haxe.xml.Parser"));
+			*(void **)__this = Parser_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Parser_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Parser",ff,10,1d,22); }
+
+		static void __boot();
+		static  ::haxe::ds::StringMap escapes;
+		static  ::Xml parse(::String str,::hx::Null< bool >  strict);
+		static ::Dynamic parse_dyn();
+
+		static int doParse(::String str,bool strict,::hx::Null< int >  p, ::Xml parent);
+		static ::Dynamic doParse_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace xml
+
+#endif /* INCLUDED_haxe_xml_Parser */ 
diff --git a/Sources/c_snikket/iinclude/haxe/xml/Printer.h b/Sources/c_snikket/iinclude/haxe/xml/Printer.h
new file mode 100644
index 0000000..5b159a1
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/xml/Printer.h
@@ -0,0 +1,66 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_xml_Printer
+#define INCLUDED_haxe_xml_Printer
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(StringBuf)
+HX_DECLARE_CLASS0(Xml)
+HX_DECLARE_CLASS2(haxe,xml,Printer)
+
+namespace haxe{
+namespace xml{
+
+
+class HXCPP_CLASS_ATTRIBUTES Printer_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Printer_obj OBJ_;
+		Printer_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5ef86269 };
+
+		void __construct(bool pretty);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.xml.Printer")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.xml.Printer"); }
+		static ::hx::ObjectPtr< Printer_obj > __new(bool pretty);
+		static ::hx::ObjectPtr< Printer_obj > __alloc(::hx::Ctx *_hx_ctx,bool pretty);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Printer_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Printer",ba,fd,84,51); }
+
+		static ::String print( ::Xml xml, ::Dynamic pretty);
+		static ::Dynamic print_dyn();
+
+		 ::StringBuf output;
+		bool pretty;
+		void writeNode( ::Xml value,::String tabs);
+		::Dynamic writeNode_dyn();
+
+		bool hasChildren( ::Xml value);
+		::Dynamic hasChildren_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace xml
+
+#endif /* INCLUDED_haxe_xml_Printer */ 
diff --git a/Sources/c_snikket/iinclude/haxe/xml/XmlParserException.h b/Sources/c_snikket/iinclude/haxe/xml/XmlParserException.h
new file mode 100644
index 0000000..a842951
--- /dev/null
+++ b/Sources/c_snikket/iinclude/haxe/xml/XmlParserException.h
@@ -0,0 +1,60 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_xml_XmlParserException
+#define INCLUDED_haxe_xml_XmlParserException
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,xml,XmlParserException)
+
+namespace haxe{
+namespace xml{
+
+
+class HXCPP_CLASS_ATTRIBUTES XmlParserException_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef XmlParserException_obj OBJ_;
+		XmlParserException_obj();
+
+	public:
+		enum { _hx_ClassId = 0x75f2332a };
+
+		void __construct(::String message,::String xml,int position);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.xml.XmlParserException")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.xml.XmlParserException"); }
+		static ::hx::ObjectPtr< XmlParserException_obj > __new(::String message,::String xml,int position);
+		static ::hx::ObjectPtr< XmlParserException_obj > __alloc(::hx::Ctx *_hx_ctx,::String message,::String xml,int position);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~XmlParserException_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("XmlParserException",79,27,d7,6b); }
+
+		::String message;
+		int lineNumber;
+		int positionAtLine;
+		int position;
+		::String xml;
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace xml
+
+#endif /* INCLUDED_haxe_xml_XmlParserException */ 
diff --git a/Sources/c_snikket/iinclude/hsluv/Hsluv.h b/Sources/c_snikket/iinclude/hsluv/Hsluv.h
new file mode 100644
index 0000000..f90390a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hsluv/Hsluv.h
@@ -0,0 +1,138 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_hsluv_Hsluv
+#define INCLUDED_hsluv_Hsluv
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(hsluv,Hsluv)
+
+namespace hsluv{
+
+
+class HXCPP_CLASS_ATTRIBUTES Hsluv_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Hsluv_obj OBJ_;
+		Hsluv_obj();
+
+	public:
+		enum { _hx_ClassId = 0x29e47ee8 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="hsluv.Hsluv")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"hsluv.Hsluv"); }
+		static ::hx::ObjectPtr< Hsluv_obj > __new();
+		static ::hx::ObjectPtr< Hsluv_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Hsluv_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Hsluv",82,a7,2f,c1); }
+
+		static void __boot();
+		static ::String hexChars;
+		static Float refY;
+		static Float refU;
+		static Float refV;
+		static Float kappa;
+		static Float epsilon;
+		static Float m_r0;
+		static Float m_r1;
+		static Float m_r2;
+		static Float m_g0;
+		static Float m_g1;
+		static Float m_g2;
+		static Float m_b0;
+		static Float m_b1;
+		static Float m_b2;
+		static Float fromLinear(Float c);
+		static ::Dynamic fromLinear_dyn();
+
+		static Float lToY(Float L);
+		static ::Dynamic lToY_dyn();
+
+		static ::String rgbChannelToHex(Float chan);
+		static ::Dynamic rgbChannelToHex_dyn();
+
+		static Float distanceFromOriginAngle(Float slope,Float intercept,Float angle);
+		static ::Dynamic distanceFromOriginAngle_dyn();
+
+		static Float min6(Float f1,Float f2,Float f3,Float f4,Float f5,Float f6);
+		static ::Dynamic min6_dyn();
+
+		::String hex;
+		Float rgb_r;
+		Float rgb_g;
+		Float rgb_b;
+		Float xyz_x;
+		Float xyz_y;
+		Float xyz_z;
+		Float luv_l;
+		Float luv_u;
+		Float luv_v;
+		Float lch_l;
+		Float lch_c;
+		Float lch_h;
+		Float hsluv_h;
+		Float hsluv_s;
+		Float hsluv_l;
+		Float r0s;
+		Float r0i;
+		Float r1s;
+		Float r1i;
+		Float g0s;
+		Float g0i;
+		Float g1s;
+		Float g1i;
+		Float b0s;
+		Float b0i;
+		Float b1s;
+		Float b1i;
+		void rgbToHex();
+		::Dynamic rgbToHex_dyn();
+
+		void xyzToRgb();
+		::Dynamic xyzToRgb_dyn();
+
+		void luvToXyz();
+		::Dynamic luvToXyz_dyn();
+
+		void lchToLuv();
+		::Dynamic lchToLuv_dyn();
+
+		void calculateBoundingLines(Float l);
+		::Dynamic calculateBoundingLines_dyn();
+
+		Float calcMaxChromaHsluv(Float h);
+		::Dynamic calcMaxChromaHsluv_dyn();
+
+		void hsluvToLch();
+		::Dynamic hsluvToLch_dyn();
+
+		void hsluvToRgb();
+		::Dynamic hsluvToRgb_dyn();
+
+		void hsluvToHex();
+		::Dynamic hsluvToHex_dyn();
+
+};
+
+} // end namespace hsluv
+
+#endif /* INCLUDED_hsluv_Hsluv */ 
diff --git a/Sources/c_snikket/iinclude/htmlparser/HtmlAttribute.h b/Sources/c_snikket/iinclude/htmlparser/HtmlAttribute.h
new file mode 100644
index 0000000..f473c92
--- /dev/null
+++ b/Sources/c_snikket/iinclude/htmlparser/HtmlAttribute.h
@@ -0,0 +1,72 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_htmlparser_HtmlAttribute
+#define INCLUDED_htmlparser_HtmlAttribute
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_630f17b70ccedfe6_10_new)
+HX_DECLARE_CLASS1(htmlparser,HtmlAttribute)
+
+namespace htmlparser{
+
+
+class HXCPP_CLASS_ATTRIBUTES HtmlAttribute_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef HtmlAttribute_obj OBJ_;
+		HtmlAttribute_obj();
+
+	public:
+		enum { _hx_ClassId = 0x49e2a647 };
+
+		void __construct(::String name,::String value,::String quote);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="htmlparser.HtmlAttribute")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"htmlparser.HtmlAttribute"); }
+
+		inline static ::hx::ObjectPtr< HtmlAttribute_obj > __new(::String name,::String value,::String quote) {
+			::hx::ObjectPtr< HtmlAttribute_obj > __this = new HtmlAttribute_obj();
+			__this->__construct(name,value,quote);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< HtmlAttribute_obj > __alloc(::hx::Ctx *_hx_ctx,::String name,::String value,::String quote) {
+			HtmlAttribute_obj *__this = (HtmlAttribute_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(HtmlAttribute_obj), true, "htmlparser.HtmlAttribute"));
+			*(void **)__this = HtmlAttribute_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_630f17b70ccedfe6_10_new)
+HXLINE(  11)		( ( ::htmlparser::HtmlAttribute)(__this) )->name = name;
+HXLINE(  12)		( ( ::htmlparser::HtmlAttribute)(__this) )->value = value;
+HXLINE(  13)		( ( ::htmlparser::HtmlAttribute)(__this) )->quote = quote;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HtmlAttribute_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HtmlAttribute",11,85,c2,03); }
+
+		::String name;
+		::String value;
+		::String quote;
+};
+
+} // end namespace htmlparser
+
+#endif /* INCLUDED_htmlparser_HtmlAttribute */ 
diff --git a/Sources/c_snikket/iinclude/htmlparser/HtmlNode.h b/Sources/c_snikket/iinclude/htmlparser/HtmlNode.h
new file mode 100644
index 0000000..2b2ab6c
--- /dev/null
+++ b/Sources/c_snikket/iinclude/htmlparser/HtmlNode.h
@@ -0,0 +1,63 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_htmlparser_HtmlNode
+#define INCLUDED_htmlparser_HtmlNode
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(htmlparser,HtmlNode)
+HX_DECLARE_CLASS1(htmlparser,HtmlNodeElement)
+
+namespace htmlparser{
+
+
+class HXCPP_CLASS_ATTRIBUTES HtmlNode_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef HtmlNode_obj OBJ_;
+		HtmlNode_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0ca65a7f };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="htmlparser.HtmlNode")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"htmlparser.HtmlNode"); }
+
+		inline static ::hx::ObjectPtr< HtmlNode_obj > __new() {
+			::hx::ObjectPtr< HtmlNode_obj > __this = new HtmlNode_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< HtmlNode_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			HtmlNode_obj *__this = (HtmlNode_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(HtmlNode_obj), true, "htmlparser.HtmlNode"));
+			*(void **)__this = HtmlNode_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HtmlNode_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HtmlNode",2d,19,fa,e5); }
+
+		 ::htmlparser::HtmlNodeElement parent;
+};
+
+} // end namespace htmlparser
+
+#endif /* INCLUDED_htmlparser_HtmlNode */ 
diff --git a/Sources/c_snikket/iinclude/htmlparser/HtmlNodeElement.h b/Sources/c_snikket/iinclude/htmlparser/HtmlNodeElement.h
new file mode 100644
index 0000000..6960292
--- /dev/null
+++ b/Sources/c_snikket/iinclude/htmlparser/HtmlNodeElement.h
@@ -0,0 +1,62 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_htmlparser_HtmlNodeElement
+#define INCLUDED_htmlparser_HtmlNodeElement
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_htmlparser_HtmlNode
+#include <htmlparser/HtmlNode.h>
+#endif
+HX_DECLARE_CLASS1(htmlparser,HtmlAttribute)
+HX_DECLARE_CLASS1(htmlparser,HtmlNode)
+HX_DECLARE_CLASS1(htmlparser,HtmlNodeElement)
+
+namespace htmlparser{
+
+
+class HXCPP_CLASS_ATTRIBUTES HtmlNodeElement_obj : public  ::htmlparser::HtmlNode_obj
+{
+	public:
+		typedef  ::htmlparser::HtmlNode_obj super;
+		typedef HtmlNodeElement_obj OBJ_;
+		HtmlNodeElement_obj();
+
+	public:
+		enum { _hx_ClassId = 0x234247c5 };
+
+		void __construct(::String name,::Array< ::Dynamic> attributes);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="htmlparser.HtmlNodeElement")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"htmlparser.HtmlNodeElement"); }
+		static ::hx::ObjectPtr< HtmlNodeElement_obj > __new(::String name,::Array< ::Dynamic> attributes);
+		static ::hx::ObjectPtr< HtmlNodeElement_obj > __alloc(::hx::Ctx *_hx_ctx,::String name,::Array< ::Dynamic> attributes);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HtmlNodeElement_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HtmlNodeElement",0f,ed,ee,fb); }
+
+		::String name;
+		::Array< ::Dynamic> attributes;
+		::Array< ::Dynamic> nodes;
+		::Array< ::Dynamic> children;
+		void addChild( ::htmlparser::HtmlNode node, ::htmlparser::HtmlNode beforeNode);
+		::Dynamic addChild_dyn();
+
+};
+
+} // end namespace htmlparser
+
+#endif /* INCLUDED_htmlparser_HtmlNodeElement */ 
diff --git a/Sources/c_snikket/iinclude/htmlparser/HtmlNodeText.h b/Sources/c_snikket/iinclude/htmlparser/HtmlNodeText.h
new file mode 100644
index 0000000..82be3b5
--- /dev/null
+++ b/Sources/c_snikket/iinclude/htmlparser/HtmlNodeText.h
@@ -0,0 +1,58 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_htmlparser_HtmlNodeText
+#define INCLUDED_htmlparser_HtmlNodeText
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_htmlparser_HtmlNode
+#include <htmlparser/HtmlNode.h>
+#endif
+HX_DECLARE_CLASS1(htmlparser,HtmlNode)
+HX_DECLARE_CLASS1(htmlparser,HtmlNodeText)
+
+namespace htmlparser{
+
+
+class HXCPP_CLASS_ATTRIBUTES HtmlNodeText_obj : public  ::htmlparser::HtmlNode_obj
+{
+	public:
+		typedef  ::htmlparser::HtmlNode_obj super;
+		typedef HtmlNodeText_obj OBJ_;
+		HtmlNodeText_obj();
+
+	public:
+		enum { _hx_ClassId = 0x699e2404 };
+
+		void __construct(::String text);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="htmlparser.HtmlNodeText")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"htmlparser.HtmlNodeText"); }
+		static ::hx::ObjectPtr< HtmlNodeText_obj > __new(::String text);
+		static ::hx::ObjectPtr< HtmlNodeText_obj > __alloc(::hx::Ctx *_hx_ctx,::String text);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HtmlNodeText_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HtmlNodeText",7a,ac,55,90); }
+
+		::String text;
+		::String toText();
+		::Dynamic toText_dyn();
+
+};
+
+} // end namespace htmlparser
+
+#endif /* INCLUDED_htmlparser_HtmlNodeText */ 
diff --git a/Sources/c_snikket/iinclude/htmlparser/HtmlParser.h b/Sources/c_snikket/iinclude/htmlparser/HtmlParser.h
new file mode 100644
index 0000000..88c417e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/htmlparser/HtmlParser.h
@@ -0,0 +1,98 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_htmlparser_HtmlParser
+#define INCLUDED_htmlparser_HtmlParser
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(EReg)
+HX_DECLARE_CLASS1(htmlparser,HtmlAttribute)
+HX_DECLARE_CLASS1(htmlparser,HtmlNode)
+HX_DECLARE_CLASS1(htmlparser,HtmlNodeElement)
+HX_DECLARE_CLASS1(htmlparser,HtmlParser)
+
+namespace htmlparser{
+
+
+class HXCPP_CLASS_ATTRIBUTES HtmlParser_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef HtmlParser_obj OBJ_;
+		HtmlParser_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0d37c69c };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="htmlparser.HtmlParser")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"htmlparser.HtmlParser"); }
+		static ::hx::ObjectPtr< HtmlParser_obj > __new();
+		static ::hx::ObjectPtr< HtmlParser_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HtmlParser_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HtmlParser",ca,0c,fb,b1); }
+
+		static void __boot();
+		static  ::Dynamic SELF_CLOSING_TAGS_HTML;
+		static ::String reID;
+		static ::String reNamespacedID;
+		static ::String reCDATA;
+		static ::String reScript;
+		static ::String reStyle;
+		static ::String reElementOpen;
+		static ::String reAttr;
+		static ::String reElementEnd;
+		static ::String reElementClose;
+		static ::String reComment;
+		static  ::EReg reMain;
+		static  ::EReg reParseAttrs;
+		static ::Array< ::Dynamic> run(::String str,::hx::Null< bool >  tolerant);
+		static ::Dynamic run_dyn();
+
+		static ::Array< ::Dynamic> parseAttrs(::String str);
+		static ::Dynamic parseAttrs_dyn();
+
+		bool tolerant;
+		::Array< ::Dynamic> matches;
+		::String str;
+		int i;
+		::Array< ::Dynamic> parse(::String str,::hx::Null< bool >  tolerant);
+		::Dynamic parse_dyn();
+
+		 ::Dynamic processMatches(::Array< ::String > openedTagsLC);
+		::Dynamic processMatches_dyn();
+
+		 ::Dynamic parseElement(::Array< ::String > openedTagsLC);
+		::Dynamic parseElement_dyn();
+
+		bool isSelfClosingTag(::String tag);
+		::Dynamic isSelfClosingTag_dyn();
+
+		 ::htmlparser::HtmlNodeElement newElement(::String name,::Array< ::Dynamic> attributes);
+		::Dynamic newElement_dyn();
+
+		 ::Dynamic getPosition(int matchIndex);
+		::Dynamic getPosition_dyn();
+
+};
+
+} // end namespace htmlparser
+
+#endif /* INCLUDED_htmlparser_HtmlParser */ 
diff --git a/Sources/c_snikket/iinclude/htmlparser/HtmlParserException.h b/Sources/c_snikket/iinclude/htmlparser/HtmlParserException.h
new file mode 100644
index 0000000..e32202a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/htmlparser/HtmlParserException.h
@@ -0,0 +1,77 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_htmlparser_HtmlParserException
+#define INCLUDED_htmlparser_HtmlParserException
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_8ec4e8a8c4e51446_12_new)
+HX_DECLARE_CLASS1(htmlparser,HtmlParserException)
+
+namespace htmlparser{
+
+
+class HXCPP_CLASS_ATTRIBUTES HtmlParserException_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef HtmlParserException_obj OBJ_;
+		HtmlParserException_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0872044b };
+
+		void __construct(::String message, ::Dynamic pos);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="htmlparser.HtmlParserException")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"htmlparser.HtmlParserException"); }
+
+		inline static ::hx::ObjectPtr< HtmlParserException_obj > __new(::String message, ::Dynamic pos) {
+			::hx::ObjectPtr< HtmlParserException_obj > __this = new HtmlParserException_obj();
+			__this->__construct(message,pos);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< HtmlParserException_obj > __alloc(::hx::Ctx *_hx_ctx,::String message, ::Dynamic pos) {
+			HtmlParserException_obj *__this = (HtmlParserException_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(HtmlParserException_obj), true, "htmlparser.HtmlParserException"));
+			*(void **)__this = HtmlParserException_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_8ec4e8a8c4e51446_12_new)
+HXLINE(  13)		( ( ::htmlparser::HtmlParserException)(__this) )->message = message;
+HXLINE(  15)		( ( ::htmlparser::HtmlParserException)(__this) )->line = ( (int)(pos->__Field(HX_("line",f4,17,b3,47),::hx::paccDynamic)) );
+HXLINE(  16)		( ( ::htmlparser::HtmlParserException)(__this) )->column = ( (int)(pos->__Field(HX_("column",d6,4e,8b,c6),::hx::paccDynamic)) );
+HXLINE(  17)		( ( ::htmlparser::HtmlParserException)(__this) )->length = ( (int)(pos->__Field(HX_("length",e6,94,07,9f),::hx::paccDynamic)) );
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HtmlParserException_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HtmlParserException",25,fa,72,da); }
+
+		::String message;
+		int line;
+		int column;
+		int length;
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+} // end namespace htmlparser
+
+#endif /* INCLUDED_htmlparser_HtmlParserException */ 
diff --git a/Sources/c_snikket/iinclude/htmlparser/HtmlTools.h b/Sources/c_snikket/iinclude/htmlparser/HtmlTools.h
new file mode 100644
index 0000000..a082fb8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/htmlparser/HtmlTools.h
@@ -0,0 +1,67 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_htmlparser_HtmlTools
+#define INCLUDED_htmlparser_HtmlTools
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS1(htmlparser,HtmlTools)
+
+namespace htmlparser{
+
+
+class HXCPP_CLASS_ATTRIBUTES HtmlTools_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef HtmlTools_obj OBJ_;
+		HtmlTools_obj();
+
+	public:
+		enum { _hx_ClassId = 0x319122e2 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="htmlparser.HtmlTools")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"htmlparser.HtmlTools"); }
+
+		inline static ::hx::ObjectPtr< HtmlTools_obj > __new() {
+			::hx::ObjectPtr< HtmlTools_obj > __this = new HtmlTools_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< HtmlTools_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			HtmlTools_obj *__this = (HtmlTools_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(HtmlTools_obj), false, "htmlparser.HtmlTools"));
+			*(void **)__this = HtmlTools_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HtmlTools_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HtmlTools",90,c8,4b,c9); }
+
+		static  ::haxe::ds::StringMap htmlUnescapeMap;
+		static  ::haxe::ds::StringMap get_htmlUnescapeMap();
+		static ::Dynamic get_htmlUnescapeMap_dyn();
+
+		static ::String unescape(::String text);
+		static ::Dynamic unescape_dyn();
+
+};
+
+} // end namespace htmlparser
+
+#endif /* INCLUDED_htmlparser_HtmlTools */ 
diff --git a/Sources/c_snikket/iinclude/httpstatus/_HttpStatusMessage/HttpStatusMessage_Impl_.h b/Sources/c_snikket/iinclude/httpstatus/_HttpStatusMessage/HttpStatusMessage_Impl_.h
new file mode 100644
index 0000000..dfe9b21
--- /dev/null
+++ b/Sources/c_snikket/iinclude/httpstatus/_HttpStatusMessage/HttpStatusMessage_Impl_.h
@@ -0,0 +1,62 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_httpstatus__HttpStatusMessage_HttpStatusMessage_Impl_
+#define INCLUDED_httpstatus__HttpStatusMessage_HttpStatusMessage_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(httpstatus,_HttpStatusMessage,HttpStatusMessage_Impl_)
+
+namespace httpstatus{
+namespace _HttpStatusMessage{
+
+
+class HXCPP_CLASS_ATTRIBUTES HttpStatusMessage_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef HttpStatusMessage_Impl__obj OBJ_;
+		HttpStatusMessage_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x0de4d9f9 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="httpstatus._HttpStatusMessage.HttpStatusMessage_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"httpstatus._HttpStatusMessage.HttpStatusMessage_Impl_"); }
+
+		inline static ::hx::ObjectPtr< HttpStatusMessage_Impl__obj > __new() {
+			::hx::ObjectPtr< HttpStatusMessage_Impl__obj > __this = new HttpStatusMessage_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< HttpStatusMessage_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			HttpStatusMessage_Impl__obj *__this = (HttpStatusMessage_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(HttpStatusMessage_Impl__obj), false, "httpstatus._HttpStatusMessage.HttpStatusMessage_Impl_"));
+			*(void **)__this = HttpStatusMessage_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HttpStatusMessage_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HttpStatusMessage_Impl_",4d,ec,1b,89); }
+
+		static ::String fromCode(int statusCode);
+		static ::Dynamic fromCode_dyn();
+
+};
+
+} // end namespace httpstatus
+} // end namespace _HttpStatusMessage
+
+#endif /* INCLUDED_httpstatus__HttpStatusMessage_HttpStatusMessage_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/hx/Anon.h b/Sources/c_snikket/iinclude/hx/Anon.h
new file mode 100644
index 0000000..f41e2ee
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/Anon.h
@@ -0,0 +1,752 @@
+#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; }
+   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
diff --git a/Sources/c_snikket/iinclude/hx/Boot.h b/Sources/c_snikket/iinclude/hx/Boot.h
new file mode 100644
index 0000000..22cafde
--- /dev/null
+++ b/Sources/c_snikket/iinclude/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
diff --git a/Sources/c_snikket/iinclude/hx/CFFI.h b/Sources/c_snikket/iinclude/hx/CFFI.h
new file mode 100644
index 0000000..872e197
--- /dev/null
+++ b/Sources/c_snikket/iinclude/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
diff --git a/Sources/c_snikket/iinclude/hx/CFFIAPI.h b/Sources/c_snikket/iinclude/hx/CFFIAPI.h
new file mode 100644
index 0000000..6a05ada
--- /dev/null
+++ b/Sources/c_snikket/iinclude/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*)
+
+
diff --git a/Sources/c_snikket/iinclude/hx/CFFIJsPrime.h b/Sources/c_snikket/iinclude/hx/CFFIJsPrime.h
new file mode 100644
index 0000000..cc72082
--- /dev/null
+++ b/Sources/c_snikket/iinclude/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*)
+*/
+
+
+}
diff --git a/Sources/c_snikket/iinclude/hx/CFFILoader.h b/Sources/c_snikket/iinclude/hx/CFFILoader.h
new file mode 100644
index 0000000..ed95f1f
--- /dev/null
+++ b/Sources/c_snikket/iinclude/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
+
+
diff --git a/Sources/c_snikket/iinclude/hx/CFFINekoLoader.h b/Sources/c_snikket/iinclude/hx/CFFINekoLoader.h
new file mode 100644
index 0000000..9fbb3b7
--- /dev/null
+++ b/Sources/c_snikket/iinclude/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
+
diff --git a/Sources/c_snikket/iinclude/hx/CFFIPrime.h b/Sources/c_snikket/iinclude/hx/CFFIPrime.h
new file mode 100644
index 0000000..88481f8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/CFFIPrime.h
@@ -0,0 +1,1101 @@
+#ifndef HX_CFFIPRIME_INCLUDED
+#define HX_CFFIPRIME_INCLUDED
+
+#include <hx/StringAlloc.h>
+
+
+#define HXCPP_PRIME
+
+
+namespace cffi
+{
+template<typename T>
+inline const char *to_utf8(const T *inStr,int &ioLen,hx::IStringAlloc *inAlloc)
+{
+  int len = 0;
+  int n = ioLen;
+  if (n==0)
+     while(inStr[n])
+        n++;
+  for(int i=0;i<n;i++)
+  {
+      int c = inStr[i];
+      if ( sizeof(T)==2 && c>=0xd800)
+      {
+         i++;
+         int peek = i<n ? inStr[i] : 0xdc00;
+         if (peek<0xdc00)
+            peek = 0xdc00;
+         c = 0x10000 | ((c-0xd800)  << 10) | (peek-0xdc00);
+      }
+
+      if( c <= 0x7F ) len++;
+      else if( c <= 0x7FF ) len+=2;
+      else if( c <= 0xFFFF ) len+=3;
+      else len+= 4;
+   }
+
+   char *result = (char *)inAlloc->allocBytes(len+1);
+   unsigned char *data =  (unsigned char *)result;
+   for(int i=0;i<n;i++)
+   {
+      int c = inStr[i];
+      if ( sizeof(T)==2 && c>=0xd800)
+      {
+         int peek = i+1<n ? 0xdc00 : inStr[i+1];
+         if (peek<0xdc00)
+            peek = 0xdc00;
+         c = 0x10000 | ((c-0xd800)  << 10) | (peek-0xdc00);
+         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;
+   ioLen = len;
+   return result;
+}
+
+static inline int decode_advance_utf8(const unsigned char * &ioPtr,const unsigned char *end)
+{
+   int c = *ioPtr++;
+   if( c < 0x80 )
+   {
+      return c;
+   }
+   else if( c < 0xE0 )
+   {
+      return ((c & 0x3F) << 6) | (ioPtr < end ? (*ioPtr++) & 0x7F : 0);
+   }
+   else if( c < 0xF0 )
+   {
+      int c2 = ioPtr<end ? *ioPtr++ : 0;
+      return  ((c & 0x1F) << 12) | ((c2 & 0x7F) << 6) | ( ioPtr<end ? (*ioPtr++) & 0x7F : 0 );
+   }
+
+   int c2 = ioPtr<end ? *ioPtr++ : 0;
+   int c3 = ioPtr<end ? *ioPtr++ : 0;
+   return ((c & 0x0F) << 18) | ((c2 & 0x7F) << 12) | ((c3 & 0x7F) << 6) | ( ioPtr<end ? (*ioPtr++) & 0x7F : 0);
+}
+
+template<typename T>
+inline const T *from_utf8(const char *inStr,int len,hx::IStringAlloc *inAlloc)
+{
+   int n = len;
+   if (n<0)
+      while(inStr[n])
+         n++;
+
+   const unsigned char *str = (const unsigned char *)inStr;
+   const unsigned char *end = str + n;
+   int count = 0;
+   while(str<end)
+   {
+      int ch = decode_advance_utf8(str,end);
+      count++;
+      if (sizeof(T)==2 &&  ch>=0x10000)
+         count++;
+   }
+   T *result = (T*)inAlloc->allocBytes( sizeof(T)*(count+1) );
+   T *dest = result;
+   str = (const unsigned char *)inStr;
+   while(str<end)
+   {
+      int ch = decode_advance_utf8(str,end);
+      if (sizeof(T)==2 && ch>=0x10000)
+      {
+         int over = (ch-0x10000);
+         *dest++ = (over>>10) + 0xd800;
+         *dest++ = (over&0x3ff) + 0xdc00;
+      }
+      else
+         *dest++ = ch;
+   }
+   *dest++ = 0;
+
+   return result;
+}
+
+}
+
+#ifdef HXCPP_JS_PRIME
+#include <string>
+typedef std::string HxString;
+
+#else
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4190 )
+#endif
+
+struct HxString
+{
+   inline HxString(const HxString &inRHS)
+   {
+      length = inRHS.length;
+      __s = inRHS.__s;
+   }
+   inline HxString() : length(0), __s(0) { }
+   inline HxString(const char *inS,int inLen=-1, bool inAllocGcString=true);
+   inline int size() const { return length; }
+   inline const char *c_str() const { return __s; }
+
+
+   int length;
+   const char *__s;
+};
+
+#include "CFFI.h"
+#endif
+
+#ifndef HXCPP_JS_PRIME
+HxString::HxString(const char *inS,int inLen, bool inAllocGcString) : length(inLen), __s(inS)
+{
+   if (!inS)
+      length = 0;
+   else
+   {
+      if (length<0)
+         for(length=0; __s[length]; length++)
+         {
+         }
+      if (inAllocGcString)
+         __s = alloc_string_data(__s, length);
+   }
+}
+#endif
+
+
+
+namespace cffi
+{
+
+inline value alloc_pointer(void *inPtr) { return alloc_abstract((vkind)(0x100 + 2),inPtr); }
+
+
+template<typename T> struct SigType { enum { Char='?' }; };
+template<> struct SigType<bool> { enum { Char='b' }; };
+template<> struct SigType<int> { enum { Char='i' }; };
+template<> struct SigType<float> { enum { Char='f' }; };
+template<> struct SigType<double> { enum { Char='d' }; };
+template<> struct SigType<value> { enum { Char='o' }; };
+template<> struct SigType<void> { enum { Char='v' }; };
+template<> struct SigType<const char *> { enum { Char='c' }; };
+template<> struct SigType<HxString> { enum { Char='s' }; };
+
+template<typename RET>
+bool CheckSig0( RET (func)(), const char *inSig)
+{
+   return SigType<RET>::Char==inSig[0] &&
+          0 == inSig[1];
+}
+
+
+template<typename RET, typename A0>
+bool CheckSig1( RET (func)(A0), const char *inSig)
+{
+   return SigType<A0>::Char==inSig[0] &&
+          SigType<RET>::Char==inSig[1] &&
+          0 == inSig[2];
+}
+
+
+template<typename RET, typename A0, typename A1>
+bool CheckSig2( RET (func)(A0,A1), const char *inSig)
+{
+   return SigType<A0>::Char==inSig[0] &&
+          SigType<A1>::Char==inSig[1] &&
+          SigType<RET>::Char==inSig[2] &&
+          0 == inSig[3];
+}
+
+
+template<typename RET, typename A0, typename A1, typename A2>
+bool CheckSig3( RET (func)(A0,A1,A2), const char *inSig)
+{
+   return SigType<A0>::Char==inSig[0] &&
+          SigType<A1>::Char==inSig[1] &&
+          SigType<A2>::Char==inSig[2] &&
+          SigType<RET>::Char==inSig[3] &&
+          0 == inSig[4];
+}
+
+
+template<typename RET, typename A0, typename A1, typename A2, typename A3>
+bool CheckSig4( RET (func)(A0,A1,A2,A3), const char *inSig)
+{
+   return SigType<A0>::Char==inSig[0] &&
+          SigType<A1>::Char==inSig[1] &&
+          SigType<A2>::Char==inSig[2] &&
+          SigType<A3>::Char==inSig[3] &&
+          SigType<RET>::Char==inSig[4] &&
+          0 == inSig[5];
+}
+
+
+template<typename RET, typename A0, typename A1, typename A2, typename A3, typename A4>
+bool CheckSig5( RET (func)(A0,A1,A2,A3,A4), const char *inSig)
+{
+   return SigType<A0>::Char==inSig[0] &&
+          SigType<A1>::Char==inSig[1] &&
+          SigType<A2>::Char==inSig[2] &&
+          SigType<A3>::Char==inSig[3] &&
+          SigType<A4>::Char==inSig[4] &&
+          SigType<RET>::Char==inSig[5] &&
+          0 == inSig[6];
+}
+
+template<typename RET, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
+bool CheckSig6( RET (func)(A0,A1,A2,A3,A4,A5), const char *inSig)
+{
+   return SigType<A0>::Char==inSig[0] &&
+          SigType<A1>::Char==inSig[1] &&
+          SigType<A2>::Char==inSig[2] &&
+          SigType<A3>::Char==inSig[3] &&
+          SigType<A4>::Char==inSig[4] &&
+          SigType<A5>::Char==inSig[5] &&
+          SigType<RET>::Char==inSig[6] &&
+          0 == inSig[7];
+}
+
+
+template<typename RET, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
+bool CheckSig7( RET (func)(A0,A1,A2,A3,A4,A5,A6), const char *inSig)
+{
+   return SigType<A0>::Char==inSig[0] &&
+          SigType<A1>::Char==inSig[1] &&
+          SigType<A2>::Char==inSig[2] &&
+          SigType<A3>::Char==inSig[3] &&
+          SigType<A4>::Char==inSig[4] &&
+          SigType<A5>::Char==inSig[5] &&
+          SigType<A6>::Char==inSig[6] &&
+          SigType<RET>::Char==inSig[7] &&
+          0 == inSig[8];
+}
+
+template<typename RET, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
+bool CheckSig8( RET (func)(A0,A1,A2,A3,A4,A5,A6,A7), const char *inSig)
+{
+   return SigType<A0>::Char==inSig[0] &&
+          SigType<A1>::Char==inSig[1] &&
+          SigType<A2>::Char==inSig[2] &&
+          SigType<A3>::Char==inSig[3] &&
+          SigType<A4>::Char==inSig[4] &&
+          SigType<A5>::Char==inSig[5] &&
+          SigType<A6>::Char==inSig[6] &&
+          SigType<A7>::Char==inSig[7] &&
+          SigType<RET>::Char==inSig[8] &&
+          0 == inSig[9];
+}
+
+
+template<typename RET, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
+bool CheckSig9( RET (func)(A0,A1,A2,A3,A4,A5,A6,A7,A8), const char *inSig)
+{
+   return SigType<A0>::Char==inSig[0] &&
+          SigType<A1>::Char==inSig[1] &&
+          SigType<A2>::Char==inSig[2] &&
+          SigType<A3>::Char==inSig[3] &&
+          SigType<A4>::Char==inSig[4] &&
+          SigType<A5>::Char==inSig[5] &&
+          SigType<A6>::Char==inSig[6] &&
+          SigType<A7>::Char==inSig[7] &&
+          SigType<A8>::Char==inSig[8] &&
+          SigType<RET>::Char==inSig[9] &&
+          0 == inSig[10];
+}
+
+template<typename RET, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
+bool CheckSig10( RET (func)(A0,A1,A2,A3,A4,A5,A6,A7,A8,A9), const char *inSig)
+{
+   return SigType<A0>::Char==inSig[0] &&
+          SigType<A1>::Char==inSig[1] &&
+          SigType<A2>::Char==inSig[2] &&
+          SigType<A3>::Char==inSig[3] &&
+          SigType<A4>::Char==inSig[4] &&
+          SigType<A5>::Char==inSig[5] &&
+          SigType<A6>::Char==inSig[6] &&
+          SigType<A7>::Char==inSig[7] &&
+          SigType<A8>::Char==inSig[8] &&
+          SigType<A9>::Char==inSig[9] &&
+          SigType<RET>::Char==inSig[10] &&
+          0 == inSig[11];
+}
+
+template<typename RET, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10>
+bool CheckSig11( RET (func)(A0,A1,A2,A3,A4,A5,A6,A7,A8,A9, A10), const char *inSig)
+{
+   return SigType<A0>::Char==inSig[0] &&
+          SigType<A1>::Char==inSig[1] &&
+          SigType<A2>::Char==inSig[2] &&
+          SigType<A3>::Char==inSig[3] &&
+          SigType<A4>::Char==inSig[4] &&
+          SigType<A5>::Char==inSig[5] &&
+          SigType<A6>::Char==inSig[6] &&
+          SigType<A7>::Char==inSig[7] &&
+          SigType<A8>::Char==inSig[8] &&
+          SigType<A9>::Char==inSig[9] &&
+          SigType<A10>::Char==inSig[10] &&
+          SigType<RET>::Char==inSig[11] &&
+          0 == inSig[12];
+}
+
+
+template<typename RET, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11>
+bool CheckSig12( RET (func)(A0,A1,A2,A3,A4,A5,A6,A7,A8,A9, A10, A11), const char *inSig)
+{
+   return SigType<A0>::Char==inSig[0] &&
+          SigType<A1>::Char==inSig[1] &&
+          SigType<A2>::Char==inSig[2] &&
+          SigType<A3>::Char==inSig[3] &&
+          SigType<A4>::Char==inSig[4] &&
+          SigType<A5>::Char==inSig[5] &&
+          SigType<A6>::Char==inSig[6] &&
+          SigType<A7>::Char==inSig[7] &&
+          SigType<A8>::Char==inSig[8] &&
+          SigType<A9>::Char==inSig[9] &&
+          SigType<A10>::Char==inSig[10] &&
+          SigType<A11>::Char==inSig[11] &&
+          SigType<RET>::Char==inSig[12] &&
+          0 == inSig[13];
+}
+
+template<typename RET, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12>
+bool CheckSig13( RET (func)(A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12), const char *inSig)
+{
+   return SigType<A0>::Char==inSig[0] &&
+          SigType<A1>::Char==inSig[1] &&
+          SigType<A2>::Char==inSig[2] &&
+          SigType<A3>::Char==inSig[3] &&
+          SigType<A4>::Char==inSig[4] &&
+          SigType<A5>::Char==inSig[5] &&
+          SigType<A6>::Char==inSig[6] &&
+          SigType<A7>::Char==inSig[7] &&
+          SigType<A8>::Char==inSig[8] &&
+          SigType<A9>::Char==inSig[9] &&
+          SigType<A10>::Char==inSig[10] &&
+          SigType<A11>::Char==inSig[11] &&
+          SigType<A12>::Char==inSig[12] &&
+          SigType<RET>::Char==inSig[13] &&
+          0 == inSig[14];
+}
+
+template<typename RET, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13>
+bool CheckSig14( RET (func)(A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13), const char *inSig)
+{
+   return SigType<A0>::Char==inSig[0] &&
+          SigType<A1>::Char==inSig[1] &&
+          SigType<A2>::Char==inSig[2] &&
+          SigType<A3>::Char==inSig[3] &&
+          SigType<A4>::Char==inSig[4] &&
+          SigType<A5>::Char==inSig[5] &&
+          SigType<A6>::Char==inSig[6] &&
+          SigType<A7>::Char==inSig[7] &&
+          SigType<A8>::Char==inSig[8] &&
+          SigType<A9>::Char==inSig[9] &&
+          SigType<A10>::Char==inSig[10] &&
+          SigType<A11>::Char==inSig[11] &&
+          SigType<A12>::Char==inSig[12] &&
+          SigType<A13>::Char==inSig[13] &&
+          SigType<RET>::Char==inSig[14] &&
+          0 == inSig[15];
+}
+
+
+template<typename RET, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14>
+bool CheckSig15( RET (func)(A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14), const char *inSig)
+{
+   return SigType<A0>::Char==inSig[0] &&
+          SigType<A1>::Char==inSig[1] &&
+          SigType<A2>::Char==inSig[2] &&
+          SigType<A3>::Char==inSig[3] &&
+          SigType<A4>::Char==inSig[4] &&
+          SigType<A5>::Char==inSig[5] &&
+          SigType<A6>::Char==inSig[6] &&
+          SigType<A7>::Char==inSig[7] &&
+          SigType<A8>::Char==inSig[8] &&
+          SigType<A9>::Char==inSig[9] &&
+          SigType<A10>::Char==inSig[10] &&
+          SigType<A11>::Char==inSig[11] &&
+          SigType<A12>::Char==inSig[12] &&
+          SigType<A13>::Char==inSig[13] &&
+          SigType<A14>::Char==inSig[14] &&
+          SigType<RET>::Char==inSig[15] &&
+          0 == inSig[16];
+}
+
+
+inline value ToValue(int inVal) { return alloc_int(inVal); }
+inline value ToValue(long inVal) { return alloc_int32(inVal); }
+inline value ToValue(float inVal) { return alloc_float(inVal); }
+inline value ToValue(double inVal) { return alloc_float(inVal); }
+inline value ToValue(value inVal) { return inVal; }
+inline value ToValue(bool inVal) { return alloc_bool(inVal); }
+#ifdef HXCPP_JS_PRIME
+inline value ToValue(HxString inVal) { return inVal.c_str() ? alloc_string_len(inVal.c_str(),inVal.size()) : alloc_null() ; }
+#else
+inline value ToValue(HxString inVal) { return inVal.__s ? alloc_string_len(inVal.c_str(),inVal.size()) : alloc_null() ; }
+#endif
+
+struct AutoValue
+{
+   value mValue;
+   
+   inline operator int()  { return val_int(mValue); }
+   inline operator long() { return (long)val_number(mValue); }
+   inline operator value() { return mValue; }
+   inline operator double() { return val_number(mValue); }
+   inline operator float() { return val_number(mValue); }
+   inline operator bool() { return val_bool(mValue); }
+   inline operator const char *() { return val_string(mValue); }
+   inline operator HxString() { return val_is_null(mValue) ? HxString(0,0) : HxString(val_string(mValue), val_strlen(mValue), false); }
+};
+
+
+
+} // end namespace cffi
+
+
+#define PRIME_ARG_DECL0
+#define PRIME_ARG_DECL1 cffi::AutoValue a0
+#define PRIME_ARG_DECL2 PRIME_ARG_DECL1, cffi::AutoValue a1
+#define PRIME_ARG_DECL3 PRIME_ARG_DECL2, cffi::AutoValue a2
+#define PRIME_ARG_DECL4 PRIME_ARG_DECL3, cffi::AutoValue a3
+#define PRIME_ARG_DECL5 PRIME_ARG_DECL4, cffi::AutoValue a4
+
+#define PRIME_ARG_LIST0
+#define PRIME_ARG_LIST1 a0
+#define PRIME_ARG_LIST2 PRIME_ARG_LIST1, a1
+#define PRIME_ARG_LIST3 PRIME_ARG_LIST2, a2
+#define PRIME_ARG_LIST4 PRIME_ARG_LIST3, a3
+#define PRIME_ARG_LIST5 PRIME_ARG_LIST4, a4
+#define PRIME_ARG_LIST6 arg[0],arg[1],arg[2],arg[3],arg[4],arg[5]
+#define PRIME_ARG_LIST7 PRIME_ARG_LIST6 ,arg[6]
+#define PRIME_ARG_LIST8 PRIME_ARG_LIST7 ,arg[7]
+#define PRIME_ARG_LIST9 PRIME_ARG_LIST8 ,arg[8]
+#define PRIME_ARG_LIST10 PRIME_ARG_LIST9 ,arg[9]
+#define PRIME_ARG_LIST11 PRIME_ARG_LIST10 ,arg[10]
+#define PRIME_ARG_LIST12 PRIME_ARG_LIST11 ,arg[11]
+#define PRIME_ARG_LIST13 PRIME_ARG_LIST12 ,arg[12]
+#define PRIME_ARG_LIST14 PRIME_ARG_LIST13 ,arg[13]
+#define PRIME_ARG_LIST15 PRIME_ARG_LIST14 ,arg[14]
+
+
+
+#ifdef HXCPP_JS_PRIME
+
+
+#define DEFINE_PRIME0(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME1(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME2(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME3(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME4(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME5(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME6(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME7(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME8(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME9(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME10(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME11(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME12(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME13(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME14(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME15(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+
+
+#define DEFINE_PRIME0v(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME1v(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME2v(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME3v(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME4v(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME5v(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME6v(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME7v(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME8v(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME9v(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME10v(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME11v(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME12v(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME13v(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME14v(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+#define DEFINE_PRIME15v(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
+
+
+#elif defined(STATIC_LINK)
+
+#if defined(HXCPP_STATIC_CFFI) || defined(HXCPP_NO_PRIME_EXPORT)
+#define PRIME_EXPORT
+#else
+#define PRIME_EXPORT EXPORT
+#endif
+
+#define DEFINE_PRIME0(func) extern "C" { \
+  PRIME_EXPORT value func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig0(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap() { return cffi::ToValue( func() ); } \
+  PRIME_EXPORT void *func##__0() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__0",(void *)(&func##__wrap)); \
+}
+
+#define DEFINE_PRIME0v(func) extern "C" { \
+  PRIME_EXPORT value func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig0(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap() { func(); return alloc_null(); } \
+  PRIME_EXPORT void *func##__0() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__0",(void *)(&func##__wrap)); \
+}
+
+
+#define DEFINE_PRIME1(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig1(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(PRIME_ARG_DECL1) { return cffi::ToValue( func(PRIME_ARG_LIST1) ); } \
+  PRIME_EXPORT void *func##__1() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__1",(void *)(&func##__wrap)); \
+}
+
+#define DEFINE_PRIME1v(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig1(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(PRIME_ARG_DECL1) { func(PRIME_ARG_LIST1); return alloc_null(); } \
+  PRIME_EXPORT void *func##__1() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__1",(void *)(&func##__wrap)); \
+}
+
+
+#define DEFINE_PRIME2(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig2(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(PRIME_ARG_DECL2) { return cffi::ToValue( func(PRIME_ARG_LIST2) ); } \
+  PRIME_EXPORT void *func##__2() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__2",(void *)(&func##__wrap)); \
+}
+
+#define DEFINE_PRIME2v(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig2(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(PRIME_ARG_DECL2) { func(PRIME_ARG_LIST2); return alloc_null(); } \
+  PRIME_EXPORT void *func##__2() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__2",(void *)(&func##__wrap)); \
+}
+
+
+#define DEFINE_PRIME3(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig3(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(PRIME_ARG_DECL3) { return cffi::ToValue( func(PRIME_ARG_LIST3) ); } \
+  PRIME_EXPORT void *func##__3() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__3",(void *)(&func##__wrap)); \
+}
+
+#define DEFINE_PRIME3v(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig3(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(PRIME_ARG_DECL3) { func(PRIME_ARG_LIST3); return alloc_null(); } \
+  PRIME_EXPORT void *func##__3() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__3",(void *)(&func##__wrap)); \
+}
+
+
+#define DEFINE_PRIME4(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig4(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(PRIME_ARG_DECL4) { return cffi::ToValue( func(PRIME_ARG_LIST4) ); } \
+  PRIME_EXPORT void *func##__4() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__4",(void *)(&func##__wrap)); \
+}
+
+#define DEFINE_PRIME4v(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig4(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(PRIME_ARG_DECL4) { func(PRIME_ARG_LIST4); return alloc_null(); } \
+  PRIME_EXPORT void *func##__4() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__4",(void *)(&func##__wrap)); \
+}
+
+
+#define DEFINE_PRIME5(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig5(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(PRIME_ARG_DECL5) { return cffi::ToValue( func(PRIME_ARG_LIST5) ); } \
+  PRIME_EXPORT void *func##__5() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__5",(void *)(&func##__wrap)); \
+}
+
+#define DEFINE_PRIME5v(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig5(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(PRIME_ARG_DECL5) { func(PRIME_ARG_LIST5); return alloc_null(); } \
+  PRIME_EXPORT void *func##__5() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__5",(void *)(&func##__wrap)); \
+}
+
+
+#define DEFINE_PRIME6(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig6(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg,int) { return cffi::ToValue( func(PRIME_ARG_LIST6) ); } \
+  PRIME_EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__MULT",(void *)(&func##__wrap)); \
+}
+
+#define DEFINE_PRIME6v(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig6(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg, int) { func(PRIME_ARG_LIST6); return alloc_null(); } \
+  PRIME_EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__MULT",(void *)(&func##__wrap)); \
+}
+
+
+#define DEFINE_PRIME7(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig7(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg,int) { return cffi::ToValue( func(PRIME_ARG_LIST7) ); } \
+  PRIME_EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__MULT",(void *)(&func##__wrap)); \
+}
+
+#define DEFINE_PRIME7v(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig7(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg, int) { func(PRIME_ARG_LIST7); return alloc_null(); } \
+  PRIME_EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__MULT",(void *)(&func##__wrap)); \
+}
+
+#define DEFINE_PRIME8(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig8(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg,int) { return cffi::ToValue( func(PRIME_ARG_LIST8) ); } \
+  PRIME_EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__MULT",(void *)(&func##__wrap)); \
+}
+
+#define DEFINE_PRIME8v(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig8(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg, int) { func(PRIME_ARG_LIST8); return alloc_null(); } \
+  PRIME_EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__MULT",(void *)(&func##__wrap)); \
+}
+
+
+#define DEFINE_PRIME9(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig9(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg,int) { return cffi::ToValue( func(PRIME_ARG_LIST9) ); } \
+  PRIME_EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__MULT",(void *)(&func##__wrap)); \
+}
+
+#define DEFINE_PRIME9v(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig9(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg, int) { func(PRIME_ARG_LIST9); return alloc_null(); } \
+  PRIME_EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__MULT",(void *)(&func##__wrap)); \
+}
+
+#define DEFINE_PRIME10(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig10(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg,int) { return cffi::ToValue( func(PRIME_ARG_LIST10) ); } \
+  PRIME_EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__MULT",(void *)(&func##__wrap)); \
+}
+
+#define DEFINE_PRIME10v(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig10(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg, int) { func(PRIME_ARG_LIST10); return alloc_null(); } \
+  PRIME_EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__MULT",(void *)(&func##__wrap)); \
+}
+
+
+#define DEFINE_PRIME11(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig11(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg,int) { return cffi::ToValue( func(PRIME_ARG_LIST11) ); } \
+  PRIME_EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__MULT",(void *)(&func##__wrap)); \
+}
+
+#define DEFINE_PRIME11v(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig11(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg, int) { func(PRIME_ARG_LIST11); return alloc_null(); } \
+  PRIME_EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__MULT",(void *)(&func##__wrap)); \
+}
+
+
+#define DEFINE_PRIME12(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig12(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg,int) { return cffi::ToValue( func(PRIME_ARG_LIST12) ); } \
+  PRIME_EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__MULT",(void *)(&func##__wrap)); \
+}
+
+#define DEFINE_PRIME12v(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig12(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg, int) { func(PRIME_ARG_LIST12); return alloc_null(); } \
+  PRIME_EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__MULT",(void *)(&func##__wrap)); \
+}
+
+
+
+#define DEFINE_PRIME13(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig13(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg,int) { return cffi::ToValue( func(PRIME_ARG_LIST13) ); } \
+  PRIME_EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__MULT",(void *)(&func##__wrap)); \
+}
+
+#define DEFINE_PRIME13v(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig13(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg, int) { func(PRIME_ARG_LIST13); return alloc_null(); } \
+  PRIME_EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__MULT",(void *)(&func##__wrap)); \
+}
+
+
+#define DEFINE_PRIME14(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig14(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg,int) { return cffi::ToValue( func(PRIME_ARG_LIST14) ); } \
+  PRIME_EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__MULT",(void *)(&func##__wrap)); \
+}
+
+#define DEFINE_PRIME14v(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig14(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg, int) { func(PRIME_ARG_LIST14); return alloc_null(); } \
+  PRIME_EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__MULT",(void *)(&func##__wrap)); \
+}
+
+
+
+#define DEFINE_PRIME15(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig15(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg,int) { return cffi::ToValue( func(PRIME_ARG_LIST15) ); } \
+  PRIME_EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__MULT",(void *)(&func##__wrap)); \
+}
+
+#define DEFINE_PRIME15v(func) extern "C" { \
+  PRIME_EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig15(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg, int) { func(PRIME_ARG_LIST15); return alloc_null(); } \
+  PRIME_EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+  int __reg_##func##__prime = hx_register_prim(#func "__prime",(void *)(&func##__prime)); \
+  int __reg_##func = hx_register_prim(#func "__MULT",(void *)(&func##__wrap)); \
+}
+
+
+#else
+
+
+#define DEFINE_PRIME0(func) extern "C" { \
+  EXPORT value func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig0(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap() { return cffi::ToValue( func() ); } \
+  EXPORT void *func##__0() { return (void*)(&func##__wrap); } \
+}
+
+#define DEFINE_PRIME0v(func) extern "C" { \
+  EXPORT value func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig0(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap() { func(); return alloc_null(); } \
+  EXPORT void *func##__0() { return (void*)(&func##__wrap); } \
+}
+
+
+#define DEFINE_PRIME1(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig1(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(PRIME_ARG_DECL1) { return cffi::ToValue( func(PRIME_ARG_LIST1) ); } \
+  EXPORT void *func##__1() { return (void*)(&func##__wrap); } \
+}
+
+#define DEFINE_PRIME1v(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig1(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(PRIME_ARG_DECL1) { func(PRIME_ARG_LIST1); return alloc_null(); } \
+  EXPORT void *func##__1() { return (void*)(&func##__wrap); } \
+}
+
+
+#define DEFINE_PRIME2(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig2(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(PRIME_ARG_DECL2) { return cffi::ToValue( func(PRIME_ARG_LIST2) ); } \
+  EXPORT void *func##__2() { return (void*)(&func##__wrap); } \
+}
+
+#define DEFINE_PRIME2v(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig2(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(PRIME_ARG_DECL2) { func(PRIME_ARG_LIST2); return alloc_null(); } \
+  EXPORT void *func##__2() { return (void*)(&func##__wrap); } \
+}
+
+
+#define DEFINE_PRIME3(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig3(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(PRIME_ARG_DECL3) { return cffi::ToValue( func(PRIME_ARG_LIST3) ); } \
+  EXPORT void *func##__3() { return (void*)(&func##__wrap); } \
+}
+
+#define DEFINE_PRIME3v(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig3(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(PRIME_ARG_DECL3) { func(PRIME_ARG_LIST3); return alloc_null(); } \
+  EXPORT void *func##__3() { return (void*)(&func##__wrap); } \
+}
+
+
+#define DEFINE_PRIME4(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig4(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(PRIME_ARG_DECL4) { return cffi::ToValue( func(PRIME_ARG_LIST4) ); } \
+  EXPORT void *func##__4() { return (void*)(&func##__wrap); } \
+}
+
+#define DEFINE_PRIME4v(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig4(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(PRIME_ARG_DECL4) { func(PRIME_ARG_LIST4); return alloc_null(); } \
+  EXPORT void *func##__4() { return (void*)(&func##__wrap); } \
+}
+
+
+#define DEFINE_PRIME5(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig5(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(PRIME_ARG_DECL5) { return cffi::ToValue( func(PRIME_ARG_LIST5) ); } \
+  EXPORT void *func##__5() { return (void*)(&func##__wrap); } \
+}
+
+#define DEFINE_PRIME5v(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig5(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(PRIME_ARG_DECL5) { func(PRIME_ARG_LIST5); return alloc_null(); } \
+  EXPORT void *func##__5() { return (void*)(&func##__wrap); } \
+}
+
+
+#define DEFINE_PRIME6(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig6(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg,int) { return cffi::ToValue( func(PRIME_ARG_LIST6) ); } \
+  EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+}
+
+#define DEFINE_PRIME6v(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig6(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg, int) { func(PRIME_ARG_LIST6); return alloc_null(); } \
+  EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+}
+
+
+#define DEFINE_PRIME7(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig7(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg,int) { return cffi::ToValue( func(PRIME_ARG_LIST7) ); } \
+  EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+}
+
+#define DEFINE_PRIME7v(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig7(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg, int) { func(PRIME_ARG_LIST7); return alloc_null(); } \
+  EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+}
+
+#define DEFINE_PRIME8(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig8(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg,int) { return cffi::ToValue( func(PRIME_ARG_LIST8) ); } \
+  EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+}
+
+#define DEFINE_PRIME8v(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig8(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg, int) { func(PRIME_ARG_LIST8); return alloc_null(); } \
+  EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+}
+
+
+#define DEFINE_PRIME9(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig9(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg,int) { return cffi::ToValue( func(PRIME_ARG_LIST9) ); } \
+  EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+}
+
+#define DEFINE_PRIME9v(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig9(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg, int) { func(PRIME_ARG_LIST9); return alloc_null(); } \
+  EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+}
+
+#define DEFINE_PRIME10(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig10(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg,int) { return cffi::ToValue( func(PRIME_ARG_LIST10) ); } \
+  EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+}
+
+#define DEFINE_PRIME10v(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig10(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg, int) { func(PRIME_ARG_LIST10); return alloc_null(); } \
+  EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+}
+
+
+#define DEFINE_PRIME11(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig11(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg,int) { return cffi::ToValue( func(PRIME_ARG_LIST11) ); } \
+  EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+}
+
+#define DEFINE_PRIME11v(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig11(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg, int) { func(PRIME_ARG_LIST11); return alloc_null(); } \
+  EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+}
+
+
+#define DEFINE_PRIME12(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig12(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg,int) { return cffi::ToValue( func(PRIME_ARG_LIST12) ); } \
+  EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+}
+
+#define DEFINE_PRIME12v(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig12(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg, int) { func(PRIME_ARG_LIST12); return alloc_null(); } \
+  EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+}
+
+
+
+#define DEFINE_PRIME13(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig13(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg,int) { return cffi::ToValue( func(PRIME_ARG_LIST13) ); } \
+  EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+}
+
+#define DEFINE_PRIME13v(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig13(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg, int) { func(PRIME_ARG_LIST13); return alloc_null(); } \
+  EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+}
+
+
+#define DEFINE_PRIME14(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig14(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg,int) { return cffi::ToValue( func(PRIME_ARG_LIST14) ); } \
+  EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+}
+
+#define DEFINE_PRIME14v(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig14(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg, int) { func(PRIME_ARG_LIST14); return alloc_null(); } \
+  EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+}
+
+#define DEFINE_PRIME15(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig15(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg,int) { return cffi::ToValue( func(PRIME_ARG_LIST15) ); } \
+  EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+}
+
+#define DEFINE_PRIME15v(func) extern "C" { \
+  EXPORT void *func##__prime(const char *inSig) { \
+     if (!cffi::CheckSig15(func,inSig)) return 0; return cffi::alloc_pointer((void*)&func); } \
+  value func##__wrap(cffi::AutoValue  *arg, int) { func(PRIME_ARG_LIST15); return alloc_null(); } \
+  EXPORT void *func##__MULT() { return (void*)(&func##__wrap); } \
+}
+
+
+
+#endif
+
+#endif
+
+
diff --git a/Sources/c_snikket/iinclude/hx/Class.h b/Sources/c_snikket/iinclude/hx/Class.h
new file mode 100644
index 0000000..adaed2e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/Class.h
@@ -0,0 +1,294 @@
+   #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 && inPtr->_hx_isInstanceOf(T::_hx_ClassId);
+}
+
+
+template<int HASH>
+inline bool TIsInterface(hx::Object *inPtr)
+{
+	return inPtr && inPtr->_hx_getInterface(HASH);
+}
+
+
+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
diff --git a/Sources/c_snikket/iinclude/hx/Debug.h b/Sources/c_snikket/iinclude/hx/Debug.h
new file mode 100644
index 0000000..903468f
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/Debug.h
@@ -0,0 +1,376 @@
+#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);
+};
+
+#if defined(HXCPP_SCRIPTABLE) && (HXCPP_API_LEVEL >= 500)
+// This is the function to call when a new script has been loaded.
+// Signature: Void -> Void
+extern Dynamic g_onScriptLoadedFunction;
+#endif
+
+
+#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);
+#if defined(HXCPP_SCRIPTABLE) && (HXCPP_API_LEVEL >= 500)
+void __hxcpp_dbg_setOnScriptLoadedFunction(Dynamic function);
+#endif
+
+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) { }
+#if defined(HXCPP_SCRIPTABLE) && (HXCPP_API_LEVEL >= 500)
+inline void __hxcpp_dbg_setOnScriptLoadedFunction(Dynamic) { }
+#endif
+
+// 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
diff --git a/Sources/c_snikket/iinclude/hx/DynamicImpl.h b/Sources/c_snikket/iinclude/hx/DynamicImpl.h
new file mode 100644
index 0000000..7661253
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/DynamicImpl.h
@@ -0,0 +1,1060 @@
+//   ##  ##  ##   ##   ####   ##  ## ## ##  ##  ####    ##
+//   ##  ##  ## ##  ## ##  ## ### ## ## ### ## ##       ##
+//    ## ## ##  ###### ###### ###### ## ###### ## ###   ##
+//    ## ## ##  ##  ## ## ##  ## ### ## ## ### ##  ##     
+//     ## ##    ##  ## ##  ## ##  ## ## ##  ##  ####    ##
+
+// DO NOT EDIT
+// This file is generated from the .tpl file
+
+ 
+
+namespace hx {
+
+struct CMemberFunction0 : public hx::Object 
+{ 
+   hx::ObjectPtr<Object> mThis; 
+   MemberFunction0 mFunction;
+   const char *mName;
+
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdCMember0 };
+
+
+   CMemberFunction0(const char *inName, hx::Object *inObj, MemberFunction0 inFunction)
+   {
+      mName = inName;
+      mThis = inObj;
+      mFunction = inFunction;
+   }
+   int __Compare(const hx::Object *inRHS) const
+   {
+      const CMemberFunction0 *other = dynamic_cast<const CMemberFunction0 *>(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 0; } 
+   ::String __ToString() const{ return String(mName); } 
+   void __Mark(hx::MarkContext *__inCtx) { HX_MARK_MEMBER_NAME(mThis,"CMemberFunction0.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());
+      
+   } 
+   Dynamic __run() 
+   { 
+      
+      return mFunction(mThis.GetPtr());
+      
+   } 
+}; 
+
+
+
+struct CStaticFunction0 : public hx::Object 
+{ 
+   StaticFunction0 mFunction;
+   const char *mName;
+
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdCStatic0 };
+
+
+   CStaticFunction0(const char *inName,StaticFunction0 inFunction)
+   {
+      mName = inName;
+      mFunction = inFunction;
+   }
+   int __Compare(const hx::Object *inRHS) const
+   {
+      const CStaticFunction0 *other = dynamic_cast<const CStaticFunction0 *>(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 0; } 
+   ::String __ToString() const{ return String(mName); } 
+   Dynamic __Run(const Array<Dynamic> &inArgs) 
+   { 
+      return mFunction();
+   } 
+   Dynamic __run() 
+   { 
+      return mFunction();
+   } 
+}; 
+
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateMemberFunction0(const char *inName,hx::Object *inObj, MemberFunction0 inFunc)
+   { return new CMemberFunction0(inName,inObj,inFunc); }
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateStaticFunction0(const char *inName,StaticFunction0 inFunc)
+   { return new CStaticFunction0(inName,inFunc); }
+
+}
+
+
+ 
+
+namespace hx {
+
+struct CMemberFunction1 : public hx::Object 
+{ 
+   hx::ObjectPtr<Object> mThis; 
+   MemberFunction1 mFunction;
+   const char *mName;
+
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdCMember1 };
+
+
+   CMemberFunction1(const char *inName, hx::Object *inObj, MemberFunction1 inFunction)
+   {
+      mName = inName;
+      mThis = inObj;
+      mFunction = inFunction;
+   }
+   int __Compare(const hx::Object *inRHS) const
+   {
+      const CMemberFunction1 *other = dynamic_cast<const CMemberFunction1 *>(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 1; } 
+   ::String __ToString() const{ return String(mName); } 
+   void __Mark(hx::MarkContext *__inCtx) { HX_MARK_MEMBER_NAME(mThis,"CMemberFunction1.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[0]);
+      
+   } 
+   Dynamic __run(const Dynamic &inArg0) 
+   { 
+      
+      return mFunction(mThis.GetPtr(), inArg0);
+      
+   } 
+}; 
+
+
+
+struct CStaticFunction1 : public hx::Object 
+{ 
+   StaticFunction1 mFunction;
+   const char *mName;
+
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdCStatic1 };
+
+
+   CStaticFunction1(const char *inName,StaticFunction1 inFunction)
+   {
+      mName = inName;
+      mFunction = inFunction;
+   }
+   int __Compare(const hx::Object *inRHS) const
+   {
+      const CStaticFunction1 *other = dynamic_cast<const CStaticFunction1 *>(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 1; } 
+   ::String __ToString() const{ return String(mName); } 
+   Dynamic __Run(const Array<Dynamic> &inArgs) 
+   { 
+      return mFunction(inArgs[0]);
+   } 
+   Dynamic __run(const Dynamic &inArg0) 
+   { 
+      return mFunction(inArg0);
+   } 
+}; 
+
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateMemberFunction1(const char *inName,hx::Object *inObj, MemberFunction1 inFunc)
+   { return new CMemberFunction1(inName,inObj,inFunc); }
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateStaticFunction1(const char *inName,StaticFunction1 inFunc)
+   { return new CStaticFunction1(inName,inFunc); }
+
+}
+
+
+ 
+
+namespace hx {
+
+struct CMemberFunction2 : public hx::Object 
+{ 
+   hx::ObjectPtr<Object> mThis; 
+   MemberFunction2 mFunction;
+   const char *mName;
+
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdCMember2 };
+
+
+   CMemberFunction2(const char *inName, hx::Object *inObj, MemberFunction2 inFunction)
+   {
+      mName = inName;
+      mThis = inObj;
+      mFunction = inFunction;
+   }
+   int __Compare(const hx::Object *inRHS) const
+   {
+      const CMemberFunction2 *other = dynamic_cast<const CMemberFunction2 *>(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 2; } 
+   ::String __ToString() const{ return String(mName); } 
+   void __Mark(hx::MarkContext *__inCtx) { HX_MARK_MEMBER_NAME(mThis,"CMemberFunction2.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[0],inArgs[1]);
+      
+   } 
+   Dynamic __run(const Dynamic &inArg0,const Dynamic &inArg1) 
+   { 
+      
+      return mFunction(mThis.GetPtr(), inArg0,inArg1);
+      
+   } 
+}; 
+
+
+
+struct CStaticFunction2 : public hx::Object 
+{ 
+   StaticFunction2 mFunction;
+   const char *mName;
+
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdCStatic2 };
+
+
+   CStaticFunction2(const char *inName,StaticFunction2 inFunction)
+   {
+      mName = inName;
+      mFunction = inFunction;
+   }
+   int __Compare(const hx::Object *inRHS) const
+   {
+      const CStaticFunction2 *other = dynamic_cast<const CStaticFunction2 *>(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 2; } 
+   ::String __ToString() const{ return String(mName); } 
+   Dynamic __Run(const Array<Dynamic> &inArgs) 
+   { 
+      return mFunction(inArgs[0],inArgs[1]);
+   } 
+   Dynamic __run(const Dynamic &inArg0,const Dynamic &inArg1) 
+   { 
+      return mFunction(inArg0,inArg1);
+   } 
+}; 
+
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateMemberFunction2(const char *inName,hx::Object *inObj, MemberFunction2 inFunc)
+   { return new CMemberFunction2(inName,inObj,inFunc); }
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateStaticFunction2(const char *inName,StaticFunction2 inFunc)
+   { return new CStaticFunction2(inName,inFunc); }
+
+}
+
+
+ 
+
+namespace hx {
+
+struct CMemberFunction3 : public hx::Object 
+{ 
+   hx::ObjectPtr<Object> mThis; 
+   MemberFunction3 mFunction;
+   const char *mName;
+
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdCMember3 };
+
+
+   CMemberFunction3(const char *inName, hx::Object *inObj, MemberFunction3 inFunction)
+   {
+      mName = inName;
+      mThis = inObj;
+      mFunction = inFunction;
+   }
+   int __Compare(const hx::Object *inRHS) const
+   {
+      const CMemberFunction3 *other = dynamic_cast<const CMemberFunction3 *>(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 3; } 
+   ::String __ToString() const{ return String(mName); } 
+   void __Mark(hx::MarkContext *__inCtx) { HX_MARK_MEMBER_NAME(mThis,"CMemberFunction3.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[0],inArgs[1],inArgs[2]);
+      
+   } 
+   Dynamic __run(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2) 
+   { 
+      
+      return mFunction(mThis.GetPtr(), inArg0,inArg1,inArg2);
+      
+   } 
+}; 
+
+
+
+struct CStaticFunction3 : public hx::Object 
+{ 
+   StaticFunction3 mFunction;
+   const char *mName;
+
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdCStatic3 };
+
+
+   CStaticFunction3(const char *inName,StaticFunction3 inFunction)
+   {
+      mName = inName;
+      mFunction = inFunction;
+   }
+   int __Compare(const hx::Object *inRHS) const
+   {
+      const CStaticFunction3 *other = dynamic_cast<const CStaticFunction3 *>(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 3; } 
+   ::String __ToString() const{ return String(mName); } 
+   Dynamic __Run(const Array<Dynamic> &inArgs) 
+   { 
+      return mFunction(inArgs[0],inArgs[1],inArgs[2]);
+   } 
+   Dynamic __run(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2) 
+   { 
+      return mFunction(inArg0,inArg1,inArg2);
+   } 
+}; 
+
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateMemberFunction3(const char *inName,hx::Object *inObj, MemberFunction3 inFunc)
+   { return new CMemberFunction3(inName,inObj,inFunc); }
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateStaticFunction3(const char *inName,StaticFunction3 inFunc)
+   { return new CStaticFunction3(inName,inFunc); }
+
+}
+
+
+ 
+
+namespace hx {
+
+struct CMemberFunction4 : public hx::Object 
+{ 
+   hx::ObjectPtr<Object> mThis; 
+   MemberFunction4 mFunction;
+   const char *mName;
+
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdCMember4 };
+
+
+   CMemberFunction4(const char *inName, hx::Object *inObj, MemberFunction4 inFunction)
+   {
+      mName = inName;
+      mThis = inObj;
+      mFunction = inFunction;
+   }
+   int __Compare(const hx::Object *inRHS) const
+   {
+      const CMemberFunction4 *other = dynamic_cast<const CMemberFunction4 *>(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 4; } 
+   ::String __ToString() const{ return String(mName); } 
+   void __Mark(hx::MarkContext *__inCtx) { HX_MARK_MEMBER_NAME(mThis,"CMemberFunction4.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[0],inArgs[1],inArgs[2],inArgs[3]);
+      
+   } 
+   Dynamic __run(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3) 
+   { 
+      
+      return mFunction(mThis.GetPtr(), inArg0,inArg1,inArg2,inArg3);
+      
+   } 
+}; 
+
+
+
+struct CStaticFunction4 : public hx::Object 
+{ 
+   StaticFunction4 mFunction;
+   const char *mName;
+
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdCStatic4 };
+
+
+   CStaticFunction4(const char *inName,StaticFunction4 inFunction)
+   {
+      mName = inName;
+      mFunction = inFunction;
+   }
+   int __Compare(const hx::Object *inRHS) const
+   {
+      const CStaticFunction4 *other = dynamic_cast<const CStaticFunction4 *>(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 4; } 
+   ::String __ToString() const{ return String(mName); } 
+   Dynamic __Run(const Array<Dynamic> &inArgs) 
+   { 
+      return mFunction(inArgs[0],inArgs[1],inArgs[2],inArgs[3]);
+   } 
+   Dynamic __run(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3) 
+   { 
+      return mFunction(inArg0,inArg1,inArg2,inArg3);
+   } 
+}; 
+
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateMemberFunction4(const char *inName,hx::Object *inObj, MemberFunction4 inFunc)
+   { return new CMemberFunction4(inName,inObj,inFunc); }
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateStaticFunction4(const char *inName,StaticFunction4 inFunc)
+   { return new CStaticFunction4(inName,inFunc); }
+
+}
+
+
+ 
+
+namespace hx {
+
+struct CMemberFunction5 : public hx::Object 
+{ 
+   hx::ObjectPtr<Object> mThis; 
+   MemberFunction5 mFunction;
+   const char *mName;
+
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdCMember5 };
+
+
+   CMemberFunction5(const char *inName, hx::Object *inObj, MemberFunction5 inFunction)
+   {
+      mName = inName;
+      mThis = inObj;
+      mFunction = inFunction;
+   }
+   int __Compare(const hx::Object *inRHS) const
+   {
+      const CMemberFunction5 *other = dynamic_cast<const CMemberFunction5 *>(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 5; } 
+   ::String __ToString() const{ return String(mName); } 
+   void __Mark(hx::MarkContext *__inCtx) { HX_MARK_MEMBER_NAME(mThis,"CMemberFunction5.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[0],inArgs[1],inArgs[2],inArgs[3],inArgs[4]);
+      
+   } 
+   Dynamic __run(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4) 
+   { 
+      
+      return mFunction(mThis.GetPtr(), inArg0,inArg1,inArg2,inArg3,inArg4);
+      
+   } 
+}; 
+
+
+
+struct CStaticFunction5 : public hx::Object 
+{ 
+   StaticFunction5 mFunction;
+   const char *mName;
+
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdCStatic5 };
+
+
+   CStaticFunction5(const char *inName,StaticFunction5 inFunction)
+   {
+      mName = inName;
+      mFunction = inFunction;
+   }
+   int __Compare(const hx::Object *inRHS) const
+   {
+      const CStaticFunction5 *other = dynamic_cast<const CStaticFunction5 *>(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 5; } 
+   ::String __ToString() const{ return String(mName); } 
+   Dynamic __Run(const Array<Dynamic> &inArgs) 
+   { 
+      return mFunction(inArgs[0],inArgs[1],inArgs[2],inArgs[3],inArgs[4]);
+   } 
+   Dynamic __run(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4) 
+   { 
+      return mFunction(inArg0,inArg1,inArg2,inArg3,inArg4);
+   } 
+}; 
+
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateMemberFunction5(const char *inName,hx::Object *inObj, MemberFunction5 inFunc)
+   { return new CMemberFunction5(inName,inObj,inFunc); }
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES
+Dynamic CreateStaticFunction5(const char *inName,StaticFunction5 inFunc)
+   { return new CStaticFunction5(inName,inFunc); }
+
+}
+
+
+ 
+Dynamic Dynamic::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5)
+{
+   CheckFPtr();
+   return mPtr->__Run(Array_obj<Dynamic>::__new(6)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5));
+}
+
+namespace cpp
+{
+::Dynamic Variant::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5)
+{
+   if (isNull()) Dynamic::ThrowBadFunctionError();
+   return valObject->__Run(Array_obj<Dynamic>::__new(6)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5));
+}
+}
+
+
+
+ 
+Dynamic Dynamic::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6)
+{
+   CheckFPtr();
+   return mPtr->__Run(Array_obj<Dynamic>::__new(7)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6));
+}
+
+namespace cpp
+{
+::Dynamic Variant::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6)
+{
+   if (isNull()) Dynamic::ThrowBadFunctionError();
+   return valObject->__Run(Array_obj<Dynamic>::__new(7)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6));
+}
+}
+
+
+
+ 
+Dynamic Dynamic::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7)
+{
+   CheckFPtr();
+   return mPtr->__Run(Array_obj<Dynamic>::__new(8)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7));
+}
+
+namespace cpp
+{
+::Dynamic Variant::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7)
+{
+   if (isNull()) Dynamic::ThrowBadFunctionError();
+   return valObject->__Run(Array_obj<Dynamic>::__new(8)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7));
+}
+}
+
+
+
+ 
+Dynamic Dynamic::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8)
+{
+   CheckFPtr();
+   return mPtr->__Run(Array_obj<Dynamic>::__new(9)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8));
+}
+
+namespace cpp
+{
+::Dynamic Variant::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8)
+{
+   if (isNull()) Dynamic::ThrowBadFunctionError();
+   return valObject->__Run(Array_obj<Dynamic>::__new(9)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8));
+}
+}
+
+
+
+ 
+Dynamic Dynamic::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9)
+{
+   CheckFPtr();
+   return mPtr->__Run(Array_obj<Dynamic>::__new(10)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9));
+}
+
+namespace cpp
+{
+::Dynamic Variant::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9)
+{
+   if (isNull()) Dynamic::ThrowBadFunctionError();
+   return valObject->__Run(Array_obj<Dynamic>::__new(10)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9));
+}
+}
+
+
+
+ 
+Dynamic Dynamic::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10)
+{
+   CheckFPtr();
+   return mPtr->__Run(Array_obj<Dynamic>::__new(11)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10));
+}
+
+namespace cpp
+{
+::Dynamic Variant::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10)
+{
+   if (isNull()) Dynamic::ThrowBadFunctionError();
+   return valObject->__Run(Array_obj<Dynamic>::__new(11)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10));
+}
+}
+
+
+
+ 
+Dynamic Dynamic::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11)
+{
+   CheckFPtr();
+   return mPtr->__Run(Array_obj<Dynamic>::__new(12)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11));
+}
+
+namespace cpp
+{
+::Dynamic Variant::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11)
+{
+   if (isNull()) Dynamic::ThrowBadFunctionError();
+   return valObject->__Run(Array_obj<Dynamic>::__new(12)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11));
+}
+}
+
+
+
+ 
+Dynamic Dynamic::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12)
+{
+   CheckFPtr();
+   return mPtr->__Run(Array_obj<Dynamic>::__new(13)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12));
+}
+
+namespace cpp
+{
+::Dynamic Variant::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12)
+{
+   if (isNull()) Dynamic::ThrowBadFunctionError();
+   return valObject->__Run(Array_obj<Dynamic>::__new(13)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12));
+}
+}
+
+
+
+ 
+Dynamic Dynamic::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13)
+{
+   CheckFPtr();
+   return mPtr->__Run(Array_obj<Dynamic>::__new(14)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12)->init(13,inArg13));
+}
+
+namespace cpp
+{
+::Dynamic Variant::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13)
+{
+   if (isNull()) Dynamic::ThrowBadFunctionError();
+   return valObject->__Run(Array_obj<Dynamic>::__new(14)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12)->init(13,inArg13));
+}
+}
+
+
+
+ 
+Dynamic Dynamic::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14)
+{
+   CheckFPtr();
+   return mPtr->__Run(Array_obj<Dynamic>::__new(15)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12)->init(13,inArg13)->init(14,inArg14));
+}
+
+namespace cpp
+{
+::Dynamic Variant::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14)
+{
+   if (isNull()) Dynamic::ThrowBadFunctionError();
+   return valObject->__Run(Array_obj<Dynamic>::__new(15)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12)->init(13,inArg13)->init(14,inArg14));
+}
+}
+
+
+
+ 
+Dynamic Dynamic::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15)
+{
+   CheckFPtr();
+   return mPtr->__Run(Array_obj<Dynamic>::__new(16)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12)->init(13,inArg13)->init(14,inArg14)->init(15,inArg15));
+}
+
+namespace cpp
+{
+::Dynamic Variant::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15)
+{
+   if (isNull()) Dynamic::ThrowBadFunctionError();
+   return valObject->__Run(Array_obj<Dynamic>::__new(16)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12)->init(13,inArg13)->init(14,inArg14)->init(15,inArg15));
+}
+}
+
+
+
+ 
+Dynamic Dynamic::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16)
+{
+   CheckFPtr();
+   return mPtr->__Run(Array_obj<Dynamic>::__new(17)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12)->init(13,inArg13)->init(14,inArg14)->init(15,inArg15)->init(16,inArg16));
+}
+
+namespace cpp
+{
+::Dynamic Variant::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16)
+{
+   if (isNull()) Dynamic::ThrowBadFunctionError();
+   return valObject->__Run(Array_obj<Dynamic>::__new(17)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12)->init(13,inArg13)->init(14,inArg14)->init(15,inArg15)->init(16,inArg16));
+}
+}
+
+
+
+ 
+Dynamic Dynamic::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17)
+{
+   CheckFPtr();
+   return mPtr->__Run(Array_obj<Dynamic>::__new(18)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12)->init(13,inArg13)->init(14,inArg14)->init(15,inArg15)->init(16,inArg16)->init(17,inArg17));
+}
+
+namespace cpp
+{
+::Dynamic Variant::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17)
+{
+   if (isNull()) Dynamic::ThrowBadFunctionError();
+   return valObject->__Run(Array_obj<Dynamic>::__new(18)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12)->init(13,inArg13)->init(14,inArg14)->init(15,inArg15)->init(16,inArg16)->init(17,inArg17));
+}
+}
+
+
+
+ 
+Dynamic Dynamic::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18)
+{
+   CheckFPtr();
+   return mPtr->__Run(Array_obj<Dynamic>::__new(19)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12)->init(13,inArg13)->init(14,inArg14)->init(15,inArg15)->init(16,inArg16)->init(17,inArg17)->init(18,inArg18));
+}
+
+namespace cpp
+{
+::Dynamic Variant::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18)
+{
+   if (isNull()) Dynamic::ThrowBadFunctionError();
+   return valObject->__Run(Array_obj<Dynamic>::__new(19)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12)->init(13,inArg13)->init(14,inArg14)->init(15,inArg15)->init(16,inArg16)->init(17,inArg17)->init(18,inArg18));
+}
+}
+
+
+
+ 
+Dynamic Dynamic::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19)
+{
+   CheckFPtr();
+   return mPtr->__Run(Array_obj<Dynamic>::__new(20)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12)->init(13,inArg13)->init(14,inArg14)->init(15,inArg15)->init(16,inArg16)->init(17,inArg17)->init(18,inArg18)->init(19,inArg19));
+}
+
+namespace cpp
+{
+::Dynamic Variant::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19)
+{
+   if (isNull()) Dynamic::ThrowBadFunctionError();
+   return valObject->__Run(Array_obj<Dynamic>::__new(20)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12)->init(13,inArg13)->init(14,inArg14)->init(15,inArg15)->init(16,inArg16)->init(17,inArg17)->init(18,inArg18)->init(19,inArg19));
+}
+}
+
+
+
+ 
+Dynamic Dynamic::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20)
+{
+   CheckFPtr();
+   return mPtr->__Run(Array_obj<Dynamic>::__new(21)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12)->init(13,inArg13)->init(14,inArg14)->init(15,inArg15)->init(16,inArg16)->init(17,inArg17)->init(18,inArg18)->init(19,inArg19)->init(20,inArg20));
+}
+
+namespace cpp
+{
+::Dynamic Variant::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20)
+{
+   if (isNull()) Dynamic::ThrowBadFunctionError();
+   return valObject->__Run(Array_obj<Dynamic>::__new(21)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12)->init(13,inArg13)->init(14,inArg14)->init(15,inArg15)->init(16,inArg16)->init(17,inArg17)->init(18,inArg18)->init(19,inArg19)->init(20,inArg20));
+}
+}
+
+
+
+ 
+Dynamic Dynamic::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20,const Dynamic &inArg21)
+{
+   CheckFPtr();
+   return mPtr->__Run(Array_obj<Dynamic>::__new(22)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12)->init(13,inArg13)->init(14,inArg14)->init(15,inArg15)->init(16,inArg16)->init(17,inArg17)->init(18,inArg18)->init(19,inArg19)->init(20,inArg20)->init(21,inArg21));
+}
+
+namespace cpp
+{
+::Dynamic Variant::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20,const Dynamic &inArg21)
+{
+   if (isNull()) Dynamic::ThrowBadFunctionError();
+   return valObject->__Run(Array_obj<Dynamic>::__new(22)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12)->init(13,inArg13)->init(14,inArg14)->init(15,inArg15)->init(16,inArg16)->init(17,inArg17)->init(18,inArg18)->init(19,inArg19)->init(20,inArg20)->init(21,inArg21));
+}
+}
+
+
+
+ 
+Dynamic Dynamic::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20,const Dynamic &inArg21,const Dynamic &inArg22)
+{
+   CheckFPtr();
+   return mPtr->__Run(Array_obj<Dynamic>::__new(23)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12)->init(13,inArg13)->init(14,inArg14)->init(15,inArg15)->init(16,inArg16)->init(17,inArg17)->init(18,inArg18)->init(19,inArg19)->init(20,inArg20)->init(21,inArg21)->init(22,inArg22));
+}
+
+namespace cpp
+{
+::Dynamic Variant::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20,const Dynamic &inArg21,const Dynamic &inArg22)
+{
+   if (isNull()) Dynamic::ThrowBadFunctionError();
+   return valObject->__Run(Array_obj<Dynamic>::__new(23)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12)->init(13,inArg13)->init(14,inArg14)->init(15,inArg15)->init(16,inArg16)->init(17,inArg17)->init(18,inArg18)->init(19,inArg19)->init(20,inArg20)->init(21,inArg21)->init(22,inArg22));
+}
+}
+
+
+
+ 
+Dynamic Dynamic::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20,const Dynamic &inArg21,const Dynamic &inArg22,const Dynamic &inArg23)
+{
+   CheckFPtr();
+   return mPtr->__Run(Array_obj<Dynamic>::__new(24)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12)->init(13,inArg13)->init(14,inArg14)->init(15,inArg15)->init(16,inArg16)->init(17,inArg17)->init(18,inArg18)->init(19,inArg19)->init(20,inArg20)->init(21,inArg21)->init(22,inArg22)->init(23,inArg23));
+}
+
+namespace cpp
+{
+::Dynamic Variant::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20,const Dynamic &inArg21,const Dynamic &inArg22,const Dynamic &inArg23)
+{
+   if (isNull()) Dynamic::ThrowBadFunctionError();
+   return valObject->__Run(Array_obj<Dynamic>::__new(24)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12)->init(13,inArg13)->init(14,inArg14)->init(15,inArg15)->init(16,inArg16)->init(17,inArg17)->init(18,inArg18)->init(19,inArg19)->init(20,inArg20)->init(21,inArg21)->init(22,inArg22)->init(23,inArg23));
+}
+}
+
+
+
+ 
+Dynamic Dynamic::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20,const Dynamic &inArg21,const Dynamic &inArg22,const Dynamic &inArg23,const Dynamic &inArg24)
+{
+   CheckFPtr();
+   return mPtr->__Run(Array_obj<Dynamic>::__new(25)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12)->init(13,inArg13)->init(14,inArg14)->init(15,inArg15)->init(16,inArg16)->init(17,inArg17)->init(18,inArg18)->init(19,inArg19)->init(20,inArg20)->init(21,inArg21)->init(22,inArg22)->init(23,inArg23)->init(24,inArg24));
+}
+
+namespace cpp
+{
+::Dynamic Variant::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20,const Dynamic &inArg21,const Dynamic &inArg22,const Dynamic &inArg23,const Dynamic &inArg24)
+{
+   if (isNull()) Dynamic::ThrowBadFunctionError();
+   return valObject->__Run(Array_obj<Dynamic>::__new(25)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12)->init(13,inArg13)->init(14,inArg14)->init(15,inArg15)->init(16,inArg16)->init(17,inArg17)->init(18,inArg18)->init(19,inArg19)->init(20,inArg20)->init(21,inArg21)->init(22,inArg22)->init(23,inArg23)->init(24,inArg24));
+}
+}
+
+
+
+ 
+Dynamic Dynamic::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20,const Dynamic &inArg21,const Dynamic &inArg22,const Dynamic &inArg23,const Dynamic &inArg24,const Dynamic &inArg25)
+{
+   CheckFPtr();
+   return mPtr->__Run(Array_obj<Dynamic>::__new(26)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12)->init(13,inArg13)->init(14,inArg14)->init(15,inArg15)->init(16,inArg16)->init(17,inArg17)->init(18,inArg18)->init(19,inArg19)->init(20,inArg20)->init(21,inArg21)->init(22,inArg22)->init(23,inArg23)->init(24,inArg24)->init(25,inArg25));
+}
+
+namespace cpp
+{
+::Dynamic Variant::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20,const Dynamic &inArg21,const Dynamic &inArg22,const Dynamic &inArg23,const Dynamic &inArg24,const Dynamic &inArg25)
+{
+   if (isNull()) Dynamic::ThrowBadFunctionError();
+   return valObject->__Run(Array_obj<Dynamic>::__new(26)->init(0,inArg0)->init(1,inArg1)->init(2,inArg2)->init(3,inArg3)->init(4,inArg4)->init(5,inArg5)->init(6,inArg6)->init(7,inArg7)->init(8,inArg8)->init(9,inArg9)->init(10,inArg10)->init(11,inArg11)->init(12,inArg12)->init(13,inArg13)->init(14,inArg14)->init(15,inArg15)->init(16,inArg16)->init(17,inArg17)->init(18,inArg18)->init(19,inArg19)->init(20,inArg20)->init(21,inArg21)->init(22,inArg22)->init(23,inArg23)->init(24,inArg24)->init(25,inArg25));
+}
+}
+
+
+
+
+
+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); }
+
+}
+
+
diff --git a/Sources/c_snikket/iinclude/hx/DynamicImpl.tpl b/Sources/c_snikket/iinclude/hx/DynamicImpl.tpl
new file mode 100644
index 0000000..ae0e380
--- /dev/null
+++ b/Sources/c_snikket/iinclude/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); }
+
+}
+
+
diff --git a/Sources/c_snikket/iinclude/hx/ErrorCodes.h b/Sources/c_snikket/iinclude/hx/ErrorCodes.h
new file mode 100644
index 0000000..fd7ca45
--- /dev/null
+++ b/Sources/c_snikket/iinclude/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
diff --git a/Sources/c_snikket/iinclude/hx/FieldRef.h b/Sources/c_snikket/iinclude/hx/FieldRef.h
new file mode 100644
index 0000000..3ba1fdc
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/FieldRef.h
@@ -0,0 +1,302 @@
+#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 );
+   }
+   inline operator hx::Val() const { return mObject ? mObject->__Field(mName, HX_PROP_DYNAMIC) : null(); }
+   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
diff --git a/Sources/c_snikket/iinclude/hx/Functions.h b/Sources/c_snikket/iinclude/hx/Functions.h
new file mode 100644
index 0000000..a27180e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/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
diff --git a/Sources/c_snikket/iinclude/hx/GC.h b/Sources/c_snikket/iinclude/hx/GC.h
new file mode 100644
index 0000000..95b65c2
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/GC.h
@@ -0,0 +1,594 @@
+#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);
+extern void __hxt_gc_alloc(void* obj, int inSize);
+extern void __hxt_gc_free_large(void* obj);
+#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
+
+
+
+class 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
+
+         #ifdef HXCPP_ALIGN_ALLOC
+         // make sure buffer is 8-byte aligned
+         unsigned char *buffer = alloc->spaceFirst + ( (size_t)alloc->spaceFirst & 4 );
+         #else
+         unsigned char *buffer = alloc->spaceFirst;
+         #endif
+         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;
+         }
+
+         #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;
+
+      #else
+         // 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;
+         #ifdef HXCPP_ALIGN_ALLOC
+            // Ensure odd alignment in 8 bytes
+            start += 4 - (start & 4);
+         #endif
+         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_alloc(buffer, inSize);
+            __hxt_gc_new((hx::StackContext *)alloc,buffer, inSize, inName);
+            #endif
+            return buffer;
+         }
+
+         // 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
+
diff --git a/Sources/c_snikket/iinclude/hx/GcTypeInference.h b/Sources/c_snikket/iinclude/hx/GcTypeInference.h
new file mode 100644
index 0000000..b1f186e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/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
diff --git a/Sources/c_snikket/iinclude/hx/GenMacro.hx b/Sources/c_snikket/iinclude/hx/GenMacro.hx
new file mode 100644
index 0000000..17e21f0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/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();
+
+   }
+
+   public static function main() { new GenMacro(); }
+}
diff --git a/Sources/c_snikket/iinclude/hx/HeaderVersion.h b/Sources/c_snikket/iinclude/hx/HeaderVersion.h
new file mode 100644
index 0000000..81a2469
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/HeaderVersion.h
@@ -0,0 +1,3 @@
+#ifndef HXCPP_HEADER_VERSION
+#define HXCPP_HEADER_VERSION 330
+#endif
diff --git a/Sources/c_snikket/iinclude/hx/HxcppMain.h b/Sources/c_snikket/iinclude/hx/HxcppMain.h
new file mode 100644
index 0000000..ad09f30
--- /dev/null
+++ b/Sources/c_snikket/iinclude/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
+
+
diff --git a/Sources/c_snikket/iinclude/hx/IndexRef.h b/Sources/c_snikket/iinclude/hx/IndexRef.h
new file mode 100644
index 0000000..9e9a183
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/IndexRef.h
@@ -0,0 +1,9 @@
+#ifndef HX_INDEX_REF_H
+#define HX_INDEX_REF_H
+
+namespace hx
+{
+
+}
+
+#endif
diff --git a/Sources/c_snikket/iinclude/hx/Interface.h b/Sources/c_snikket/iinclude/hx/Interface.h
new file mode 100644
index 0000000..e7438fe
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/Interface.h
@@ -0,0 +1,31 @@
+#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);
+}
+
+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
+
diff --git a/Sources/c_snikket/iinclude/hx/LessThanEq.h b/Sources/c_snikket/iinclude/hx/LessThanEq.h
new file mode 100644
index 0000000..e87ebb0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/LessThanEq.h
@@ -0,0 +1,473 @@
+#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> { };
+template <> struct CompareTraits<char16_t> : public CompareTraits<int> { };
+
+
+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
diff --git a/Sources/c_snikket/iinclude/hx/Macros.h b/Sources/c_snikket/iinclude/hx/Macros.h
new file mode 100644
index 0000000..ac4e050
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/Macros.h
@@ -0,0 +1,1099 @@
+//   ##  ##  ##   ##   ####   ##  ## ## ##  ##  ####    ##
+//   ##  ##  ## ##  ## ##  ## ### ## ## ### ## ##       ##
+//    ## ## ##  ###### ###### ###### ## ###### ## ###   ##
+//    ## ## ##  ##  ## ## ##  ## ### ## ## ### ##  ##     
+//     ## ##    ##  ## ##  ## ##  ## ## ##  ##  ####    ##
+
+// DO NOT EDIT
+// This file is generated from the .tpl file
+#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 ----------------------
+
+#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); \
+}
+
+// ---- Fields ----------------------
+
+#define HX_IS_INSTANCE_OF bool _hx_isInstanceOf(int inClassId) { return inClassId==1 || inClassId==(int)_hx_ClassId; }
+
+#define HX_DO_RTTI_ALL \
+   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::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
+
+
+#ifndef HX_MACROS_H
+#define HX_MACROS_H
+
+// --- Functions and their parameters ----
+
+
+#define HX_ARR_LIST0 
+#define HX_ARR_LIST1 inArgs[0]
+#define HX_ARR_LIST2 inArgs[0],inArgs[1]
+#define HX_ARR_LIST3 inArgs[0],inArgs[1],inArgs[2]
+#define HX_ARR_LIST4 inArgs[0],inArgs[1],inArgs[2],inArgs[3]
+#define HX_ARR_LIST5 inArgs[0],inArgs[1],inArgs[2],inArgs[3],inArgs[4]
+#define HX_ARR_LIST6 inArgs[0],inArgs[1],inArgs[2],inArgs[3],inArgs[4],inArgs[5]
+#define HX_ARR_LIST7 inArgs[0],inArgs[1],inArgs[2],inArgs[3],inArgs[4],inArgs[5],inArgs[6]
+#define HX_ARR_LIST8 inArgs[0],inArgs[1],inArgs[2],inArgs[3],inArgs[4],inArgs[5],inArgs[6],inArgs[7]
+#define HX_ARR_LIST9 inArgs[0],inArgs[1],inArgs[2],inArgs[3],inArgs[4],inArgs[5],inArgs[6],inArgs[7],inArgs[8]
+#define HX_ARR_LIST10 inArgs[0],inArgs[1],inArgs[2],inArgs[3],inArgs[4],inArgs[5],inArgs[6],inArgs[7],inArgs[8],inArgs[9]
+#define HX_ARR_LIST11 inArgs[0],inArgs[1],inArgs[2],inArgs[3],inArgs[4],inArgs[5],inArgs[6],inArgs[7],inArgs[8],inArgs[9],inArgs[10]
+#define HX_ARR_LIST12 inArgs[0],inArgs[1],inArgs[2],inArgs[3],inArgs[4],inArgs[5],inArgs[6],inArgs[7],inArgs[8],inArgs[9],inArgs[10],inArgs[11]
+#define HX_ARR_LIST13 inArgs[0],inArgs[1],inArgs[2],inArgs[3],inArgs[4],inArgs[5],inArgs[6],inArgs[7],inArgs[8],inArgs[9],inArgs[10],inArgs[11],inArgs[12]
+#define HX_ARR_LIST14 inArgs[0],inArgs[1],inArgs[2],inArgs[3],inArgs[4],inArgs[5],inArgs[6],inArgs[7],inArgs[8],inArgs[9],inArgs[10],inArgs[11],inArgs[12],inArgs[13]
+#define HX_ARR_LIST15 inArgs[0],inArgs[1],inArgs[2],inArgs[3],inArgs[4],inArgs[5],inArgs[6],inArgs[7],inArgs[8],inArgs[9],inArgs[10],inArgs[11],inArgs[12],inArgs[13],inArgs[14]
+#define HX_ARR_LIST16 inArgs[0],inArgs[1],inArgs[2],inArgs[3],inArgs[4],inArgs[5],inArgs[6],inArgs[7],inArgs[8],inArgs[9],inArgs[10],inArgs[11],inArgs[12],inArgs[13],inArgs[14],inArgs[15]
+#define HX_ARR_LIST17 inArgs[0],inArgs[1],inArgs[2],inArgs[3],inArgs[4],inArgs[5],inArgs[6],inArgs[7],inArgs[8],inArgs[9],inArgs[10],inArgs[11],inArgs[12],inArgs[13],inArgs[14],inArgs[15],inArgs[16]
+#define HX_ARR_LIST18 inArgs[0],inArgs[1],inArgs[2],inArgs[3],inArgs[4],inArgs[5],inArgs[6],inArgs[7],inArgs[8],inArgs[9],inArgs[10],inArgs[11],inArgs[12],inArgs[13],inArgs[14],inArgs[15],inArgs[16],inArgs[17]
+#define HX_ARR_LIST19 inArgs[0],inArgs[1],inArgs[2],inArgs[3],inArgs[4],inArgs[5],inArgs[6],inArgs[7],inArgs[8],inArgs[9],inArgs[10],inArgs[11],inArgs[12],inArgs[13],inArgs[14],inArgs[15],inArgs[16],inArgs[17],inArgs[18]
+#define HX_ARR_LIST20 inArgs[0],inArgs[1],inArgs[2],inArgs[3],inArgs[4],inArgs[5],inArgs[6],inArgs[7],inArgs[8],inArgs[9],inArgs[10],inArgs[11],inArgs[12],inArgs[13],inArgs[14],inArgs[15],inArgs[16],inArgs[17],inArgs[18],inArgs[19]
+#define HX_ARR_LIST21 inArgs[0],inArgs[1],inArgs[2],inArgs[3],inArgs[4],inArgs[5],inArgs[6],inArgs[7],inArgs[8],inArgs[9],inArgs[10],inArgs[11],inArgs[12],inArgs[13],inArgs[14],inArgs[15],inArgs[16],inArgs[17],inArgs[18],inArgs[19],inArgs[20]
+#define HX_ARR_LIST22 inArgs[0],inArgs[1],inArgs[2],inArgs[3],inArgs[4],inArgs[5],inArgs[6],inArgs[7],inArgs[8],inArgs[9],inArgs[10],inArgs[11],inArgs[12],inArgs[13],inArgs[14],inArgs[15],inArgs[16],inArgs[17],inArgs[18],inArgs[19],inArgs[20],inArgs[21]
+#define HX_ARR_LIST23 inArgs[0],inArgs[1],inArgs[2],inArgs[3],inArgs[4],inArgs[5],inArgs[6],inArgs[7],inArgs[8],inArgs[9],inArgs[10],inArgs[11],inArgs[12],inArgs[13],inArgs[14],inArgs[15],inArgs[16],inArgs[17],inArgs[18],inArgs[19],inArgs[20],inArgs[21],inArgs[22]
+#define HX_ARR_LIST24 inArgs[0],inArgs[1],inArgs[2],inArgs[3],inArgs[4],inArgs[5],inArgs[6],inArgs[7],inArgs[8],inArgs[9],inArgs[10],inArgs[11],inArgs[12],inArgs[13],inArgs[14],inArgs[15],inArgs[16],inArgs[17],inArgs[18],inArgs[19],inArgs[20],inArgs[21],inArgs[22],inArgs[23]
+#define HX_ARR_LIST25 inArgs[0],inArgs[1],inArgs[2],inArgs[3],inArgs[4],inArgs[5],inArgs[6],inArgs[7],inArgs[8],inArgs[9],inArgs[10],inArgs[11],inArgs[12],inArgs[13],inArgs[14],inArgs[15],inArgs[16],inArgs[17],inArgs[18],inArgs[19],inArgs[20],inArgs[21],inArgs[22],inArgs[23],inArgs[24]
+#define HX_ARR_LIST26 inArgs[0],inArgs[1],inArgs[2],inArgs[3],inArgs[4],inArgs[5],inArgs[6],inArgs[7],inArgs[8],inArgs[9],inArgs[10],inArgs[11],inArgs[12],inArgs[13],inArgs[14],inArgs[15],inArgs[16],inArgs[17],inArgs[18],inArgs[19],inArgs[20],inArgs[21],inArgs[22],inArgs[23],inArgs[24],inArgs[25]
+
+
+#define HX_DYNAMIC_ARG_LIST0 
+#define HX_DYNAMIC_ARG_LIST1 const Dynamic &inArg0
+#define HX_DYNAMIC_ARG_LIST2 const Dynamic &inArg0,const Dynamic &inArg1
+#define HX_DYNAMIC_ARG_LIST3 const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2
+#define HX_DYNAMIC_ARG_LIST4 const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3
+#define HX_DYNAMIC_ARG_LIST5 const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4
+#define HX_DYNAMIC_ARG_LIST6 const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5
+#define HX_DYNAMIC_ARG_LIST7 const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6
+#define HX_DYNAMIC_ARG_LIST8 const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7
+#define HX_DYNAMIC_ARG_LIST9 const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8
+#define HX_DYNAMIC_ARG_LIST10 const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9
+#define HX_DYNAMIC_ARG_LIST11 const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10
+#define HX_DYNAMIC_ARG_LIST12 const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11
+#define HX_DYNAMIC_ARG_LIST13 const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12
+#define HX_DYNAMIC_ARG_LIST14 const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13
+#define HX_DYNAMIC_ARG_LIST15 const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14
+#define HX_DYNAMIC_ARG_LIST16 const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15
+#define HX_DYNAMIC_ARG_LIST17 const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16
+#define HX_DYNAMIC_ARG_LIST18 const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17
+#define HX_DYNAMIC_ARG_LIST19 const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18
+#define HX_DYNAMIC_ARG_LIST20 const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19
+#define HX_DYNAMIC_ARG_LIST21 const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20
+#define HX_DYNAMIC_ARG_LIST22 const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20,const Dynamic &inArg21
+#define HX_DYNAMIC_ARG_LIST23 const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20,const Dynamic &inArg21,const Dynamic &inArg22
+#define HX_DYNAMIC_ARG_LIST24 const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20,const Dynamic &inArg21,const Dynamic &inArg22,const Dynamic &inArg23
+#define HX_DYNAMIC_ARG_LIST25 const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20,const Dynamic &inArg21,const Dynamic &inArg22,const Dynamic &inArg23,const Dynamic &inArg24
+#define HX_DYNAMIC_ARG_LIST26 const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20,const Dynamic &inArg21,const Dynamic &inArg22,const Dynamic &inArg23,const Dynamic &inArg24,const Dynamic &inArg25
+
+
+#define HX_ARG_LIST0 
+#define HX_ARG_LIST1 inArg0
+#define HX_ARG_LIST2 inArg0,inArg1
+#define HX_ARG_LIST3 inArg0,inArg1,inArg2
+#define HX_ARG_LIST4 inArg0,inArg1,inArg2,inArg3
+#define HX_ARG_LIST5 inArg0,inArg1,inArg2,inArg3,inArg4
+#define HX_ARG_LIST6 inArg0,inArg1,inArg2,inArg3,inArg4,inArg5
+#define HX_ARG_LIST7 inArg0,inArg1,inArg2,inArg3,inArg4,inArg5,inArg6
+#define HX_ARG_LIST8 inArg0,inArg1,inArg2,inArg3,inArg4,inArg5,inArg6,inArg7
+#define HX_ARG_LIST9 inArg0,inArg1,inArg2,inArg3,inArg4,inArg5,inArg6,inArg7,inArg8
+#define HX_ARG_LIST10 inArg0,inArg1,inArg2,inArg3,inArg4,inArg5,inArg6,inArg7,inArg8,inArg9
+#define HX_ARG_LIST11 inArg0,inArg1,inArg2,inArg3,inArg4,inArg5,inArg6,inArg7,inArg8,inArg9,inArg10
+#define HX_ARG_LIST12 inArg0,inArg1,inArg2,inArg3,inArg4,inArg5,inArg6,inArg7,inArg8,inArg9,inArg10,inArg11
+#define HX_ARG_LIST13 inArg0,inArg1,inArg2,inArg3,inArg4,inArg5,inArg6,inArg7,inArg8,inArg9,inArg10,inArg11,inArg12
+#define HX_ARG_LIST14 inArg0,inArg1,inArg2,inArg3,inArg4,inArg5,inArg6,inArg7,inArg8,inArg9,inArg10,inArg11,inArg12,inArg13
+#define HX_ARG_LIST15 inArg0,inArg1,inArg2,inArg3,inArg4,inArg5,inArg6,inArg7,inArg8,inArg9,inArg10,inArg11,inArg12,inArg13,inArg14
+#define HX_ARG_LIST16 inArg0,inArg1,inArg2,inArg3,inArg4,inArg5,inArg6,inArg7,inArg8,inArg9,inArg10,inArg11,inArg12,inArg13,inArg14,inArg15
+#define HX_ARG_LIST17 inArg0,inArg1,inArg2,inArg3,inArg4,inArg5,inArg6,inArg7,inArg8,inArg9,inArg10,inArg11,inArg12,inArg13,inArg14,inArg15,inArg16
+#define HX_ARG_LIST18 inArg0,inArg1,inArg2,inArg3,inArg4,inArg5,inArg6,inArg7,inArg8,inArg9,inArg10,inArg11,inArg12,inArg13,inArg14,inArg15,inArg16,inArg17
+#define HX_ARG_LIST19 inArg0,inArg1,inArg2,inArg3,inArg4,inArg5,inArg6,inArg7,inArg8,inArg9,inArg10,inArg11,inArg12,inArg13,inArg14,inArg15,inArg16,inArg17,inArg18
+#define HX_ARG_LIST20 inArg0,inArg1,inArg2,inArg3,inArg4,inArg5,inArg6,inArg7,inArg8,inArg9,inArg10,inArg11,inArg12,inArg13,inArg14,inArg15,inArg16,inArg17,inArg18,inArg19
+#define HX_ARG_LIST21 inArg0,inArg1,inArg2,inArg3,inArg4,inArg5,inArg6,inArg7,inArg8,inArg9,inArg10,inArg11,inArg12,inArg13,inArg14,inArg15,inArg16,inArg17,inArg18,inArg19,inArg20
+#define HX_ARG_LIST22 inArg0,inArg1,inArg2,inArg3,inArg4,inArg5,inArg6,inArg7,inArg8,inArg9,inArg10,inArg11,inArg12,inArg13,inArg14,inArg15,inArg16,inArg17,inArg18,inArg19,inArg20,inArg21
+#define HX_ARG_LIST23 inArg0,inArg1,inArg2,inArg3,inArg4,inArg5,inArg6,inArg7,inArg8,inArg9,inArg10,inArg11,inArg12,inArg13,inArg14,inArg15,inArg16,inArg17,inArg18,inArg19,inArg20,inArg21,inArg22
+#define HX_ARG_LIST24 inArg0,inArg1,inArg2,inArg3,inArg4,inArg5,inArg6,inArg7,inArg8,inArg9,inArg10,inArg11,inArg12,inArg13,inArg14,inArg15,inArg16,inArg17,inArg18,inArg19,inArg20,inArg21,inArg22,inArg23
+#define HX_ARG_LIST25 inArg0,inArg1,inArg2,inArg3,inArg4,inArg5,inArg6,inArg7,inArg8,inArg9,inArg10,inArg11,inArg12,inArg13,inArg14,inArg15,inArg16,inArg17,inArg18,inArg19,inArg20,inArg21,inArg22,inArg23,inArg24
+#define HX_ARG_LIST26 inArg0,inArg1,inArg2,inArg3,inArg4,inArg5,inArg6,inArg7,inArg8,inArg9,inArg10,inArg11,inArg12,inArg13,inArg14,inArg15,inArg16,inArg17,inArg18,inArg19,inArg20,inArg21,inArg22,inArg23,inArg24,inArg25
+
+#define HX_DEFINE_DYNAMIC_FUNC0(class,func,ret) \
+static ::Dynamic __##class##func( ::hx::Object *inObj) \
+{ \
+      ret reinterpret_cast<class *>(inObj)->func(); return  ::Dynamic(); \
+}; \
+ ::Dynamic class::func##_dyn() \
+{\
+   return  ::hx::CreateMemberFunction0(#func,this,__##class##func); \
+}
+
+
+#define HX_DEFINE_DYNAMIC_FUNC(class,N,func,ret,array_list,dynamic_arg_list,arg_list) \
+static ::Dynamic __##class##func( ::hx::Object *inObj, dynamic_arg_list) \
+{ \
+      ret reinterpret_cast<class *>(inObj)->func(arg_list); return  ::Dynamic(); \
+}; \
+ ::Dynamic class::func##_dyn() \
+{\
+   return  ::hx::CreateMemberFunction##N(#func,this,__##class##func); \
+}
+
+
+#define HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,N,func,ret,array_list,dynamic_arg_list,arg_list) \
+static ::Dynamic __##class##func( ::hx::Object *inObj, const Array< ::Dynamic> &inArgs) \
+{ \
+      ret reinterpret_cast<class *>(inObj)->func(array_list); return  ::Dynamic(); \
+}; \
+ ::Dynamic class::func##_dyn() \
+{\
+   return  ::hx::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) \
+    ::Dynamic func##_dyn(dynamic_arg_list);
+
+#define STATIC_HX_DECLARE_DYNAMIC_FUNC(func,dynamic_arg_list) \
+   static  ::Dynamic func##_dyn(dynamic_arg_list);
+
+
+
+
+
+#define HX_DEFINE_DYNAMIC_FUNC1(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC(class,1,func,ret,HX_ARR_LIST1,HX_DYNAMIC_ARG_LIST1,HX_ARG_LIST1)
+
+
+
+#define HX_DEFINE_DYNAMIC_FUNC2(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC(class,2,func,ret,HX_ARR_LIST2,HX_DYNAMIC_ARG_LIST2,HX_ARG_LIST2)
+
+
+
+#define HX_DEFINE_DYNAMIC_FUNC3(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC(class,3,func,ret,HX_ARR_LIST3,HX_DYNAMIC_ARG_LIST3,HX_ARG_LIST3)
+
+
+
+#define HX_DEFINE_DYNAMIC_FUNC4(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC(class,4,func,ret,HX_ARR_LIST4,HX_DYNAMIC_ARG_LIST4,HX_ARG_LIST4)
+
+
+
+#define HX_DEFINE_DYNAMIC_FUNC5(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC(class,5,func,ret,HX_ARR_LIST5,HX_DYNAMIC_ARG_LIST5,HX_ARG_LIST5)
+
+
+
+#define HX_DEFINE_DYNAMIC_FUNC6(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,6,func,ret,HX_ARR_LIST6,HX_DYNAMIC_ARG_LIST6,HX_ARG_LIST6)
+
+
+
+#define HX_DEFINE_DYNAMIC_FUNC7(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,7,func,ret,HX_ARR_LIST7,HX_DYNAMIC_ARG_LIST7,HX_ARG_LIST7)
+
+
+
+#define HX_DEFINE_DYNAMIC_FUNC8(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,8,func,ret,HX_ARR_LIST8,HX_DYNAMIC_ARG_LIST8,HX_ARG_LIST8)
+
+
+
+#define HX_DEFINE_DYNAMIC_FUNC9(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,9,func,ret,HX_ARR_LIST9,HX_DYNAMIC_ARG_LIST9,HX_ARG_LIST9)
+
+
+
+#define HX_DEFINE_DYNAMIC_FUNC10(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,10,func,ret,HX_ARR_LIST10,HX_DYNAMIC_ARG_LIST10,HX_ARG_LIST10)
+
+
+
+#define HX_DEFINE_DYNAMIC_FUNC11(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,11,func,ret,HX_ARR_LIST11,HX_DYNAMIC_ARG_LIST11,HX_ARG_LIST11)
+
+
+
+#define HX_DEFINE_DYNAMIC_FUNC12(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,12,func,ret,HX_ARR_LIST12,HX_DYNAMIC_ARG_LIST12,HX_ARG_LIST12)
+
+
+
+#define HX_DEFINE_DYNAMIC_FUNC13(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,13,func,ret,HX_ARR_LIST13,HX_DYNAMIC_ARG_LIST13,HX_ARG_LIST13)
+
+
+
+#define HX_DEFINE_DYNAMIC_FUNC14(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,14,func,ret,HX_ARR_LIST14,HX_DYNAMIC_ARG_LIST14,HX_ARG_LIST14)
+
+
+
+#define HX_DEFINE_DYNAMIC_FUNC15(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,15,func,ret,HX_ARR_LIST15,HX_DYNAMIC_ARG_LIST15,HX_ARG_LIST15)
+
+
+
+#define HX_DEFINE_DYNAMIC_FUNC16(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,16,func,ret,HX_ARR_LIST16,HX_DYNAMIC_ARG_LIST16,HX_ARG_LIST16)
+
+
+
+#define HX_DEFINE_DYNAMIC_FUNC17(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,17,func,ret,HX_ARR_LIST17,HX_DYNAMIC_ARG_LIST17,HX_ARG_LIST17)
+
+
+
+#define HX_DEFINE_DYNAMIC_FUNC18(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,18,func,ret,HX_ARR_LIST18,HX_DYNAMIC_ARG_LIST18,HX_ARG_LIST18)
+
+
+
+#define HX_DEFINE_DYNAMIC_FUNC19(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,19,func,ret,HX_ARR_LIST19,HX_DYNAMIC_ARG_LIST19,HX_ARG_LIST19)
+
+
+
+#define HX_DEFINE_DYNAMIC_FUNC20(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,20,func,ret,HX_ARR_LIST20,HX_DYNAMIC_ARG_LIST20,HX_ARG_LIST20)
+
+
+
+#define HX_DEFINE_DYNAMIC_FUNC21(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,21,func,ret,HX_ARR_LIST21,HX_DYNAMIC_ARG_LIST21,HX_ARG_LIST21)
+
+
+
+#define HX_DEFINE_DYNAMIC_FUNC22(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,22,func,ret,HX_ARR_LIST22,HX_DYNAMIC_ARG_LIST22,HX_ARG_LIST22)
+
+
+
+#define HX_DEFINE_DYNAMIC_FUNC23(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,23,func,ret,HX_ARR_LIST23,HX_DYNAMIC_ARG_LIST23,HX_ARG_LIST23)
+
+
+
+#define HX_DEFINE_DYNAMIC_FUNC24(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,24,func,ret,HX_ARR_LIST24,HX_DYNAMIC_ARG_LIST24,HX_ARG_LIST24)
+
+
+
+#define HX_DEFINE_DYNAMIC_FUNC25(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,25,func,ret,HX_ARR_LIST25,HX_DYNAMIC_ARG_LIST25,HX_ARG_LIST25)
+
+
+
+#define HX_DEFINE_DYNAMIC_FUNC26(class,func,ret) \
+          HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,26,func,ret,HX_ARR_LIST26,HX_DYNAMIC_ARG_LIST26,HX_ARG_LIST26)
+
+
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC0(class,func,ret) \
+static ::Dynamic __##class##func() \
+{ \
+      ret class::func(); return  ::Dynamic(); \
+}; \
+ ::Dynamic class::func##_dyn() \
+{\
+   return  ::hx::CreateStaticFunction0(#func,__##class##func); \
+}
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC(class,N,func,ret,array_list,dynamic_arg_list,arg_list) \
+static ::Dynamic __##class##func(dynamic_arg_list) \
+{ \
+      ret class::func(arg_list); return  ::Dynamic(); \
+}; \
+ ::Dynamic class::func##_dyn() \
+{\
+   return  ::hx::CreateStaticFunction##N(#func,__##class##func); \
+}
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,N,func,ret,array_list,dynamic_arg_list,arg_list) \
+static ::Dynamic __##class##func(const Array< ::Dynamic> &inArgs) \
+{ \
+      ret class::func(array_list); return  ::Dynamic(); \
+}; \
+ ::Dynamic class::func##_dyn() \
+{\
+   return  ::hx::CreateStaticFunctionVar(#func,__##class##func,N); \
+}
+
+
+
+
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC1(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC(class,1,func,ret,HX_ARR_LIST1,HX_DYNAMIC_ARG_LIST1,HX_ARG_LIST1)
+
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC2(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC(class,2,func,ret,HX_ARR_LIST2,HX_DYNAMIC_ARG_LIST2,HX_ARG_LIST2)
+
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC3(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC(class,3,func,ret,HX_ARR_LIST3,HX_DYNAMIC_ARG_LIST3,HX_ARG_LIST3)
+
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC4(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC(class,4,func,ret,HX_ARR_LIST4,HX_DYNAMIC_ARG_LIST4,HX_ARG_LIST4)
+
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC5(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC(class,5,func,ret,HX_ARR_LIST5,HX_DYNAMIC_ARG_LIST5,HX_ARG_LIST5)
+
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC6(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,6,func,ret,HX_ARR_LIST6,HX_DYNAMIC_ARG_LIST6,HX_ARG_LIST6)
+
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC7(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,7,func,ret,HX_ARR_LIST7,HX_DYNAMIC_ARG_LIST7,HX_ARG_LIST7)
+
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC8(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,8,func,ret,HX_ARR_LIST8,HX_DYNAMIC_ARG_LIST8,HX_ARG_LIST8)
+
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC9(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,9,func,ret,HX_ARR_LIST9,HX_DYNAMIC_ARG_LIST9,HX_ARG_LIST9)
+
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC10(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,10,func,ret,HX_ARR_LIST10,HX_DYNAMIC_ARG_LIST10,HX_ARG_LIST10)
+
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC11(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,11,func,ret,HX_ARR_LIST11,HX_DYNAMIC_ARG_LIST11,HX_ARG_LIST11)
+
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC12(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,12,func,ret,HX_ARR_LIST12,HX_DYNAMIC_ARG_LIST12,HX_ARG_LIST12)
+
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC13(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,13,func,ret,HX_ARR_LIST13,HX_DYNAMIC_ARG_LIST13,HX_ARG_LIST13)
+
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC14(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,14,func,ret,HX_ARR_LIST14,HX_DYNAMIC_ARG_LIST14,HX_ARG_LIST14)
+
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC15(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,15,func,ret,HX_ARR_LIST15,HX_DYNAMIC_ARG_LIST15,HX_ARG_LIST15)
+
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC16(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,16,func,ret,HX_ARR_LIST16,HX_DYNAMIC_ARG_LIST16,HX_ARG_LIST16)
+
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC17(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,17,func,ret,HX_ARR_LIST17,HX_DYNAMIC_ARG_LIST17,HX_ARG_LIST17)
+
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC18(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,18,func,ret,HX_ARR_LIST18,HX_DYNAMIC_ARG_LIST18,HX_ARG_LIST18)
+
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC19(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,19,func,ret,HX_ARR_LIST19,HX_DYNAMIC_ARG_LIST19,HX_ARG_LIST19)
+
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC20(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,20,func,ret,HX_ARR_LIST20,HX_DYNAMIC_ARG_LIST20,HX_ARG_LIST20)
+
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC21(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,21,func,ret,HX_ARR_LIST21,HX_DYNAMIC_ARG_LIST21,HX_ARG_LIST21)
+
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC22(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,22,func,ret,HX_ARR_LIST22,HX_DYNAMIC_ARG_LIST22,HX_ARG_LIST22)
+
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC23(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,23,func,ret,HX_ARR_LIST23,HX_DYNAMIC_ARG_LIST23,HX_ARG_LIST23)
+
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC24(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,24,func,ret,HX_ARR_LIST24,HX_DYNAMIC_ARG_LIST24,HX_ARG_LIST24)
+
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC25(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,25,func,ret,HX_ARR_LIST25,HX_DYNAMIC_ARG_LIST25,HX_ARG_LIST25)
+
+
+
+#define STATIC_HX_DEFINE_DYNAMIC_FUNC26(class,func,ret) \
+          STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,26,func,ret,HX_ARR_LIST26,HX_DYNAMIC_ARG_LIST26,HX_ARG_LIST26)
+
+
+
+
+#define HX_DYNAMIC_CALL(ret,func,array_args,dyn_arg_list,arg_list) \
+    ::Dynamic __Run(const Array< ::Dynamic> &inArgs) { ret func( array_args ); return null();} \
+    ::Dynamic __run(dyn_arg_list) { ret func( arg_list ); return null();}
+
+
+#define HX_DYNAMIC_CALL0(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST0,HX_DYNAMIC_ARG_LIST0,HX_ARG_LIST0)
+#define HX_DYNAMIC_CALL1(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST1,HX_DYNAMIC_ARG_LIST1,HX_ARG_LIST1)
+#define HX_DYNAMIC_CALL2(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST2,HX_DYNAMIC_ARG_LIST2,HX_ARG_LIST2)
+#define HX_DYNAMIC_CALL3(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST3,HX_DYNAMIC_ARG_LIST3,HX_ARG_LIST3)
+#define HX_DYNAMIC_CALL4(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST4,HX_DYNAMIC_ARG_LIST4,HX_ARG_LIST4)
+#define HX_DYNAMIC_CALL5(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST5,HX_DYNAMIC_ARG_LIST5,HX_ARG_LIST5)
+#define HX_DYNAMIC_CALL6(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST6,HX_DYNAMIC_ARG_LIST6,HX_ARG_LIST6)
+#define HX_DYNAMIC_CALL7(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST7,HX_DYNAMIC_ARG_LIST7,HX_ARG_LIST7)
+#define HX_DYNAMIC_CALL8(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST8,HX_DYNAMIC_ARG_LIST8,HX_ARG_LIST8)
+#define HX_DYNAMIC_CALL9(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST9,HX_DYNAMIC_ARG_LIST9,HX_ARG_LIST9)
+#define HX_DYNAMIC_CALL10(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST10,HX_DYNAMIC_ARG_LIST10,HX_ARG_LIST10)
+#define HX_DYNAMIC_CALL11(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST11,HX_DYNAMIC_ARG_LIST11,HX_ARG_LIST11)
+#define HX_DYNAMIC_CALL12(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST12,HX_DYNAMIC_ARG_LIST12,HX_ARG_LIST12)
+#define HX_DYNAMIC_CALL13(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST13,HX_DYNAMIC_ARG_LIST13,HX_ARG_LIST13)
+#define HX_DYNAMIC_CALL14(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST14,HX_DYNAMIC_ARG_LIST14,HX_ARG_LIST14)
+#define HX_DYNAMIC_CALL15(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST15,HX_DYNAMIC_ARG_LIST15,HX_ARG_LIST15)
+#define HX_DYNAMIC_CALL16(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST16,HX_DYNAMIC_ARG_LIST16,HX_ARG_LIST16)
+#define HX_DYNAMIC_CALL17(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST17,HX_DYNAMIC_ARG_LIST17,HX_ARG_LIST17)
+#define HX_DYNAMIC_CALL18(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST18,HX_DYNAMIC_ARG_LIST18,HX_ARG_LIST18)
+#define HX_DYNAMIC_CALL19(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST19,HX_DYNAMIC_ARG_LIST19,HX_ARG_LIST19)
+#define HX_DYNAMIC_CALL20(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST20,HX_DYNAMIC_ARG_LIST20,HX_ARG_LIST20)
+#define HX_DYNAMIC_CALL21(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST21,HX_DYNAMIC_ARG_LIST21,HX_ARG_LIST21)
+#define HX_DYNAMIC_CALL22(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST22,HX_DYNAMIC_ARG_LIST22,HX_ARG_LIST22)
+#define HX_DYNAMIC_CALL23(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST23,HX_DYNAMIC_ARG_LIST23,HX_ARG_LIST23)
+#define HX_DYNAMIC_CALL24(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST24,HX_DYNAMIC_ARG_LIST24,HX_ARG_LIST24)
+#define HX_DYNAMIC_CALL25(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST25,HX_DYNAMIC_ARG_LIST25,HX_ARG_LIST25)
+#define HX_DYNAMIC_CALL26(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST26,HX_DYNAMIC_ARG_LIST26,HX_ARG_LIST26)
+
+#define HX_BEGIN_DEFAULT_FUNC(name,t0) \
+	namespace { \
+   struct name : public  ::hx::Object { int __GetType() const { return vtFunction; } \
+   HX_IS_INSTANCE_OF enum { _hx_ClassId =  ::hx::clsIdClosure }; \
+    ::hx::ObjectPtr<t0> __this; \
+   name( ::hx::ObjectPtr<t0> __0 = null()) : __this(__0) {} \
+   void __Mark( ::hx::MarkContext *__inCtx) { HX_MARK_MEMBER(__this); } \
+   void __Visit( ::hx::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 =  ::hx::clsIdClosure }; \
+   void __Mark( ::hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); } \
+   void __Visit( ::hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); } \
+   name() {}
+
+
+#define HX_BEGIN_LOCAL_FUNC_S1(SUPER,name,t0,v0) \
+   struct name : public SUPER { \
+   HX_IS_INSTANCE_OF enum { _hx_ClassId =  ::hx::clsIdClosure }; \
+   t0 v0; \
+   void __Mark( ::hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); } \
+   void __Visit( ::hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); } \
+   name(t0 __0) : v0(__0) {}
+#define HX_BEGIN_LOCAL_FUNC_S2(SUPER,name,t0,v0,t1,v1) \
+   struct name : public SUPER { \
+   HX_IS_INSTANCE_OF enum { _hx_ClassId =  ::hx::clsIdClosure }; \
+   t0 v0;t1 v1; \
+   void __Mark( ::hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); } \
+   void __Visit( ::hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); } \
+   name(t0 __0,t1 __1) : v0(__0),v1(__1) {}
+#define HX_BEGIN_LOCAL_FUNC_S3(SUPER,name,t0,v0,t1,v1,t2,v2) \
+   struct name : public SUPER { \
+   HX_IS_INSTANCE_OF enum { _hx_ClassId =  ::hx::clsIdClosure }; \
+   t0 v0;t1 v1;t2 v2; \
+   void __Mark( ::hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); } \
+   void __Visit( ::hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); } \
+   name(t0 __0,t1 __1,t2 __2) : v0(__0),v1(__1),v2(__2) {}
+#define HX_BEGIN_LOCAL_FUNC_S4(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3) \
+   struct name : public SUPER { \
+   HX_IS_INSTANCE_OF enum { _hx_ClassId =  ::hx::clsIdClosure }; \
+   t0 v0;t1 v1;t2 v2;t3 v3; \
+   void __Mark( ::hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); } \
+   void __Visit( ::hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3) : v0(__0),v1(__1),v2(__2),v3(__3) {}
+#define HX_BEGIN_LOCAL_FUNC_S5(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4) \
+   struct name : public SUPER { \
+   HX_IS_INSTANCE_OF enum { _hx_ClassId =  ::hx::clsIdClosure }; \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4; \
+   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); } \
+   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); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4) {}
+#define HX_BEGIN_LOCAL_FUNC_S6(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5) \
+   struct name : public SUPER { \
+   HX_IS_INSTANCE_OF enum { _hx_ClassId =  ::hx::clsIdClosure }; \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5; \
+   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); } \
+   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); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5) {}
+#define HX_BEGIN_LOCAL_FUNC_S7(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6) \
+   struct name : public SUPER { \
+   HX_IS_INSTANCE_OF enum { _hx_ClassId =  ::hx::clsIdClosure }; \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6; \
+   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); } \
+   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); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6) {}
+#define HX_BEGIN_LOCAL_FUNC_S8(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7) \
+   struct name : public SUPER { \
+   HX_IS_INSTANCE_OF enum { _hx_ClassId =  ::hx::clsIdClosure }; \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7; \
+   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); } \
+   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); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7) {}
+#define HX_BEGIN_LOCAL_FUNC_S9(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8) \
+   struct name : public SUPER { \
+   HX_IS_INSTANCE_OF enum { _hx_ClassId =  ::hx::clsIdClosure }; \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8; \
+   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); } \
+   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); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8) {}
+#define HX_BEGIN_LOCAL_FUNC_S10(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9) \
+   struct name : public SUPER { \
+   HX_IS_INSTANCE_OF enum { _hx_ClassId =  ::hx::clsIdClosure }; \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9; \
+   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); } \
+   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); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9) {}
+#define HX_BEGIN_LOCAL_FUNC_S11(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10) \
+   struct name : public SUPER { \
+   HX_IS_INSTANCE_OF enum { _hx_ClassId =  ::hx::clsIdClosure }; \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10; \
+   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); } \
+   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); } \
+   name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10) {}
+#define HX_BEGIN_LOCAL_FUNC_S12(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) \
+   struct name : public SUPER { \
+   HX_IS_INSTANCE_OF enum { _hx_ClassId =  ::hx::clsIdClosure }; \
+   t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11; \
+   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); } \
+   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); } \
+   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) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11) {}
+#define HX_BEGIN_LOCAL_FUNC_S13(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) \
+   struct name : public SUPER { \
+   HX_IS_INSTANCE_OF enum { _hx_ClassId =  ::hx::clsIdClosure }; \
+   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; \
+   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); } \
+   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); } \
+   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) : 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) {}
+#define HX_BEGIN_LOCAL_FUNC_S14(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) \
+   struct name : public SUPER { \
+   HX_IS_INSTANCE_OF enum { _hx_ClassId =  ::hx::clsIdClosure }; \
+   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; \
+   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); } \
+   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); } \
+   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) : 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) {}
+#define HX_BEGIN_LOCAL_FUNC_S15(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) \
+   struct name : public SUPER { \
+   HX_IS_INSTANCE_OF enum { _hx_ClassId =  ::hx::clsIdClosure }; \
+   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; \
+   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); } \
+   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); } \
+   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) : 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) {}
+#define HX_BEGIN_LOCAL_FUNC_S16(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) \
+   struct name : public SUPER { \
+   HX_IS_INSTANCE_OF enum { _hx_ClassId =  ::hx::clsIdClosure }; \
+   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; \
+   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); } \
+   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); } \
+   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) : 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) {}
+#define HX_BEGIN_LOCAL_FUNC_S17(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) \
+   struct name : public SUPER { \
+   HX_IS_INSTANCE_OF enum { _hx_ClassId =  ::hx::clsIdClosure }; \
+   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; \
+   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); } \
+   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); } \
+   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) : 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) {}
+#define HX_BEGIN_LOCAL_FUNC_S18(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) \
+   struct name : public SUPER { \
+   HX_IS_INSTANCE_OF enum { _hx_ClassId =  ::hx::clsIdClosure }; \
+   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; \
+   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); } \
+   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); } \
+   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) : 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) {}
+#define HX_BEGIN_LOCAL_FUNC_S19(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) \
+   struct name : public SUPER { \
+   HX_IS_INSTANCE_OF enum { _hx_ClassId =  ::hx::clsIdClosure }; \
+   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; \
+   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); } \
+   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); } \
+   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) : 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) {}
+
+#define HX_LOCAL_RUN _hx_run
+
+#define HX_END_LOCAL_FUNC0(ret) HX_DYNAMIC_CALL0(ret, HX_LOCAL_RUN ) };
+
+#define HX_END_LOCAL_FUNC1(ret) HX_DYNAMIC_CALL1(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC2(ret) HX_DYNAMIC_CALL2(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC3(ret) HX_DYNAMIC_CALL3(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC4(ret) HX_DYNAMIC_CALL4(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC5(ret) HX_DYNAMIC_CALL5(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC6(ret) HX_DYNAMIC_CALL6(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC7(ret) HX_DYNAMIC_CALL7(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC8(ret) HX_DYNAMIC_CALL8(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC9(ret) HX_DYNAMIC_CALL9(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC10(ret) HX_DYNAMIC_CALL10(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC11(ret) HX_DYNAMIC_CALL11(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC12(ret) HX_DYNAMIC_CALL12(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC13(ret) HX_DYNAMIC_CALL13(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC14(ret) HX_DYNAMIC_CALL14(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC15(ret) HX_DYNAMIC_CALL15(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC16(ret) HX_DYNAMIC_CALL16(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC17(ret) HX_DYNAMIC_CALL17(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC18(ret) HX_DYNAMIC_CALL18(ret, HX_LOCAL_RUN ) };
+#define HX_END_LOCAL_FUNC19(ret) HX_DYNAMIC_CALL19(ret, HX_LOCAL_RUN ) };
+
+// For compatibility until next version of haxe is released
+#define HX_BEGIN_LOCAL_FUNC0(name) \
+      HX_BEGIN_LOCAL_FUNC_S0( ::hx::LocalFunc,name)
+
+#define HX_BEGIN_LOCAL_FUNC1(name,t0,v0) \
+      HX_BEGIN_LOCAL_FUNC_S1( ::hx::LocalFunc,name,t0,v0)
+#define HX_BEGIN_LOCAL_FUNC2(name,t0,v0,t1,v1) \
+      HX_BEGIN_LOCAL_FUNC_S2( ::hx::LocalFunc,name,t0,v0,t1,v1)
+#define HX_BEGIN_LOCAL_FUNC3(name,t0,v0,t1,v1,t2,v2) \
+      HX_BEGIN_LOCAL_FUNC_S3( ::hx::LocalFunc,name,t0,v0,t1,v1,t2,v2)
+#define HX_BEGIN_LOCAL_FUNC4(name,t0,v0,t1,v1,t2,v2,t3,v3) \
+      HX_BEGIN_LOCAL_FUNC_S4( ::hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3)
+#define HX_BEGIN_LOCAL_FUNC5(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4) \
+      HX_BEGIN_LOCAL_FUNC_S5( ::hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4)
+#define HX_BEGIN_LOCAL_FUNC6(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5) \
+      HX_BEGIN_LOCAL_FUNC_S6( ::hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5)
+#define HX_BEGIN_LOCAL_FUNC7(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6) \
+      HX_BEGIN_LOCAL_FUNC_S7( ::hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6)
+#define HX_BEGIN_LOCAL_FUNC8(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7) \
+      HX_BEGIN_LOCAL_FUNC_S8( ::hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7)
+#define HX_BEGIN_LOCAL_FUNC9(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8) \
+      HX_BEGIN_LOCAL_FUNC_S9( ::hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8)
+#define HX_BEGIN_LOCAL_FUNC10(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9) \
+      HX_BEGIN_LOCAL_FUNC_S10( ::hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9)
+#define HX_BEGIN_LOCAL_FUNC11(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10) \
+      HX_BEGIN_LOCAL_FUNC_S11( ::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)
+#define HX_BEGIN_LOCAL_FUNC12(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) \
+      HX_BEGIN_LOCAL_FUNC_S12( ::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)
+#define HX_BEGIN_LOCAL_FUNC13(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) \
+      HX_BEGIN_LOCAL_FUNC_S13( ::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)
+#define HX_BEGIN_LOCAL_FUNC14(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) \
+      HX_BEGIN_LOCAL_FUNC_S14( ::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)
+#define HX_BEGIN_LOCAL_FUNC15(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) \
+      HX_BEGIN_LOCAL_FUNC_S15( ::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)
+#define HX_BEGIN_LOCAL_FUNC16(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) \
+      HX_BEGIN_LOCAL_FUNC_S16( ::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)
+#define HX_BEGIN_LOCAL_FUNC17(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) \
+      HX_BEGIN_LOCAL_FUNC_S17( ::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)
+#define HX_BEGIN_LOCAL_FUNC18(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) \
+      HX_BEGIN_LOCAL_FUNC_S18( ::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)
+#define HX_BEGIN_LOCAL_FUNC19(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) \
+      HX_BEGIN_LOCAL_FUNC_S19( ::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)
+
+
+#define HX_DECLARE_DYNAMIC_FUNCTIONS \
+               ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20,const Dynamic &inArg21); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20,const Dynamic &inArg21,const Dynamic &inArg22); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20,const Dynamic &inArg21,const Dynamic &inArg22,const Dynamic &inArg23); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20,const Dynamic &inArg21,const Dynamic &inArg22,const Dynamic &inArg23,const Dynamic &inArg24); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20,const Dynamic &inArg21,const Dynamic &inArg22,const Dynamic &inArg23,const Dynamic &inArg24,const Dynamic &inArg25); \
+ 
+
+
+#define HX_DECLARE_VARIANT_FUNCTIONS \
+  inline  ::Dynamic operator()(); \
+   inline  ::Dynamic operator()(const Dynamic &inArg0); \
+   inline  ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1); \
+   inline  ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2); \
+   inline  ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3); \
+   inline  ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20,const Dynamic &inArg21); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20,const Dynamic &inArg21,const Dynamic &inArg22); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20,const Dynamic &inArg21,const Dynamic &inArg22,const Dynamic &inArg23); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20,const Dynamic &inArg21,const Dynamic &inArg22,const Dynamic &inArg23,const Dynamic &inArg24); \
+    ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5,const Dynamic &inArg6,const Dynamic &inArg7,const Dynamic &inArg8,const Dynamic &inArg9,const Dynamic &inArg10,const Dynamic &inArg11,const Dynamic &inArg12,const Dynamic &inArg13,const Dynamic &inArg14,const Dynamic &inArg15,const Dynamic &inArg16,const Dynamic &inArg17,const Dynamic &inArg18,const Dynamic &inArg19,const Dynamic &inArg20,const Dynamic &inArg21,const Dynamic &inArg22,const Dynamic &inArg23,const Dynamic &inArg24,const Dynamic &inArg25); \
+ 
+
+
+#define HX_IMPLEMENT_INLINE_VARIANT_FUNCTIONS \
+  ::Dynamic Variant::operator()() { CheckFPtr(); return valObject->__run(); } \
+   ::Dynamic Variant::operator()(const Dynamic &inArg0) { CheckFPtr(); return valObject->__run(inArg0); } \
+   ::Dynamic Variant::operator()(const Dynamic &inArg0,const Dynamic &inArg1) { CheckFPtr(); return valObject->__run(inArg0,inArg1); } \
+   ::Dynamic Variant::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2) { CheckFPtr(); return valObject->__run(inArg0,inArg1,inArg2); } \
+   ::Dynamic Variant::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3) { CheckFPtr(); return valObject->__run(inArg0,inArg1,inArg2,inArg3); } \
+   ::Dynamic Variant::operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4) { CheckFPtr(); return valObject->__run(inArg0,inArg1,inArg2,inArg3,inArg4); } \
+                                           
+
+
+#endif
+
+
diff --git a/Sources/c_snikket/iinclude/hx/Macros.tpl b/Sources/c_snikket/iinclude/hx/Macros.tpl
new file mode 100644
index 0000000..bae9abf
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/Macros.tpl
@@ -0,0 +1,191 @@
+#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::
+
+#define HX_LOCAL_RUN _hx_run
+
+#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
+
+
diff --git a/Sources/c_snikket/iinclude/hx/MacrosFixed.h b/Sources/c_snikket/iinclude/hx/MacrosFixed.h
new file mode 100644
index 0000000..d3c194a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/MacrosFixed.h
@@ -0,0 +1,320 @@
+#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 ----------------------
+
+#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); \
+}
+
+// ---- Fields ----------------------
+
+#define HX_IS_INSTANCE_OF bool _hx_isInstanceOf(int inClassId) { return inClassId==1 || inClassId==(int)_hx_ClassId; }
+
+#define HX_DO_RTTI_ALL \
+   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::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
+
+
diff --git a/Sources/c_snikket/iinclude/hx/MacrosJumbo.h b/Sources/c_snikket/iinclude/hx/MacrosJumbo.h
new file mode 100644
index 0000000..52b6d93
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/MacrosJumbo.h
@@ -0,0 +1,402 @@
+//   ##  ##  ##   ##   ####   ##  ## ## ##  ##  ####    ##
+//   ##  ##  ## ##  ## ##  ## ### ## ## ### ## ##       ##
+//    ## ## ##  ###### ###### ###### ## ###### ## ###   ##
+//    ## ## ##  ##  ## ## ##  ## ### ## ## ### ##  ##     
+//     ## ##    ##  ## ##  ## ##  ## ## ##  ##  ####    ##
+
+// 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) {}
+
+#define HX_LOCAL_RUN _hx_run
+
+
+#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
+
+
diff --git a/Sources/c_snikket/iinclude/hx/MacrosJumbo.tpl b/Sources/c_snikket/iinclude/hx/MacrosJumbo.tpl
new file mode 100644
index 0000000..213b272
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/MacrosJumbo.tpl
@@ -0,0 +1,25 @@
+#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::
+
+#define HX_LOCAL_RUN _hx_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
+::foreach LOCALS::
+#define HX_BEGIN_LOCAL_FUNC::ARG::(name,::TYPE_ARGS::) \
+      HX_BEGIN_LOCAL_FUNC_S::ARG::(hx::LocalFunc,name,::TYPE_ARGS::)::end::
+
+
+#endif
+
+
diff --git a/Sources/c_snikket/iinclude/hx/Memory.h b/Sources/c_snikket/iinclude/hx/Memory.h
new file mode 100644
index 0000000..dbb5d3d
--- /dev/null
+++ b/Sources/c_snikket/iinclude/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
diff --git a/Sources/c_snikket/iinclude/hx/Native.h b/Sources/c_snikket/iinclude/hx/Native.h
new file mode 100644
index 0000000..4b68982
--- /dev/null
+++ b/Sources/c_snikket/iinclude/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(bool stayAttached=true);
+   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
+
diff --git a/Sources/c_snikket/iinclude/hx/NekoFunc.h b/Sources/c_snikket/iinclude/hx/NekoFunc.h
new file mode 100644
index 0000000..382a589
--- /dev/null
+++ b/Sources/c_snikket/iinclude/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
diff --git a/Sources/c_snikket/iinclude/hx/OS.h b/Sources/c_snikket/iinclude/hx/OS.h
new file mode 100644
index 0000000..cb28c20
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/OS.h
@@ -0,0 +1,96 @@
+#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)
+#	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
diff --git a/Sources/c_snikket/iinclude/hx/ObjcHelpers.h b/Sources/c_snikket/iinclude/hx/ObjcHelpers.h
new file mode 100644
index 0000000..90ef857
--- /dev/null
+++ b/Sources/c_snikket/iinclude/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
+
diff --git a/Sources/c_snikket/iinclude/hx/Object.h b/Sources/c_snikket/iinclude/hx/Object.h
new file mode 100644
index 0000000..8cf2fa8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/Object.h
@@ -0,0 +1,407 @@
+#ifndef HX_OBJECT_H
+#define HX_OBJECT_H
+
+#ifndef HXCPP_H
+#error "Please include hxcpp.h, not hx/Object.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 (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
+
+#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,
+   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 * ) { }
+
+   virtual bool _hx_isInstanceOf(int inClassId);
+
+   //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; }
+   virtual double __ToDouble() const { return __ToInt(); }
+   virtual cpp::Int64 __ToInt64() const { return (cpp::Int64)(__ToDouble()); }
+   virtual const char * __CStr() const;
+   virtual String toString();
+   virtual bool __HasField(const String &inString);
+   virtual hx::Val __Field(const String &inString, hx::PropertyAccess inCallProp);
+
+   // Non-virtual
+   Dynamic __IField(int inFieldID);
+   double __INumField(int inFieldID);
+   virtual void *_hx_getInterface(int inId);
+
+   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
+
+   inline bool __compare( hx::Object *inRHS ) { return this!=inRHS; }
+
+   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)
+      {
+         mPtr = inPtr->_hx_isInstanceOf(OBJ_::_hx_ClassId) ? reinterpret_cast<OBJ_*>(inPtr) : 0;
+
+         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
diff --git a/Sources/c_snikket/iinclude/hx/Operators.h b/Sources/c_snikket/iinclude/hx/Operators.h
new file mode 100644
index 0000000..862a5da
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/Operators.h
@@ -0,0 +1,439 @@
+#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;
+   }
+};
+
+template< > struct TCast< cpp::VirtualArray >
+{
+   template<typename VAL> static inline cpp::VirtualArray cast(VAL inVal ) {
+      return  cpp::VirtualArray(inVal);
+   }
+};
+
+// 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) }; };
+template<> struct DynamicConvertType< cpp::VirtualArray_obj * > { enum { Convert = aciVirtualArray }; };
+
+}
+
+
+
+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
+   {
+      outForced.mPtr = (VALUE *)(inD.mPtr);
+   }
+}
+
+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
diff --git a/Sources/c_snikket/iinclude/hx/QuickVec.h b/Sources/c_snikket/iinclude/hx/QuickVec.h
new file mode 100644
index 0000000..2427904
--- /dev/null
+++ b/Sources/c_snikket/iinclude/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
diff --git a/Sources/c_snikket/iinclude/hx/Scriptable.h b/Sources/c_snikket/iinclude/hx/Scriptable.h
new file mode 100644
index 0000000..db66f25
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/Scriptable.h
@@ -0,0 +1,275 @@
+#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);
+
+
+void ScriptableRegisterInterface( String inName, ScriptNamedFunction *inFunctions, void *inInterfacePointers);
+void ScriptableRegisterNameSlots(const char *inNames[], int inLength);
+
+::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);
+
+#define HX_SCRIPTABLE_REGISTER_INTERFACE(name,class) \
+    hx::ScriptableRegisterInterface( HX_CSTRING(name), __scriptableFunctions, & class##_scriptable )
+
+#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
diff --git a/Sources/c_snikket/iinclude/hx/StackContext.h b/Sources/c_snikket/iinclude/hx/StackContext.h
new file mode 100644
index 0000000..67dc563
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/StackContext.h
@@ -0,0 +1,746 @@
+#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
+
+   const hx::StackPosition *position;
+
+   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
diff --git a/Sources/c_snikket/iinclude/hx/StdLibs.h b/Sources/c_snikket/iinclude/hx/StdLibs.h
new file mode 100644
index 0000000..8bb7190
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/StdLibs.h
@@ -0,0 +1,925 @@
+#ifndef HX_STDLIBS_H
+#define HX_STDLIBS_H
+
+// --- Resource -------------------------------------------------------------
+
+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 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
diff --git a/Sources/c_snikket/iinclude/hx/StdString.h b/Sources/c_snikket/iinclude/hx/StdString.h
new file mode 100644
index 0000000..82c9adc
--- /dev/null
+++ b/Sources/c_snikket/iinclude/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
diff --git a/Sources/c_snikket/iinclude/hx/StringAlloc.h b/Sources/c_snikket/iinclude/hx/StringAlloc.h
new file mode 100755
index 0000000..29fb7f7
--- /dev/null
+++ b/Sources/c_snikket/iinclude/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
diff --git a/Sources/c_snikket/iinclude/hx/Telemetry.h b/Sources/c_snikket/iinclude/hx/Telemetry.h
new file mode 100644
index 0000000..cf86577
--- /dev/null
+++ b/Sources/c_snikket/iinclude/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
diff --git a/Sources/c_snikket/iinclude/hx/TelemetryTracy.h b/Sources/c_snikket/iinclude/hx/TelemetryTracy.h
new file mode 100644
index 0000000..178932a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/TelemetryTracy.h
@@ -0,0 +1,44 @@
+#ifndef HX_TELEMETRY_TRACY_H
+#define HX_TELEMETRY_TRACY_H
+
+#ifndef HXCPP_TRACY
+	#error "Error: HXCPP_TRACY must be defined."
+#endif
+
+#define TRACY_ENABLE
+#include <hxcpp.h>
+#include "../../project/thirdparty/tracy-0.11.1/tracy/TracyC.h"
+#include "../../project/thirdparty/tracy-0.11.1/tracy/Tracy.hpp"
+
+#ifdef HXCPP_TRACY_MEMORY
+	#ifdef HXCPP_GC_MOVING
+		#error "Error: HXCPP_TRACY_MEMORY is not supported when HXCPP_GC_MOVING is active."
+	#endif
+	#ifdef HXCPP_GC_GENERATIONAL
+		#error "Error: HXCPP_TRACY_MEMORY is not supported when HXCPP_GC_GENERATIONAL is active."
+	#endif
+#endif
+
+#ifdef HXCPP_TRACY_INCLUDE_CALLSTACKS
+#define HXCPP_TRACY_ZONE(name) \
+	::hx::strbuf TracyConcat(_hx_tracy_str_buffer, TracyLine); \
+	int TracyConcat(_hx_tracy_str_length, TracyLine); \
+	const char *TracyConcat(_hx_tracy_str_buffer_ptr, TracyLine) = name.utf8_str(&TracyConcat(_hx_tracy_str_buffer, TracyLine), false, &TracyConcat(_hx_tracy_str_length, TracyLine)); \
+	::tracy::ScopedZone TracyConcat(_hx_tracy_scoped_zone,TracyLine)(_hx_stackframe.lineNumber, _hx_stackframe.position->fileName, strlen(_hx_stackframe.position->fileName), _hx_stackframe.position->fullName, strlen(_hx_stackframe.position->fullName), TracyConcat(_hx_tracy_str_buffer_ptr, TracyLine), TracyConcat(_hx_tracy_str_length, TracyLine), __hxcpp_tracy_get_zone_count());
+#else
+#define HXCPP_TRACY_ZONE(name) \
+	::hx::strbuf TracyConcat(_hx_tracy_str_buffer, TracyLine); \
+	int TracyConcat(_hx_tracy_str_length, TracyLine); \
+	const char *TracyConcat(_hx_tracy_str_buffer_ptr, TracyLine) = name.utf8_str(&TracyConcat(_hx_tracy_str_buffer, TracyLine), false, &TracyConcat(_hx_tracy_str_length, TracyLine)); \
+	::tracy::ScopedZone TracyConcat(_hx_tracy_scoped_zone,TracyLine)(_hx_stackframe.lineNumber, _hx_stackframe.position->fileName, strlen(_hx_stackframe.position->fileName), _hx_stackframe.position->fullName, strlen(_hx_stackframe.position->fullName), TracyConcat(_hx_tracy_str_buffer_ptr, TracyLine), TracyConcat(_hx_tracy_str_length, TracyLine));
+#endif
+
+void __hxcpp_tracy_framemark();
+void __hxcpp_tracy_plot(::String name, ::Float val);
+void __hxcpp_tracy_plot_config(::String name, uint8_t format, bool step, bool fill, int color);
+void __hxcpp_tracy_message(::String msg, int color);
+void __hxcpp_tracy_message_app_info(::String info);
+void __hxcpp_tracy_set_thread_name_and_group(String name, int groupHint);
+int __hxcpp_tracy_get_zone_count();
+
+#endif
diff --git a/Sources/c_snikket/iinclude/hx/Thread.h b/Sources/c_snikket/iinclude/hx/Thread.h
new file mode 100644
index 0000000..069d51e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/Thread.h
@@ -0,0 +1,345 @@
+#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
+
+#ifdef 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(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);
+      mMutex = new pthread_mutex_t();
+      mValid = pthread_mutex_init(mMutex,&mta) ==0;
+   }
+   ~HxMutex()
+   {
+      if (mValid)
+         pthread_mutex_destroy(mMutex);
+      delete 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(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;
+      mCondition = new pthread_cond_t();
+      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);
+      }
+      delete mCondition;
+   }
+
+
+   HxMutex         mMutex;
+   pthread_cond_t  *mCondition;
+   bool            mSet;
+   bool            mValid;
+};
+
+
+#endif
+
+
+#if 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
diff --git a/Sources/c_snikket/iinclude/hx/Tls.h b/Sources/c_snikket/iinclude/hx/Tls.h
new file mode 100755
index 0000000..689d4bb
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/Tls.h
@@ -0,0 +1,165 @@
+#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
+
+#ifdef HX_WINDOWS
+
+  #ifdef HX_WINRT
+    // Nothing
+  #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
diff --git a/Sources/c_snikket/iinclude/hx/Undefine.h b/Sources/c_snikket/iinclude/hx/Undefine.h
new file mode 100644
index 0000000..9400821
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/Undefine.h
@@ -0,0 +1,28 @@
+#ifndef HX_UNDEFINE_H
+#define HX_UNDEFINE_H
+
+#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
diff --git a/Sources/c_snikket/iinclude/hx/Unordered.h b/Sources/c_snikket/iinclude/hx/Unordered.h
new file mode 100644
index 0000000..ca5d69c
--- /dev/null
+++ b/Sources/c_snikket/iinclude/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
diff --git a/Sources/c_snikket/iinclude/hx/strings/RandomStrings.h b/Sources/c_snikket/iinclude/hx/strings/RandomStrings.h
new file mode 100644
index 0000000..ff1c160
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/strings/RandomStrings.h
@@ -0,0 +1,74 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_hx_strings_RandomStrings
+#define INCLUDED_hx_strings_RandomStrings
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(hx,strings,RandomStrings)
+HX_DECLARE_CLASS4(hx,strings,internal,_Either2,_Either2)
+
+namespace hx{
+namespace strings{
+
+
+class HXCPP_CLASS_ATTRIBUTES RandomStrings_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef RandomStrings_obj OBJ_;
+		RandomStrings_obj();
+
+	public:
+		enum { _hx_ClassId = 0x48d6a291 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="hx.strings.RandomStrings")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"hx.strings.RandomStrings"); }
+
+		inline static ::hx::ObjectPtr< RandomStrings_obj > __new() {
+			::hx::ObjectPtr< RandomStrings_obj > __this = new RandomStrings_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< RandomStrings_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			RandomStrings_obj *__this = (RandomStrings_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(RandomStrings_obj), false, "hx.strings.RandomStrings"));
+			*(void **)__this = RandomStrings_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~RandomStrings_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("RandomStrings",9f,7a,45,55); }
+
+		static void __boot();
+		static ::Array< int > DIGITS;
+		static ::Array< int > _genAsciiAlpha();
+		static ::Dynamic _genAsciiAlpha_dyn();
+
+		static ::Array< int > ASCII_ALPHA;
+		static ::Array< int > ASCII_ALPHA_NUMERIC;
+		static ::String random(int length, ::hx::strings::internal::_Either2::_Either2 chars);
+		static ::Dynamic random_dyn();
+
+		static ::String randomUUIDv4(::String separator);
+		static ::Dynamic randomUUIDv4_dyn();
+
+};
+
+} // end namespace hx
+} // end namespace strings
+
+#endif /* INCLUDED_hx_strings_RandomStrings */ 
diff --git a/Sources/c_snikket/iinclude/hx/strings/StringBuilder.h b/Sources/c_snikket/iinclude/hx/strings/StringBuilder.h
new file mode 100644
index 0000000..8115925
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/strings/StringBuilder.h
@@ -0,0 +1,70 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_hx_strings_StringBuilder
+#define INCLUDED_hx_strings_StringBuilder
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(StringBuf)
+HX_DECLARE_CLASS2(hx,strings,StringBuilder)
+
+namespace hx{
+namespace strings{
+
+
+class HXCPP_CLASS_ATTRIBUTES StringBuilder_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef StringBuilder_obj OBJ_;
+		StringBuilder_obj();
+
+	public:
+		enum { _hx_ClassId = 0x32066fb8 };
+
+		void __construct(::String initialContent);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="hx.strings.StringBuilder")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"hx.strings.StringBuilder"); }
+		static ::hx::ObjectPtr< StringBuilder_obj > __new(::String initialContent);
+		static ::hx::ObjectPtr< StringBuilder_obj > __alloc(::hx::Ctx *_hx_ctx,::String initialContent);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~StringBuilder_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("StringBuilder",2a,56,d0,8d); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		 ::StringBuf sb;
+		::Array< ::String > pre;
+		int len;
+		 ::hx::strings::StringBuilder add(::String item);
+		::Dynamic add_dyn();
+
+		 ::hx::strings::StringBuilder addChar(int ch);
+		::Dynamic addChar_dyn();
+
+		 ::hx::strings::StringBuilder clear();
+		::Dynamic clear_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+} // end namespace hx
+} // end namespace strings
+
+#endif /* INCLUDED_hx_strings_StringBuilder */ 
diff --git a/Sources/c_snikket/iinclude/hx/strings/Strings.h b/Sources/c_snikket/iinclude/hx/strings/Strings.h
new file mode 100644
index 0000000..6629ee7
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/strings/Strings.h
@@ -0,0 +1,62 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_hx_strings_Strings
+#define INCLUDED_hx_strings_Strings
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(hx,strings,Strings)
+
+namespace hx{
+namespace strings{
+
+
+class HXCPP_CLASS_ATTRIBUTES Strings_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Strings_obj OBJ_;
+		Strings_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0e5b539c };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="hx.strings.Strings")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"hx.strings.Strings"); }
+
+		inline static ::hx::ObjectPtr< Strings_obj > __new() {
+			::hx::ObjectPtr< Strings_obj > __this = new Strings_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Strings_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Strings_obj *__this = (Strings_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Strings_obj), false, "hx.strings.Strings"));
+			*(void **)__this = Strings_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Strings_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Strings",62,b6,44,c6); }
+
+		static ::Array< int > toChars(::String str);
+		static ::Dynamic toChars_dyn();
+
+};
+
+} // end namespace hx
+} // end namespace strings
+
+#endif /* INCLUDED_hx_strings_Strings */ 
diff --git a/Sources/c_snikket/iinclude/hx/strings/internal/_Either2/_Either2.h b/Sources/c_snikket/iinclude/hx/strings/internal/_Either2/_Either2.h
new file mode 100644
index 0000000..189b578
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hx/strings/internal/_Either2/_Either2.h
@@ -0,0 +1,41 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_hx_strings_internal__Either2__Either2
+#define INCLUDED_hx_strings_internal__Either2__Either2
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS4(hx,strings,internal,_Either2,_Either2)
+namespace hx{
+namespace strings{
+namespace internal{
+namespace _Either2{
+
+
+class _Either2_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef _Either2_obj OBJ_;
+
+	public:
+		_Either2_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("hx.strings.internal._Either2._Either2",07,08,e6,82); }
+		::String __ToString() const { return HX_("_Either2.",c0,d7,a7,46) + _hx_tag; }
+
+		static ::hx::strings::internal::_Either2::_Either2 a( ::Dynamic v);
+		static ::Dynamic a_dyn();
+		static ::hx::strings::internal::_Either2::_Either2 b( ::Dynamic v);
+		static ::Dynamic b_dyn();
+};
+
+} // end namespace hx
+} // end namespace strings
+} // end namespace internal
+} // end namespace _Either2
+
+#endif /* INCLUDED_hx_strings_internal__Either2__Either2 */ 
diff --git a/Sources/c_snikket/iinclude/hxMath.h b/Sources/c_snikket/iinclude/hxMath.h
new file mode 100644
index 0000000..1e4b1b6
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hxMath.h
@@ -0,0 +1,84 @@
+#ifndef HX_MATH
+#define HX_MATH
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#include <cmath>
+#include <stdlib.h>
+
+class HXCPP_EXTERN_CLASS_ATTRIBUTES Math_obj : public hx::Object
+{
+public:
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdMath };
+
+   typedef hx::Object super;
+   typedef Math_obj OBJ_;
+   HX_DO_RTTI;
+   void __construct();
+   static Dynamic __CreateEmpty();
+   static void __boot();
+
+   inline static int floor(double inX) { return __int__(::std::floor(inX)); }
+   inline static int ceil(double inX) { return __int__(::std::ceil(inX)); }
+   inline static int round(double inX) { return floor(inX+0.5); }
+   inline static double ffloor(double inX) { return ::std::floor(inX); }
+   inline static double fceil(double inX) { return ::std::ceil(inX); }
+   inline static double fround(double inX) { return ::std::floor(inX+0.5); }
+   inline static double random() { return __hxcpp_drand(); }
+   inline static double sqrt(double inX) { return ::std::sqrt(inX); }
+   inline static double cos(double inX) { return ::std::cos(inX); }
+   inline static double sin(double inX) { return ::std::sin(inX); }
+   inline static double tan(double inX) { return ::std::tan(inX); }
+   inline static double atan2(double inY,double inX) { return ::std::atan2(inY,inX); }
+   inline static double abs(double inX) { return ::std::fabs(inX); }
+   inline static double pow(double inA,double inB) { return ::std::pow(inA,inB); }
+   inline static double log(double inA) { return ::std::log(inA); }
+   inline static double max(double inA,double inB) { return inA>inB ? inA:inA==inA?inB:inA; }
+   inline static double min(double inA,double inB) { return inA<inB ? inA:inA==inA?inB:inA; }
+
+   inline static double atan(double inA) { return ::std::atan(inA); }
+   inline static double asin(double inA) { return ::std::asin(inA); }
+   inline static double acos(double inA) { return ::std::acos(inA); }
+   inline static double exp(double inA) { return ::std::exp(inA); }
+
+
+   static bool isNaN(double inX);
+   static bool isFinite(double inX);
+
+
+   static Dynamic floor_dyn();
+   static Dynamic ceil_dyn();
+   static Dynamic round_dyn();
+   static Dynamic ffloor_dyn();
+   static Dynamic fceil_dyn();
+   static Dynamic fround_dyn();
+   static Dynamic random_dyn();
+   static Dynamic sqrt_dyn();
+   static Dynamic cos_dyn();
+   static Dynamic sin_dyn();
+   static Dynamic tan_dyn();
+   static Dynamic atan2_dyn();
+   static Dynamic abs_dyn();
+   static Dynamic pow_dyn();
+   static Dynamic log_dyn();
+   static Dynamic min_dyn();
+   static Dynamic max_dyn();
+   static Dynamic atan_dyn();
+   static Dynamic asin_dyn();
+   static Dynamic acos_dyn();
+   static Dynamic exp_dyn();
+   static Dynamic isNaN_dyn();
+   static Dynamic isFinite_dyn();
+
+   static double NaN;
+   static double PI;
+   static double NEGATIVE_INFINITY;
+   static double POSITIVE_INFINITY;
+};
+
+typedef hx::ObjectPtr<Math_obj> Math;
+
+
+#endif
diff --git a/Sources/c_snikket/iinclude/hxString.h b/Sources/c_snikket/iinclude/hxString.h
new file mode 100644
index 0000000..e390ac3
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hxString.h
@@ -0,0 +1,404 @@
+#ifndef HX_STRING_H
+#define HX_STRING_H
+
+#ifndef HXCPP_H
+#error "Please include hxcpp.h, not hx/Object.h"
+#endif
+
+#include <hx/StringAlloc.h>
+
+#ifdef __OBJC__
+#import <Foundation/Foundation.h>
+#endif
+
+
+// --- String --------------------------------------------------------
+//
+// Basic String type for hxcpp.
+// It's based on garbage collection of the wchar_t (or char ) *ptr.
+// Note: this does not inherit from "hx::Object", so in some ways it acts more
+// like a standard "int" type than a mode generic class.
+
+class HXCPP_EXTERN_CLASS_ATTRIBUTES String
+{
+   friend class StringOffset;
+
+public:
+  // These allocate the function using the garbage-colleced malloc
+   void *operator new( size_t inSize );
+   inline void* operator new( size_t, void* ptr ) { return ptr; }
+   void operator delete( void * ) { }
+
+   inline String() : length(0), __s(0) { }
+
+   // Uses pointer
+   inline String(const char *inPtr,int inLen) : __s(inPtr), length(inLen) { }
+   #ifdef HX_SMART_STRINGS
+   inline String(const char16_t *inPtr,int inLen) : __w(inPtr), length(inLen) { }
+   #endif
+
+   // Makes copy
+   inline String(const wchar_t *inPtr) { *this = create(inPtr); }
+   inline String(const char16_t *inPtr) { *this = create(inPtr); }
+   inline String(const char *inPtr) { *this = create(inPtr); }
+
+   static String create(const wchar_t *inPtr,int inLen=-1);
+   static String create(const char16_t *inPtr,int inLen=-1);
+   static String create(const char *inPtr,int inLen=-1);
+
+   // Uses non-gc memory and wont ever be collected
+   static ::String createPermanent(const char *inUtf8, int inLen);
+   const ::String &makePermanent() const;
+   hx::Object *makePermanentObject() const;
+
+   // Legacy
+   ::String &dup();
+
+
+   #ifdef __OBJC__
+   inline String(NSString *inString)
+   {
+      if (inString)
+         *this = String([inString UTF8String]);
+      else
+      {
+         length = 0;
+         __s = 0;
+      }
+   }
+   inline operator NSString * () const
+   {
+      hx::strbuf buf;
+      return [[NSString alloc] initWithUTF8String:utf8_str(&buf) ];
+   }
+   #endif
+   #if defined(HX_WINRT) && defined(__cplusplus_winrt)
+   inline String(Platform::String^ inString)
+   {
+      *this = String(inString->Data());
+   }
+   inline String(Platform::StringReference inString)
+   {
+      *this = String(inString.Data());
+   }
+   #endif
+
+   inline String(const ::String &inRHS) : __s(inRHS.__s), length(inRHS.length) { }
+   String(const int &inRHS);
+   String(const unsigned int &inRHS);
+   String(const short &inRHS) { fromInt(inRHS); }
+   String(const unsigned short &inRHS) { fromInt(inRHS); }
+   String(const signed char &inRHS) { fromInt(inRHS); }
+   String(const unsigned char &inRHS) { fromInt(inRHS); }
+   String(const cpp::CppInt32__ &inRHS);
+   String(const double &inRHS);
+   String(const float &inRHS);
+   String(const cpp::Int64 &inRHS);
+   String(const cpp::UInt64 &inRHS);
+   String(const unsigned long &inRHS);
+   explicit String(const bool &inRHS);
+   inline String(const null &inRHS) : __s(0), length(0) { }
+   String(hx::Null< ::String > inRHS) : __s(inRHS.value.__s), length(inRHS.value.length) { }
+   inline String(const ::cpp::Variant &inRHS) { *this = inRHS.asString(); }
+   template<typename T>
+   inline String( const ::cpp::Pointer<T> &inRHS) { fromPointer(inRHS.ptr); }
+   template<typename T>
+   inline String( const hx::Native<T> &n ) { fromPointer(n.ptr); }
+
+   static String emptyString;
+   static void __boot();
+
+   hx::Object *__ToObject() const;
+
+   template<typename T,typename S>
+   explicit inline String(const cpp::Struct<T,S> &inRHS);
+   template<typename OBJ>
+   explicit inline String(const hx::ObjectPtr<OBJ> &inRHS);
+   void fromInt(int inI);
+   void fromPointer(const void *p);
+
+
+
+   /*
+    This causes ambiguous problem with Object==Dynamic (String==Dynamic vs Object==Object)
+     and syntactically, String(Dynamic) should be enough I think.
+    Could perhaps make it explicit
+
+   template<typename T>
+   inline String(const hx::ObjectPtr<T> &inRHS)
+   {
+      if (inRHS.mPtr)
+      {
+         ::String s = static_cast<hx::Object *>(inRHS.mPtr)->toString();
+         __s = s.__s;
+         length = s.length;
+      }
+      else { __s = 0; length = 0; }
+   }
+   */
+    String(const Dynamic &inRHS);
+
+    inline ::String &operator=(const ::String &inRHS)
+           { length = inRHS.length; __s = inRHS.__s; return *this; }
+
+   ::String Default(const ::String &inDef) { return __s ? *this : inDef; }
+
+
+   ::String toString() { return *this; }
+
+    ::String __URLEncode() const;
+    ::String __URLDecode() const;
+
+
+    ::String toUpperCase() const;
+    ::String toLowerCase() const;
+    ::String charAt(int inPos) const;
+    Dynamic charCodeAt(int inPos) const;
+    int indexOf(const ::String &inValue, Dynamic inStart) const;
+    int lastIndexOf(const ::String &inValue, Dynamic inStart) const;
+    Array<String> split(const ::String &inDelimiter) const;
+    ::String substr(int inPos,Dynamic inLen) const;
+    ::String substring(int inStartIndex, Dynamic inEndIndex) const;
+
+   inline const char *&raw_ref() { return __s; }
+   inline const char *raw_ptr() const { return __s; }
+   const char *utf8_str(hx::IStringAlloc *inBuffer = 0,bool throwInvalid=true, int *byteLength = 0) const;
+   const char *ascii_substr(hx::IStringAlloc *inBuffer,int start, int length) const;
+   inline const char *c_str() const { return utf8_str(); }
+   inline const char *out_str(hx::IStringAlloc *inBuffer = 0) const { return utf8_str(inBuffer,false); }
+   const wchar_t *wchar_str(hx::IStringAlloc *inBuffer = 0) const;
+   const char16_t *wc_str(hx::IStringAlloc *inBuffer = 0, int *outCharLength = 0) const;
+
+   const char *__CStr() const { return utf8_str(); };
+   const wchar_t *__WCStr() const { return wchar_str(0); }
+   inline operator const char *() { return utf8_str(); }
+
+   #ifdef HX_SMART_STRINGS
+   inline const char16_t *raw_wptr() const { return __w; }
+   #endif
+   inline bool isUTF16Encoded() const {
+      #ifdef HX_SMART_STRINGS
+      return __w && ((unsigned int *)__w)[-1] & HX_GC_STRING_CHAR16_T;
+      #else
+      return false;
+      #endif
+   }
+
+   inline bool isAsciiEncoded() const {
+      #ifdef HX_SMART_STRINGS
+      return !__w || !(((unsigned int *)__w)[-1] & HX_GC_STRING_CHAR16_T);
+      #else
+      return true;
+      #endif
+   }
+
+   inline bool isAsciiEncodedQ() const {
+      #ifdef HX_SMART_STRINGS
+      return !(((unsigned int *)__w)[-1] & HX_GC_STRING_CHAR16_T);
+      #else
+      return true;
+      #endif
+   }
+
+
+
+   static  ::String fromCharCode(int inCode);
+
+   inline bool operator==(const null &inRHS) const { return __s==0; }
+   inline bool operator!=(const null &inRHS) const { return __s!=0; }
+
+   inline int getChar( int index ) {
+      if (isUTF16Encoded())
+         return __w[index];
+      return __s[index];
+   }
+   inline unsigned int hash( ) const
+   {
+      if (!__s) return 0;
+      if ( __s[HX_GC_STRING_HASH_OFFSET] & HX_GC_STRING_HASH_BIT)
+      {
+         #ifdef HXCPP_PARANOID
+         unsigned int result = calcHash();
+
+         unsigned int have = (((unsigned int *)__s)[-1] & HX_GC_CONST_ALLOC_BIT) ?
+                ((unsigned int *)__s)[-2] :  *((unsigned int *)(__s+length+1) );
+
+         if ( have != result )
+         {
+             printf("Bad string hash for %s\n", __s );
+             printf(" Is %08x\n", result );
+             printf(" Baked %08x\n", have );
+             printf(" Mark %08x\n",   ((unsigned int *)__s)[-1]  );
+         }
+         #endif
+         if (__s[HX_GC_CONST_ALLOC_MARK_OFFSET] & HX_GC_CONST_ALLOC_MARK_BIT)
+         {
+            #ifdef EMSCRIPTEN
+            return  ((emscripten_align1_int*)__s)[-2];
+            #else
+            return  ((unsigned int *)__s)[-2];
+            #endif
+         }
+        #ifdef EMSCRIPTEN
+           return *((emscripten_align1_int *)(__s+length+1) );
+        #else
+           return *((unsigned int *)(__s+length+1) );
+        #endif
+      }
+
+      // Slow path..
+      return calcHash();
+   }
+
+   unsigned int calcHash() const;
+   unsigned int calcSubHash(int start, int length) const;
+
+   #ifdef HX_SMART_STRINGS
+   int compare(const ::String &inRHS) const;
+   #else
+   inline int compare(const ::String &inRHS) const
+   {
+      const char *r = inRHS.__s;
+      if (__s == r) return inRHS.length-length;
+      if (__s==0) return -1;
+      if (r==0) return 1;
+
+      return strcmp(__s,r);
+      //return memcmp(__s,r,length);
+   }
+   #endif
+
+
+   ::String &operator+=(const ::String &inRHS);
+   ::String operator+(const ::String &inRHS) const;
+   ::String operator+(const int &inRHS) const { return *this + ::String(inRHS); }
+   ::String operator+(const bool &inRHS) const { return *this + ::String(inRHS); }
+   ::String operator+(const double &inRHS) const { return *this + ::String(inRHS); }
+   ::String operator+(const float &inRHS) const { return *this + ::String(inRHS); }
+   ::String operator+(const null &inRHS) const{ return *this + HX_CSTRING("null"); } 
+   //::String operator+(const char *inRHS) const{ return *this + ::String(inRHS); } 
+   ::String operator+(const cpp::CppInt32__ &inRHS) const{ return *this + ::String(inRHS); } 
+   template<typename T>
+   inline ::String operator+(const hx::ObjectPtr<T> &inRHS) const
+      { return *this + (inRHS.mPtr ? const_cast<hx::ObjectPtr<T>&>(inRHS)->toString() : HX_CSTRING("null") ); }
+   ::String operator+(const cpp::Variant &inRHS) const{ return *this + inRHS.asString(); } 
+
+
+
+   #ifdef HX_SMART_STRINGS
+   bool eq(const ::String &inRHS) const;
+   #else
+   inline bool eq(const ::String &inRHS) const
+   {
+      // Strings are known not to be null...
+      return length==inRHS.length && !memcmp(__s,inRHS.__s,length);
+   }
+   #endif
+
+   inline bool operator==(const ::String &inRHS) const
+   {
+      if (!inRHS.__s)
+         return !__s;
+      if (!__s)
+         return false;
+      return eq(inRHS);
+   }
+   inline bool operator!=(const ::String &inRHS) const
+   {
+      if (!inRHS.__s)
+         return __s;
+      if (!__s)
+         return true;
+      return !eq(inRHS);
+   }
+
+   inline bool operator<(const ::String &inRHS) const { return compare(inRHS)<0; }
+   inline bool operator<=(const ::String &inRHS) const { return compare(inRHS)<=0; }
+   inline bool operator>(const ::String &inRHS) const { return compare(inRHS)>0; }
+   inline bool operator>=(const ::String &inRHS) const { return compare(inRHS)>=0; }
+
+   inline bool operator<(const Dynamic &inRHS) const { return compare(inRHS)<0; }
+   inline bool operator<=(const Dynamic &inRHS) const { return compare(inRHS)<=0; }
+   inline bool operator>(const Dynamic &inRHS) const { return compare(inRHS)>0; }
+   inline bool operator>=(const Dynamic &inRHS) const { return compare(inRHS)>=0; }
+
+   inline int cca(int inPos) const
+   {
+      if ((unsigned)inPos>=length) return 0;
+      #ifdef HX_SMART_STRINGS
+      if (isUTF16Encoded())
+         return __w[inPos];
+      #endif
+      return ((unsigned char *)__s)[inPos];
+   }
+
+   inline Dynamic iterator();
+   inline Dynamic keyValueIterator();
+
+   static char16_t *allocChar16Ptr(int len);
+
+
+   static  Dynamic fromCharCode_dyn();
+
+
+   Dynamic charAt_dyn();
+   Dynamic charCodeAt_dyn();
+   Dynamic indexOf_dyn();
+   Dynamic lastIndexOf_dyn();
+   Dynamic split_dyn();
+   Dynamic substr_dyn();
+   Dynamic substring_dyn();
+   Dynamic toLowerCase_dyn();
+   Dynamic toString_dyn();
+   Dynamic toUpperCase_dyn();
+
+   // This is used by the string-wrapped-as-dynamic class
+   hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+
+   // The actual implementation.
+   // Note that "__s" is const - if you want to change it, you should create a new string.
+   //  this allows for multiple strings to point to the same data.
+   int length;
+
+   #ifdef HX_SMART_STRINGS
+   // TODO private:
+     // Use c_str, wc_str, raw_str instead
+   #endif
+
+   union {
+      const char *__s;
+      const char16_t *__w;
+   };
+
+};
+
+class StringOffset
+{
+   public:
+      enum { Ptr = offsetof(String,__s) };
+};
+
+
+
+
+
+inline HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_string_create(const char *str, int len)
+{
+   return String::create(str,len);
+}
+
+inline int HXCPP_EXTERN_CLASS_ATTRIBUTES _hx_string_compare(String inString0, String inString1)
+{
+   return inString0.compare(inString1);
+}
+
+String HXCPP_EXTERN_CLASS_ATTRIBUTES _hx_utf8_to_utf16(const unsigned char *ptr, int inUtf8Len, bool addHash);
+
+int HXCPP_EXTERN_CLASS_ATTRIBUTES _hx_utf8_char_code_at(String inString, int inIndex);
+int HXCPP_EXTERN_CLASS_ATTRIBUTES _hx_utf8_length(String inString);
+bool HXCPP_EXTERN_CLASS_ATTRIBUTES _hx_utf8_is_valid(String inString);
+String HXCPP_EXTERN_CLASS_ATTRIBUTES _hx_utf8_sub(String inString0, int inStart, int inLen);
+int HXCPP_EXTERN_CLASS_ATTRIBUTES _hx_utf8_decode_advance(char *&ioPtr);
+
+
+#endif
diff --git a/Sources/c_snikket/iinclude/hxcpp.h b/Sources/c_snikket/iinclude/hxcpp.h
new file mode 100755
index 0000000..008f135
--- /dev/null
+++ b/Sources/c_snikket/iinclude/hxcpp.h
@@ -0,0 +1,362 @@
+#ifndef HXCPP_H
+#define HXCPP_H
+
+// Standard headers ....
+
+// Windows hack
+#define NOMINMAX
+
+#ifndef HXCPP_API_LEVEL
+   #define HXCPP_API_LEVEL 0
+#endif
+
+#include "hx/HeaderVersion.h"
+
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+   #if _MSC_VER >= 1423
+      #include <typeinfo>
+   #else
+      #include <typeinfo.h>
+   #endif
+   #if defined(__BORLANDC__)
+   namespace hx { typedef std::type_info type_info; }
+   #else
+   namespace hx { typedef ::type_info type_info; }
+   #endif
+#else
+   #include <typeinfo>
+   #include <stdint.h>
+   #include <cstddef>
+   namespace hx { typedef std::type_info type_info; }
+   #ifndef EMSCRIPTEN
+      using hx::type_info;
+      #ifdef __MINGW32__
+         #include <stdint.h>
+      #else
+         typedef int64_t  __int64;
+      #endif
+   #endif
+#endif
+
+#if defined(EMSCRIPTEN) || defined(IPHONE) || defined(APPLETV)
+  #include <unistd.h>
+  #include <cstdlib>
+#endif
+
+#if defined(EMSCRIPTEN)
+  #include <emscripten.h>
+#endif
+
+#ifdef __OBJC__
+#ifdef HXCPP_OBJC
+  #import <Foundation/Foundation.h>
+#endif
+#endif
+
+
+#include <string.h>
+
+#include <wchar.h>
+
+#ifdef HX_LINUX
+  #include <unistd.h>
+  #include <cstdio>
+  #include <stddef.h>
+#endif
+
+#if defined(EMSCRIPTEN)  || defined(_ARM_) || defined(__arm__) || defined(GCW0)
+   #define HXCPP_ALIGN_FLOAT
+#endif
+
+// Must allign allocs to 8 bytes to match floating point requirement?
+// Ints must br read on 4-byte boundary
+#if (!defined(HXCPP_ALIGN_FLOAT) && (defined(EMSCRIPTEN) || defined(GCW0)) )
+   #define HXCPP_ALIGN_ALLOC
+#endif
+
+
+// Some compilers are over-enthusiastic about what they #define ...
+//#ifdef NULL
+//#undef NULL
+//#endif
+
+#ifdef assert
+#undef assert
+#endif
+
+#define HXCPP_CLASS_ATTRIBUTES
+
+#ifdef _MSC_VER
+  #if defined(HXCPP_DLL_IMPORT)
+     #define HXCPP_EXTERN_CLASS_ATTRIBUTES __declspec(dllimport)
+  #elif defined (HXCPP_DLL_EXPORT)
+     #define HXCPP_EXTERN_CLASS_ATTRIBUTES __declspec(dllexport)
+  #else
+     #define HXCPP_EXTERN_CLASS_ATTRIBUTES
+  #endif
+#else
+  #if defined(HXCPP_DLL_EXPORT)
+     #define HXCPP_EXTERN_CLASS_ATTRIBUTES __attribute__((visibility("default")))
+  #else
+     #define HXCPP_EXTERN_CLASS_ATTRIBUTES
+  #endif
+#endif
+
+typedef char HX_CHAR;
+
+
+
+#if (defined(HXCPP_DEBUG) || defined(HXCPP_DEBUGGER)) && !defined HXCPP_CHECK_POINTER
+#define HXCPP_CHECK_POINTER
+#endif
+
+#ifdef HX_WINRT
+
+#define WINRT_LOG(fmt, ...) {char buf[1024];sprintf_s(buf,1024,"****LOG: %s(%d): %s \n    [" fmt "]\n",__FILE__,__LINE__,__FUNCTION__, __VA_ARGS__);OutputDebugString(buf);}
+#define WINRT_PRINTF(fmt, ...) {char buf[2048];sprintf_s(buf,2048,fmt,__VA_ARGS__);OutputDebugString(buf);}
+
+#endif
+
+
+#ifdef BIG_ENDIAN
+#undef BIG_ENDIAN
+
+  #ifndef HXCPP_BIG_ENDIAN
+  #define HXCPP_BIG_ENDIAN
+  #endif
+#endif
+
+#ifdef __BIG_ENDIAN__
+  #ifndef HXCPP_BIG_ENDIAN
+  #define HXCPP_BIG_ENDIAN
+  #endif
+#endif
+
+#ifdef LITTLE_ENDIAN
+#undef LITTLE_ENDIAN
+
+  #ifdef HXCPP_BIG_ENDIAN
+  #undef HXCPP_BIG_ENDIAN
+  #endif
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+  #ifdef HXCPP_BIG_ENDIAN
+  #undef HXCPP_BIG_ENDIAN
+  #endif
+#endif
+
+
+// HX_HCSTRING is for constant strings with built-in hashes
+//     HX_GC_CONST_ALLOC_BIT | HX_GC_STRING_HASH
+// HX_CSTRING is for constant strings without built-in hashes
+//     HX_GC_CONST_ALLOC_BIT
+// HX_GC_CONST_ALLOC_BIT = 0x80000000
+// HX_GC_STRING_HASH     = 0x00100000
+// HX_GC_STRING_CHAR16_T = 0x00200000
+
+// For making generated code easier to read
+#define HX_HASH_JOIN(A, B) A##B
+#define HX_JOIN_PARTS(A, B) HX_HASH_JOIN(A, B)
+#define HX_HASH_OF(A) #A
+#define HX_HASH_OF_W(A) HX_HASH_JOIN(u,#A)
+#define HX_STR_QUOTE(A) HX_HASH_OF(A)
+#define HX_STR_QUOTE_W(A) HX_HASH_OF_W(A)
+#define HX_HEX_QUOTE(hex) HX_STR_QUOTE(HX_JOIN_PARTS(\x,hex))
+#define HX_HEX_QUOTE_W(hex) HX_STR_QUOTE_W(HX_JOIN_PARTS(\x,hex))
+
+#ifdef HXCPP_BIG_ENDIAN
+
+#define HX_HCSTRING(s,h0,h1,h2,h3) ::String( const_cast<char *>((h3 h2 h1 h0 "\x80\x10\x00\x00" s)) + 8 , sizeof(s)/sizeof(char)-1)
+#define HX_(s,h0,h1,h2,h3) ::String( const_cast<char *>(( HX_HEX_QUOTE(h3) HX_HEX_QUOTE(h2) HX_HEX_QUOTE(h1) HX_HEX_QUOTE(h0) "\x80\x10\x00\x00" s )) + 8 , sizeof(s)/sizeof(char)-1)
+#define HX_STRINGI(s,len) ::String( const_cast<char *>(("\x80\x00\x00\x00" s)) + 4 ,len)
+#define HX_W(s,h0,h1) ::String( const_cast<char16_t *>(( HX_HEX_QUOTE_W(h1) HX_HEX_QUOTE_W(h0) u"\x8030\x0000" s )) + 4, sizeof(s)/2-1)
+
+#else
+
+#define HX_HCSTRING(s,h0,h1,h2,h3) ::String( const_cast<char *>((h0 h1 h2 h3 "\x00\x00\x10\x80" s )) + 8 , sizeof(s)/sizeof(char)-1)
+#define HX_(s,h0,h1,h2,h3) ::String( const_cast<char *>(( HX_HEX_QUOTE(h0) HX_HEX_QUOTE(h1) HX_HEX_QUOTE(h2) HX_HEX_QUOTE(h3) "\x00\x00\x10\x80" s )) + 8 , sizeof(s)/sizeof(char)-1)
+#define HX_STRINGI(s,len) ::String( const_cast<char *>(("\x00\x00\x0\x80" s)) + 4 ,len)
+
+#define HX_W(s,h0,h1) ::String( const_cast<char16_t *>(( HX_HEX_QUOTE_W(h0) HX_HEX_QUOTE_W(h1) u"\x0000\x8030" s )) + 4, sizeof(s)/2-1)
+
+#endif
+
+
+#define HX_STRI(s) HX_STRINGI(s,sizeof(s)/sizeof(char)-1)
+#define HX_CSTRING(x) HX_STRI(x)
+#define HX_CSTRING2(wide,len,utf8) HX_STRI(utf8)
+
+#ifdef HX_SMART_STRINGS
+  #define HX_FIELD_EQ(name,field) (name.isAsciiEncoded() && !::memcmp(name.raw_ptr(), field, sizeof(field)/sizeof(char)))
+  // No null check is performedd...
+  #define HX_QSTR_EQ(name,field) (name.length==field.length && field.isAsciiEncodedQ() && !::memcmp(name.raw_ptr(), field.raw_ptr() , field.length) )
+  // field is known to be isAsciiEncodedQ
+  #define HX_QSTR_EQ_AE(name,field) (name.length==field.length && !::memcmp(name.raw_ptr(), field.raw_ptr() , field.length) )
+#else
+  #define HX_FIELD_EQ(name,field) !::memcmp(name.__s, field, sizeof(field)/sizeof(char))
+  // No null check is performed....
+  #define HX_QSTR_EQ(name,field) (name.length==field.length && !::memcmp(name.__s, field.__s, field.length))
+  #define HX_QSTR_EQ_AE(name,field) (name.length==field.length && !::memcmp(name.__s, field.__s, field.length))
+#endif
+
+
+
+#pragma warning(disable:4251)
+#pragma warning(disable:4800)
+
+#if defined(_MSC_VER) && _MSC_VER < 1201
+#error MSVC 7.1 does not support template specialization and is not supported by HXCPP
+#endif
+
+
+// HXCPP includes...
+
+// Basic mapping from haxe -> c++
+
+#ifdef HXCPP_FLOAT32
+typedef float Float;
+#else
+typedef double Float;
+#endif
+
+
+// Extended mapping - cpp namespace
+namespace cpp
+{
+   typedef signed char Int8;
+   typedef unsigned char UInt8;
+   typedef char Char;
+   typedef signed short Int16;
+   typedef unsigned short UInt16;
+   typedef signed int Int32;
+   typedef unsigned int UInt32;
+   #ifdef _WIN32
+   typedef __int64 Int64;
+   typedef unsigned __int64 UInt64;
+   // TODO - EMSCRIPTEN?
+   #else
+   typedef int64_t Int64;
+   typedef uint64_t UInt64;
+   #endif
+   typedef float Float32;
+   typedef double Float64;
+   typedef volatile int AtomicInt;
+};
+// Extended mapping - old way
+namespace haxe { namespace io { typedef unsigned char Unsigned_char__; } }
+
+// --- Forward decalarations --------------------------------------------
+
+class null;
+namespace hx { class Object; }
+namespace hx { class FieldRef; }
+namespace hx { class IndexRef; }
+namespace hx { class NativeInterface; }
+namespace hx { class StackContext; }
+namespace hx { template<typename T> class Native; }
+namespace hx { template<typename O> class ObjectPtr; }
+namespace cpp { template<typename S,typename H> class Struct; }
+namespace cpp { template<typename T> class Pointer; }
+namespace cpp { template<typename T> class Function; }
+template<typename ELEM_> class Array_obj;
+template<typename ELEM_> class Array;
+namespace hx {
+   class Class_obj;
+   typedef hx::ObjectPtr<hx::Class_obj> Class;
+}
+namespace cpp {
+     struct Variant;
+     class VirtualArray_obj;
+     class VirtualArray;
+     class CppInt32__;
+}
+
+class Dynamic;
+class String;
+
+// Use an external routine to throw to avoid sjlj overhead on iphone.
+namespace hx { HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic Throw(Dynamic inDynamic); }
+namespace hx { HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic Rethrow(Dynamic inDynamic); }
+namespace hx { HXCPP_EXTERN_CLASS_ATTRIBUTES void CriticalError(const String &inError, bool inAllowFixup=false); }
+namespace hx { HXCPP_EXTERN_CLASS_ATTRIBUTES void NullReference(const char *type, bool allowFixup); }
+namespace hx { extern String sNone[]; }
+void __hxcpp_check_overflow(int inVal);
+
+namespace hx
+{
+class MarkContext;
+
+
+class VisitContext
+{
+public:
+   virtual void visitObject(hx::Object **ioPtr)=0;
+   virtual void visitAlloc(void **ioPtr)=0;
+};
+
+typedef ::cpp::Variant Val;
+
+#ifdef HXCPP_GC_GENERATIONAL
+  #define HXCPP_GC_NURSERY
+#endif
+
+
+//#define HXCPP_COMBINE_STRINGS
+
+enum PropertyAccessMode
+{
+   paccNever   = 0,
+   paccDynamic = 1,
+   paccAlways  = 2,
+};
+typedef PropertyAccessMode PropertyAccess;
+#define HX_PROP_NEVER  hx::paccNever
+#define HX_PROP_DYNAMIC hx::paccDynamic
+#define HX_PROP_ALWAYS hx::paccAlways
+
+} // end namespace hx
+
+#define HX_COMMA ,
+
+
+// The order of these includes has been chosen to minimize forward declarations.
+// You should not include the individual files, just this one.
+
+// First time ...
+#include <hx/Macros.h>
+#include <cpp/Variant.h>
+#include <hx/ErrorCodes.h>
+#include <hx/GC.h>
+#include <hx/StackContext.h>
+#include "null.h"
+#include <hx/Object.h>
+#include "hxString.h"
+#include "Dynamic.h"
+#include <cpp/CppInt32__.h>
+// This needs to "see" other declarations ...
+#include <hx/GcTypeInference.h>
+#include <hx/FieldRef.h>
+#include "Array.h"
+#include <hx/Anon.h>
+#include <hx/Class.h>
+#include "Enum.h"
+#include <hx/Interface.h>
+#include <hx/Telemetry.h>
+#if defined(__OBJC__) && defined(HXCPP_OBJC)
+  #include <hx/ObjcHelpers.h>
+#endif
+#include <hx/StdLibs.h>
+#include <cpp/Pointer.h>
+#include <hx/Native.h>
+#include <hx/Operators.h>
+#include <hx/Functions.h>
+// second time ...
+#include <cpp/Variant.h>
+#include <hx/Debug.h>
+#include <hx/Boot.h>
+#include <hx/Undefine.h>
+#include <hx/LessThanEq.h>
+
+#endif
+
diff --git a/Sources/c_snikket/iinclude/include/Date.h b/Sources/c_snikket/iinclude/include/Date.h
new file mode 100644
index 0000000..370b920
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/Date.h
@@ -0,0 +1,95 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_Date
+#define INCLUDED_Date
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_8e4589df03e4f3cc_26_new)
+HX_DECLARE_CLASS0(Date)
+
+
+
+class HXCPP_CLASS_ATTRIBUTES Date_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Date_obj OBJ_;
+		Date_obj();
+
+	public:
+		enum { _hx_ClassId = 0x018f7872 };
+
+		void __construct(int year,int month,int day,int hour,int min,int sec);
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="Date")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"Date"); }
+
+		inline static ::hx::ObjectPtr< Date_obj > __new(int year,int month,int day,int hour,int min,int sec) {
+			::hx::ObjectPtr< Date_obj > __this = new Date_obj();
+			__this->__construct(year,month,day,hour,min,sec);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Date_obj > __alloc(::hx::Ctx *_hx_ctx,int year,int month,int day,int hour,int min,int sec) {
+			Date_obj *__this = (Date_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Date_obj), false, "Date"));
+			*(void **)__this = Date_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_8e4589df03e4f3cc_26_new)
+HXDLIN(  26)		( ( ::Date)(__this) )->mSeconds =  ::__hxcpp_new_date(year,month,day,hour,min,sec);
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Date_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Date",4e,82,3c,2d); }
+
+		static  ::Date now();
+		static ::Dynamic now_dyn();
+
+		static  ::Date fromTime(Float t);
+		static ::Dynamic fromTime_dyn();
+
+		Float mSeconds;
+		Float getTime();
+		::Dynamic getTime_dyn();
+
+		int getUTCHours();
+		::Dynamic getUTCHours_dyn();
+
+		int getUTCMinutes();
+		::Dynamic getUTCMinutes_dyn();
+
+		int getUTCSeconds();
+		::Dynamic getUTCSeconds_dyn();
+
+		int getUTCFullYear();
+		::Dynamic getUTCFullYear_dyn();
+
+		int getUTCMonth();
+		::Dynamic getUTCMonth_dyn();
+
+		int getUTCDate();
+		::Dynamic getUTCDate_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+
+#endif /* INCLUDED_Date */ 
diff --git a/Sources/c_snikket/iinclude/include/EReg.h b/Sources/c_snikket/iinclude/include/EReg.h
new file mode 100644
index 0000000..9cf6865
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/EReg.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_EReg
+#define INCLUDED_EReg
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(EReg)
+
+
+
+class HXCPP_CLASS_ATTRIBUTES EReg_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef EReg_obj OBJ_;
+		EReg_obj();
+
+	public:
+		enum { _hx_ClassId = 0x022d4033 };
+
+		void __construct(::String r,::String opt);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="EReg")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"EReg"); }
+		static ::hx::ObjectPtr< EReg_obj > __new(::String r,::String opt);
+		static ::hx::ObjectPtr< EReg_obj > __alloc(::hx::Ctx *_hx_ctx,::String r,::String opt);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~EReg_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("EReg",0f,4a,da,2d); }
+
+		 ::Dynamic r;
+		::String last;
+		bool global;
+		bool match(::String s);
+		::Dynamic match_dyn();
+
+		::String matched(int n);
+		::Dynamic matched_dyn();
+
+		 ::Dynamic matchedPos();
+		::Dynamic matchedPos_dyn();
+
+		bool matchSub(::String s,int pos,::hx::Null< int >  len);
+		::Dynamic matchSub_dyn();
+
+		::String replace(::String s,::String by);
+		::Dynamic replace_dyn();
+
+		::String map(::String s, ::Dynamic f);
+		::Dynamic map_dyn();
+
+};
+
+
+#endif /* INCLUDED_EReg */ 
diff --git a/Sources/c_snikket/iinclude/include/HaxeCBridge.h b/Sources/c_snikket/iinclude/include/HaxeCBridge.h
new file mode 100644
index 0000000..6c32ea0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/HaxeCBridge.h
@@ -0,0 +1,44 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_HaxeCBridge
+#define INCLUDED_HaxeCBridge
+
+#ifndef HXCPP_H
+#ifdef HXCPP_API_LEVEL
+#include <hxcpp.h>
+#else
+#include <hx/Native.h>
+#endif
+#endif
+
+#ifndef INCLUDED_cbce7ceea2d0df24
+#define INCLUDED_cbce7ceea2d0df24
+#include "HaxeCBridge.h"
+#endif
+
+
+
+class HXCPP_CLASS_ATTRIBUTES HaxeCBridge
+{
+	public:
+		static void mainThreadInit(::cpp::Function< bool  () > isMainThreadCb);
+
+		static void mainThreadRun(::cpp::Function< void  () > processNativeCalls,::cpp::Function< void  (const char*) > onUnhandledException);
+
+		static void** retainHaxeArray(::cpp::VirtualArray haxeArray);
+
+		static void* retainHaxeObject( ::Dynamic haxeObject);
+
+		static const char* retainHaxeString(::String haxeString);
+
+		static void releaseHaxePtr(void * haxePtr);
+
+		static bool isMainThread();
+
+		static void endMainThread(bool waitOnScheduledEvents);
+
+		static void wakeMainThread();
+
+};
+
+
+#endif /* INCLUDED_HaxeCBridge */ 
diff --git a/Sources/c_snikket/iinclude/include/Lambda.h b/Sources/c_snikket/iinclude/include/Lambda.h
new file mode 100644
index 0000000..43b4ef0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/Lambda.h
@@ -0,0 +1,76 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_Lambda
+#define INCLUDED_Lambda
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(Lambda)
+
+
+
+class HXCPP_CLASS_ATTRIBUTES Lambda_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Lambda_obj OBJ_;
+		Lambda_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4cec6e4b };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="Lambda")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"Lambda"); }
+
+		inline static ::hx::ObjectPtr< Lambda_obj > __new() {
+			::hx::ObjectPtr< Lambda_obj > __this = new Lambda_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Lambda_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Lambda_obj *__this = (Lambda_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Lambda_obj), false, "Lambda"));
+			*(void **)__this = Lambda_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Lambda_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Lambda",27,a7,54,85); }
+
+		static ::cpp::VirtualArray array( ::Dynamic it);
+		static ::Dynamic array_dyn();
+
+		static bool exists( ::Dynamic it, ::Dynamic f);
+		static ::Dynamic exists_dyn();
+
+		static ::cpp::VirtualArray filter( ::Dynamic it, ::Dynamic f);
+		static ::Dynamic filter_dyn();
+
+		static  ::Dynamic fold( ::Dynamic it, ::Dynamic f, ::Dynamic first);
+		static ::Dynamic fold_dyn();
+
+		static bool empty( ::Dynamic it);
+		static ::Dynamic empty_dyn();
+
+		static  ::Dynamic find( ::Dynamic it, ::Dynamic f);
+		static ::Dynamic find_dyn();
+
+		static int findIndex( ::Dynamic it, ::Dynamic f);
+		static ::Dynamic findIndex_dyn();
+
+};
+
+
+#endif /* INCLUDED_Lambda */ 
diff --git a/Sources/c_snikket/iinclude/include/Reflect.h b/Sources/c_snikket/iinclude/include/Reflect.h
new file mode 100644
index 0000000..87d8d52
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/Reflect.h
@@ -0,0 +1,91 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_Reflect
+#define INCLUDED_Reflect
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(Reflect)
+
+
+
+class HXCPP_CLASS_ATTRIBUTES Reflect_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Reflect_obj OBJ_;
+		Reflect_obj();
+
+	public:
+		enum { _hx_ClassId = 0x769a515d };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="Reflect")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"Reflect"); }
+
+		inline static ::hx::ObjectPtr< Reflect_obj > __new() {
+			::hx::ObjectPtr< Reflect_obj > __this = new Reflect_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Reflect_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Reflect_obj *__this = (Reflect_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Reflect_obj), false, "Reflect"));
+			*(void **)__this = Reflect_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Reflect_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Reflect",1d,ac,7a,b6); }
+
+		static bool hasField( ::Dynamic o,::String field);
+		static ::Dynamic hasField_dyn();
+
+		static  ::Dynamic field( ::Dynamic o,::String field);
+		static ::Dynamic field_dyn();
+
+		static void setField( ::Dynamic o,::String field, ::Dynamic value);
+		static ::Dynamic setField_dyn();
+
+		static  ::Dynamic getProperty( ::Dynamic o,::String field);
+		static ::Dynamic getProperty_dyn();
+
+		static  ::Dynamic callMethod( ::Dynamic o, ::Dynamic func,::cpp::VirtualArray args);
+		static ::Dynamic callMethod_dyn();
+
+		static ::Array< ::String > fields( ::Dynamic o);
+		static ::Dynamic fields_dyn();
+
+		static bool isFunction( ::Dynamic f);
+		static ::Dynamic isFunction_dyn();
+
+		static int compare( ::Dynamic a, ::Dynamic b);
+		static ::Dynamic compare_dyn();
+
+		static bool compareMethods( ::Dynamic f1, ::Dynamic f2);
+		static ::Dynamic compareMethods_dyn();
+
+		static bool isObject( ::Dynamic v);
+		static ::Dynamic isObject_dyn();
+
+		static bool isEnumValue( ::Dynamic v);
+		static ::Dynamic isEnumValue_dyn();
+
+		static  ::Dynamic copy( ::Dynamic o);
+		static ::Dynamic copy_dyn();
+
+};
+
+
+#endif /* INCLUDED_Reflect */ 
diff --git a/Sources/c_snikket/iinclude/include/Std.h b/Sources/c_snikket/iinclude/include/Std.h
new file mode 100644
index 0000000..c837022
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/Std.h
@@ -0,0 +1,83 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_Std
+#define INCLUDED_Std
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(Std)
+
+
+
+class HXCPP_CLASS_ATTRIBUTES Std_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Std_obj OBJ_;
+		Std_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7ee3a517 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="Std")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"Std"); }
+
+		inline static ::hx::ObjectPtr< Std_obj > __new() {
+			::hx::ObjectPtr< Std_obj > __this = new Std_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Std_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Std_obj *__this = (Std_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Std_obj), false, "Std"));
+			*(void **)__this = Std_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Std_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Std",83,60,3f,00); }
+
+		static bool is( ::Dynamic v, ::Dynamic t);
+		static ::Dynamic is_dyn();
+
+		static bool isOfType( ::Dynamic v, ::Dynamic t);
+		static ::Dynamic isOfType_dyn();
+
+		static  ::Dynamic downcast( ::Dynamic value,::hx::Class c);
+		static ::Dynamic downcast_dyn();
+
+		static  ::Dynamic instance( ::Dynamic value,::hx::Class c);
+		static ::Dynamic instance_dyn();
+
+		static ::String string( ::Dynamic s);
+		static ::Dynamic string_dyn();
+
+		static int _hx_int(Float x);
+		static ::Dynamic _hx_int_dyn();
+
+		static  ::Dynamic parseInt(::String x);
+		static ::Dynamic parseInt_dyn();
+
+		static Float parseFloat(::String x);
+		static ::Dynamic parseFloat_dyn();
+
+		static int random(int x);
+		static ::Dynamic random_dyn();
+
+		static inline String string(String &s) { return s; }
+};
+
+
+#endif /* INCLUDED_Std */ 
diff --git a/Sources/c_snikket/iinclude/include/StringBuf.h b/Sources/c_snikket/iinclude/include/StringBuf.h
new file mode 100644
index 0000000..575e391
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/StringBuf.h
@@ -0,0 +1,78 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_StringBuf
+#define INCLUDED_StringBuf
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_8b63e6eaf513c097_35_new)
+HX_DECLARE_CLASS0(StringBuf)
+
+
+
+class HXCPP_CLASS_ATTRIBUTES StringBuf_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef StringBuf_obj OBJ_;
+		StringBuf_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2cc74002 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="StringBuf")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"StringBuf"); }
+
+		inline static ::hx::ObjectPtr< StringBuf_obj > __new() {
+			::hx::ObjectPtr< StringBuf_obj > __this = new StringBuf_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< StringBuf_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			StringBuf_obj *__this = (StringBuf_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(StringBuf_obj), true, "StringBuf"));
+			*(void **)__this = StringBuf_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_8b63e6eaf513c097_35_new)
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~StringBuf_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("StringBuf",c2,ca,83,69); }
+
+		::Array< ::String > b;
+		::Array< char > charBuf;
+		::String charBufAsString();
+		::Dynamic charBufAsString_dyn();
+
+		void flush();
+		::Dynamic flush_dyn();
+
+		int get_length();
+		::Dynamic get_length_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+
+#endif /* INCLUDED_StringBuf */ 
diff --git a/Sources/c_snikket/iinclude/include/StringTools.h b/Sources/c_snikket/iinclude/include/StringTools.h
new file mode 100644
index 0000000..039cb8b
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/StringTools.h
@@ -0,0 +1,88 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_StringTools
+#define INCLUDED_StringTools
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(StringTools)
+
+
+
+class HXCPP_CLASS_ATTRIBUTES StringTools_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef StringTools_obj OBJ_;
+		StringTools_obj();
+
+	public:
+		enum { _hx_ClassId = 0x084f186e };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="StringTools")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"StringTools"); }
+
+		inline static ::hx::ObjectPtr< StringTools_obj > __new() {
+			::hx::ObjectPtr< StringTools_obj > __this = new StringTools_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< StringTools_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			StringTools_obj *__this = (StringTools_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(StringTools_obj), false, "StringTools"));
+			*(void **)__this = StringTools_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~StringTools_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("StringTools",6a,db,63,03); }
+
+		static ::String urlEncode(::String s);
+		static ::Dynamic urlEncode_dyn();
+
+		static ::String htmlEscape(::String s, ::Dynamic quotes);
+		static ::Dynamic htmlEscape_dyn();
+
+		static bool startsWith(::String s,::String start);
+		static ::Dynamic startsWith_dyn();
+
+		static bool endsWith(::String s,::String end);
+		static ::Dynamic endsWith_dyn();
+
+		static bool isSpace(::String s,int pos);
+		static ::Dynamic isSpace_dyn();
+
+		static ::String ltrim(::String s);
+		static ::Dynamic ltrim_dyn();
+
+		static ::String rtrim(::String s);
+		static ::Dynamic rtrim_dyn();
+
+		static ::String trim(::String s);
+		static ::Dynamic trim_dyn();
+
+		static ::String lpad(::String s,::String c,int l);
+		static ::Dynamic lpad_dyn();
+
+		static ::String replace(::String s,::String sub,::String by);
+		static ::Dynamic replace_dyn();
+
+		static ::String hex(int n, ::Dynamic digits);
+		static ::Dynamic hex_dyn();
+
+};
+
+
+#endif /* INCLUDED_StringTools */ 
diff --git a/Sources/c_snikket/iinclude/include/Sys.h b/Sources/c_snikket/iinclude/include/Sys.h
new file mode 100644
index 0000000..4834a8a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/Sys.h
@@ -0,0 +1,67 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_Sys
+#define INCLUDED_Sys
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(Sys)
+
+
+
+class HXCPP_CLASS_ATTRIBUTES Sys_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Sys_obj OBJ_;
+		Sys_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7ee3a981 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="Sys")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"Sys"); }
+
+		inline static ::hx::ObjectPtr< Sys_obj > __new() {
+			::hx::ObjectPtr< Sys_obj > __this = new Sys_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Sys_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Sys_obj *__this = (Sys_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Sys_obj), false, "Sys"));
+			*(void **)__this = Sys_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Sys_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Sys",ed,64,3f,00); }
+
+		static ::String getEnv(::String s);
+		static ::Dynamic getEnv_dyn();
+
+		static ::String getCwd();
+		static ::Dynamic getCwd_dyn();
+
+		static ::String systemName();
+		static ::Dynamic systemName_dyn();
+
+		static Float time();
+		static ::Dynamic time_dyn();
+
+};
+
+
+#endif /* INCLUDED_Sys */ 
diff --git a/Sources/c_snikket/iinclude/include/Type.h b/Sources/c_snikket/iinclude/include/Type.h
new file mode 100644
index 0000000..4c1fe40
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/Type.h
@@ -0,0 +1,71 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_Type
+#define INCLUDED_Type
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(Type)
+HX_DECLARE_CLASS0(ValueType)
+
+
+
+class HXCPP_CLASS_ATTRIBUTES Type_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Type_obj OBJ_;
+		Type_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0c3514fe };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="Type")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"Type"); }
+
+		inline static ::hx::ObjectPtr< Type_obj > __new() {
+			::hx::ObjectPtr< Type_obj > __this = new Type_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Type_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Type_obj *__this = (Type_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Type_obj), false, "Type"));
+			*(void **)__this = Type_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Type_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Type",da,1e,e2,37); }
+
+		static ::hx::Class getClass( ::Dynamic o);
+		static ::Dynamic getClass_dyn();
+
+		static ::String getClassName(::hx::Class c);
+		static ::Dynamic getClassName_dyn();
+
+		static ::Array< ::String > getInstanceFields(::hx::Class c);
+		static ::Dynamic getInstanceFields_dyn();
+
+		static  ::ValueType _hx_typeof( ::Dynamic v);
+		static ::Dynamic _hx_typeof_dyn();
+
+		static ::cpp::VirtualArray enumParameters( ::Dynamic e);
+		static ::Dynamic enumParameters_dyn();
+
+};
+
+
+#endif /* INCLUDED_Type */ 
diff --git a/Sources/c_snikket/iinclude/include/ValueType.h b/Sources/c_snikket/iinclude/include/ValueType.h
new file mode 100644
index 0000000..ce988c6
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/ValueType.h
@@ -0,0 +1,47 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_ValueType
+#define INCLUDED_ValueType
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(ValueType)
+
+
+class ValueType_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef ValueType_obj OBJ_;
+
+	public:
+		ValueType_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("ValueType",ab,8a,60,3b); }
+		::String __ToString() const { return HX_("ValueType.",23,cb,18,b9) + _hx_tag; }
+
+		static ::ValueType TBool;
+		static inline ::ValueType TBool_dyn() { return TBool; }
+		static ::ValueType TClass(::hx::Class c);
+		static ::Dynamic TClass_dyn();
+		static ::ValueType TEnum(::hx::Class e);
+		static ::Dynamic TEnum_dyn();
+		static ::ValueType TFloat;
+		static inline ::ValueType TFloat_dyn() { return TFloat; }
+		static ::ValueType TFunction;
+		static inline ::ValueType TFunction_dyn() { return TFunction; }
+		static ::ValueType TInt;
+		static inline ::ValueType TInt_dyn() { return TInt; }
+		static ::ValueType TNull;
+		static inline ::ValueType TNull_dyn() { return TNull; }
+		static ::ValueType TObject;
+		static inline ::ValueType TObject_dyn() { return TObject; }
+		static ::ValueType TUnknown;
+		static inline ::ValueType TUnknown_dyn() { return TUnknown; }
+};
+
+
+#endif /* INCLUDED_ValueType */ 
diff --git a/Sources/c_snikket/iinclude/include/Xml.h b/Sources/c_snikket/iinclude/include/Xml.h
new file mode 100644
index 0000000..2b2f152
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/Xml.h
@@ -0,0 +1,114 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_Xml
+#define INCLUDED_Xml
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(Xml)
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+
+
+
+class HXCPP_CLASS_ATTRIBUTES Xml_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Xml_obj OBJ_;
+		Xml_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7ee76a4b };
+
+		void __construct(int nodeType);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="Xml")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"Xml"); }
+		static ::hx::ObjectPtr< Xml_obj > __new(int nodeType);
+		static ::hx::ObjectPtr< Xml_obj > __alloc(::hx::Ctx *_hx_ctx,int nodeType);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Xml_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Xml",b7,25,43,00); }
+
+		static void __boot();
+		static int Element;
+		static int PCData;
+		static int CData;
+		static int Comment;
+		static int DocType;
+		static int ProcessingInstruction;
+		static int Document;
+		static  ::Xml parse(::String str);
+		static ::Dynamic parse_dyn();
+
+		static  ::Xml createElement(::String name);
+		static ::Dynamic createElement_dyn();
+
+		static  ::Xml createPCData(::String data);
+		static ::Dynamic createPCData_dyn();
+
+		static  ::Xml createCData(::String data);
+		static ::Dynamic createCData_dyn();
+
+		static  ::Xml createComment(::String data);
+		static ::Dynamic createComment_dyn();
+
+		static  ::Xml createDocType(::String data);
+		static ::Dynamic createDocType_dyn();
+
+		static  ::Xml createProcessingInstruction(::String data);
+		static ::Dynamic createProcessingInstruction_dyn();
+
+		static  ::Xml createDocument();
+		static ::Dynamic createDocument_dyn();
+
+		int nodeType;
+		::String nodeName;
+		::String nodeValue;
+		 ::Xml parent;
+		::Array< ::Dynamic> children;
+		 ::haxe::ds::StringMap attributeMap;
+		::String get(::String att);
+		::Dynamic get_dyn();
+
+		void set(::String att,::String value);
+		::Dynamic set_dyn();
+
+		bool exists(::String att);
+		::Dynamic exists_dyn();
+
+		 ::Dynamic attributes();
+		::Dynamic attributes_dyn();
+
+		 ::Xml firstElement();
+		::Dynamic firstElement_dyn();
+
+		void addChild( ::Xml x);
+		::Dynamic addChild_dyn();
+
+		bool removeChild( ::Xml x);
+		::Dynamic removeChild_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+
+#endif /* INCLUDED_Xml */ 
diff --git a/Sources/c_snikket/iinclude/include/_HaxeCBridge/Int64Map_Impl_.h b/Sources/c_snikket/iinclude/include/_HaxeCBridge/Int64Map_Impl_.h
new file mode 100644
index 0000000..cf001a9
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/_HaxeCBridge/Int64Map_Impl_.h
@@ -0,0 +1,62 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED__HaxeCBridge_Int64Map_Impl_
+#define INCLUDED__HaxeCBridge_Int64Map_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(_HaxeCBridge,Int64Map_Impl_)
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,IntMap)
+
+namespace _HaxeCBridge{
+
+
+class HXCPP_CLASS_ATTRIBUTES Int64Map_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Int64Map_Impl__obj OBJ_;
+		Int64Map_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x09ceba9e };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="_HaxeCBridge.Int64Map_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"_HaxeCBridge.Int64Map_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Int64Map_Impl__obj > __new() {
+			::hx::ObjectPtr< Int64Map_Impl__obj > __this = new Int64Map_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Int64Map_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Int64Map_Impl__obj *__this = (Int64Map_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Int64Map_Impl__obj), false, "_HaxeCBridge.Int64Map_Impl_"));
+			*(void **)__this = Int64Map_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Int64Map_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Int64Map_Impl_",af,5c,92,21); }
+
+		static  ::haxe::ds::IntMap _new();
+		static ::Dynamic _new_dyn();
+
+};
+
+} // end namespace _HaxeCBridge
+
+#endif /* INCLUDED__HaxeCBridge_Int64Map_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/include/_HaxeCBridge/Internal.h b/Sources/c_snikket/iinclude/include/_HaxeCBridge/Internal.h
new file mode 100644
index 0000000..a2a1fae
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/_HaxeCBridge/Internal.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED__HaxeCBridge_Internal
+#define INCLUDED__HaxeCBridge_Internal
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(_HaxeCBridge,Internal)
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,IntMap)
+HX_DECLARE_CLASS2(sys,thread,Lock)
+
+namespace _HaxeCBridge{
+
+
+class HXCPP_CLASS_ATTRIBUTES Internal_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Internal_obj OBJ_;
+		Internal_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0f2147a8 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="_HaxeCBridge.Internal")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"_HaxeCBridge.Internal"); }
+
+		inline static ::hx::ObjectPtr< Internal_obj > __new() {
+			::hx::ObjectPtr< Internal_obj > __this = new Internal_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Internal_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Internal_obj *__this = (Internal_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Internal_obj), false, "_HaxeCBridge.Internal"));
+			*(void **)__this = Internal_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Internal_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Internal",5d,23,28,02); }
+
+		static void __boot();
+		static ::cpp::Function< bool  () > isMainThreadCb;
+		static Dynamic isMainThreadCb_dyn() { return isMainThreadCb;}
+		static  ::sys::thread::Lock mainThreadWaitLock;
+		static bool mainThreadLoopActive;
+		static bool mainThreadEndIfNoPending;
+		static  ::haxe::ds::IntMap gcRetainMap;
+};
+
+} // end namespace _HaxeCBridge
+
+#endif /* INCLUDED__HaxeCBridge_Internal */ 
diff --git a/Sources/c_snikket/iinclude/include/_UnicodeString/UnicodeString_Impl_.h b/Sources/c_snikket/iinclude/include/_UnicodeString/UnicodeString_Impl_.h
new file mode 100644
index 0000000..eb2190b
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/_UnicodeString/UnicodeString_Impl_.h
@@ -0,0 +1,66 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED__UnicodeString_UnicodeString_Impl_
+#define INCLUDED__UnicodeString_UnicodeString_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(_UnicodeString,UnicodeString_Impl_)
+
+namespace _UnicodeString{
+
+
+class HXCPP_CLASS_ATTRIBUTES UnicodeString_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef UnicodeString_Impl__obj OBJ_;
+		UnicodeString_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x699a1cff };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="_UnicodeString.UnicodeString_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"_UnicodeString.UnicodeString_Impl_"); }
+
+		inline static ::hx::ObjectPtr< UnicodeString_Impl__obj > __new() {
+			::hx::ObjectPtr< UnicodeString_Impl__obj > __this = new UnicodeString_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< UnicodeString_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			UnicodeString_Impl__obj *__this = (UnicodeString_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(UnicodeString_Impl__obj), false, "_UnicodeString.UnicodeString_Impl_"));
+			*(void **)__this = UnicodeString_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~UnicodeString_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("UnicodeString_Impl_",ce,64,09,f3); }
+
+		static ::String charAt(::String this1,int index);
+		static ::Dynamic charAt_dyn();
+
+		static ::String substr(::String this1,int pos, ::Dynamic len);
+		static ::Dynamic substr_dyn();
+
+		static int get_length(::String this1);
+		static ::Dynamic get_length_dyn();
+
+};
+
+} // end namespace _UnicodeString
+
+#endif /* INCLUDED__UnicodeString_UnicodeString_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/include/_Xml/XmlType_Impl_.h b/Sources/c_snikket/iinclude/include/_Xml/XmlType_Impl_.h
new file mode 100644
index 0000000..43c8ecc
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/_Xml/XmlType_Impl_.h
@@ -0,0 +1,60 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED__Xml_XmlType_Impl_
+#define INCLUDED__Xml_XmlType_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(_Xml,XmlType_Impl_)
+
+namespace _Xml{
+
+
+class HXCPP_CLASS_ATTRIBUTES XmlType_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef XmlType_Impl__obj OBJ_;
+		XmlType_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x29df0a39 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="_Xml.XmlType_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"_Xml.XmlType_Impl_"); }
+
+		inline static ::hx::ObjectPtr< XmlType_Impl__obj > __new() {
+			::hx::ObjectPtr< XmlType_Impl__obj > __this = new XmlType_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< XmlType_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			XmlType_Impl__obj *__this = (XmlType_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(XmlType_Impl__obj), false, "_Xml.XmlType_Impl_"));
+			*(void **)__this = XmlType_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~XmlType_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("XmlType_Impl_",71,0b,9f,dd); }
+
+		static ::String toString(int this1);
+		static ::Dynamic toString_dyn();
+
+};
+
+} // end namespace _Xml
+
+#endif /* INCLUDED__Xml_XmlType_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/include/cpp/Lib.h b/Sources/c_snikket/iinclude/include/cpp/Lib.h
new file mode 100644
index 0000000..38d98b7
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/cpp/Lib.h
@@ -0,0 +1,56 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_cpp_Lib
+#define INCLUDED_cpp_Lib
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(cpp,Lib)
+
+namespace cpp{
+
+
+class HXCPP_CLASS_ATTRIBUTES Lib_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Lib_obj OBJ_;
+		Lib_obj();
+
+	public:
+		enum { _hx_ClassId = 0x561f6486 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="cpp.Lib")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"cpp.Lib"); }
+
+		inline static ::hx::ObjectPtr< Lib_obj > __new() {
+			::hx::ObjectPtr< Lib_obj > __this = new Lib_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Lib_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Lib_obj *__this = (Lib_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Lib_obj), false, "cpp.Lib"));
+			*(void **)__this = Lib_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Lib_obj();
+
+		HX_DO_RTTI_ALL;
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Lib",25,07,3a,00); }
+
+};
+
+} // end namespace cpp
+
+#endif /* INCLUDED_cpp_Lib */ 
diff --git a/Sources/c_snikket/iinclude/include/datetime/_DateTime/DateTime_Impl_.h b/Sources/c_snikket/iinclude/include/datetime/_DateTime/DateTime_Impl_.h
new file mode 100644
index 0000000..94bc87f
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/datetime/_DateTime/DateTime_Impl_.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_datetime__DateTime_DateTime_Impl_
+#define INCLUDED_datetime__DateTime_DateTime_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(datetime,_DateTime,DateTime_Impl_)
+
+namespace datetime{
+namespace _DateTime{
+
+
+class HXCPP_CLASS_ATTRIBUTES DateTime_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef DateTime_Impl__obj OBJ_;
+		DateTime_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x3ae93836 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="datetime._DateTime.DateTime_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"datetime._DateTime.DateTime_Impl_"); }
+
+		inline static ::hx::ObjectPtr< DateTime_Impl__obj > __new() {
+			::hx::ObjectPtr< DateTime_Impl__obj > __this = new DateTime_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< DateTime_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			DateTime_Impl__obj *__this = (DateTime_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(DateTime_Impl__obj), false, "datetime._DateTime.DateTime_Impl_"));
+			*(void **)__this = DateTime_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~DateTime_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DateTime_Impl_",5b,c4,e6,72); }
+
+		static int getYear(Float this1);
+		static ::Dynamic getYear_dyn();
+
+		static Float yearStart(Float this1);
+		static ::Dynamic yearStart_dyn();
+
+		static bool isLeapYear(Float this1);
+		static ::Dynamic isLeapYear_dyn();
+
+};
+
+} // end namespace datetime
+} // end namespace _DateTime
+
+#endif /* INCLUDED_datetime__DateTime_DateTime_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/include/datetime/_DateTimeInterval/DateTimeInterval_Impl_.h b/Sources/c_snikket/iinclude/include/datetime/_DateTimeInterval/DateTimeInterval_Impl_.h
new file mode 100644
index 0000000..2d7ed1a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/datetime/_DateTimeInterval/DateTimeInterval_Impl_.h
@@ -0,0 +1,63 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_datetime__DateTimeInterval_DateTimeInterval_Impl_
+#define INCLUDED_datetime__DateTimeInterval_DateTimeInterval_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(datetime,_DateTimeInterval,DateTimeInterval_Impl_)
+HX_DECLARE_CLASS2(datetime,cores,DateTimeIntervalCore)
+
+namespace datetime{
+namespace _DateTimeInterval{
+
+
+class HXCPP_CLASS_ATTRIBUTES DateTimeInterval_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef DateTimeInterval_Impl__obj OBJ_;
+		DateTimeInterval_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x35e51cc0 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="datetime._DateTimeInterval.DateTimeInterval_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"datetime._DateTimeInterval.DateTimeInterval_Impl_"); }
+
+		inline static ::hx::ObjectPtr< DateTimeInterval_Impl__obj > __new() {
+			::hx::ObjectPtr< DateTimeInterval_Impl__obj > __this = new DateTimeInterval_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< DateTimeInterval_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			DateTimeInterval_Impl__obj *__this = (DateTimeInterval_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(DateTimeInterval_Impl__obj), false, "datetime._DateTimeInterval.DateTimeInterval_Impl_"));
+			*(void **)__this = DateTimeInterval_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~DateTimeInterval_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DateTimeInterval_Impl_",80,46,d9,2e); }
+
+		static  ::datetime::cores::DateTimeIntervalCore create(Float begin,Float end);
+		static ::Dynamic create_dyn();
+
+};
+
+} // end namespace datetime
+} // end namespace _DateTimeInterval
+
+#endif /* INCLUDED_datetime__DateTimeInterval_DateTimeInterval_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/include/datetime/cores/DateTimeIntervalCore.h b/Sources/c_snikket/iinclude/include/datetime/cores/DateTimeIntervalCore.h
new file mode 100644
index 0000000..8cfdba1
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/datetime/cores/DateTimeIntervalCore.h
@@ -0,0 +1,92 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_datetime_cores_DateTimeIntervalCore
+#define INCLUDED_datetime_cores_DateTimeIntervalCore
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(datetime,cores,DateTimeIntervalCore)
+
+namespace datetime{
+namespace cores{
+
+
+class HXCPP_CLASS_ATTRIBUTES DateTimeIntervalCore_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef DateTimeIntervalCore_obj OBJ_;
+		DateTimeIntervalCore_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2dc1c9d4 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="datetime.cores.DateTimeIntervalCore")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"datetime.cores.DateTimeIntervalCore"); }
+		static ::hx::ObjectPtr< DateTimeIntervalCore_obj > __new();
+		static ::hx::ObjectPtr< DateTimeIntervalCore_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~DateTimeIntervalCore_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DateTimeIntervalCore",5f,bb,ed,3d); }
+
+		bool negative;
+		Float begin;
+		Float end;
+		int years;
+		int months;
+		int days;
+		int hours;
+		int minutes;
+		int seconds;
+		int getYears();
+		::Dynamic getYears_dyn();
+
+		int getMonths();
+		::Dynamic getMonths_dyn();
+
+		int getTotalMonths();
+		::Dynamic getTotalMonths_dyn();
+
+		int getDays();
+		::Dynamic getDays_dyn();
+
+		int getTotalDays();
+		::Dynamic getTotalDays_dyn();
+
+		int getHours();
+		::Dynamic getHours_dyn();
+
+		int getTotalHours();
+		::Dynamic getTotalHours_dyn();
+
+		int getMinutes();
+		::Dynamic getMinutes_dyn();
+
+		int getTotalMinutes();
+		::Dynamic getTotalMinutes_dyn();
+
+		int getSeconds();
+		::Dynamic getSeconds_dyn();
+
+		Float getTotalSeconds();
+		::Dynamic getTotalSeconds_dyn();
+
+};
+
+} // end namespace datetime
+} // end namespace cores
+
+#endif /* INCLUDED_datetime_cores_DateTimeIntervalCore */ 
diff --git a/Sources/c_snikket/iinclude/include/datetime/utils/DateTimeIntervalUtils.h b/Sources/c_snikket/iinclude/include/datetime/utils/DateTimeIntervalUtils.h
new file mode 100644
index 0000000..f6bc00b
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/datetime/utils/DateTimeIntervalUtils.h
@@ -0,0 +1,63 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_datetime_utils_DateTimeIntervalUtils
+#define INCLUDED_datetime_utils_DateTimeIntervalUtils
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(datetime,cores,DateTimeIntervalCore)
+HX_DECLARE_CLASS2(datetime,utils,DateTimeIntervalUtils)
+
+namespace datetime{
+namespace utils{
+
+
+class HXCPP_CLASS_ATTRIBUTES DateTimeIntervalUtils_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef DateTimeIntervalUtils_obj OBJ_;
+		DateTimeIntervalUtils_obj();
+
+	public:
+		enum { _hx_ClassId = 0x144eafbf };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="datetime.utils.DateTimeIntervalUtils")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"datetime.utils.DateTimeIntervalUtils"); }
+
+		inline static ::hx::ObjectPtr< DateTimeIntervalUtils_obj > __new() {
+			::hx::ObjectPtr< DateTimeIntervalUtils_obj > __this = new DateTimeIntervalUtils_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< DateTimeIntervalUtils_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			DateTimeIntervalUtils_obj *__this = (DateTimeIntervalUtils_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(DateTimeIntervalUtils_obj), false, "datetime.utils.DateTimeIntervalUtils"));
+			*(void **)__this = DateTimeIntervalUtils_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~DateTimeIntervalUtils_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DateTimeIntervalUtils",31,ec,93,52); }
+
+		static ::String strftime( ::datetime::cores::DateTimeIntervalCore dti,::String format);
+		static ::Dynamic strftime_dyn();
+
+};
+
+} // end namespace datetime
+} // end namespace utils
+
+#endif /* INCLUDED_datetime_utils_DateTimeIntervalUtils */ 
diff --git a/Sources/c_snikket/iinclude/include/datetime/utils/DateTimeMonthUtils.h b/Sources/c_snikket/iinclude/include/datetime/utils/DateTimeMonthUtils.h
new file mode 100644
index 0000000..ab9584a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/datetime/utils/DateTimeMonthUtils.h
@@ -0,0 +1,71 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_datetime_utils_DateTimeMonthUtils
+#define INCLUDED_datetime_utils_DateTimeMonthUtils
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(datetime,utils,DateTimeMonthUtils)
+
+namespace datetime{
+namespace utils{
+
+
+class HXCPP_CLASS_ATTRIBUTES DateTimeMonthUtils_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef DateTimeMonthUtils_obj OBJ_;
+		DateTimeMonthUtils_obj();
+
+	public:
+		enum { _hx_ClassId = 0x250427de };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="datetime.utils.DateTimeMonthUtils")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"datetime.utils.DateTimeMonthUtils"); }
+
+		inline static ::hx::ObjectPtr< DateTimeMonthUtils_obj > __new() {
+			::hx::ObjectPtr< DateTimeMonthUtils_obj > __this = new DateTimeMonthUtils_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< DateTimeMonthUtils_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			DateTimeMonthUtils_obj *__this = (DateTimeMonthUtils_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(DateTimeMonthUtils_obj), false, "datetime.utils.DateTimeMonthUtils"));
+			*(void **)__this = DateTimeMonthUtils_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~DateTimeMonthUtils_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DateTimeMonthUtils",2c,90,be,68); }
+
+		static int days(int month,::hx::Null< bool >  isLeapYear);
+		static ::Dynamic days_dyn();
+
+		static int getMonth(int days,::hx::Null< bool >  isLeapYear);
+		static ::Dynamic getMonth_dyn();
+
+		static int getMonthDay(int days,::hx::Null< bool >  isLeapYear);
+		static ::Dynamic getMonthDay_dyn();
+
+		static int toSeconds(int month,::hx::Null< bool >  isLeapYear);
+		static ::Dynamic toSeconds_dyn();
+
+};
+
+} // end namespace datetime
+} // end namespace utils
+
+#endif /* INCLUDED_datetime_utils_DateTimeMonthUtils */ 
diff --git a/Sources/c_snikket/iinclude/include/datetime/utils/DateTimeUtils.h b/Sources/c_snikket/iinclude/include/datetime/utils/DateTimeUtils.h
new file mode 100644
index 0000000..b774eb8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/datetime/utils/DateTimeUtils.h
@@ -0,0 +1,71 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_datetime_utils_DateTimeUtils
+#define INCLUDED_datetime_utils_DateTimeUtils
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(datetime,utils,DateTimeUtils)
+
+namespace datetime{
+namespace utils{
+
+
+class HXCPP_CLASS_ATTRIBUTES DateTimeUtils_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef DateTimeUtils_obj OBJ_;
+		DateTimeUtils_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4dd3c90c };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="datetime.utils.DateTimeUtils")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"datetime.utils.DateTimeUtils"); }
+
+		inline static ::hx::ObjectPtr< DateTimeUtils_obj > __new() {
+			::hx::ObjectPtr< DateTimeUtils_obj > __this = new DateTimeUtils_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< DateTimeUtils_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			DateTimeUtils_obj *__this = (DateTimeUtils_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(DateTimeUtils_obj), false, "datetime.utils.DateTimeUtils"));
+			*(void **)__this = DateTimeUtils_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~DateTimeUtils_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DateTimeUtils",b6,22,76,b4); }
+
+		static Float fromString(::String str);
+		static ::Dynamic fromString_dyn();
+
+		static Float parse(::String str);
+		static ::Dynamic parse_dyn();
+
+		static Float fromIsoString(::String str);
+		static ::Dynamic fromIsoString_dyn();
+
+		static Float yearToStamp(int year);
+		static ::Dynamic yearToStamp_dyn();
+
+};
+
+} // end namespace datetime
+} // end namespace utils
+
+#endif /* INCLUDED_datetime_utils_DateTimeUtils */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/EntryPoint.h b/Sources/c_snikket/iinclude/include/haxe/EntryPoint.h
new file mode 100644
index 0000000..170f0e7
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/EntryPoint.h
@@ -0,0 +1,60 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_EntryPoint
+#define INCLUDED_haxe_EntryPoint
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,EntryPoint)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES EntryPoint_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef EntryPoint_obj OBJ_;
+		EntryPoint_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7dc0c864 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.EntryPoint")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"haxe.EntryPoint"); }
+
+		inline static ::hx::ObjectPtr< EntryPoint_obj > __new() {
+			::hx::ObjectPtr< EntryPoint_obj > __this = new EntryPoint_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< EntryPoint_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			EntryPoint_obj *__this = (EntryPoint_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(EntryPoint_obj), false, "haxe.EntryPoint"));
+			*(void **)__this = EntryPoint_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~EntryPoint_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("EntryPoint",9e,d2,23,a2); }
+
+		static void run();
+		static ::Dynamic run_dyn();
+
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_EntryPoint */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/Exception.h b/Sources/c_snikket/iinclude/include/haxe/Exception.h
new file mode 100644
index 0000000..5e7cabd
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/Exception.h
@@ -0,0 +1,65 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_Exception
+#define INCLUDED_haxe_Exception
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,Exception)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES Exception_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Exception_obj OBJ_;
+		Exception_obj();
+
+	public:
+		enum { _hx_ClassId = 0x677ddc49 };
+
+		void __construct(::String message, ::haxe::Exception previous, ::Dynamic native);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.Exception")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.Exception"); }
+		static ::hx::ObjectPtr< Exception_obj > __new(::String message, ::haxe::Exception previous, ::Dynamic native);
+		static ::hx::ObjectPtr< Exception_obj > __alloc(::hx::Ctx *_hx_ctx,::String message, ::haxe::Exception previous, ::Dynamic native);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Exception_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Exception",2f,f0,6c,eb); }
+
+		static  ::haxe::Exception caught( ::Dynamic value);
+		static ::Dynamic caught_dyn();
+
+		::String _hx___exceptionMessage;
+		::Array< ::String > _hx___nativeStack;
+		int _hx___skipStack;
+		 ::Dynamic _hx___nativeException;
+		 ::haxe::Exception _hx___previousException;
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+		::String get_message();
+		::Dynamic get_message_dyn();
+
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_Exception */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/IMap.h b/Sources/c_snikket/iinclude/include/haxe/IMap.h
new file mode 100644
index 0000000..b3e5b1a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/IMap.h
@@ -0,0 +1,31 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_IMap
+#define INCLUDED_haxe_IMap
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES IMap_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		 ::Dynamic (::hx::Object :: *_hx_get)( ::Dynamic k); 
+		static inline  ::Dynamic get( ::Dynamic _hx_, ::Dynamic k) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::haxe::IMap_obj *>(_hx_.mPtr->_hx_getInterface(0x09c2bd39)))->_hx_get)(k);
+		}
+		 ::Dynamic (::hx::Object :: *_hx_keys)(); 
+		static inline  ::Dynamic keys( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::haxe::IMap_obj *>(_hx_.mPtr->_hx_getInterface(0x09c2bd39)))->_hx_keys)();
+		}
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_IMap */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/Log.h b/Sources/c_snikket/iinclude/include/haxe/Log.h
new file mode 100644
index 0000000..86c3163
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/Log.h
@@ -0,0 +1,62 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_Log
+#define INCLUDED_haxe_Log
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,Log)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES Log_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Log_obj OBJ_;
+		Log_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3c235b1a };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.Log")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"haxe.Log"); }
+
+		inline static ::hx::ObjectPtr< Log_obj > __new() {
+			::hx::ObjectPtr< Log_obj > __this = new Log_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Log_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Log_obj *__this = (Log_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Log_obj), false, "haxe.Log"));
+			*(void **)__this = Log_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Log_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Log",64,0c,3a,00); }
+
+		static void __boot();
+		static ::Dynamic trace;
+		static inline ::Dynamic &trace_dyn() {return trace; }
+
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_Log */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/MainEvent.h b/Sources/c_snikket/iinclude/include/haxe/MainEvent.h
new file mode 100644
index 0000000..472de6e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/MainEvent.h
@@ -0,0 +1,57 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_MainEvent
+#define INCLUDED_haxe_MainEvent
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,MainEvent)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES MainEvent_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef MainEvent_obj OBJ_;
+		MainEvent_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0b5efb53 };
+
+		void __construct( ::Dynamic f,int p);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.MainEvent")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.MainEvent"); }
+		static ::hx::ObjectPtr< MainEvent_obj > __new( ::Dynamic f,int p);
+		static ::hx::ObjectPtr< MainEvent_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic f,int p);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~MainEvent_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("MainEvent",01,71,3b,31); }
+
+		 ::Dynamic f;
+		Dynamic f_dyn() { return f;}
+		 ::haxe::MainEvent prev;
+		 ::haxe::MainEvent next;
+		bool isBlocking;
+		Float nextRun;
+		int priority;
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_MainEvent */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/MainLoop.h b/Sources/c_snikket/iinclude/include/haxe/MainLoop.h
new file mode 100644
index 0000000..d8ad31a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/MainLoop.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_MainLoop
+#define INCLUDED_haxe_MainLoop
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,MainEvent)
+HX_DECLARE_CLASS1(haxe,MainLoop)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES MainLoop_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef MainLoop_obj OBJ_;
+		MainLoop_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0c7b74e7 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.MainLoop")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"haxe.MainLoop"); }
+
+		inline static ::hx::ObjectPtr< MainLoop_obj > __new() {
+			::hx::ObjectPtr< MainLoop_obj > __this = new MainLoop_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< MainLoop_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			MainLoop_obj *__this = (MainLoop_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(MainLoop_obj), false, "haxe.MainLoop"));
+			*(void **)__this = MainLoop_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~MainLoop_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("MainLoop",5d,d7,eb,79); }
+
+		static  ::haxe::MainEvent pending;
+		static bool hasEvents();
+		static ::Dynamic hasEvents_dyn();
+
+		static void sortEvents();
+		static ::Dynamic sortEvents_dyn();
+
+		static Float tick();
+		static ::Dynamic tick_dyn();
+
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_MainLoop */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/NativeStackTrace.h b/Sources/c_snikket/iinclude/include/haxe/NativeStackTrace.h
new file mode 100644
index 0000000..dc1054c
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/NativeStackTrace.h
@@ -0,0 +1,66 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_NativeStackTrace
+#define INCLUDED_haxe_NativeStackTrace
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,NativeStackTrace)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES NativeStackTrace_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef NativeStackTrace_obj OBJ_;
+		NativeStackTrace_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3984963e };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.NativeStackTrace")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"haxe.NativeStackTrace"); }
+
+		inline static ::hx::ObjectPtr< NativeStackTrace_obj > __new() {
+			::hx::ObjectPtr< NativeStackTrace_obj > __this = new NativeStackTrace_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< NativeStackTrace_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			NativeStackTrace_obj *__this = (NativeStackTrace_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(NativeStackTrace_obj), false, "haxe.NativeStackTrace"));
+			*(void **)__this = NativeStackTrace_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~NativeStackTrace_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("NativeStackTrace",b4,5e,6d,3c); }
+
+		static void saveStack( ::Dynamic exception);
+		static ::Dynamic saveStack_dyn();
+
+		static ::Array< ::String > callStack();
+		static ::Dynamic callStack_dyn();
+
+		static ::Array< ::String > exceptionStack();
+		static ::Dynamic exceptionStack_dyn();
+
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_NativeStackTrace */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/StackItem.h b/Sources/c_snikket/iinclude/include/haxe/StackItem.h
new file mode 100644
index 0000000..bf28552
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/StackItem.h
@@ -0,0 +1,41 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_StackItem
+#define INCLUDED_haxe_StackItem
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,StackItem)
+namespace haxe{
+
+
+class StackItem_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef StackItem_obj OBJ_;
+
+	public:
+		StackItem_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("haxe.StackItem",13,26,c7,2d); }
+		::String __ToString() const { return HX_("StackItem.",73,53,dc,cb) + _hx_tag; }
+
+		static ::haxe::StackItem CFunction;
+		static inline ::haxe::StackItem CFunction_dyn() { return CFunction; }
+		static ::haxe::StackItem FilePos( ::haxe::StackItem s,::String file,int line, ::Dynamic column);
+		static ::Dynamic FilePos_dyn();
+		static ::haxe::StackItem LocalFunction( ::Dynamic v);
+		static ::Dynamic LocalFunction_dyn();
+		static ::haxe::StackItem Method(::String classname,::String method);
+		static ::Dynamic Method_dyn();
+		static ::haxe::StackItem Module(::String m);
+		static ::Dynamic Module_dyn();
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_StackItem */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/Timer.h b/Sources/c_snikket/iinclude/include/haxe/Timer.h
new file mode 100644
index 0000000..27ba251
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/Timer.h
@@ -0,0 +1,65 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_Timer
+#define INCLUDED_haxe_Timer
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,Timer)
+HX_DECLARE_CLASS3(sys,thread,_EventLoop,RegularEvent)
+HX_DECLARE_CLASS3(sys,thread,_Thread,HaxeThread)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES Timer_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Timer_obj OBJ_;
+		Timer_obj();
+
+	public:
+		enum { _hx_ClassId = 0x04eaa0bb };
+
+		void __construct(int time_ms);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.Timer")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.Timer"); }
+		static ::hx::ObjectPtr< Timer_obj > __new(int time_ms);
+		static ::hx::ObjectPtr< Timer_obj > __alloc(::hx::Ctx *_hx_ctx,int time_ms);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		static void __alloc_dynamic_functions(::hx::Ctx *_hx_alloc,Timer_obj *_hx_obj);
+		//~Timer_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Timer",a5,2f,63,a3); }
+
+		static  ::haxe::Timer delay( ::Dynamic f,int time_ms);
+		static ::Dynamic delay_dyn();
+
+		 ::sys::thread::_Thread::HaxeThread thread;
+		 ::sys::thread::_EventLoop::RegularEvent eventHandler;
+		void stop();
+		::Dynamic stop_dyn();
+
+		::Dynamic run;
+		inline ::Dynamic &run_dyn() {return run; }
+
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_Timer */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/ValueException.h b/Sources/c_snikket/iinclude/include/haxe/ValueException.h
new file mode 100644
index 0000000..b515757
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/ValueException.h
@@ -0,0 +1,55 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_ValueException
+#define INCLUDED_haxe_ValueException
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_Exception
+#include <haxe/Exception.h>
+#endif
+HX_DECLARE_CLASS1(haxe,Exception)
+HX_DECLARE_CLASS1(haxe,ValueException)
+
+namespace haxe{
+
+
+class HXCPP_CLASS_ATTRIBUTES ValueException_obj : public  ::haxe::Exception_obj
+{
+	public:
+		typedef  ::haxe::Exception_obj super;
+		typedef ValueException_obj OBJ_;
+		ValueException_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0af01d58 };
+
+		void __construct( ::Dynamic value, ::haxe::Exception previous, ::Dynamic native);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.ValueException")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.ValueException"); }
+		static ::hx::ObjectPtr< ValueException_obj > __new( ::Dynamic value, ::haxe::Exception previous, ::Dynamic native);
+		static ::hx::ObjectPtr< ValueException_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic value, ::haxe::Exception previous, ::Dynamic native);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ValueException_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ValueException",be,0e,61,3f); }
+
+		 ::Dynamic value;
+};
+
+} // end namespace haxe
+
+#endif /* INCLUDED_haxe_ValueException */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/crypto/Base64.h b/Sources/c_snikket/iinclude/include/haxe/crypto/Base64.h
new file mode 100644
index 0000000..0f00eaf
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/crypto/Base64.h
@@ -0,0 +1,78 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_crypto_Base64
+#define INCLUDED_haxe_crypto_Base64
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,crypto,Base64)
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+
+namespace haxe{
+namespace crypto{
+
+
+class HXCPP_CLASS_ATTRIBUTES Base64_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Base64_obj OBJ_;
+		Base64_obj();
+
+	public:
+		enum { _hx_ClassId = 0x08b38de6 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.crypto.Base64")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"haxe.crypto.Base64"); }
+
+		inline static ::hx::ObjectPtr< Base64_obj > __new() {
+			::hx::ObjectPtr< Base64_obj > __this = new Base64_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Base64_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Base64_obj *__this = (Base64_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Base64_obj), false, "haxe.crypto.Base64"));
+			*(void **)__this = Base64_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Base64_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Base64",af,71,bc,89); }
+
+		static void __boot();
+		static ::String CHARS;
+		static  ::haxe::io::Bytes BYTES;
+		static ::String URL_CHARS;
+		static  ::haxe::io::Bytes URL_BYTES;
+		static ::String encode( ::haxe::io::Bytes bytes,::hx::Null< bool >  complement);
+		static ::Dynamic encode_dyn();
+
+		static  ::haxe::io::Bytes decode(::String str,::hx::Null< bool >  complement);
+		static ::Dynamic decode_dyn();
+
+		static ::String urlEncode( ::haxe::io::Bytes bytes,::hx::Null< bool >  complement);
+		static ::Dynamic urlEncode_dyn();
+
+		static  ::haxe::io::Bytes urlDecode(::String str,::hx::Null< bool >  complement);
+		static ::Dynamic urlDecode_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace crypto
+
+#endif /* INCLUDED_haxe_crypto_Base64 */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/crypto/BaseCode.h b/Sources/c_snikket/iinclude/include/haxe/crypto/BaseCode.h
new file mode 100644
index 0000000..bd80353
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/crypto/BaseCode.h
@@ -0,0 +1,65 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_crypto_BaseCode
+#define INCLUDED_haxe_crypto_BaseCode
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,crypto,BaseCode)
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+
+namespace haxe{
+namespace crypto{
+
+
+class HXCPP_CLASS_ATTRIBUTES BaseCode_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef BaseCode_obj OBJ_;
+		BaseCode_obj();
+
+	public:
+		enum { _hx_ClassId = 0x34980465 };
+
+		void __construct( ::haxe::io::Bytes base);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.crypto.BaseCode")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.crypto.BaseCode"); }
+		static ::hx::ObjectPtr< BaseCode_obj > __new( ::haxe::io::Bytes base);
+		static ::hx::ObjectPtr< BaseCode_obj > __alloc(::hx::Ctx *_hx_ctx, ::haxe::io::Bytes base);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~BaseCode_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("BaseCode",fe,5d,c4,cf); }
+
+		 ::haxe::io::Bytes base;
+		int nbits;
+		::Array< int > tbl;
+		 ::haxe::io::Bytes encodeBytes( ::haxe::io::Bytes b);
+		::Dynamic encodeBytes_dyn();
+
+		void initTable();
+		::Dynamic initTable_dyn();
+
+		 ::haxe::io::Bytes decodeBytes( ::haxe::io::Bytes b);
+		::Dynamic decodeBytes_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace crypto
+
+#endif /* INCLUDED_haxe_crypto_BaseCode */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/crypto/Sha1.h b/Sources/c_snikket/iinclude/include/haxe/crypto/Sha1.h
new file mode 100644
index 0000000..e2986e1
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/crypto/Sha1.h
@@ -0,0 +1,81 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_crypto_Sha1
+#define INCLUDED_haxe_crypto_Sha1
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_b388adc1457cbfc2_48_new)
+HX_DECLARE_CLASS2(haxe,crypto,Sha1)
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+
+namespace haxe{
+namespace crypto{
+
+
+class HXCPP_CLASS_ATTRIBUTES Sha1_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Sha1_obj OBJ_;
+		Sha1_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3a249b8c };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.crypto.Sha1")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"haxe.crypto.Sha1"); }
+
+		inline static ::hx::ObjectPtr< Sha1_obj > __new() {
+			::hx::ObjectPtr< Sha1_obj > __this = new Sha1_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Sha1_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Sha1_obj *__this = (Sha1_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Sha1_obj), false, "haxe.crypto.Sha1"));
+			*(void **)__this = Sha1_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_b388adc1457cbfc2_48_new)
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Sha1_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Sha1",a5,f4,2b,37); }
+
+		static  ::haxe::io::Bytes make( ::haxe::io::Bytes b);
+		static ::Dynamic make_dyn();
+
+		static ::Array< int > bytes2blks( ::haxe::io::Bytes b);
+		static ::Dynamic bytes2blks_dyn();
+
+		::Array< int > doEncode(::Array< int > x);
+		::Dynamic doEncode_dyn();
+
+		int ft(int t,int b,int c,int d);
+		::Dynamic ft_dyn();
+
+		int kt(int t);
+		::Dynamic kt_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace crypto
+
+#endif /* INCLUDED_haxe_crypto_Sha1 */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/crypto/Sha256.h b/Sources/c_snikket/iinclude/include/haxe/crypto/Sha256.h
new file mode 100644
index 0000000..6851954
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/crypto/Sha256.h
@@ -0,0 +1,75 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_crypto_Sha256
+#define INCLUDED_haxe_crypto_Sha256
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_0a4e95b4276e5057_48_new)
+HX_DECLARE_CLASS2(haxe,crypto,Sha256)
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+
+namespace haxe{
+namespace crypto{
+
+
+class HXCPP_CLASS_ATTRIBUTES Sha256_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Sha256_obj OBJ_;
+		Sha256_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0c0976ea };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.crypto.Sha256")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"haxe.crypto.Sha256"); }
+
+		inline static ::hx::ObjectPtr< Sha256_obj > __new() {
+			::hx::ObjectPtr< Sha256_obj > __this = new Sha256_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Sha256_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Sha256_obj *__this = (Sha256_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Sha256_obj), false, "haxe.crypto.Sha256"));
+			*(void **)__this = Sha256_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_0a4e95b4276e5057_48_new)
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Sha256_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Sha256",87,18,8f,51); }
+
+		static  ::haxe::io::Bytes make( ::haxe::io::Bytes b);
+		static ::Dynamic make_dyn();
+
+		static ::Array< int > bytes2blks( ::haxe::io::Bytes b);
+		static ::Dynamic bytes2blks_dyn();
+
+		::Array< int > doEncode(::Array< int > m,int l);
+		::Dynamic doEncode_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace crypto
+
+#endif /* INCLUDED_haxe_crypto_Sha256 */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/ds/BalancedTree.h b/Sources/c_snikket/iinclude/include/haxe/ds/BalancedTree.h
new file mode 100644
index 0000000..4f5b9e6
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/ds/BalancedTree.h
@@ -0,0 +1,83 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_ds_BalancedTree
+#define INCLUDED_haxe_ds_BalancedTree
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,BalancedTree)
+HX_DECLARE_CLASS2(haxe,ds,TreeNode)
+
+namespace haxe{
+namespace ds{
+
+
+class HXCPP_CLASS_ATTRIBUTES BalancedTree_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef BalancedTree_obj OBJ_;
+		BalancedTree_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4cc9cf7f };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.ds.BalancedTree")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.ds.BalancedTree"); }
+		static ::hx::ObjectPtr< BalancedTree_obj > __new();
+		static ::hx::ObjectPtr< BalancedTree_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~BalancedTree_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("BalancedTree",66,71,f8,aa); }
+
+		 ::haxe::ds::TreeNode root;
+		void set( ::Dynamic key, ::Dynamic value);
+		::Dynamic set_dyn();
+
+		 ::Dynamic get( ::Dynamic key);
+		::Dynamic get_dyn();
+
+		bool exists( ::Dynamic key);
+		::Dynamic exists_dyn();
+
+		 ::Dynamic keys();
+		::Dynamic keys_dyn();
+
+		 ::haxe::ds::TreeNode setLoop( ::Dynamic k, ::Dynamic v, ::haxe::ds::TreeNode node);
+		::Dynamic setLoop_dyn();
+
+		void keysLoop( ::haxe::ds::TreeNode node,::cpp::VirtualArray acc);
+		::Dynamic keysLoop_dyn();
+
+		 ::haxe::ds::TreeNode balance( ::haxe::ds::TreeNode l, ::Dynamic k, ::Dynamic v, ::haxe::ds::TreeNode r);
+		::Dynamic balance_dyn();
+
+		virtual int compare( ::Dynamic k1, ::Dynamic k2);
+		::Dynamic compare_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace ds
+
+#endif /* INCLUDED_haxe_ds_BalancedTree */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/ds/Either.h b/Sources/c_snikket/iinclude/include/haxe/ds/Either.h
new file mode 100644
index 0000000..64e3fd7
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/ds/Either.h
@@ -0,0 +1,37 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_ds_Either
+#define INCLUDED_haxe_ds_Either
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,ds,Either)
+namespace haxe{
+namespace ds{
+
+
+class Either_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef Either_obj OBJ_;
+
+	public:
+		Either_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("haxe.ds.Either",1c,1a,b7,a4); }
+		::String __ToString() const { return HX_("Either.",29,67,48,40) + _hx_tag; }
+
+		static ::haxe::ds::Either Left( ::Dynamic v);
+		static ::Dynamic Left_dyn();
+		static ::haxe::ds::Either Right( ::Dynamic v);
+		static ::Dynamic Right_dyn();
+};
+
+} // end namespace haxe
+} // end namespace ds
+
+#endif /* INCLUDED_haxe_ds_Either */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/ds/EnumValueMap.h b/Sources/c_snikket/iinclude/include/haxe/ds/EnumValueMap.h
new file mode 100644
index 0000000..48f7525
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/ds/EnumValueMap.h
@@ -0,0 +1,65 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_ds_EnumValueMap
+#define INCLUDED_haxe_ds_EnumValueMap
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_ds_BalancedTree
+#include <haxe/ds/BalancedTree.h>
+#endif
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,BalancedTree)
+HX_DECLARE_CLASS2(haxe,ds,EnumValueMap)
+
+namespace haxe{
+namespace ds{
+
+
+class HXCPP_CLASS_ATTRIBUTES EnumValueMap_obj : public  ::haxe::ds::BalancedTree_obj
+{
+	public:
+		typedef  ::haxe::ds::BalancedTree_obj super;
+		typedef EnumValueMap_obj OBJ_;
+		EnumValueMap_obj();
+
+	public:
+		enum { _hx_ClassId = 0x34ccfa05 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.ds.EnumValueMap")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.ds.EnumValueMap"); }
+		static ::hx::ObjectPtr< EnumValueMap_obj > __new();
+		static ::hx::ObjectPtr< EnumValueMap_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~EnumValueMap_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("EnumValueMap",ec,9b,fb,92); }
+
+		int compare( ::Dynamic _tmp_k1, ::Dynamic _tmp_k2);
+
+		int compareArgs(::cpp::VirtualArray a1,::cpp::VirtualArray a2);
+		::Dynamic compareArgs_dyn();
+
+		int compareArg( ::Dynamic v1, ::Dynamic v2);
+		::Dynamic compareArg_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace ds
+
+#endif /* INCLUDED_haxe_ds_EnumValueMap */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/ds/IntMap.h b/Sources/c_snikket/iinclude/include/haxe/ds/IntMap.h
new file mode 100644
index 0000000..c5e3745
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/ds/IntMap.h
@@ -0,0 +1,102 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_ds_IntMap
+#define INCLUDED_haxe_ds_IntMap
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,IntMap)
+
+namespace haxe{
+namespace ds{
+
+
+class HXCPP_CLASS_ATTRIBUTES IntMap_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef IntMap_obj OBJ_;
+		IntMap_obj();
+
+	public:
+		enum { _hx_ClassId = 0x269a1502 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.ds.IntMap")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.ds.IntMap"); }
+		static ::hx::ObjectPtr< IntMap_obj > __new();
+		static ::hx::ObjectPtr< IntMap_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~IntMap_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		 ::Dynamic get_a7a2487a( ::Dynamic k);
+		::String __ToString() const { return HX_("IntMap",0d,a9,08,d3); }
+
+		 ::Dynamic h;
+		void set(int key, ::Dynamic value);
+		::Dynamic set_dyn();
+
+		 ::Dynamic get(int key);
+		::Dynamic get_dyn();
+
+		bool remove(int key);
+		::Dynamic remove_dyn();
+
+		 ::Dynamic keys();
+		::Dynamic keys_dyn();
+
+
+  inline void set(int key, ::null value) { __int_hash_set(HX_MAP_THIS,key,value); }
+  inline void set(int key, bool value) { __int_hash_set(HX_MAP_THIS,key,value); }
+  inline void set(int key, char value) { __int_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(int key, unsigned char value) { __int_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(int key, signed char value) { __int_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(int key, short value) { __int_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(int key, unsigned short value) { __int_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(int key, int value) { __int_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(int key, unsigned int value) { __int_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(int key, float value) { __int_hash_set_float(HX_MAP_THIS,key,value); }
+  inline void set(int key, double value) { __int_hash_set_float(HX_MAP_THIS,key,value); }
+  inline void set(int key, ::String value) { __int_hash_set_string(HX_MAP_THIS,key,value); }
+  inline void set(int key, cpp::Int64 value) { __int_hash_set_int64(HX_MAP_THIS,key,value); }
+
+  template<typename V, typename H>
+  inline void set(int key, const ::cpp::Struct<V,H> &value) {__int_hash_set(HX_MAP_THIS,key,value); }
+  template<typename F>
+  inline void set(int key, const ::cpp::Function<F> &value) {__int_hash_set(HX_MAP_THIS,key,value); }
+  template<typename V>
+  inline void set(int key, const ::cpp::Pointer<V> &value) {__int_hash_set(HX_MAP_THIS,key,(Dynamic)value ); }
+
+  template<typename VALUE>
+  inline void set(Dynamic &key, const VALUE &value) { set( (int)key, value ); }
+
+  inline bool get_bool(int key) { return __int_hash_get_bool(h,key); }
+  inline int get_int(int key) { return __int_hash_get_int(h,key); }
+  inline Float get_float(int key) { return __int_hash_get_float(h,key); }
+  inline String get_string(int key) { return __int_hash_get_string(h,key); }
+  inline cpp::Int64 get_int64(int key) { return __int_hash_get_int64(h,key); }
+
+};
+
+} // end namespace haxe
+} // end namespace ds
+
+#endif /* INCLUDED_haxe_ds_IntMap */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/ds/List.h b/Sources/c_snikket/iinclude/include/haxe/ds/List.h
new file mode 100644
index 0000000..f0559ec
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/ds/List.h
@@ -0,0 +1,62 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_ds_List
+#define INCLUDED_haxe_ds_List
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,ds,List)
+HX_DECLARE_CLASS3(haxe,ds,_List,ListNode)
+
+namespace haxe{
+namespace ds{
+
+
+class HXCPP_CLASS_ATTRIBUTES List_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef List_obj OBJ_;
+		List_obj();
+
+	public:
+		enum { _hx_ClassId = 0x39a75d33 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.ds.List")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.ds.List"); }
+		static ::hx::ObjectPtr< List_obj > __new();
+		static ::hx::ObjectPtr< List_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~List_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("List",7e,48,8c,32); }
+
+		 ::haxe::ds::_List::ListNode h;
+		 ::haxe::ds::_List::ListNode q;
+		int length;
+		void push( ::Dynamic item);
+		::Dynamic push_dyn();
+
+		 ::Dynamic pop();
+		::Dynamic pop_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace ds
+
+#endif /* INCLUDED_haxe_ds_List */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/ds/ObjectMap.h b/Sources/c_snikket/iinclude/include/haxe/ds/ObjectMap.h
new file mode 100644
index 0000000..02cde81
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/ds/ObjectMap.h
@@ -0,0 +1,96 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_ds_ObjectMap
+#define INCLUDED_haxe_ds_ObjectMap
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,ObjectMap)
+
+namespace haxe{
+namespace ds{
+
+
+class HXCPP_CLASS_ATTRIBUTES ObjectMap_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef ObjectMap_obj OBJ_;
+		ObjectMap_obj();
+
+	public:
+		enum { _hx_ClassId = 0x6cba6d44 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.ds.ObjectMap")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.ds.ObjectMap"); }
+		static ::hx::ObjectPtr< ObjectMap_obj > __new();
+		static ::hx::ObjectPtr< ObjectMap_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ObjectMap_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("ObjectMap",fd,a4,50,e5); }
+
+		 ::Dynamic h;
+		void set( ::Dynamic key, ::Dynamic value);
+		::Dynamic set_dyn();
+
+		 ::Dynamic get( ::Dynamic key);
+		::Dynamic get_dyn();
+
+		 ::Dynamic keys();
+		::Dynamic keys_dyn();
+
+
+  inline void set(Dynamic key, ::null value) { __object_hash_set(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, bool value) { __object_hash_set(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, char value) { __object_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, unsigned char value) { __object_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, signed char value) { __object_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, short value) { __object_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, unsigned short value) { __object_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, int value) { __object_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, unsigned int value) { __object_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, float value) { __object_hash_set_float(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, double value) { __object_hash_set_float(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, ::String value) { __object_hash_set_string(HX_MAP_THIS,key,value); }
+  inline void set(Dynamic key, cpp::Int64 value) { __object_hash_set_int64(HX_MAP_THIS,key,value); }
+
+
+  template<typename V, typename H>
+  inline void set(Dynamic key, const ::cpp::Struct<V,H> &value) {__object_hash_set(HX_MAP_THIS,key,value); }
+  template<typename V>
+  inline void set(Dynamic key, const ::cpp::Function<V> &value) {__object_hash_set(HX_MAP_THIS,key,(Dynamic)value ); }
+  template<typename V>
+  inline void set(Dynamic key, const ::cpp::Pointer<V> &value) {__object_hash_set(HX_MAP_THIS,key,(Dynamic)value ); }
+
+  inline bool get_bool(Dynamic key) { return __object_hash_get_bool(h,key); }
+  inline int get_int(Dynamic key) { return __object_hash_get_int(h,key); }
+  inline Float get_float(Dynamic key) { return __object_hash_get_float(h,key); }
+  inline String get_string(Dynamic key) { return __object_hash_get_string(h,key); }
+  inline cpp::Int64 get_int64(Dynamic key) { return __object_hash_get_int64(h,key); }
+
+};
+
+} // end namespace haxe
+} // end namespace ds
+
+#endif /* INCLUDED_haxe_ds_ObjectMap */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/ds/Option.h b/Sources/c_snikket/iinclude/include/haxe/ds/Option.h
new file mode 100644
index 0000000..f2703eb
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/ds/Option.h
@@ -0,0 +1,37 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_ds_Option
+#define INCLUDED_haxe_ds_Option
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,ds,Option)
+namespace haxe{
+namespace ds{
+
+
+class Option_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef Option_obj OBJ_;
+
+	public:
+		Option_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("haxe.ds.Option",4c,90,17,ac); }
+		::String __ToString() const { return HX_("Option.",f9,5a,4f,ad) + _hx_tag; }
+
+		static ::haxe::ds::Option None;
+		static inline ::haxe::ds::Option None_dyn() { return None; }
+		static ::haxe::ds::Option Some( ::Dynamic v);
+		static ::Dynamic Some_dyn();
+};
+
+} // end namespace haxe
+} // end namespace ds
+
+#endif /* INCLUDED_haxe_ds_Option */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/ds/StringMap.h b/Sources/c_snikket/iinclude/include/haxe/ds/StringMap.h
new file mode 100644
index 0000000..527e7db
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/ds/StringMap.h
@@ -0,0 +1,111 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_ds_StringMap
+#define INCLUDED_haxe_ds_StringMap
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+
+namespace haxe{
+namespace ds{
+
+
+class HXCPP_CLASS_ATTRIBUTES StringMap_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef StringMap_obj OBJ_;
+		StringMap_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4260cd56 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.ds.StringMap")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.ds.StringMap"); }
+		static ::hx::ObjectPtr< StringMap_obj > __new();
+		static ::hx::ObjectPtr< StringMap_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~StringMap_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		 ::Dynamic get_a7a2487a( ::Dynamic k);
+		::String __ToString() const { return HX_("StringMap",2b,12,8c,69); }
+
+		 ::Dynamic h;
+		void set(::String key, ::Dynamic value);
+		::Dynamic set_dyn();
+
+		 ::Dynamic get(::String key);
+		::Dynamic get_dyn();
+
+		bool exists(::String key);
+		::Dynamic exists_dyn();
+
+		bool remove(::String key);
+		::Dynamic remove_dyn();
+
+		 ::Dynamic keys();
+		::Dynamic keys_dyn();
+
+		 ::Dynamic iterator();
+		::Dynamic iterator_dyn();
+
+		void clear();
+		::Dynamic clear_dyn();
+
+
+  inline void set(String key, ::null value) { __string_hash_set(HX_MAP_THIS,key,value); }
+  inline void set(String key, bool value) { __string_hash_set(HX_MAP_THIS,key,value); }
+  inline void set(String key, char value) { __string_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(String key, unsigned char value) { __string_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(String key, signed char value) { __string_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(String key, short value) { __string_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(String key, unsigned short value) { __string_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(String key, int value) { __string_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(String key, unsigned int value) { __string_hash_set_int(HX_MAP_THIS,key,value); }
+  inline void set(String key, float value) { __string_hash_set_float(HX_MAP_THIS,key,value); }
+  inline void set(String key, double value) { __string_hash_set_float(HX_MAP_THIS,key,value); }
+  inline void set(String key, ::String value) { __string_hash_set_string(HX_MAP_THIS,key,value); }
+  inline void set(String key, cpp::Int64 value) { __string_hash_set_int64(HX_MAP_THIS,key,value); }
+
+  template<typename V, typename H>
+  inline void set(String key, const ::cpp::Struct<V,H> &value) {__string_hash_set(HX_MAP_THIS,key,value); }
+  template<typename V>
+  inline void set(String key, const ::cpp::Function<V> &value) {__string_hash_set(HX_MAP_THIS,key,(Dynamic)value ); }
+  template<typename V>
+  inline void set(String key, const ::cpp::Pointer<V> &value) {__string_hash_set(HX_MAP_THIS,key,(Dynamic)value ); }
+
+  template<typename VALUE>
+  inline void set(Dynamic &key, const VALUE &value) { set( (String)key, value ); }
+
+  inline bool get_bool(String key) { return __string_hash_get_bool(h,key); }
+  inline int get_int(String key) { return __string_hash_get_int(h,key); }
+  inline Float get_float(String key) { return __string_hash_get_float(h,key); }
+  inline String get_string(String key) { return __string_hash_get_string(h,key); }
+  inline cpp::Int64 get_int64(String key) { return __string_hash_get_int64(h,key); }
+
+};
+
+} // end namespace haxe
+} // end namespace ds
+
+#endif /* INCLUDED_haxe_ds_StringMap */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/ds/TreeNode.h b/Sources/c_snikket/iinclude/include/haxe/ds/TreeNode.h
new file mode 100644
index 0000000..9eb45af
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/ds/TreeNode.h
@@ -0,0 +1,119 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_ds_TreeNode
+#define INCLUDED_haxe_ds_TreeNode
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_bd32df1abf02b23a_252_new)
+HX_DECLARE_CLASS2(haxe,ds,TreeNode)
+
+namespace haxe{
+namespace ds{
+
+
+class HXCPP_CLASS_ATTRIBUTES TreeNode_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef TreeNode_obj OBJ_;
+		TreeNode_obj();
+
+	public:
+		enum { _hx_ClassId = 0x723fa5d5 };
+
+		void __construct( ::haxe::ds::TreeNode l, ::Dynamic k, ::Dynamic v, ::haxe::ds::TreeNode r,::hx::Null< int >  __o_h);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.ds.TreeNode")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.ds.TreeNode"); }
+
+		inline static ::hx::ObjectPtr< TreeNode_obj > __new( ::haxe::ds::TreeNode l, ::Dynamic k, ::Dynamic v, ::haxe::ds::TreeNode r,::hx::Null< int >  __o_h) {
+			::hx::ObjectPtr< TreeNode_obj > __this = new TreeNode_obj();
+			__this->__construct(l,k,v,r,__o_h);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< TreeNode_obj > __alloc(::hx::Ctx *_hx_ctx, ::haxe::ds::TreeNode l, ::Dynamic k, ::Dynamic v, ::haxe::ds::TreeNode r,::hx::Null< int >  __o_h) {
+			TreeNode_obj *__this = (TreeNode_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(TreeNode_obj), true, "haxe.ds.TreeNode"));
+			*(void **)__this = TreeNode_obj::_hx_vtable;
+{
+            		int h = __o_h.Default(-1);
+            	HX_STACKFRAME(&_hx_pos_bd32df1abf02b23a_252_new)
+HXLINE( 253)		( ( ::haxe::ds::TreeNode)(__this) )->left = l;
+HXLINE( 254)		( ( ::haxe::ds::TreeNode)(__this) )->key = k;
+HXLINE( 255)		( ( ::haxe::ds::TreeNode)(__this) )->value = v;
+HXLINE( 256)		( ( ::haxe::ds::TreeNode)(__this) )->right = r;
+HXLINE( 257)		if ((h == -1)) {
+HXLINE( 258)			int _hx_tmp;
+HXDLIN( 258)			 ::haxe::ds::TreeNode _this = ( ( ::haxe::ds::TreeNode)(__this) )->left;
+HXDLIN( 258)			int _hx_tmp1;
+HXDLIN( 258)			if (::hx::IsNull( _this )) {
+HXLINE( 258)				_hx_tmp1 = 0;
+            			}
+            			else {
+HXLINE( 258)				_hx_tmp1 = _this->_height;
+            			}
+HXDLIN( 258)			 ::haxe::ds::TreeNode _this1 = ( ( ::haxe::ds::TreeNode)(__this) )->right;
+HXDLIN( 258)			int _hx_tmp2;
+HXDLIN( 258)			if (::hx::IsNull( _this1 )) {
+HXLINE( 258)				_hx_tmp2 = 0;
+            			}
+            			else {
+HXLINE( 258)				_hx_tmp2 = _this1->_height;
+            			}
+HXDLIN( 258)			if ((_hx_tmp1 > _hx_tmp2)) {
+HXLINE( 258)				 ::haxe::ds::TreeNode _this2 = ( ( ::haxe::ds::TreeNode)(__this) )->left;
+HXDLIN( 258)				if (::hx::IsNull( _this2 )) {
+HXLINE( 258)					_hx_tmp = 0;
+            				}
+            				else {
+HXLINE( 258)					_hx_tmp = _this2->_height;
+            				}
+            			}
+            			else {
+HXLINE( 258)				 ::haxe::ds::TreeNode _this3 = ( ( ::haxe::ds::TreeNode)(__this) )->right;
+HXDLIN( 258)				if (::hx::IsNull( _this3 )) {
+HXLINE( 258)					_hx_tmp = 0;
+            				}
+            				else {
+HXLINE( 258)					_hx_tmp = _this3->_height;
+            				}
+            			}
+HXDLIN( 258)			( ( ::haxe::ds::TreeNode)(__this) )->_height = (_hx_tmp + 1);
+            		}
+            		else {
+HXLINE( 260)			( ( ::haxe::ds::TreeNode)(__this) )->_height = h;
+            		}
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~TreeNode_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("TreeNode",a0,92,83,06); }
+
+		 ::haxe::ds::TreeNode left;
+		 ::haxe::ds::TreeNode right;
+		 ::Dynamic key;
+		 ::Dynamic value;
+		int _height;
+};
+
+} // end namespace haxe
+} // end namespace ds
+
+#endif /* INCLUDED_haxe_ds_TreeNode */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/ds/_List/ListNode.h b/Sources/c_snikket/iinclude/include/haxe/ds/_List/ListNode.h
new file mode 100644
index 0000000..c8b20b9
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/ds/_List/ListNode.h
@@ -0,0 +1,74 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_ds__List_ListNode
+#define INCLUDED_haxe_ds__List_ListNode
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_d7fe8fcac3c6136e_266_new)
+HX_DECLARE_CLASS3(haxe,ds,_List,ListNode)
+
+namespace haxe{
+namespace ds{
+namespace _List{
+
+
+class HXCPP_CLASS_ATTRIBUTES ListNode_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef ListNode_obj OBJ_;
+		ListNode_obj();
+
+	public:
+		enum { _hx_ClassId = 0x567ed068 };
+
+		void __construct( ::Dynamic item, ::haxe::ds::_List::ListNode next);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.ds._List.ListNode")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.ds._List.ListNode"); }
+
+		inline static ::hx::ObjectPtr< ListNode_obj > __new( ::Dynamic item, ::haxe::ds::_List::ListNode next) {
+			::hx::ObjectPtr< ListNode_obj > __this = new ListNode_obj();
+			__this->__construct(item,next);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< ListNode_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic item, ::haxe::ds::_List::ListNode next) {
+			ListNode_obj *__this = (ListNode_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(ListNode_obj), true, "haxe.ds._List.ListNode"));
+			*(void **)__this = ListNode_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_d7fe8fcac3c6136e_266_new)
+HXLINE( 267)		( ( ::haxe::ds::_List::ListNode)(__this) )->item = item;
+HXLINE( 268)		( ( ::haxe::ds::_List::ListNode)(__this) )->next = next;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ListNode_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ListNode",a0,95,b0,02); }
+
+		 ::Dynamic item;
+		 ::haxe::ds::_List::ListNode next;
+};
+
+} // end namespace haxe
+} // end namespace ds
+} // end namespace _List
+
+#endif /* INCLUDED_haxe_ds__List_ListNode */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/exceptions/NotImplementedException.h b/Sources/c_snikket/iinclude/include/haxe/exceptions/NotImplementedException.h
new file mode 100644
index 0000000..8af474a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/exceptions/NotImplementedException.h
@@ -0,0 +1,71 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_exceptions_NotImplementedException
+#define INCLUDED_haxe_exceptions_NotImplementedException
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_exceptions_PosException
+#include <haxe/exceptions/PosException.h>
+#endif
+HX_DECLARE_STACK_FRAME(_hx_pos_6becf3ac06fb2a12_8_new)
+HX_DECLARE_CLASS1(haxe,Exception)
+HX_DECLARE_CLASS2(haxe,exceptions,NotImplementedException)
+HX_DECLARE_CLASS2(haxe,exceptions,PosException)
+
+namespace haxe{
+namespace exceptions{
+
+
+class HXCPP_CLASS_ATTRIBUTES NotImplementedException_obj : public  ::haxe::exceptions::PosException_obj
+{
+	public:
+		typedef  ::haxe::exceptions::PosException_obj super;
+		typedef NotImplementedException_obj OBJ_;
+		NotImplementedException_obj();
+
+	public:
+		enum { _hx_ClassId = 0x081bdbd6 };
+
+		void __construct(::String __o_message, ::haxe::Exception previous, ::Dynamic pos);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.exceptions.NotImplementedException")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.exceptions.NotImplementedException"); }
+
+		inline static ::hx::ObjectPtr< NotImplementedException_obj > __new(::String __o_message, ::haxe::Exception previous, ::Dynamic pos) {
+			::hx::ObjectPtr< NotImplementedException_obj > __this = new NotImplementedException_obj();
+			__this->__construct(__o_message,previous,pos);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< NotImplementedException_obj > __alloc(::hx::Ctx *_hx_ctx,::String __o_message, ::haxe::Exception previous, ::Dynamic pos) {
+			NotImplementedException_obj *__this = (NotImplementedException_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(NotImplementedException_obj), true, "haxe.exceptions.NotImplementedException"));
+			*(void **)__this = NotImplementedException_obj::_hx_vtable;
+{
+            		::String message = __o_message;
+            		if (::hx::IsNull(__o_message)) message = HX_("Not implemented",15,1e,32,34);
+            	HX_STACKFRAME(&_hx_pos_6becf3ac06fb2a12_8_new)
+HXDLIN(   8)		__this->super::__construct(message,previous,pos);
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~NotImplementedException_obj();
+
+		HX_DO_RTTI_ALL;
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("NotImplementedException",c0,57,2c,4a); }
+
+};
+
+} // end namespace haxe
+} // end namespace exceptions
+
+#endif /* INCLUDED_haxe_exceptions_NotImplementedException */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/exceptions/PosException.h b/Sources/c_snikket/iinclude/include/haxe/exceptions/PosException.h
new file mode 100644
index 0000000..df1f2b8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/exceptions/PosException.h
@@ -0,0 +1,82 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_exceptions_PosException
+#define INCLUDED_haxe_exceptions_PosException
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_Exception
+#include <haxe/Exception.h>
+#endif
+HX_DECLARE_STACK_FRAME(_hx_pos_9487fa79a58895e3_12_new)
+HX_DECLARE_CLASS1(haxe,Exception)
+HX_DECLARE_CLASS2(haxe,exceptions,PosException)
+
+namespace haxe{
+namespace exceptions{
+
+
+class HXCPP_CLASS_ATTRIBUTES PosException_obj : public  ::haxe::Exception_obj
+{
+	public:
+		typedef  ::haxe::Exception_obj super;
+		typedef PosException_obj OBJ_;
+		PosException_obj();
+
+	public:
+		enum { _hx_ClassId = 0x65f7252d };
+
+		void __construct(::String message, ::haxe::Exception previous, ::Dynamic pos);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.exceptions.PosException")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.exceptions.PosException"); }
+
+		inline static ::hx::ObjectPtr< PosException_obj > __new(::String message, ::haxe::Exception previous, ::Dynamic pos) {
+			::hx::ObjectPtr< PosException_obj > __this = new PosException_obj();
+			__this->__construct(message,previous,pos);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< PosException_obj > __alloc(::hx::Ctx *_hx_ctx,::String message, ::haxe::Exception previous, ::Dynamic pos) {
+			PosException_obj *__this = (PosException_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(PosException_obj), true, "haxe.exceptions.PosException"));
+			*(void **)__this = PosException_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_9487fa79a58895e3_12_new)
+HXLINE(  13)		__this->super::__construct(message,previous,null());
+HXLINE(  14)		if (::hx::IsNull( pos )) {
+HXLINE(  15)			( ( ::haxe::exceptions::PosException)(__this) )->posInfos = ::hx::SourceInfo(HX_("(unknown)",87,5d,fc,5f),0,HX_("(unknown)",87,5d,fc,5f),HX_("(unknown)",87,5d,fc,5f));
+            		}
+            		else {
+HXLINE(  17)			( ( ::haxe::exceptions::PosException)(__this) )->posInfos = pos;
+            		}
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~PosException_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("PosException",3b,8c,23,b9); }
+
+		 ::Dynamic posInfos;
+		virtual ::String toString();
+
+};
+
+} // end namespace haxe
+} // end namespace exceptions
+
+#endif /* INCLUDED_haxe_exceptions_PosException */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/format/JsonParser.h b/Sources/c_snikket/iinclude/include/haxe/format/JsonParser.h
new file mode 100644
index 0000000..be8707a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/format/JsonParser.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_format_JsonParser
+#define INCLUDED_haxe_format_JsonParser
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,format,JsonParser)
+
+namespace haxe{
+namespace format{
+
+
+class HXCPP_CLASS_ATTRIBUTES JsonParser_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef JsonParser_obj OBJ_;
+		JsonParser_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0ae51690 };
+
+		void __construct(::String str);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.format.JsonParser")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.format.JsonParser"); }
+		static ::hx::ObjectPtr< JsonParser_obj > __new(::String str);
+		static ::hx::ObjectPtr< JsonParser_obj > __alloc(::hx::Ctx *_hx_ctx,::String str);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~JsonParser_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("JsonParser",47,65,2e,25); }
+
+		::String str;
+		int pos;
+		 ::Dynamic doParse();
+		::Dynamic doParse_dyn();
+
+		 ::Dynamic parseRec();
+		::Dynamic parseRec_dyn();
+
+		::String parseString();
+		::Dynamic parseString_dyn();
+
+		void invalidChar();
+		::Dynamic invalidChar_dyn();
+
+		void invalidNumber(int start);
+		::Dynamic invalidNumber_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace format
+
+#endif /* INCLUDED_haxe_format_JsonParser */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/format/JsonPrinter.h b/Sources/c_snikket/iinclude/include/haxe/format/JsonPrinter.h
new file mode 100644
index 0000000..4ac12b9
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/format/JsonPrinter.h
@@ -0,0 +1,75 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_format_JsonPrinter
+#define INCLUDED_haxe_format_JsonPrinter
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(StringBuf)
+HX_DECLARE_CLASS2(haxe,format,JsonPrinter)
+
+namespace haxe{
+namespace format{
+
+
+class HXCPP_CLASS_ATTRIBUTES JsonPrinter_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef JsonPrinter_obj OBJ_;
+		JsonPrinter_obj();
+
+	public:
+		enum { _hx_ClassId = 0x385642d1 };
+
+		void __construct( ::Dynamic replacer,::String space);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.format.JsonPrinter")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.format.JsonPrinter"); }
+		static ::hx::ObjectPtr< JsonPrinter_obj > __new( ::Dynamic replacer,::String space);
+		static ::hx::ObjectPtr< JsonPrinter_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic replacer,::String space);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~JsonPrinter_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("JsonPrinter",72,68,9d,fd); }
+
+		static ::String print( ::Dynamic o, ::Dynamic replacer,::String space);
+		static ::Dynamic print_dyn();
+
+		 ::StringBuf buf;
+		 ::Dynamic replacer;
+		Dynamic replacer_dyn() { return replacer;}
+		::String indent;
+		bool pretty;
+		int nind;
+		void write( ::Dynamic k, ::Dynamic v);
+		::Dynamic write_dyn();
+
+		void classString( ::Dynamic v);
+		::Dynamic classString_dyn();
+
+		void fieldsString( ::Dynamic v,::Array< ::String > fields);
+		::Dynamic fieldsString_dyn();
+
+		void quote(::String s);
+		::Dynamic quote_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace format
+
+#endif /* INCLUDED_haxe_format_JsonPrinter */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/http/HttpBase.h b/Sources/c_snikket/iinclude/include/haxe/http/HttpBase.h
new file mode 100644
index 0000000..fb9bfeb
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/http/HttpBase.h
@@ -0,0 +1,90 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_http_HttpBase
+#define INCLUDED_haxe_http_HttpBase
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,http,HttpBase)
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+
+namespace haxe{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES HttpBase_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef HttpBase_obj OBJ_;
+		HttpBase_obj();
+
+	public:
+		enum { _hx_ClassId = 0x10c0921f };
+
+		void __construct(::String url);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.http.HttpBase")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.http.HttpBase"); }
+		static ::hx::ObjectPtr< HttpBase_obj > __new(::String url);
+		static ::hx::ObjectPtr< HttpBase_obj > __alloc(::hx::Ctx *_hx_ctx,::String url);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		static void __alloc_dynamic_functions(::hx::Ctx *_hx_alloc,HttpBase_obj *_hx_obj);
+		//~HttpBase_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HttpBase",d9,cf,1a,f8); }
+
+		::String url;
+		 ::haxe::io::Bytes responseBytes;
+		::String responseAsString;
+		::String postData;
+		 ::haxe::io::Bytes postBytes;
+		::Array< ::Dynamic> headers;
+		::Array< ::Dynamic> params;
+		 ::Dynamic emptyOnData;
+		Dynamic emptyOnData_dyn() { return emptyOnData;}
+		void setHeader(::String name,::String value);
+		::Dynamic setHeader_dyn();
+
+		void setPostData(::String data);
+		::Dynamic setPostData_dyn();
+
+		::Dynamic onData;
+		inline ::Dynamic &onData_dyn() {return onData; }
+
+		::Dynamic onBytes;
+		inline ::Dynamic &onBytes_dyn() {return onBytes; }
+
+		::Dynamic onError;
+		inline ::Dynamic &onError_dyn() {return onError; }
+
+		::Dynamic onStatus;
+		inline ::Dynamic &onStatus_dyn() {return onStatus; }
+
+		bool hasOnData();
+		::Dynamic hasOnData_dyn();
+
+		void success( ::haxe::io::Bytes data);
+		::Dynamic success_dyn();
+
+		::String get_responseData();
+		::Dynamic get_responseData_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace http
+
+#endif /* INCLUDED_haxe_http_HttpBase */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/io/Bytes.h b/Sources/c_snikket/iinclude/include/haxe/io/Bytes.h
new file mode 100644
index 0000000..49850b2
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/io/Bytes.h
@@ -0,0 +1,86 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_io_Bytes
+#define INCLUDED_haxe_io_Bytes
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Encoding)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES Bytes_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Bytes_obj OBJ_;
+		Bytes_obj();
+
+	public:
+		enum { _hx_ClassId = 0x195c64b7 };
+
+		void __construct(int length,::Array< unsigned char > b);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.io.Bytes")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.io.Bytes"); }
+		static ::hx::ObjectPtr< Bytes_obj > __new(int length,::Array< unsigned char > b);
+		static ::hx::ObjectPtr< Bytes_obj > __alloc(::hx::Ctx *_hx_ctx,int length,::Array< unsigned char > b);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Bytes_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Bytes",4b,78,c5,50); }
+
+		static  ::haxe::io::Bytes alloc(int length);
+		static ::Dynamic alloc_dyn();
+
+		static  ::haxe::io::Bytes ofString(::String s, ::haxe::io::Encoding encoding);
+		static ::Dynamic ofString_dyn();
+
+		static  ::haxe::io::Bytes ofData(::Array< unsigned char > b);
+		static ::Dynamic ofData_dyn();
+
+		static  ::haxe::io::Bytes ofHex(::String s);
+		static ::Dynamic ofHex_dyn();
+
+		int length;
+		::Array< unsigned char > b;
+		void blit(int pos, ::haxe::io::Bytes src,int srcpos,int len);
+		::Dynamic blit_dyn();
+
+		void fill(int pos,int len,int value);
+		::Dynamic fill_dyn();
+
+		 ::haxe::io::Bytes sub(int pos,int len);
+		::Dynamic sub_dyn();
+
+		::String getString(int pos,int len, ::haxe::io::Encoding encoding);
+		::Dynamic getString_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+		::String toHex();
+		::Dynamic toHex_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Bytes */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/io/BytesBuffer.h b/Sources/c_snikket/iinclude/include/haxe/io/BytesBuffer.h
new file mode 100644
index 0000000..531cf7a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/io/BytesBuffer.h
@@ -0,0 +1,57 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_io_BytesBuffer
+#define INCLUDED_haxe_io_BytesBuffer
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,BytesBuffer)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES BytesBuffer_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef BytesBuffer_obj OBJ_;
+		BytesBuffer_obj();
+
+	public:
+		enum { _hx_ClassId = 0x183160df };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.io.BytesBuffer")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.io.BytesBuffer"); }
+		static ::hx::ObjectPtr< BytesBuffer_obj > __new();
+		static ::hx::ObjectPtr< BytesBuffer_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~BytesBuffer_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("BytesBuffer",ab,73,22,f6); }
+
+		::Array< unsigned char > b;
+		 ::haxe::io::Bytes getBytes();
+		::Dynamic getBytes_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_BytesBuffer */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/io/BytesInput.h b/Sources/c_snikket/iinclude/include/haxe/io/BytesInput.h
new file mode 100644
index 0000000..4385c8d
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/io/BytesInput.h
@@ -0,0 +1,65 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_io_BytesInput
+#define INCLUDED_haxe_io_BytesInput
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_io_Input
+#include <haxe/io/Input.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,BytesInput)
+HX_DECLARE_CLASS2(haxe,io,Input)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES BytesInput_obj : public  ::haxe::io::Input_obj
+{
+	public:
+		typedef  ::haxe::io::Input_obj super;
+		typedef BytesInput_obj OBJ_;
+		BytesInput_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7e26810b };
+
+		void __construct( ::haxe::io::Bytes b, ::Dynamic pos, ::Dynamic len);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.io.BytesInput")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.io.BytesInput"); }
+		static ::hx::ObjectPtr< BytesInput_obj > __new( ::haxe::io::Bytes b, ::Dynamic pos, ::Dynamic len);
+		static ::hx::ObjectPtr< BytesInput_obj > __alloc(::hx::Ctx *_hx_ctx, ::haxe::io::Bytes b, ::Dynamic pos, ::Dynamic len);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~BytesInput_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("BytesInput",bf,cb,76,e6); }
+
+		::Array< unsigned char > b;
+		int pos;
+		int len;
+		int totlen;
+		int readByte();
+
+		int readBytes( ::haxe::io::Bytes buf,int pos,int len);
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_BytesInput */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/io/BytesOutput.h b/Sources/c_snikket/iinclude/include/haxe/io/BytesOutput.h
new file mode 100644
index 0000000..15fc989
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/io/BytesOutput.h
@@ -0,0 +1,66 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_io_BytesOutput
+#define INCLUDED_haxe_io_BytesOutput
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_io_Output
+#include <haxe/io/Output.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,BytesBuffer)
+HX_DECLARE_CLASS2(haxe,io,BytesOutput)
+HX_DECLARE_CLASS2(haxe,io,Output)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES BytesOutput_obj : public  ::haxe::io::Output_obj
+{
+	public:
+		typedef  ::haxe::io::Output_obj super;
+		typedef BytesOutput_obj OBJ_;
+		BytesOutput_obj();
+
+	public:
+		enum { _hx_ClassId = 0x541db2e0 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.io.BytesOutput")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.io.BytesOutput"); }
+		static ::hx::ObjectPtr< BytesOutput_obj > __new();
+		static ::hx::ObjectPtr< BytesOutput_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~BytesOutput_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("BytesOutput",ac,c5,0e,32); }
+
+		 ::haxe::io::BytesBuffer b;
+		void writeByte(int c);
+
+		int writeBytes( ::haxe::io::Bytes buf,int pos,int len);
+
+		 ::haxe::io::Bytes getBytes();
+		::Dynamic getBytes_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_BytesOutput */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/io/Encoding.h b/Sources/c_snikket/iinclude/include/haxe/io/Encoding.h
new file mode 100644
index 0000000..2103145
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/io/Encoding.h
@@ -0,0 +1,37 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_io_Encoding
+#define INCLUDED_haxe_io_Encoding
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Encoding)
+namespace haxe{
+namespace io{
+
+
+class Encoding_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef Encoding_obj OBJ_;
+
+	public:
+		Encoding_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("haxe.io.Encoding",33,a6,6d,22); }
+		::String __ToString() const { return HX_("Encoding.",db,8b,f5,be) + _hx_tag; }
+
+		static ::haxe::io::Encoding RawNative;
+		static inline ::haxe::io::Encoding RawNative_dyn() { return RawNative; }
+		static ::haxe::io::Encoding UTF8;
+		static inline ::haxe::io::Encoding UTF8_dyn() { return UTF8; }
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Encoding */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/io/Eof.h b/Sources/c_snikket/iinclude/include/haxe/io/Eof.h
new file mode 100644
index 0000000..4daee4e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/io/Eof.h
@@ -0,0 +1,67 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_io_Eof
+#define INCLUDED_haxe_io_Eof
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_c4f7e3feda612c90_29_new)
+HX_DECLARE_CLASS2(haxe,io,Eof)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES Eof_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Eof_obj OBJ_;
+		Eof_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1d7955d0 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.io.Eof")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"haxe.io.Eof"); }
+
+		inline static ::hx::ObjectPtr< Eof_obj > __new() {
+			::hx::ObjectPtr< Eof_obj > __this = new Eof_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Eof_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Eof_obj *__this = (Eof_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Eof_obj), false, "haxe.io.Eof"));
+			*(void **)__this = Eof_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_c4f7e3feda612c90_29_new)
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Eof_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Eof",9c,bc,34,00); }
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Eof */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/io/Error.h b/Sources/c_snikket/iinclude/include/haxe/io/Error.h
new file mode 100644
index 0000000..83aadc4
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/io/Error.h
@@ -0,0 +1,41 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_io_Error
+#define INCLUDED_haxe_io_Error
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Error)
+namespace haxe{
+namespace io{
+
+
+class Error_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef Error_obj OBJ_;
+
+	public:
+		Error_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("haxe.io.Error",68,16,01,55); }
+		::String __ToString() const { return HX_("Error.",86,f7,fc,85) + _hx_tag; }
+
+		static ::haxe::io::Error Blocked;
+		static inline ::haxe::io::Error Blocked_dyn() { return Blocked; }
+		static ::haxe::io::Error Custom( ::Dynamic e);
+		static ::Dynamic Custom_dyn();
+		static ::haxe::io::Error OutsideBounds;
+		static inline ::haxe::io::Error OutsideBounds_dyn() { return OutsideBounds; }
+		static ::haxe::io::Error Overflow;
+		static inline ::haxe::io::Error Overflow_dyn() { return Overflow; }
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Error */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/io/Input.h b/Sources/c_snikket/iinclude/include/haxe/io/Input.h
new file mode 100644
index 0000000..8e88cce
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/io/Input.h
@@ -0,0 +1,81 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_io_Input
+#define INCLUDED_haxe_io_Input
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Input)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES Input_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Input_obj OBJ_;
+		Input_obj();
+
+	public:
+		enum { _hx_ClassId = 0x19e22056 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.io.Input")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"haxe.io.Input"); }
+
+		inline static ::hx::ObjectPtr< Input_obj > __new() {
+			::hx::ObjectPtr< Input_obj > __this = new Input_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Input_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Input_obj *__this = (Input_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Input_obj), false, "haxe.io.Input"));
+			*(void **)__this = Input_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Input_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Input",ea,33,4b,51); }
+
+		bool bigEndian;
+		virtual int readByte();
+		::Dynamic readByte_dyn();
+
+		virtual int readBytes( ::haxe::io::Bytes s,int pos,int len);
+		::Dynamic readBytes_dyn();
+
+		virtual void close();
+		::Dynamic close_dyn();
+
+		bool set_bigEndian(bool b);
+		::Dynamic set_bigEndian_dyn();
+
+		 ::haxe::io::Bytes readAll( ::Dynamic bufsize);
+		::Dynamic readAll_dyn();
+
+		int readInt32();
+		::Dynamic readInt32_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Input */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/io/Output.h b/Sources/c_snikket/iinclude/include/haxe/io/Output.h
new file mode 100644
index 0000000..7fc6dc3
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/io/Output.h
@@ -0,0 +1,82 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_io_Output
+#define INCLUDED_haxe_io_Output
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Encoding)
+HX_DECLARE_CLASS2(haxe,io,Output)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES Output_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Output_obj OBJ_;
+		Output_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0a55a26d };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.io.Output")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"haxe.io.Output"); }
+
+		inline static ::hx::ObjectPtr< Output_obj > __new() {
+			::hx::ObjectPtr< Output_obj > __this = new Output_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Output_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Output_obj *__this = (Output_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Output_obj), false, "haxe.io.Output"));
+			*(void **)__this = Output_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Output_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Output",21,83,15,41); }
+
+		virtual void writeByte(int c);
+		::Dynamic writeByte_dyn();
+
+		virtual int writeBytes( ::haxe::io::Bytes s,int pos,int len);
+		::Dynamic writeBytes_dyn();
+
+		virtual void close();
+		::Dynamic close_dyn();
+
+		void write( ::haxe::io::Bytes s);
+		::Dynamic write_dyn();
+
+		void writeFullBytes( ::haxe::io::Bytes s,int pos,int len);
+		::Dynamic writeFullBytes_dyn();
+
+		void prepare(int nbytes);
+		::Dynamic prepare_dyn();
+
+		void writeString(::String s, ::haxe::io::Encoding encoding);
+		::Dynamic writeString_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Output */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/io/Path.h b/Sources/c_snikket/iinclude/include/haxe/io/Path.h
new file mode 100644
index 0000000..c3b75d8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/io/Path.h
@@ -0,0 +1,78 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_io_Path
+#define INCLUDED_haxe_io_Path
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Path)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES Path_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Path_obj OBJ_;
+		Path_obj();
+
+	public:
+		enum { _hx_ClassId = 0x026896d9 };
+
+		void __construct(::String path);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.io.Path")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.io.Path"); }
+		static ::hx::ObjectPtr< Path_obj > __new(::String path);
+		static ::hx::ObjectPtr< Path_obj > __alloc(::hx::Ctx *_hx_ctx,::String path);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Path_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Path",c5,11,2b,35); }
+
+		static ::String withoutDirectory(::String path);
+		static ::Dynamic withoutDirectory_dyn();
+
+		static ::String join(::Array< ::String > paths);
+		static ::Dynamic join_dyn();
+
+		static ::String normalize(::String path);
+		static ::Dynamic normalize_dyn();
+
+		static ::String addTrailingSlash(::String path);
+		static ::Dynamic addTrailingSlash_dyn();
+
+		static ::String removeTrailingSlashes(::String path);
+		static ::Dynamic removeTrailingSlashes_dyn();
+
+		static bool isAbsolute(::String path);
+		static ::Dynamic isAbsolute_dyn();
+
+		::String dir;
+		::String file;
+		::String ext;
+		bool backslash;
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Path */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/iterators/ArrayIterator.h b/Sources/c_snikket/iinclude/include/haxe/iterators/ArrayIterator.h
new file mode 100644
index 0000000..15325b9
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/iterators/ArrayIterator.h
@@ -0,0 +1,78 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_iterators_ArrayIterator
+#define INCLUDED_haxe_iterators_ArrayIterator
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_44ded26575b0f4de_28_new)
+HX_DECLARE_CLASS2(haxe,iterators,ArrayIterator)
+
+namespace haxe{
+namespace iterators{
+
+
+class HXCPP_CLASS_ATTRIBUTES ArrayIterator_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef ArrayIterator_obj OBJ_;
+		ArrayIterator_obj();
+
+	public:
+		enum { _hx_ClassId = 0x189859c8 };
+
+		void __construct(::cpp::VirtualArray array);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.iterators.ArrayIterator")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.iterators.ArrayIterator"); }
+
+		inline static ::hx::ObjectPtr< ArrayIterator_obj > __new(::cpp::VirtualArray array) {
+			::hx::ObjectPtr< ArrayIterator_obj > __this = new ArrayIterator_obj();
+			__this->__construct(array);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< ArrayIterator_obj > __alloc(::hx::Ctx *_hx_ctx,::cpp::VirtualArray array) {
+			ArrayIterator_obj *__this = (ArrayIterator_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(ArrayIterator_obj), true, "haxe.iterators.ArrayIterator"));
+			*(void **)__this = ArrayIterator_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_44ded26575b0f4de_28_new)
+HXLINE(  30)		( ( ::haxe::iterators::ArrayIterator)(__this) )->current = 0;
+HXLINE(  37)		( ( ::haxe::iterators::ArrayIterator)(__this) )->array = array;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ArrayIterator_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ArrayIterator",87,84,c8,5d); }
+
+		::cpp::VirtualArray array;
+		int current;
+		bool hasNext();
+		::Dynamic hasNext_dyn();
+
+		 ::Dynamic next();
+		::Dynamic next_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace iterators
+
+#endif /* INCLUDED_haxe_iterators_ArrayIterator */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/iterators/MapKeyValueIterator.h b/Sources/c_snikket/iinclude/include/haxe/iterators/MapKeyValueIterator.h
new file mode 100644
index 0000000..22cf306
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/iterators/MapKeyValueIterator.h
@@ -0,0 +1,61 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_iterators_MapKeyValueIterator
+#define INCLUDED_haxe_iterators_MapKeyValueIterator
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,iterators,MapKeyValueIterator)
+
+namespace haxe{
+namespace iterators{
+
+
+class HXCPP_CLASS_ATTRIBUTES MapKeyValueIterator_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef MapKeyValueIterator_obj OBJ_;
+		MapKeyValueIterator_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5732dffd };
+
+		void __construct(::Dynamic map);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.iterators.MapKeyValueIterator")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.iterators.MapKeyValueIterator"); }
+		static ::hx::ObjectPtr< MapKeyValueIterator_obj > __new(::Dynamic map);
+		static ::hx::ObjectPtr< MapKeyValueIterator_obj > __alloc(::hx::Ctx *_hx_ctx,::Dynamic map);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~MapKeyValueIterator_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("MapKeyValueIterator",fc,23,62,2c); }
+
+		::Dynamic map;
+		 ::Dynamic keys;
+		bool hasNext();
+		::Dynamic hasNext_dyn();
+
+		 ::Dynamic next();
+		::Dynamic next_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace iterators
+
+#endif /* INCLUDED_haxe_iterators_MapKeyValueIterator */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/xml/Parser.h b/Sources/c_snikket/iinclude/include/haxe/xml/Parser.h
new file mode 100644
index 0000000..b6ef3d6
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/xml/Parser.h
@@ -0,0 +1,71 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_xml_Parser
+#define INCLUDED_haxe_xml_Parser
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(Xml)
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS2(haxe,xml,Parser)
+
+namespace haxe{
+namespace xml{
+
+
+class HXCPP_CLASS_ATTRIBUTES Parser_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Parser_obj OBJ_;
+		Parser_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1c6f1730 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.xml.Parser")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"haxe.xml.Parser"); }
+
+		inline static ::hx::ObjectPtr< Parser_obj > __new() {
+			::hx::ObjectPtr< Parser_obj > __this = new Parser_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Parser_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Parser_obj *__this = (Parser_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Parser_obj), false, "haxe.xml.Parser"));
+			*(void **)__this = Parser_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Parser_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Parser",ff,10,1d,22); }
+
+		static void __boot();
+		static  ::haxe::ds::StringMap escapes;
+		static  ::Xml parse(::String str,::hx::Null< bool >  strict);
+		static ::Dynamic parse_dyn();
+
+		static int doParse(::String str,bool strict,::hx::Null< int >  p, ::Xml parent);
+		static ::Dynamic doParse_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace xml
+
+#endif /* INCLUDED_haxe_xml_Parser */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/xml/Printer.h b/Sources/c_snikket/iinclude/include/haxe/xml/Printer.h
new file mode 100644
index 0000000..5b159a1
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/xml/Printer.h
@@ -0,0 +1,66 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_xml_Printer
+#define INCLUDED_haxe_xml_Printer
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(StringBuf)
+HX_DECLARE_CLASS0(Xml)
+HX_DECLARE_CLASS2(haxe,xml,Printer)
+
+namespace haxe{
+namespace xml{
+
+
+class HXCPP_CLASS_ATTRIBUTES Printer_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Printer_obj OBJ_;
+		Printer_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5ef86269 };
+
+		void __construct(bool pretty);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.xml.Printer")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.xml.Printer"); }
+		static ::hx::ObjectPtr< Printer_obj > __new(bool pretty);
+		static ::hx::ObjectPtr< Printer_obj > __alloc(::hx::Ctx *_hx_ctx,bool pretty);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Printer_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Printer",ba,fd,84,51); }
+
+		static ::String print( ::Xml xml, ::Dynamic pretty);
+		static ::Dynamic print_dyn();
+
+		 ::StringBuf output;
+		bool pretty;
+		void writeNode( ::Xml value,::String tabs);
+		::Dynamic writeNode_dyn();
+
+		bool hasChildren( ::Xml value);
+		::Dynamic hasChildren_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace xml
+
+#endif /* INCLUDED_haxe_xml_Printer */ 
diff --git a/Sources/c_snikket/iinclude/include/haxe/xml/XmlParserException.h b/Sources/c_snikket/iinclude/include/haxe/xml/XmlParserException.h
new file mode 100644
index 0000000..a842951
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/haxe/xml/XmlParserException.h
@@ -0,0 +1,60 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_haxe_xml_XmlParserException
+#define INCLUDED_haxe_xml_XmlParserException
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,xml,XmlParserException)
+
+namespace haxe{
+namespace xml{
+
+
+class HXCPP_CLASS_ATTRIBUTES XmlParserException_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef XmlParserException_obj OBJ_;
+		XmlParserException_obj();
+
+	public:
+		enum { _hx_ClassId = 0x75f2332a };
+
+		void __construct(::String message,::String xml,int position);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.xml.XmlParserException")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"haxe.xml.XmlParserException"); }
+		static ::hx::ObjectPtr< XmlParserException_obj > __new(::String message,::String xml,int position);
+		static ::hx::ObjectPtr< XmlParserException_obj > __alloc(::hx::Ctx *_hx_ctx,::String message,::String xml,int position);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~XmlParserException_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("XmlParserException",79,27,d7,6b); }
+
+		::String message;
+		int lineNumber;
+		int positionAtLine;
+		int position;
+		::String xml;
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace xml
+
+#endif /* INCLUDED_haxe_xml_XmlParserException */ 
diff --git a/Sources/c_snikket/iinclude/include/hsluv/Hsluv.h b/Sources/c_snikket/iinclude/include/hsluv/Hsluv.h
new file mode 100644
index 0000000..f90390a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/hsluv/Hsluv.h
@@ -0,0 +1,138 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_hsluv_Hsluv
+#define INCLUDED_hsluv_Hsluv
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(hsluv,Hsluv)
+
+namespace hsluv{
+
+
+class HXCPP_CLASS_ATTRIBUTES Hsluv_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Hsluv_obj OBJ_;
+		Hsluv_obj();
+
+	public:
+		enum { _hx_ClassId = 0x29e47ee8 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="hsluv.Hsluv")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"hsluv.Hsluv"); }
+		static ::hx::ObjectPtr< Hsluv_obj > __new();
+		static ::hx::ObjectPtr< Hsluv_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Hsluv_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Hsluv",82,a7,2f,c1); }
+
+		static void __boot();
+		static ::String hexChars;
+		static Float refY;
+		static Float refU;
+		static Float refV;
+		static Float kappa;
+		static Float epsilon;
+		static Float m_r0;
+		static Float m_r1;
+		static Float m_r2;
+		static Float m_g0;
+		static Float m_g1;
+		static Float m_g2;
+		static Float m_b0;
+		static Float m_b1;
+		static Float m_b2;
+		static Float fromLinear(Float c);
+		static ::Dynamic fromLinear_dyn();
+
+		static Float lToY(Float L);
+		static ::Dynamic lToY_dyn();
+
+		static ::String rgbChannelToHex(Float chan);
+		static ::Dynamic rgbChannelToHex_dyn();
+
+		static Float distanceFromOriginAngle(Float slope,Float intercept,Float angle);
+		static ::Dynamic distanceFromOriginAngle_dyn();
+
+		static Float min6(Float f1,Float f2,Float f3,Float f4,Float f5,Float f6);
+		static ::Dynamic min6_dyn();
+
+		::String hex;
+		Float rgb_r;
+		Float rgb_g;
+		Float rgb_b;
+		Float xyz_x;
+		Float xyz_y;
+		Float xyz_z;
+		Float luv_l;
+		Float luv_u;
+		Float luv_v;
+		Float lch_l;
+		Float lch_c;
+		Float lch_h;
+		Float hsluv_h;
+		Float hsluv_s;
+		Float hsluv_l;
+		Float r0s;
+		Float r0i;
+		Float r1s;
+		Float r1i;
+		Float g0s;
+		Float g0i;
+		Float g1s;
+		Float g1i;
+		Float b0s;
+		Float b0i;
+		Float b1s;
+		Float b1i;
+		void rgbToHex();
+		::Dynamic rgbToHex_dyn();
+
+		void xyzToRgb();
+		::Dynamic xyzToRgb_dyn();
+
+		void luvToXyz();
+		::Dynamic luvToXyz_dyn();
+
+		void lchToLuv();
+		::Dynamic lchToLuv_dyn();
+
+		void calculateBoundingLines(Float l);
+		::Dynamic calculateBoundingLines_dyn();
+
+		Float calcMaxChromaHsluv(Float h);
+		::Dynamic calcMaxChromaHsluv_dyn();
+
+		void hsluvToLch();
+		::Dynamic hsluvToLch_dyn();
+
+		void hsluvToRgb();
+		::Dynamic hsluvToRgb_dyn();
+
+		void hsluvToHex();
+		::Dynamic hsluvToHex_dyn();
+
+};
+
+} // end namespace hsluv
+
+#endif /* INCLUDED_hsluv_Hsluv */ 
diff --git a/Sources/c_snikket/iinclude/include/htmlparser/HtmlAttribute.h b/Sources/c_snikket/iinclude/include/htmlparser/HtmlAttribute.h
new file mode 100644
index 0000000..f473c92
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/htmlparser/HtmlAttribute.h
@@ -0,0 +1,72 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_htmlparser_HtmlAttribute
+#define INCLUDED_htmlparser_HtmlAttribute
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_630f17b70ccedfe6_10_new)
+HX_DECLARE_CLASS1(htmlparser,HtmlAttribute)
+
+namespace htmlparser{
+
+
+class HXCPP_CLASS_ATTRIBUTES HtmlAttribute_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef HtmlAttribute_obj OBJ_;
+		HtmlAttribute_obj();
+
+	public:
+		enum { _hx_ClassId = 0x49e2a647 };
+
+		void __construct(::String name,::String value,::String quote);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="htmlparser.HtmlAttribute")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"htmlparser.HtmlAttribute"); }
+
+		inline static ::hx::ObjectPtr< HtmlAttribute_obj > __new(::String name,::String value,::String quote) {
+			::hx::ObjectPtr< HtmlAttribute_obj > __this = new HtmlAttribute_obj();
+			__this->__construct(name,value,quote);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< HtmlAttribute_obj > __alloc(::hx::Ctx *_hx_ctx,::String name,::String value,::String quote) {
+			HtmlAttribute_obj *__this = (HtmlAttribute_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(HtmlAttribute_obj), true, "htmlparser.HtmlAttribute"));
+			*(void **)__this = HtmlAttribute_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_630f17b70ccedfe6_10_new)
+HXLINE(  11)		( ( ::htmlparser::HtmlAttribute)(__this) )->name = name;
+HXLINE(  12)		( ( ::htmlparser::HtmlAttribute)(__this) )->value = value;
+HXLINE(  13)		( ( ::htmlparser::HtmlAttribute)(__this) )->quote = quote;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HtmlAttribute_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HtmlAttribute",11,85,c2,03); }
+
+		::String name;
+		::String value;
+		::String quote;
+};
+
+} // end namespace htmlparser
+
+#endif /* INCLUDED_htmlparser_HtmlAttribute */ 
diff --git a/Sources/c_snikket/iinclude/include/htmlparser/HtmlNode.h b/Sources/c_snikket/iinclude/include/htmlparser/HtmlNode.h
new file mode 100644
index 0000000..2b2ab6c
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/htmlparser/HtmlNode.h
@@ -0,0 +1,63 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_htmlparser_HtmlNode
+#define INCLUDED_htmlparser_HtmlNode
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(htmlparser,HtmlNode)
+HX_DECLARE_CLASS1(htmlparser,HtmlNodeElement)
+
+namespace htmlparser{
+
+
+class HXCPP_CLASS_ATTRIBUTES HtmlNode_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef HtmlNode_obj OBJ_;
+		HtmlNode_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0ca65a7f };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="htmlparser.HtmlNode")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"htmlparser.HtmlNode"); }
+
+		inline static ::hx::ObjectPtr< HtmlNode_obj > __new() {
+			::hx::ObjectPtr< HtmlNode_obj > __this = new HtmlNode_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< HtmlNode_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			HtmlNode_obj *__this = (HtmlNode_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(HtmlNode_obj), true, "htmlparser.HtmlNode"));
+			*(void **)__this = HtmlNode_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HtmlNode_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HtmlNode",2d,19,fa,e5); }
+
+		 ::htmlparser::HtmlNodeElement parent;
+};
+
+} // end namespace htmlparser
+
+#endif /* INCLUDED_htmlparser_HtmlNode */ 
diff --git a/Sources/c_snikket/iinclude/include/htmlparser/HtmlNodeElement.h b/Sources/c_snikket/iinclude/include/htmlparser/HtmlNodeElement.h
new file mode 100644
index 0000000..6960292
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/htmlparser/HtmlNodeElement.h
@@ -0,0 +1,62 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_htmlparser_HtmlNodeElement
+#define INCLUDED_htmlparser_HtmlNodeElement
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_htmlparser_HtmlNode
+#include <htmlparser/HtmlNode.h>
+#endif
+HX_DECLARE_CLASS1(htmlparser,HtmlAttribute)
+HX_DECLARE_CLASS1(htmlparser,HtmlNode)
+HX_DECLARE_CLASS1(htmlparser,HtmlNodeElement)
+
+namespace htmlparser{
+
+
+class HXCPP_CLASS_ATTRIBUTES HtmlNodeElement_obj : public  ::htmlparser::HtmlNode_obj
+{
+	public:
+		typedef  ::htmlparser::HtmlNode_obj super;
+		typedef HtmlNodeElement_obj OBJ_;
+		HtmlNodeElement_obj();
+
+	public:
+		enum { _hx_ClassId = 0x234247c5 };
+
+		void __construct(::String name,::Array< ::Dynamic> attributes);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="htmlparser.HtmlNodeElement")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"htmlparser.HtmlNodeElement"); }
+		static ::hx::ObjectPtr< HtmlNodeElement_obj > __new(::String name,::Array< ::Dynamic> attributes);
+		static ::hx::ObjectPtr< HtmlNodeElement_obj > __alloc(::hx::Ctx *_hx_ctx,::String name,::Array< ::Dynamic> attributes);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HtmlNodeElement_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HtmlNodeElement",0f,ed,ee,fb); }
+
+		::String name;
+		::Array< ::Dynamic> attributes;
+		::Array< ::Dynamic> nodes;
+		::Array< ::Dynamic> children;
+		void addChild( ::htmlparser::HtmlNode node, ::htmlparser::HtmlNode beforeNode);
+		::Dynamic addChild_dyn();
+
+};
+
+} // end namespace htmlparser
+
+#endif /* INCLUDED_htmlparser_HtmlNodeElement */ 
diff --git a/Sources/c_snikket/iinclude/include/htmlparser/HtmlNodeText.h b/Sources/c_snikket/iinclude/include/htmlparser/HtmlNodeText.h
new file mode 100644
index 0000000..82be3b5
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/htmlparser/HtmlNodeText.h
@@ -0,0 +1,58 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_htmlparser_HtmlNodeText
+#define INCLUDED_htmlparser_HtmlNodeText
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_htmlparser_HtmlNode
+#include <htmlparser/HtmlNode.h>
+#endif
+HX_DECLARE_CLASS1(htmlparser,HtmlNode)
+HX_DECLARE_CLASS1(htmlparser,HtmlNodeText)
+
+namespace htmlparser{
+
+
+class HXCPP_CLASS_ATTRIBUTES HtmlNodeText_obj : public  ::htmlparser::HtmlNode_obj
+{
+	public:
+		typedef  ::htmlparser::HtmlNode_obj super;
+		typedef HtmlNodeText_obj OBJ_;
+		HtmlNodeText_obj();
+
+	public:
+		enum { _hx_ClassId = 0x699e2404 };
+
+		void __construct(::String text);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="htmlparser.HtmlNodeText")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"htmlparser.HtmlNodeText"); }
+		static ::hx::ObjectPtr< HtmlNodeText_obj > __new(::String text);
+		static ::hx::ObjectPtr< HtmlNodeText_obj > __alloc(::hx::Ctx *_hx_ctx,::String text);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HtmlNodeText_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HtmlNodeText",7a,ac,55,90); }
+
+		::String text;
+		::String toText();
+		::Dynamic toText_dyn();
+
+};
+
+} // end namespace htmlparser
+
+#endif /* INCLUDED_htmlparser_HtmlNodeText */ 
diff --git a/Sources/c_snikket/iinclude/include/htmlparser/HtmlParser.h b/Sources/c_snikket/iinclude/include/htmlparser/HtmlParser.h
new file mode 100644
index 0000000..88c417e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/htmlparser/HtmlParser.h
@@ -0,0 +1,98 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_htmlparser_HtmlParser
+#define INCLUDED_htmlparser_HtmlParser
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(EReg)
+HX_DECLARE_CLASS1(htmlparser,HtmlAttribute)
+HX_DECLARE_CLASS1(htmlparser,HtmlNode)
+HX_DECLARE_CLASS1(htmlparser,HtmlNodeElement)
+HX_DECLARE_CLASS1(htmlparser,HtmlParser)
+
+namespace htmlparser{
+
+
+class HXCPP_CLASS_ATTRIBUTES HtmlParser_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef HtmlParser_obj OBJ_;
+		HtmlParser_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0d37c69c };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="htmlparser.HtmlParser")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"htmlparser.HtmlParser"); }
+		static ::hx::ObjectPtr< HtmlParser_obj > __new();
+		static ::hx::ObjectPtr< HtmlParser_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HtmlParser_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HtmlParser",ca,0c,fb,b1); }
+
+		static void __boot();
+		static  ::Dynamic SELF_CLOSING_TAGS_HTML;
+		static ::String reID;
+		static ::String reNamespacedID;
+		static ::String reCDATA;
+		static ::String reScript;
+		static ::String reStyle;
+		static ::String reElementOpen;
+		static ::String reAttr;
+		static ::String reElementEnd;
+		static ::String reElementClose;
+		static ::String reComment;
+		static  ::EReg reMain;
+		static  ::EReg reParseAttrs;
+		static ::Array< ::Dynamic> run(::String str,::hx::Null< bool >  tolerant);
+		static ::Dynamic run_dyn();
+
+		static ::Array< ::Dynamic> parseAttrs(::String str);
+		static ::Dynamic parseAttrs_dyn();
+
+		bool tolerant;
+		::Array< ::Dynamic> matches;
+		::String str;
+		int i;
+		::Array< ::Dynamic> parse(::String str,::hx::Null< bool >  tolerant);
+		::Dynamic parse_dyn();
+
+		 ::Dynamic processMatches(::Array< ::String > openedTagsLC);
+		::Dynamic processMatches_dyn();
+
+		 ::Dynamic parseElement(::Array< ::String > openedTagsLC);
+		::Dynamic parseElement_dyn();
+
+		bool isSelfClosingTag(::String tag);
+		::Dynamic isSelfClosingTag_dyn();
+
+		 ::htmlparser::HtmlNodeElement newElement(::String name,::Array< ::Dynamic> attributes);
+		::Dynamic newElement_dyn();
+
+		 ::Dynamic getPosition(int matchIndex);
+		::Dynamic getPosition_dyn();
+
+};
+
+} // end namespace htmlparser
+
+#endif /* INCLUDED_htmlparser_HtmlParser */ 
diff --git a/Sources/c_snikket/iinclude/include/htmlparser/HtmlParserException.h b/Sources/c_snikket/iinclude/include/htmlparser/HtmlParserException.h
new file mode 100644
index 0000000..e32202a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/htmlparser/HtmlParserException.h
@@ -0,0 +1,77 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_htmlparser_HtmlParserException
+#define INCLUDED_htmlparser_HtmlParserException
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_8ec4e8a8c4e51446_12_new)
+HX_DECLARE_CLASS1(htmlparser,HtmlParserException)
+
+namespace htmlparser{
+
+
+class HXCPP_CLASS_ATTRIBUTES HtmlParserException_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef HtmlParserException_obj OBJ_;
+		HtmlParserException_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0872044b };
+
+		void __construct(::String message, ::Dynamic pos);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="htmlparser.HtmlParserException")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"htmlparser.HtmlParserException"); }
+
+		inline static ::hx::ObjectPtr< HtmlParserException_obj > __new(::String message, ::Dynamic pos) {
+			::hx::ObjectPtr< HtmlParserException_obj > __this = new HtmlParserException_obj();
+			__this->__construct(message,pos);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< HtmlParserException_obj > __alloc(::hx::Ctx *_hx_ctx,::String message, ::Dynamic pos) {
+			HtmlParserException_obj *__this = (HtmlParserException_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(HtmlParserException_obj), true, "htmlparser.HtmlParserException"));
+			*(void **)__this = HtmlParserException_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_8ec4e8a8c4e51446_12_new)
+HXLINE(  13)		( ( ::htmlparser::HtmlParserException)(__this) )->message = message;
+HXLINE(  15)		( ( ::htmlparser::HtmlParserException)(__this) )->line = ( (int)(pos->__Field(HX_("line",f4,17,b3,47),::hx::paccDynamic)) );
+HXLINE(  16)		( ( ::htmlparser::HtmlParserException)(__this) )->column = ( (int)(pos->__Field(HX_("column",d6,4e,8b,c6),::hx::paccDynamic)) );
+HXLINE(  17)		( ( ::htmlparser::HtmlParserException)(__this) )->length = ( (int)(pos->__Field(HX_("length",e6,94,07,9f),::hx::paccDynamic)) );
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HtmlParserException_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HtmlParserException",25,fa,72,da); }
+
+		::String message;
+		int line;
+		int column;
+		int length;
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+} // end namespace htmlparser
+
+#endif /* INCLUDED_htmlparser_HtmlParserException */ 
diff --git a/Sources/c_snikket/iinclude/include/htmlparser/HtmlTools.h b/Sources/c_snikket/iinclude/include/htmlparser/HtmlTools.h
new file mode 100644
index 0000000..a082fb8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/htmlparser/HtmlTools.h
@@ -0,0 +1,67 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_htmlparser_HtmlTools
+#define INCLUDED_htmlparser_HtmlTools
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS1(htmlparser,HtmlTools)
+
+namespace htmlparser{
+
+
+class HXCPP_CLASS_ATTRIBUTES HtmlTools_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef HtmlTools_obj OBJ_;
+		HtmlTools_obj();
+
+	public:
+		enum { _hx_ClassId = 0x319122e2 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="htmlparser.HtmlTools")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"htmlparser.HtmlTools"); }
+
+		inline static ::hx::ObjectPtr< HtmlTools_obj > __new() {
+			::hx::ObjectPtr< HtmlTools_obj > __this = new HtmlTools_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< HtmlTools_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			HtmlTools_obj *__this = (HtmlTools_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(HtmlTools_obj), false, "htmlparser.HtmlTools"));
+			*(void **)__this = HtmlTools_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HtmlTools_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HtmlTools",90,c8,4b,c9); }
+
+		static  ::haxe::ds::StringMap htmlUnescapeMap;
+		static  ::haxe::ds::StringMap get_htmlUnescapeMap();
+		static ::Dynamic get_htmlUnescapeMap_dyn();
+
+		static ::String unescape(::String text);
+		static ::Dynamic unescape_dyn();
+
+};
+
+} // end namespace htmlparser
+
+#endif /* INCLUDED_htmlparser_HtmlTools */ 
diff --git a/Sources/c_snikket/iinclude/include/httpstatus/_HttpStatusMessage/HttpStatusMessage_Impl_.h b/Sources/c_snikket/iinclude/include/httpstatus/_HttpStatusMessage/HttpStatusMessage_Impl_.h
new file mode 100644
index 0000000..dfe9b21
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/httpstatus/_HttpStatusMessage/HttpStatusMessage_Impl_.h
@@ -0,0 +1,62 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_httpstatus__HttpStatusMessage_HttpStatusMessage_Impl_
+#define INCLUDED_httpstatus__HttpStatusMessage_HttpStatusMessage_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(httpstatus,_HttpStatusMessage,HttpStatusMessage_Impl_)
+
+namespace httpstatus{
+namespace _HttpStatusMessage{
+
+
+class HXCPP_CLASS_ATTRIBUTES HttpStatusMessage_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef HttpStatusMessage_Impl__obj OBJ_;
+		HttpStatusMessage_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x0de4d9f9 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="httpstatus._HttpStatusMessage.HttpStatusMessage_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"httpstatus._HttpStatusMessage.HttpStatusMessage_Impl_"); }
+
+		inline static ::hx::ObjectPtr< HttpStatusMessage_Impl__obj > __new() {
+			::hx::ObjectPtr< HttpStatusMessage_Impl__obj > __this = new HttpStatusMessage_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< HttpStatusMessage_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			HttpStatusMessage_Impl__obj *__this = (HttpStatusMessage_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(HttpStatusMessage_Impl__obj), false, "httpstatus._HttpStatusMessage.HttpStatusMessage_Impl_"));
+			*(void **)__this = HttpStatusMessage_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HttpStatusMessage_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HttpStatusMessage_Impl_",4d,ec,1b,89); }
+
+		static ::String fromCode(int statusCode);
+		static ::Dynamic fromCode_dyn();
+
+};
+
+} // end namespace httpstatus
+} // end namespace _HttpStatusMessage
+
+#endif /* INCLUDED_httpstatus__HttpStatusMessage_HttpStatusMessage_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/include/hx/strings/RandomStrings.h b/Sources/c_snikket/iinclude/include/hx/strings/RandomStrings.h
new file mode 100644
index 0000000..ff1c160
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/hx/strings/RandomStrings.h
@@ -0,0 +1,74 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_hx_strings_RandomStrings
+#define INCLUDED_hx_strings_RandomStrings
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(hx,strings,RandomStrings)
+HX_DECLARE_CLASS4(hx,strings,internal,_Either2,_Either2)
+
+namespace hx{
+namespace strings{
+
+
+class HXCPP_CLASS_ATTRIBUTES RandomStrings_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef RandomStrings_obj OBJ_;
+		RandomStrings_obj();
+
+	public:
+		enum { _hx_ClassId = 0x48d6a291 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="hx.strings.RandomStrings")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"hx.strings.RandomStrings"); }
+
+		inline static ::hx::ObjectPtr< RandomStrings_obj > __new() {
+			::hx::ObjectPtr< RandomStrings_obj > __this = new RandomStrings_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< RandomStrings_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			RandomStrings_obj *__this = (RandomStrings_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(RandomStrings_obj), false, "hx.strings.RandomStrings"));
+			*(void **)__this = RandomStrings_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~RandomStrings_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("RandomStrings",9f,7a,45,55); }
+
+		static void __boot();
+		static ::Array< int > DIGITS;
+		static ::Array< int > _genAsciiAlpha();
+		static ::Dynamic _genAsciiAlpha_dyn();
+
+		static ::Array< int > ASCII_ALPHA;
+		static ::Array< int > ASCII_ALPHA_NUMERIC;
+		static ::String random(int length, ::hx::strings::internal::_Either2::_Either2 chars);
+		static ::Dynamic random_dyn();
+
+		static ::String randomUUIDv4(::String separator);
+		static ::Dynamic randomUUIDv4_dyn();
+
+};
+
+} // end namespace hx
+} // end namespace strings
+
+#endif /* INCLUDED_hx_strings_RandomStrings */ 
diff --git a/Sources/c_snikket/iinclude/include/hx/strings/StringBuilder.h b/Sources/c_snikket/iinclude/include/hx/strings/StringBuilder.h
new file mode 100644
index 0000000..8115925
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/hx/strings/StringBuilder.h
@@ -0,0 +1,70 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_hx_strings_StringBuilder
+#define INCLUDED_hx_strings_StringBuilder
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(StringBuf)
+HX_DECLARE_CLASS2(hx,strings,StringBuilder)
+
+namespace hx{
+namespace strings{
+
+
+class HXCPP_CLASS_ATTRIBUTES StringBuilder_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef StringBuilder_obj OBJ_;
+		StringBuilder_obj();
+
+	public:
+		enum { _hx_ClassId = 0x32066fb8 };
+
+		void __construct(::String initialContent);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="hx.strings.StringBuilder")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"hx.strings.StringBuilder"); }
+		static ::hx::ObjectPtr< StringBuilder_obj > __new(::String initialContent);
+		static ::hx::ObjectPtr< StringBuilder_obj > __alloc(::hx::Ctx *_hx_ctx,::String initialContent);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~StringBuilder_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("StringBuilder",2a,56,d0,8d); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		 ::StringBuf sb;
+		::Array< ::String > pre;
+		int len;
+		 ::hx::strings::StringBuilder add(::String item);
+		::Dynamic add_dyn();
+
+		 ::hx::strings::StringBuilder addChar(int ch);
+		::Dynamic addChar_dyn();
+
+		 ::hx::strings::StringBuilder clear();
+		::Dynamic clear_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+} // end namespace hx
+} // end namespace strings
+
+#endif /* INCLUDED_hx_strings_StringBuilder */ 
diff --git a/Sources/c_snikket/iinclude/include/hx/strings/Strings.h b/Sources/c_snikket/iinclude/include/hx/strings/Strings.h
new file mode 100644
index 0000000..6629ee7
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/hx/strings/Strings.h
@@ -0,0 +1,62 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_hx_strings_Strings
+#define INCLUDED_hx_strings_Strings
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(hx,strings,Strings)
+
+namespace hx{
+namespace strings{
+
+
+class HXCPP_CLASS_ATTRIBUTES Strings_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Strings_obj OBJ_;
+		Strings_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0e5b539c };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="hx.strings.Strings")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"hx.strings.Strings"); }
+
+		inline static ::hx::ObjectPtr< Strings_obj > __new() {
+			::hx::ObjectPtr< Strings_obj > __this = new Strings_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Strings_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Strings_obj *__this = (Strings_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Strings_obj), false, "hx.strings.Strings"));
+			*(void **)__this = Strings_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Strings_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Strings",62,b6,44,c6); }
+
+		static ::Array< int > toChars(::String str);
+		static ::Dynamic toChars_dyn();
+
+};
+
+} // end namespace hx
+} // end namespace strings
+
+#endif /* INCLUDED_hx_strings_Strings */ 
diff --git a/Sources/c_snikket/iinclude/include/hx/strings/internal/_Either2/_Either2.h b/Sources/c_snikket/iinclude/include/hx/strings/internal/_Either2/_Either2.h
new file mode 100644
index 0000000..189b578
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/hx/strings/internal/_Either2/_Either2.h
@@ -0,0 +1,41 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_hx_strings_internal__Either2__Either2
+#define INCLUDED_hx_strings_internal__Either2__Either2
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS4(hx,strings,internal,_Either2,_Either2)
+namespace hx{
+namespace strings{
+namespace internal{
+namespace _Either2{
+
+
+class _Either2_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef _Either2_obj OBJ_;
+
+	public:
+		_Either2_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("hx.strings.internal._Either2._Either2",07,08,e6,82); }
+		::String __ToString() const { return HX_("_Either2.",c0,d7,a7,46) + _hx_tag; }
+
+		static ::hx::strings::internal::_Either2::_Either2 a( ::Dynamic v);
+		static ::Dynamic a_dyn();
+		static ::hx::strings::internal::_Either2::_Either2 b( ::Dynamic v);
+		static ::Dynamic b_dyn();
+};
+
+} // end namespace hx
+} // end namespace strings
+} // end namespace internal
+} // end namespace _Either2
+
+#endif /* INCLUDED_hx_strings_internal__Either2__Either2 */ 
diff --git a/Sources/c_snikket/iinclude/include/sha/Hash.h b/Sources/c_snikket/iinclude/include/sha/Hash.h
new file mode 100644
index 0000000..105a34b
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sha/Hash.h
@@ -0,0 +1,60 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sha_Hash
+#define INCLUDED_sha_Hash
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS1(sha,Hash)
+
+namespace sha{
+
+
+class HXCPP_CLASS_ATTRIBUTES Hash_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Hash_obj OBJ_;
+		Hash_obj();
+
+	public:
+		enum { _hx_ClassId = 0x49a7eb1a };
+
+		void __construct(int blockSize,int finalSize);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sha.Hash")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sha.Hash"); }
+
+		//~Hash_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Hash",ee,5b,e1,2f); }
+
+		int finalSize;
+		int length;
+		 ::haxe::io::Bytes block;
+		 ::sha::Hash update( ::haxe::io::Bytes data);
+		::Dynamic update_dyn();
+
+		 ::haxe::io::Bytes digest();
+		::Dynamic digest_dyn();
+
+		virtual void _update( ::haxe::io::Bytes data) {}
+		::Dynamic _update_dyn();
+		virtual  ::haxe::io::Bytes _hash() { return 0; }
+		::Dynamic _hash_dyn();
+};
+
+} // end namespace sha
+
+#endif /* INCLUDED_sha_Hash */ 
diff --git a/Sources/c_snikket/iinclude/include/sha/SHA256.h b/Sources/c_snikket/iinclude/include/sha/SHA256.h
new file mode 100644
index 0000000..28722a8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sha/SHA256.h
@@ -0,0 +1,86 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sha_SHA256
+#define INCLUDED_sha_SHA256
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_sha_Hash
+#include <sha/Hash.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS1(sha,Hash)
+HX_DECLARE_CLASS1(sha,SHA256)
+
+namespace sha{
+
+
+class HXCPP_CLASS_ATTRIBUTES SHA256_obj : public  ::sha::Hash_obj
+{
+	public:
+		typedef  ::sha::Hash_obj super;
+		typedef SHA256_obj OBJ_;
+		SHA256_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0251ab23 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sha.SHA256")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sha.SHA256"); }
+		static ::hx::ObjectPtr< SHA256_obj > __new();
+		static ::hx::ObjectPtr< SHA256_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SHA256_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SHA256",87,b4,95,cf); }
+
+		int _a;
+		int _b;
+		int _c;
+		int _d;
+		int _e;
+		int _f;
+		int _g;
+		int _h;
+		::Array< int > _w;
+		int sigma0(int x);
+		::Dynamic sigma0_dyn();
+
+		int sigma1(int x);
+		::Dynamic sigma1_dyn();
+
+		int gamma0(int x);
+		::Dynamic gamma0_dyn();
+
+		int gamma1(int x);
+		::Dynamic gamma1_dyn();
+
+		int ch(int x,int y,int z);
+		::Dynamic ch_dyn();
+
+		int maj(int x,int y,int z);
+		::Dynamic maj_dyn();
+
+		void _update( ::haxe::io::Bytes data);
+
+		 ::haxe::io::Bytes _hash();
+
+};
+
+} // end namespace sha
+
+#endif /* INCLUDED_sha_SHA256 */ 
diff --git a/Sources/c_snikket/iinclude/include/sha/_SHA256/SHA256_Fields_.h b/Sources/c_snikket/iinclude/include/sha/_SHA256/SHA256_Fields_.h
new file mode 100644
index 0000000..3d1d69a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sha/_SHA256/SHA256_Fields_.h
@@ -0,0 +1,62 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sha__SHA256_SHA256_Fields_
+#define INCLUDED_sha__SHA256_SHA256_Fields_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(sha,_SHA256,SHA256_Fields_)
+
+namespace sha{
+namespace _SHA256{
+
+
+class HXCPP_CLASS_ATTRIBUTES SHA256_Fields__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef SHA256_Fields__obj OBJ_;
+		SHA256_Fields__obj();
+
+	public:
+		enum { _hx_ClassId = 0x07d39014 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="sha._SHA256.SHA256_Fields_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"sha._SHA256.SHA256_Fields_"); }
+
+		inline static ::hx::ObjectPtr< SHA256_Fields__obj > __new() {
+			::hx::ObjectPtr< SHA256_Fields__obj > __this = new SHA256_Fields__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< SHA256_Fields__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			SHA256_Fields__obj *__this = (SHA256_Fields__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(SHA256_Fields__obj), false, "sha._SHA256.SHA256_Fields_"));
+			*(void **)__this = SHA256_Fields__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SHA256_Fields__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SHA256_Fields_",ae,b0,ef,ea); }
+
+		static void __boot();
+		static ::Array< int > K;
+};
+
+} // end namespace sha
+} // end namespace _SHA256
+
+#endif /* INCLUDED_sha__SHA256_SHA256_Fields_ */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/AttachmentSource.h b/Sources/c_snikket/iinclude/include/snikket/AttachmentSource.h
new file mode 100644
index 0000000..35e0bb9
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/AttachmentSource.h
@@ -0,0 +1,72 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_AttachmentSource
+#define INCLUDED_snikket_AttachmentSource
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,AttachmentSource)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES AttachmentSource_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef AttachmentSource_obj OBJ_;
+		AttachmentSource_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3b403b17 };
+
+		void __construct(::String path,::String mime);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.AttachmentSource")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.AttachmentSource"); }
+		static ::hx::ObjectPtr< AttachmentSource_obj > __new(::String path,::String mime);
+		static ::hx::ObjectPtr< AttachmentSource_obj > __alloc(::hx::Ctx *_hx_ctx,::String path,::String mime);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~AttachmentSource_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("AttachmentSource",3e,95,3b,6c); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		::String path;
+		::String path__fromC();
+		::Dynamic path__fromC_dyn();
+
+		::String type;
+		::String type__fromC();
+		::Dynamic type__fromC_dyn();
+
+		::String name;
+		::String name__fromC();
+		::Dynamic name__fromC_dyn();
+
+		int size;
+		int size__fromC();
+		::Dynamic size__fromC_dyn();
+
+		::Dynamic tinkSource();
+		::Dynamic tinkSource_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_AttachmentSource */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/Autolink.h b/Sources/c_snikket/iinclude/include/snikket/Autolink.h
new file mode 100644
index 0000000..f244927
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/Autolink.h
@@ -0,0 +1,90 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Autolink
+#define INCLUDED_snikket_Autolink
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Autolink)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Autolink_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Autolink_obj OBJ_;
+		Autolink_obj();
+
+	public:
+		enum { _hx_ClassId = 0x257fedc6 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket.Autolink")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket.Autolink"); }
+
+		inline static ::hx::ObjectPtr< Autolink_obj > __new() {
+			::hx::ObjectPtr< Autolink_obj > __this = new Autolink_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Autolink_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Autolink_obj *__this = (Autolink_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Autolink_obj), false, "snikket.Autolink"));
+			*(void **)__this = Autolink_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Autolink_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Autolink",09,97,b1,19); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static ::String IANA_TOP_LEVEL_DOMAINS;
+		static ::String GOOD_IRI_CHAR;
+		static ::String IP_ADDRESS;
+		static ::String IP6_ADDRESS;
+		static ::String UCS_CHAR;
+		static ::String LABEL_CHAR;
+		static ::String IRI_LABEL;
+		static ::String PUNYCODE_TLD;
+		static ::String PROTOCOL;
+		static ::String WORD_BOUNDARY;
+		static ::String USER_INFO;
+		static ::String PORT_NUMBER;
+		static ::String PATH_CHAR;
+		static ::String PATH_AND_QUERY;
+		static ::String STRICT_TLD;
+		static ::String STRICT_HOST_NAME;
+		static ::String STRICT_DOMAIN_NAME;
+		static ::String RELAXED_DOMAIN_NAME;
+		static ::String WEB_URL_WITHOUT_PROTOCOL;
+		static ::String WEB_URL_WITH_PROTOCOL;
+		static ::String AUTOLINK_WEB_URL;
+		static ::String TEL_URI;
+		static ::String SMS_URI;
+		static ::String XMPP_URI;
+		static  ::Dynamic one(::String s,int start);
+		static ::Dynamic one_dyn();
+
+		static  ::Dynamic match(::String s,int start,::String pattern,bool addHttps);
+		static ::Dynamic match_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Autolink */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/AvailableChat.h b/Sources/c_snikket/iinclude/include/snikket/AvailableChat.h
new file mode 100644
index 0000000..80ae01e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/AvailableChat.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_AvailableChat
+#define INCLUDED_snikket_AvailableChat
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,AvailableChat)
+HX_DECLARE_CLASS1(snikket,Caps)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES AvailableChat_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef AvailableChat_obj OBJ_;
+		AvailableChat_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7aa46944 };
+
+		void __construct(::String chatId,::String displayName,::String note, ::snikket::Caps caps);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.AvailableChat")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.AvailableChat"); }
+		static ::hx::ObjectPtr< AvailableChat_obj > __new(::String chatId,::String displayName,::String note, ::snikket::Caps caps);
+		static ::hx::ObjectPtr< AvailableChat_obj > __alloc(::hx::Ctx *_hx_ctx,::String chatId,::String displayName,::String note, ::snikket::Caps caps);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~AvailableChat_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("AvailableChat",21,4d,b7,ce); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		::String chatId;
+		::String chatId__fromC();
+		::Dynamic chatId__fromC_dyn();
+
+		::String displayName;
+		::String displayName__fromC();
+		::Dynamic displayName__fromC_dyn();
+
+		::String note;
+		::String note__fromC();
+		::Dynamic note__fromC_dyn();
+
+		 ::snikket::Caps caps;
+		bool isChannel();
+		::Dynamic isChannel_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_AvailableChat */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/Builder.h b/Sources/c_snikket/iinclude/include/snikket/Builder.h
new file mode 100644
index 0000000..2b371f1
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/Builder.h
@@ -0,0 +1,62 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Builder
+#define INCLUDED_snikket_Builder
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Builder)
+HX_DECLARE_CLASS1(snikket,Symbol)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Builder_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Builder_obj OBJ_;
+		Builder_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7b0e9a2a };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Builder")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Builder"); }
+		static ::hx::ObjectPtr< Builder_obj > __new();
+		static ::hx::ObjectPtr< Builder_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Builder_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Builder",fb,02,0c,3d); }
+
+		static bool isMerger(int codepoint);
+		static ::Dynamic isMerger_dyn();
+
+		::Array< int > codepoints;
+		bool offer(int codepoint);
+		::Dynamic offer_dyn();
+
+		 ::snikket::Symbol build();
+		::Dynamic build_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Builder */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/Caps.h b/Sources/c_snikket/iinclude/include/snikket/Caps.h
new file mode 100644
index 0000000..908402f
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/Caps.h
@@ -0,0 +1,83 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Caps
+#define INCLUDED_snikket_Caps
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Caps)
+HX_DECLARE_CLASS1(snikket,Hash)
+HX_DECLARE_CLASS1(snikket,Identity)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Caps_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Caps_obj OBJ_;
+		Caps_obj();
+
+	public:
+		enum { _hx_ClassId = 0x02663c7e };
+
+		void __construct(::String node,::Array< ::Dynamic> identities,::Array< ::String > features);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Caps")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Caps"); }
+		static ::hx::ObjectPtr< Caps_obj > __new(::String node,::Array< ::Dynamic> identities,::Array< ::String > features);
+		static ::hx::ObjectPtr< Caps_obj > __alloc(::hx::Ctx *_hx_ctx,::String node,::Array< ::Dynamic> identities,::Array< ::String > features);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Caps_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Caps",41,48,93,2c); }
+
+		static ::Array< ::String > withIdentity( ::Dynamic caps,::String category,::String type);
+		static ::Dynamic withIdentity_dyn();
+
+		static ::Array< ::String > withFeature( ::Dynamic caps,::String feature);
+		static ::Dynamic withFeature_dyn();
+
+		::String node;
+		::Array< ::Dynamic> identities;
+		::Array< ::String > features;
+		 ::snikket::Hash _ver;
+		bool isChannel(::String chatId);
+		::Dynamic isChannel_dyn();
+
+		 ::snikket::Stanza discoReply();
+		::Dynamic discoReply_dyn();
+
+		 ::snikket::Stanza addC( ::snikket::Stanza stanza);
+		::Dynamic addC_dyn();
+
+		 ::snikket::Hash computeVer();
+		::Dynamic computeVer_dyn();
+
+		 ::snikket::Hash verRaw();
+		::Dynamic verRaw_dyn();
+
+		::String ver();
+		::Dynamic ver_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Caps */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/Channel.h b/Sources/c_snikket/iinclude/include/snikket/Channel.h
new file mode 100644
index 0000000..74066bc
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/Channel.h
@@ -0,0 +1,144 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Channel
+#define INCLUDED_snikket_Channel
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_Chat
+#include <snikket/Chat.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Caps)
+HX_DECLARE_CLASS1(snikket,Channel)
+HX_DECLARE_CLASS1(snikket,Chat)
+HX_DECLARE_CLASS1(snikket,ChatMessage)
+HX_DECLARE_CLASS1(snikket,ChatMessageBuilder)
+HX_DECLARE_CLASS1(snikket,Client)
+HX_DECLARE_CLASS1(snikket,EventEmitter)
+HX_DECLARE_CLASS1(snikket,GenericStream)
+HX_DECLARE_CLASS1(snikket,JID)
+HX_DECLARE_CLASS1(snikket,MessageSync)
+HX_DECLARE_CLASS1(snikket,Participant)
+HX_DECLARE_CLASS1(snikket,Persistence)
+HX_DECLARE_CLASS1(snikket,Presence)
+HX_DECLARE_CLASS1(snikket,Reaction)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Channel_obj : public  ::snikket::Chat_obj
+{
+	public:
+		typedef  ::snikket::Chat_obj super;
+		typedef Channel_obj OBJ_;
+		Channel_obj();
+
+	public:
+		enum { _hx_ClassId = 0x23f2b886 };
+
+		void __construct( ::snikket::Client client, ::snikket::GenericStream stream,::Dynamic persistence,::String chatId,::hx::Null< int >  __o_uiState,::hx::Null< bool >  __o_isBlocked, ::snikket::Stanza extensions,::String readUpToId,::String readUpToBy, ::snikket::Caps disco);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Channel")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Channel"); }
+		static ::hx::ObjectPtr< Channel_obj > __new( ::snikket::Client client, ::snikket::GenericStream stream,::Dynamic persistence,::String chatId,::hx::Null< int >  __o_uiState,::hx::Null< bool >  __o_isBlocked, ::snikket::Stanza extensions,::String readUpToId,::String readUpToBy, ::snikket::Caps disco);
+		static ::hx::ObjectPtr< Channel_obj > __alloc(::hx::Ctx *_hx_ctx, ::snikket::Client client, ::snikket::GenericStream stream,::Dynamic persistence,::String chatId,::hx::Null< int >  __o_uiState,::hx::Null< bool >  __o_isBlocked, ::snikket::Stanza extensions,::String readUpToId,::String readUpToBy, ::snikket::Caps disco);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Channel_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Channel",a3,28,23,9a); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		 ::snikket::Caps disco;
+		bool inSync;
+		 ::snikket::MessageSync sync;
+		bool forceLive;
+		::String _nickInUse;
+		void selfPing(bool refresh);
+		::Dynamic selfPing_dyn();
+
+		void join();
+		::Dynamic join_dyn();
+
+		void selfPingSuccess();
+		::Dynamic selfPingSuccess_dyn();
+
+		void setPresence(::String resource, ::snikket::Presence presence);
+
+		void doSync(::String lastId);
+		::Dynamic doSync_dyn();
+
+		bool isTrusted();
+
+		bool isPrivate();
+		::Dynamic isPrivate_dyn();
+
+		void refreshDisco( ::Dynamic callback);
+		::Dynamic refreshDisco_dyn();
+
+		::String preview();
+
+		bool livePresence();
+
+		bool syncing();
+
+		bool canAudioCall();
+
+		bool canVideoCall();
+
+		::String nickInUse();
+		::Dynamic nickInUse_dyn();
+
+		 ::snikket::JID getFullJid();
+		::Dynamic getFullJid_dyn();
+
+		::Array< ::String > getParticipants();
+
+		 ::snikket::Participant getParticipantDetails(::String participantId);
+
+		void getMessagesBefore(::String beforeId,::String beforeTime, ::Dynamic handler);
+
+		void getMessagesAfter(::String afterId,::String afterTime, ::Dynamic handler);
+
+		void getMessagesAround(::String aroundId,::String aroundTime, ::Dynamic handler);
+
+		 ::snikket::ChatMessageBuilder prepareIncomingMessage( ::snikket::ChatMessageBuilder message, ::snikket::Stanza stanza);
+
+		 ::snikket::ChatMessageBuilder prepareOutgoingMessage( ::snikket::ChatMessageBuilder message);
+		::Dynamic prepareOutgoingMessage_dyn();
+
+		void correctMessage(::String localId, ::snikket::ChatMessageBuilder message);
+
+		void sendMessage( ::snikket::ChatMessageBuilder message);
+
+		void removeReaction( ::snikket::ChatMessage m, ::snikket::Reaction reaction);
+
+		::String lastMessageId();
+
+		void markReadUpTo( ::snikket::ChatMessage message);
+
+		void bookmark();
+
+		void sendChatState(::String state,::String threadId);
+
+		void close();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Channel */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/Chat.h b/Sources/c_snikket/iinclude/include/snikket/Chat.h
new file mode 100644
index 0000000..244dff4
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/Chat.h
@@ -0,0 +1,295 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Chat
+#define INCLUDED_snikket_Chat
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS1(haxe,Timer)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS1(snikket,Caps)
+HX_DECLARE_CLASS1(snikket,Chat)
+HX_DECLARE_CLASS1(snikket,ChatMessage)
+HX_DECLARE_CLASS1(snikket,ChatMessageBuilder)
+HX_DECLARE_CLASS1(snikket,Client)
+HX_DECLARE_CLASS1(snikket,EventEmitter)
+HX_DECLARE_CLASS1(snikket,GenericStream)
+HX_DECLARE_CLASS1(snikket,MessageSync)
+HX_DECLARE_CLASS1(snikket,Participant)
+HX_DECLARE_CLASS1(snikket,Persistence)
+HX_DECLARE_CLASS1(snikket,Presence)
+HX_DECLARE_CLASS1(snikket,Reaction)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,jingle,DTMFSender)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStream)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStreamTrack)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Chat_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Chat_obj OBJ_;
+		Chat_obj();
+
+	public:
+		enum { _hx_ClassId = 0x026b7f35 };
+
+		void __construct( ::snikket::Client client, ::snikket::GenericStream stream,::Dynamic persistence,::String chatId,::hx::Null< int >  __o_uiState,::hx::Null< bool >  __o_isBlocked, ::snikket::Stanza extensions,::String readUpToId,::String readUpToBy);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Chat")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Chat"); }
+
+		//~Chat_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Chat",f8,8a,98,2c); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		 ::snikket::Client client;
+		 ::snikket::GenericStream stream;
+		::Dynamic persistence;
+		::Array< unsigned char > avatarSha1;
+		 ::haxe::ds::StringMap presence;
+		bool trusted;
+		::String chatId;
+		::String chatId__fromC();
+		::Dynamic chatId__fromC_dyn();
+
+		 ::haxe::ds::StringMap jingleSessions;
+		::String displayName;
+		int uiState;
+		int uiState__fromC();
+		::Dynamic uiState__fromC_dyn();
+
+		bool isBlocked;
+		bool isBlocked__fromC();
+		::Dynamic isBlocked__fromC_dyn();
+
+		 ::snikket::Stanza extensions;
+		int _unreadCount;
+		 ::snikket::ChatMessage lastMessage;
+		::String readUpToId;
+		::String readUpToBy;
+		bool isTyping;
+		::String typingThread;
+		 ::haxe::Timer typingTimer;
+		 ::Dynamic isActive;
+		::String activeThread;
+		 ::Dynamic notificationSettings;
+		virtual  ::snikket::ChatMessageBuilder prepareIncomingMessage( ::snikket::ChatMessageBuilder message, ::snikket::Stanza stanza) { return 0; }
+		::Dynamic prepareIncomingMessage_dyn();
+		virtual void getMessagesBefore(::String beforeId,::String beforeTime, ::Dynamic handler) {}
+		::Dynamic getMessagesBefore_dyn();
+		void getMessagesBefore__fromC(::String beforeId,::String beforeTime,::cpp::Function< void  (void**,size_t,void*) > handler,void* handler__context);
+
+		virtual void getMessagesAfter(::String afterId,::String afterTime, ::Dynamic handler) {}
+		::Dynamic getMessagesAfter_dyn();
+		void getMessagesAfter__fromC(::String afterId,::String afterTime,::cpp::Function< void  (void**,size_t,void*) > handler,void* handler__context);
+
+		virtual void getMessagesAround(::String aroundId,::String aroundTime, ::Dynamic handler) {}
+		::Dynamic getMessagesAround_dyn();
+		void getMessagesAround__fromC(::String aroundId,::String aroundTime,::cpp::Function< void  (void**,size_t,void*) > handler,void* handler__context);
+
+		void fetchFromSync( ::snikket::MessageSync sync, ::Dynamic callback);
+		::Dynamic fetchFromSync_dyn();
+
+		virtual void sendMessage( ::snikket::ChatMessageBuilder message) {}
+		::Dynamic sendMessage_dyn();
+		void sendMessage__fromC( ::snikket::ChatMessageBuilder message);
+		::Dynamic sendMessage__fromC_dyn();
+
+		virtual void markReadUpTo( ::snikket::ChatMessage message) {}
+		::Dynamic markReadUpTo_dyn();
+		void markReadUpTo__fromC( ::snikket::ChatMessage message);
+		::Dynamic markReadUpTo__fromC_dyn();
+
+		virtual void bookmark() {}
+		::Dynamic bookmark_dyn();
+		void bookmark__fromC();
+		::Dynamic bookmark__fromC_dyn();
+
+		virtual ::Array< ::String > getParticipants() { return 0; }
+		::Dynamic getParticipants_dyn();
+		size_t getParticipants__fromC(const char*** outPtr);
+
+		virtual  ::snikket::Participant getParticipantDetails(::String participantId) { return 0; }
+		::Dynamic getParticipantDetails_dyn();
+		 ::snikket::Participant getParticipantDetails__fromC(::String participantId);
+		::Dynamic getParticipantDetails__fromC_dyn();
+
+		virtual void correctMessage(::String localId, ::snikket::ChatMessageBuilder message) {}
+		::Dynamic correctMessage_dyn();
+		void correctMessage__fromC(::String localId, ::snikket::ChatMessageBuilder message);
+		::Dynamic correctMessage__fromC_dyn();
+
+		void addReaction( ::snikket::ChatMessage m, ::snikket::Reaction reaction);
+		::Dynamic addReaction_dyn();
+
+		virtual void removeReaction( ::snikket::ChatMessage m, ::snikket::Reaction reaction) {}
+		::Dynamic removeReaction_dyn();
+		void removeReaction__fromC( ::snikket::ChatMessage m, ::snikket::Reaction reaction);
+		::Dynamic removeReaction__fromC_dyn();
+
+		virtual void sendChatState(::String state,::String threadId) {}
+		::Dynamic sendChatState_dyn();
+		void typing(::String threadId,::String content);
+		::Dynamic typing_dyn();
+
+		void setActive(bool active,::String threadId);
+		::Dynamic setActive_dyn();
+
+		virtual void close() {}
+		::Dynamic close_dyn();
+		void close__fromC();
+		::Dynamic close__fromC_dyn();
+
+		void togglePinned();
+		::Dynamic togglePinned_dyn();
+
+		void block( ::snikket::ChatMessage reportSpam,bool onServer);
+		::Dynamic block_dyn();
+
+		void unblock(bool onServer);
+		::Dynamic unblock_dyn();
+
+		void setNotifications(bool filtered,bool mention,bool reply);
+		::Dynamic setNotifications_dyn();
+
+		bool notificationsFiltered();
+		::Dynamic notificationsFiltered_dyn();
+
+		bool notifyMention();
+		::Dynamic notifyMention_dyn();
+
+		bool notifyReply();
+		::Dynamic notifyReply_dyn();
+
+		virtual ::String lastMessageId() { return 0; }
+		::Dynamic lastMessageId_dyn();
+		::String lastMessageId__fromC();
+		::Dynamic lastMessageId__fromC_dyn();
+
+		::String lastMessageTimestamp();
+		::Dynamic lastMessageTimestamp_dyn();
+
+		void updateFromBookmark( ::snikket::Stanza item);
+		::Dynamic updateFromBookmark_dyn();
+
+		void updateFromRoster( ::Dynamic item);
+		::Dynamic updateFromRoster_dyn();
+
+		::String getPhoto();
+		::Dynamic getPhoto_dyn();
+
+		::String getPlaceholder();
+		::Dynamic getPlaceholder_dyn();
+
+		::String readUpTo();
+		::Dynamic readUpTo_dyn();
+
+		int unreadCount();
+		::Dynamic unreadCount_dyn();
+
+		void setUnreadCount(int count);
+		::Dynamic setUnreadCount_dyn();
+
+		virtual ::String preview();
+		::Dynamic preview_dyn();
+
+		void setLastMessage( ::snikket::ChatMessage message);
+		::Dynamic setLastMessage_dyn();
+
+		void setDisplayName(::String fn);
+		::Dynamic setDisplayName_dyn();
+
+		::String getDisplayName();
+		::Dynamic getDisplayName_dyn();
+
+		virtual void setPresence(::String resource, ::snikket::Presence presence);
+		::Dynamic setPresence_dyn();
+
+		void setCaps(::String resource, ::snikket::Caps caps);
+		::Dynamic setCaps_dyn();
+
+		void removePresence(::String resource);
+		::Dynamic removePresence_dyn();
+
+		 ::Dynamic getCaps();
+		::Dynamic getCaps_dyn();
+
+		 ::snikket::Caps getResourceCaps(::String resource);
+		::Dynamic getResourceCaps_dyn();
+
+		void setAvatarSha1(::Array< unsigned char > sha1);
+		::Dynamic setAvatarSha1_dyn();
+
+		void setTrusted(bool trusted);
+		::Dynamic setTrusted_dyn();
+
+		virtual bool isTrusted();
+		::Dynamic isTrusted_dyn();
+
+		virtual bool livePresence();
+		::Dynamic livePresence_dyn();
+
+		virtual bool syncing();
+		::Dynamic syncing_dyn();
+
+		virtual bool canAudioCall();
+		::Dynamic canAudioCall_dyn();
+
+		virtual bool canVideoCall();
+		::Dynamic canVideoCall_dyn();
+
+		void startCall(bool audio,bool video);
+		::Dynamic startCall_dyn();
+
+		void addMedia(::Array< ::Dynamic> streams);
+		::Dynamic addMedia_dyn();
+
+		void acceptCall();
+		::Dynamic acceptCall_dyn();
+
+		void hangup();
+		::Dynamic hangup_dyn();
+
+		::String callStatus();
+		::Dynamic callStatus_dyn();
+
+		 ::snikket::jingle::DTMFSender dtmf();
+		::Dynamic dtmf_dyn();
+
+		::Array< ::Dynamic> videoTracks();
+		::Dynamic videoTracks_dyn();
+
+		size_t videoTracks__fromC(void*** outPtr);
+
+		void markReadUpToId(::String upTo,::String upToBy, ::Dynamic callback);
+		::Dynamic markReadUpToId_dyn();
+
+		void markReadUpToMessage( ::snikket::ChatMessage message, ::Dynamic callback);
+		::Dynamic markReadUpToMessage_dyn();
+
+		void publishMds();
+		::Dynamic publishMds_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Chat */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/ChatAttachment.h b/Sources/c_snikket/iinclude/include/snikket/ChatAttachment.h
new file mode 100644
index 0000000..a22273b
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/ChatAttachment.h
@@ -0,0 +1,75 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_ChatAttachment
+#define INCLUDED_snikket_ChatAttachment
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,ChatAttachment)
+HX_DECLARE_CLASS1(snikket,Hash)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES ChatAttachment_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef ChatAttachment_obj OBJ_;
+		ChatAttachment_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2f907f78 };
+
+		void __construct(::String name,::String mime, ::Dynamic size,::Array< ::String > uris,::Array< ::Dynamic> hashes);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.ChatAttachment")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.ChatAttachment"); }
+		static ::hx::ObjectPtr< ChatAttachment_obj > __new(::String name,::String mime, ::Dynamic size,::Array< ::String > uris,::Array< ::Dynamic> hashes);
+		static ::hx::ObjectPtr< ChatAttachment_obj > __alloc(::hx::Ctx *_hx_ctx,::String name,::String mime, ::Dynamic size,::Array< ::String > uris,::Array< ::Dynamic> hashes);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ChatAttachment_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ChatAttachment",fb,fc,04,6c); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static  ::snikket::ChatAttachment create(::String name,::String mime,int size,::String uri);
+		static ::Dynamic create_dyn();
+
+		::String name;
+		::String name__fromC();
+		::Dynamic name__fromC_dyn();
+
+		::String mime;
+		::String mime__fromC();
+		::Dynamic mime__fromC_dyn();
+
+		 ::Dynamic size;
+		 ::Dynamic size__fromC();
+		::Dynamic size__fromC_dyn();
+
+		::Array< ::String > uris;
+		size_t uris__fromC(const char*** outPtr);
+
+		::Array< ::Dynamic> hashes;
+		size_t hashes__fromC(void*** outPtr);
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_ChatAttachment */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/ChatMessage.h b/Sources/c_snikket/iinclude/include/snikket/ChatMessage.h
new file mode 100644
index 0000000..c2531ac
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/ChatMessage.h
@@ -0,0 +1,172 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_ChatMessage
+#define INCLUDED_snikket_ChatMessage
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS1(snikket,ChatAttachment)
+HX_DECLARE_CLASS1(snikket,ChatMessage)
+HX_DECLARE_CLASS1(snikket,ChatMessageBuilder)
+HX_DECLARE_CLASS1(snikket,Hash)
+HX_DECLARE_CLASS1(snikket,JID)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES ChatMessage_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef ChatMessage_obj OBJ_;
+		ChatMessage_obj();
+
+	public:
+		enum { _hx_ClassId = 0x36665f12 };
+
+		void __construct( ::Dynamic params);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.ChatMessage")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.ChatMessage"); }
+		static ::hx::ObjectPtr< ChatMessage_obj > __new( ::Dynamic params);
+		static ::hx::ObjectPtr< ChatMessage_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic params);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ChatMessage_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ChatMessage",af,a1,2d,18); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static  ::snikket::ChatMessage fromStanza( ::snikket::Stanza stanza, ::snikket::JID localJid, ::Dynamic addContext);
+		static ::Dynamic fromStanza_dyn();
+
+		::String localId;
+		::String localId__fromC();
+		::Dynamic localId__fromC_dyn();
+
+		::String serverId;
+		::String serverId__fromC();
+		::Dynamic serverId__fromC_dyn();
+
+		::String serverIdBy;
+		::String serverIdBy__fromC();
+		::Dynamic serverIdBy__fromC_dyn();
+
+		int type;
+		int type__fromC();
+		::Dynamic type__fromC_dyn();
+
+		bool syncPoint;
+		::String replyId;
+		::String timestamp;
+		::String timestamp__fromC();
+		::Dynamic timestamp__fromC_dyn();
+
+		 ::snikket::JID to;
+		 ::snikket::JID from;
+		::Array< ::Dynamic> recipients;
+		::Array< ::Dynamic> replyTo;
+		::String senderId;
+		::String senderId__fromC();
+		::Dynamic senderId__fromC_dyn();
+
+		 ::snikket::ChatMessage replyToMessage;
+		 ::snikket::ChatMessage replyToMessage__fromC();
+		::Dynamic replyToMessage__fromC_dyn();
+
+		::String threadId;
+		::String threadId__fromC();
+		::Dynamic threadId__fromC_dyn();
+
+		::Array< ::Dynamic> attachments;
+		size_t attachments__fromC(void*** outPtr);
+
+		 ::haxe::ds::StringMap reactions;
+		::String text;
+		::String text__fromC();
+		::Dynamic text__fromC_dyn();
+
+		::String lang;
+		::String lang__fromC();
+		::Dynamic lang__fromC_dyn();
+
+		int direction;
+		int direction__fromC();
+		::Dynamic direction__fromC_dyn();
+
+		int status;
+		int status__fromC();
+		::Dynamic status__fromC_dyn();
+
+		void set_status__fromC(int value);
+		::Dynamic set_status__fromC_dyn();
+
+		::Array< ::Dynamic> versions;
+		size_t versions__fromC(void*** outPtr);
+
+		::Array< ::Dynamic> payloads;
+		 ::snikket::Stanza stanza;
+		 ::snikket::ChatMessageBuilder reply();
+		::Dynamic reply_dyn();
+
+		::String getReplyId();
+		::Dynamic getReplyId_dyn();
+
+		 ::snikket::ChatMessage set_replyToMessage( ::snikket::ChatMessage m);
+		::Dynamic set_replyToMessage_dyn();
+
+		 ::haxe::ds::StringMap set_reactions( ::haxe::ds::StringMap r);
+		::Dynamic set_reactions_dyn();
+
+		::Array< ::Dynamic> inlineHashReferences();
+		::Dynamic inlineHashReferences_dyn();
+
+		::String html();
+		::Dynamic html_dyn();
+
+		::String chatId();
+		::Dynamic chatId_dyn();
+
+		::String account();
+		::Dynamic account_dyn();
+
+		bool isIncoming();
+		::Dynamic isIncoming_dyn();
+
+		::String threadIcon();
+		::Dynamic threadIcon_dyn();
+
+		::String callStatus();
+		::Dynamic callStatus_dyn();
+
+		::String callSid();
+		::Dynamic callSid_dyn();
+
+		::String callDuration();
+		::Dynamic callDuration_dyn();
+
+		 ::snikket::Stanza asStanza();
+		::Dynamic asStanza_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_ChatMessage */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/ChatMessageBuilder.h b/Sources/c_snikket/iinclude/include/snikket/ChatMessageBuilder.h
new file mode 100644
index 0000000..041e48a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/ChatMessageBuilder.h
@@ -0,0 +1,189 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_ChatMessageBuilder
+#define INCLUDED_snikket_ChatMessageBuilder
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS1(htmlparser,HtmlNode)
+HX_DECLARE_CLASS1(snikket,ChatAttachment)
+HX_DECLARE_CLASS1(snikket,ChatMessage)
+HX_DECLARE_CLASS1(snikket,ChatMessageBuilder)
+HX_DECLARE_CLASS1(snikket,JID)
+HX_DECLARE_CLASS1(snikket,Node)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES ChatMessageBuilder_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef ChatMessageBuilder_obj OBJ_;
+		ChatMessageBuilder_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1d9d1345 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.ChatMessageBuilder")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.ChatMessageBuilder"); }
+		static ::hx::ObjectPtr< ChatMessageBuilder_obj > __new();
+		static ::hx::ObjectPtr< ChatMessageBuilder_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ChatMessageBuilder_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ChatMessageBuilder",2c,85,c0,07); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static  ::snikket::ChatMessage makeModerated( ::snikket::ChatMessage m,::String timestamp,::String moderatorId,::String reason);
+		static ::Dynamic makeModerated_dyn();
+
+		::String localId;
+		::String localId__fromC();
+		::Dynamic localId__fromC_dyn();
+
+		void set_localId__fromC(::String value);
+		::Dynamic set_localId__fromC_dyn();
+
+		::String serverId;
+		::String serverId__fromC();
+		::Dynamic serverId__fromC_dyn();
+
+		void set_serverId__fromC(::String value);
+		::Dynamic set_serverId__fromC_dyn();
+
+		::String serverIdBy;
+		::String serverIdBy__fromC();
+		::Dynamic serverIdBy__fromC_dyn();
+
+		void set_serverIdBy__fromC(::String value);
+		::Dynamic set_serverIdBy__fromC_dyn();
+
+		int type;
+		int type__fromC();
+		::Dynamic type__fromC_dyn();
+
+		void set_type__fromC(int value);
+		::Dynamic set_type__fromC_dyn();
+
+		bool syncPoint;
+		::String replyId;
+		::String timestamp;
+		::String timestamp__fromC();
+		::Dynamic timestamp__fromC_dyn();
+
+		void set_timestamp__fromC(::String value);
+		::Dynamic set_timestamp__fromC_dyn();
+
+		 ::snikket::JID to;
+		 ::snikket::JID from;
+		 ::snikket::JID sender;
+		::Array< ::Dynamic> recipients;
+		::Array< ::Dynamic> replyTo;
+		::String senderId;
+		::String senderId__fromC();
+		::Dynamic senderId__fromC_dyn();
+
+		void set_senderId__fromC(::String value);
+		::Dynamic set_senderId__fromC_dyn();
+
+		 ::snikket::ChatMessage replyToMessage;
+		 ::snikket::ChatMessage replyToMessage__fromC();
+		::Dynamic replyToMessage__fromC_dyn();
+
+		void set_replyToMessage__fromC( ::snikket::ChatMessage value);
+		::Dynamic set_replyToMessage__fromC_dyn();
+
+		::String threadId;
+		::String threadId__fromC();
+		::Dynamic threadId__fromC_dyn();
+
+		void set_threadId__fromC(::String value);
+		::Dynamic set_threadId__fromC_dyn();
+
+		::Array< ::Dynamic> attachments;
+		size_t attachments__fromC(void*** outPtr);
+
+		 ::haxe::ds::StringMap reactions;
+		::String text;
+		::String text__fromC();
+		::Dynamic text__fromC_dyn();
+
+		void set_text__fromC(::String value);
+		::Dynamic set_text__fromC_dyn();
+
+		::String lang;
+		::String lang__fromC();
+		::Dynamic lang__fromC_dyn();
+
+		void set_lang__fromC(::String value);
+		::Dynamic set_lang__fromC_dyn();
+
+		int direction;
+		int direction__fromC();
+		::Dynamic direction__fromC_dyn();
+
+		void set_direction__fromC(int value);
+		::Dynamic set_direction__fromC_dyn();
+
+		int status;
+		int status__fromC();
+		::Dynamic status__fromC_dyn();
+
+		void set_status__fromC(int value);
+		::Dynamic set_status__fromC_dyn();
+
+		::Array< ::Dynamic> versions;
+		size_t versions__fromC(void*** outPtr);
+
+		::Array< ::Dynamic> payloads;
+		 ::snikket::Stanza stanza;
+		void attachSims( ::snikket::Stanza sims);
+		::Dynamic attachSims_dyn();
+
+		void addAttachment( ::snikket::ChatAttachment attachment);
+		::Dynamic addAttachment_dyn();
+
+		void setHtml(::String html);
+		::Dynamic setHtml_dyn();
+
+		 ::snikket::Node htmlToNode( ::htmlparser::HtmlNode node);
+		::Dynamic htmlToNode_dyn();
+
+		::String chatId();
+		::Dynamic chatId_dyn();
+
+		::String get_senderId();
+		::Dynamic get_senderId_dyn();
+
+		bool isIncoming();
+		::Dynamic isIncoming_dyn();
+
+		 ::snikket::ChatMessage build();
+		::Dynamic build_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_ChatMessageBuilder */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/Client.h b/Sources/c_snikket/iinclude/include/snikket/Client.h
new file mode 100644
index 0000000..8908f68
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/Client.h
@@ -0,0 +1,279 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Client
+#define INCLUDED_snikket_Client
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_EventEmitter
+#include <snikket/EventEmitter.h>
+#endif
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS1(snikket,AttachmentSource)
+HX_DECLARE_CLASS1(snikket,AvailableChat)
+HX_DECLARE_CLASS1(snikket,Caps)
+HX_DECLARE_CLASS1(snikket,Chat)
+HX_DECLARE_CLASS1(snikket,ChatAttachment)
+HX_DECLARE_CLASS1(snikket,ChatMessage)
+HX_DECLARE_CLASS1(snikket,Client)
+HX_DECLARE_CLASS1(snikket,DirectChat)
+HX_DECLARE_CLASS1(snikket,EventEmitter)
+HX_DECLARE_CLASS1(snikket,EventResult)
+HX_DECLARE_CLASS1(snikket,GenericStream)
+HX_DECLARE_CLASS1(snikket,Hash)
+HX_DECLARE_CLASS1(snikket,JID)
+HX_DECLARE_CLASS1(snikket,ModerationAction)
+HX_DECLARE_CLASS1(snikket,Persistence)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,jingle,InitiatedSession)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStream)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStreamTrack)
+HX_DECLARE_CLASS2(snikket,jingle,Session)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Client_obj : public  ::snikket::EventEmitter_obj
+{
+	public:
+		typedef  ::snikket::EventEmitter_obj super;
+		typedef Client_obj OBJ_;
+		Client_obj();
+
+	public:
+		enum { _hx_ClassId = 0x668a7be8 };
+
+		void __construct(::String address,::Dynamic persistence);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Client")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Client"); }
+		static ::hx::ObjectPtr< Client_obj > __new(::String address,::Dynamic persistence);
+		static ::hx::ObjectPtr< Client_obj > __alloc(::hx::Ctx *_hx_ctx,::String address,::Dynamic persistence);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Client_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Client",6b,3e,e4,3e); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		bool sendAvailable;
+		void set_sendAvailable__fromC(bool value);
+		::Dynamic set_sendAvailable__fromC_dyn();
+
+		 ::snikket::GenericStream stream;
+		::Array< ::Dynamic> chatMessageHandlers;
+		::Array< ::Dynamic> syncMessageHandlers;
+		::Array< ::Dynamic> chatStateHandlers;
+		 ::snikket::JID jid;
+		::Array< ::Dynamic> chats;
+		::Dynamic persistence;
+		 ::snikket::Caps caps;
+		::String _displayName;
+		::String fastMechanism;
+		::String token;
+		 ::haxe::ds::StringMap pendingCaps;
+		bool inSync;
+		void start();
+		::Dynamic start_dyn();
+
+		void logout(bool completely);
+		::Dynamic logout_dyn();
+
+		void usePassword(::String password);
+		::Dynamic usePassword_dyn();
+
+		::String accountId();
+		::Dynamic accountId_dyn();
+
+		::String displayName();
+		::Dynamic displayName_dyn();
+
+		void setDisplayName(::String displayName);
+		::Dynamic setDisplayName_dyn();
+
+		bool updateDisplayName(::String fn);
+		::Dynamic updateDisplayName_dyn();
+
+		 ::snikket::EventResult onConnected( ::Dynamic data);
+		::Dynamic onConnected_dyn();
+
+		void prepareAttachment( ::snikket::AttachmentSource source, ::Dynamic callback);
+		::Dynamic prepareAttachment_dyn();
+
+		void prepareAttachment__fromC( ::snikket::AttachmentSource source,::cpp::Function< void  (void*,void*) > callback,void* callback__context);
+
+		void prepareAttachmentFor( ::snikket::AttachmentSource source,::Array< ::Dynamic> services,::Array< ::Dynamic> hashes, ::Dynamic callback);
+		::Dynamic prepareAttachmentFor_dyn();
+
+		::Array< ::Dynamic> getChats();
+		::Dynamic getChats_dyn();
+
+		size_t getChats__fromC(void*** outPtr);
+
+		void findAvailableChats(::String q, ::Dynamic callback);
+		::Dynamic findAvailableChats_dyn();
+
+		void findAvailableChats__fromC(::String q,::cpp::Function< void  (const char*,void**,size_t,void*) > callback,void* callback__context);
+
+		 ::snikket::Chat startChat( ::snikket::AvailableChat availableChat);
+		::Dynamic startChat_dyn();
+
+		 ::snikket::Chat getChat(::String chatId);
+		::Dynamic getChat_dyn();
+
+		::Dynamic moderateMessage( ::snikket::ModerationAction action);
+		::Dynamic moderateMessage_dyn();
+
+		 ::snikket::DirectChat getDirectChat(::String chatId,::hx::Null< bool >  triggerIfNew);
+		::Dynamic getDirectChat_dyn();
+
+		void addPasswordNeededListener( ::Dynamic handler);
+		::Dynamic addPasswordNeededListener_dyn();
+
+		void addPasswordNeededListener__fromC(::cpp::Function< void  (void*,void*) > handler,void* handler__context);
+
+		void addStatusOnlineListener( ::Dynamic handler);
+		::Dynamic addStatusOnlineListener_dyn();
+
+		void addStatusOnlineListener__fromC(::cpp::Function< void  (void*) > handler,void* handler__context);
+
+		void addStatusOfflineListener( ::Dynamic handler);
+		::Dynamic addStatusOfflineListener_dyn();
+
+		void addStatusOfflineListener__fromC(::cpp::Function< void  (void*) > handler,void* handler__context);
+
+		void addConnectionFailedListener( ::Dynamic handler);
+		::Dynamic addConnectionFailedListener_dyn();
+
+		void addConnectionFailedListener__fromC(::cpp::Function< void  (void*) > handler,void* handler__context);
+
+		void addChatMessageListener( ::Dynamic handler);
+		::Dynamic addChatMessageListener_dyn();
+
+		void addChatMessageListener__fromC(::cpp::Function< void  (void*,int,void*) > handler,void* handler__context);
+
+		void addSyncMessageListener( ::Dynamic handler);
+		::Dynamic addSyncMessageListener_dyn();
+
+		void addSyncMessageListener__fromC(::cpp::Function< void  (void*,void*) > handler,void* handler__context);
+
+		void addChatsUpdatedListener( ::Dynamic handler);
+		::Dynamic addChatsUpdatedListener_dyn();
+
+		void addChatsUpdatedListener__fromC(::cpp::Function< void  (void**,size_t,void*) > handler,void* handler__context);
+
+		void addCallRingListener( ::Dynamic handler);
+		::Dynamic addCallRingListener_dyn();
+
+		void addCallRingListener__fromC(::cpp::Function< void  (void*,const char*,void*) > handler,void* handler__context);
+
+		void addCallRetractListener( ::Dynamic handler);
+		::Dynamic addCallRetractListener_dyn();
+
+		void addCallRetractListener__fromC(::cpp::Function< void  (const char*,void*) > handler,void* handler__context);
+
+		void addCallRingingListener( ::Dynamic handler);
+		::Dynamic addCallRingingListener_dyn();
+
+		void addCallRingingListener__fromC(::cpp::Function< void  (const char*,void*) > handler,void* handler__context);
+
+		void addCallMediaListener( ::Dynamic handler);
+		::Dynamic addCallMediaListener_dyn();
+
+		void addCallMediaListener__fromC(::cpp::Function< void  (void*,bool,bool,void*) > handler,void* handler__context);
+
+		void addCallTrackListener( ::Dynamic handler);
+		::Dynamic addCallTrackListener_dyn();
+
+		void addCallTrackListener__fromC(::cpp::Function< void  (const char*,void*,void**,size_t,void*) > handler,void* handler__context);
+
+		void setInForeground();
+		::Dynamic setInForeground_dyn();
+
+		void setNotInForeground();
+		::Dynamic setNotInForeground_dyn();
+
+		::Dynamic fetchMediaByHash(::Array< ::Dynamic> hashes,::Array< ::Dynamic> counterparts);
+		::Dynamic fetchMediaByHash_dyn();
+
+		::Dynamic fetchMediaByHashOneCounterpart(::Array< ::Dynamic> hashes, ::snikket::JID counterpart);
+		::Dynamic fetchMediaByHashOneCounterpart_dyn();
+
+		void chatActivity( ::snikket::Chat chat,::hx::Null< bool >  trigger);
+		::Dynamic chatActivity_dyn();
+
+		void sortChats();
+		::Dynamic sortChats_dyn();
+
+		void storeMessages(::Array< ::Dynamic> messages, ::Dynamic callback);
+		::Dynamic storeMessages_dyn();
+
+		void sendQuery( ::snikket::queries::GenericQuery query);
+		::Dynamic sendQuery_dyn();
+
+		void sendStanza( ::snikket::Stanza stanza);
+		::Dynamic sendStanza_dyn();
+
+		void sendPresence(::String to, ::Dynamic augment);
+		::Dynamic sendPresence_dyn();
+
+		void getIceServers( ::Dynamic callback);
+		::Dynamic getIceServers_dyn();
+
+		void discoverServices( ::snikket::JID target,::String node, ::Dynamic callback);
+		::Dynamic discoverServices_dyn();
+
+		void notifyMessageHandlers( ::snikket::ChatMessage message,int event);
+		::Dynamic notifyMessageHandlers_dyn();
+
+		void notifySyncMessageHandlers( ::snikket::ChatMessage message);
+		::Dynamic notifySyncMessageHandlers_dyn();
+
+		void rosterGet();
+		::Dynamic rosterGet_dyn();
+
+		void startChatWith(::String jid, ::Dynamic handleCaps, ::Dynamic handleChat);
+		::Dynamic startChatWith_dyn();
+
+		void serverBlocked(::String blocked);
+		::Dynamic serverBlocked_dyn();
+
+		void bookmarksGet( ::Dynamic callback);
+		::Dynamic bookmarksGet_dyn();
+
+		void sync( ::Dynamic callback);
+		::Dynamic sync_dyn();
+
+		void onMAMJMI(::String sid, ::snikket::Stanza stanza);
+		::Dynamic onMAMJMI_dyn();
+
+		void doSync( ::Dynamic callback,::String lastId);
+		::Dynamic doSync_dyn();
+
+		void pingAllChannels(bool refresh);
+		::Dynamic pingAllChannels_dyn();
+
+		void joinAllChannels();
+		::Dynamic joinAllChannels_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Client */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/Color.h b/Sources/c_snikket/iinclude/include/snikket/Color.h
new file mode 100644
index 0000000..074383f
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/Color.h
@@ -0,0 +1,63 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Color
+#define INCLUDED_snikket_Color
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Color)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Color_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Color_obj OBJ_;
+		Color_obj();
+
+	public:
+		enum { _hx_ClassId = 0x204ca266 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket.Color")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket.Color"); }
+
+		inline static ::hx::ObjectPtr< Color_obj > __new() {
+			::hx::ObjectPtr< Color_obj > __this = new Color_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Color_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Color_obj *__this = (Color_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Color_obj), false, "snikket.Color"));
+			*(void **)__this = Color_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Color_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Color",43,e1,89,dd); }
+
+		static ::String forString(::String s);
+		static ::Dynamic forString_dyn();
+
+		static ::String defaultPhoto(::String input,::String letter);
+		static ::Dynamic defaultPhoto_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Color */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/Config.h b/Sources/c_snikket/iinclude/include/snikket/Config.h
new file mode 100644
index 0000000..a987dd2
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/Config.h
@@ -0,0 +1,60 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Config
+#define INCLUDED_snikket_Config
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Config)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Config_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Config_obj OBJ_;
+		Config_obj();
+
+	public:
+		enum { _hx_ClassId = 0x240d085f };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket.Config")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket.Config"); }
+
+		inline static ::hx::ObjectPtr< Config_obj > __new() {
+			::hx::ObjectPtr< Config_obj > __this = new Config_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Config_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Config_obj *__this = (Config_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Config_obj), false, "snikket.Config"));
+			*(void **)__this = Config_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Config_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Config",e2,ca,66,fc); }
+
+		static void __boot();
+		static bool relativeHashUri;
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Config */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/CustomEmojiReaction.h b/Sources/c_snikket/iinclude/include/snikket/CustomEmojiReaction.h
new file mode 100644
index 0000000..304c858
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/CustomEmojiReaction.h
@@ -0,0 +1,62 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_CustomEmojiReaction
+#define INCLUDED_snikket_CustomEmojiReaction
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_Reaction
+#include <snikket/Reaction.h>
+#endif
+HX_DECLARE_CLASS1(snikket,CustomEmojiReaction)
+HX_DECLARE_CLASS1(snikket,Reaction)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES CustomEmojiReaction_obj : public  ::snikket::Reaction_obj
+{
+	public:
+		typedef  ::snikket::Reaction_obj super;
+		typedef CustomEmojiReaction_obj OBJ_;
+		CustomEmojiReaction_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1e93c5e9 };
+
+		void __construct(::String senderId,::String timestamp,::String text,::String uri,::String envelopeId);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.CustomEmojiReaction")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.CustomEmojiReaction"); }
+		static ::hx::ObjectPtr< CustomEmojiReaction_obj > __new(::String senderId,::String timestamp,::String text,::String uri,::String envelopeId);
+		static ::hx::ObjectPtr< CustomEmojiReaction_obj > __alloc(::hx::Ctx *_hx_ctx,::String senderId,::String timestamp,::String text,::String uri,::String envelopeId);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~CustomEmojiReaction_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("CustomEmojiReaction",be,8e,6d,ec); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		::String uri;
+		::String uri__fromC();
+		::Dynamic uri__fromC_dyn();
+
+		 ::Dynamic render( ::Dynamic forText, ::Dynamic forImage);
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_CustomEmojiReaction */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/Date.h b/Sources/c_snikket/iinclude/include/snikket/Date.h
new file mode 100644
index 0000000..19af500
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/Date.h
@@ -0,0 +1,61 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Date
+#define INCLUDED_snikket_Date
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(Date)
+HX_DECLARE_CLASS1(snikket,Date)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Date_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Date_obj OBJ_;
+		Date_obj();
+
+	public:
+		enum { _hx_ClassId = 0x030f768b };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket.Date")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket.Date"); }
+
+		inline static ::hx::ObjectPtr< Date_obj > __new() {
+			::hx::ObjectPtr< Date_obj > __this = new Date_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Date_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Date_obj *__this = (Date_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Date_obj), false, "snikket.Date"));
+			*(void **)__this = Date_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Date_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Date",4e,82,3c,2d); }
+
+		static ::String format( ::Date d);
+		static ::Dynamic format_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Date */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/DirectChat.h b/Sources/c_snikket/iinclude/include/snikket/DirectChat.h
new file mode 100644
index 0000000..e8a37c4
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/DirectChat.h
@@ -0,0 +1,96 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_DirectChat
+#define INCLUDED_snikket_DirectChat
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_Chat
+#include <snikket/Chat.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Chat)
+HX_DECLARE_CLASS1(snikket,ChatMessage)
+HX_DECLARE_CLASS1(snikket,ChatMessageBuilder)
+HX_DECLARE_CLASS1(snikket,Client)
+HX_DECLARE_CLASS1(snikket,DirectChat)
+HX_DECLARE_CLASS1(snikket,EventEmitter)
+HX_DECLARE_CLASS1(snikket,GenericStream)
+HX_DECLARE_CLASS1(snikket,Participant)
+HX_DECLARE_CLASS1(snikket,Persistence)
+HX_DECLARE_CLASS1(snikket,Reaction)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES DirectChat_obj : public  ::snikket::Chat_obj
+{
+	public:
+		typedef  ::snikket::Chat_obj super;
+		typedef DirectChat_obj OBJ_;
+		DirectChat_obj();
+
+	public:
+		enum { _hx_ClassId = 0x62c262be };
+
+		void __construct( ::snikket::Client client, ::snikket::GenericStream stream,::Dynamic persistence,::String chatId,::hx::Null< int >  __o_uiState,::hx::Null< bool >  __o_isBlocked, ::snikket::Stanza extensions,::String readUpToId,::String readUpToBy);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.DirectChat")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.DirectChat"); }
+		static ::hx::ObjectPtr< DirectChat_obj > __new( ::snikket::Client client, ::snikket::GenericStream stream,::Dynamic persistence,::String chatId,::hx::Null< int >  __o_uiState,::hx::Null< bool >  __o_isBlocked, ::snikket::Stanza extensions,::String readUpToId,::String readUpToBy);
+		static ::hx::ObjectPtr< DirectChat_obj > __alloc(::hx::Ctx *_hx_ctx, ::snikket::Client client, ::snikket::GenericStream stream,::Dynamic persistence,::String chatId,::hx::Null< int >  __o_uiState,::hx::Null< bool >  __o_isBlocked, ::snikket::Stanza extensions,::String readUpToId,::String readUpToBy);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~DirectChat_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DirectChat",c1,22,a3,05); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		::Array< ::String > getParticipants();
+
+		::Array< ::String > counterparts();
+		::Dynamic counterparts_dyn();
+
+		 ::snikket::Participant getParticipantDetails(::String participantId);
+
+		void getMessagesBefore(::String beforeId,::String beforeTime, ::Dynamic handler);
+
+		void getMessagesAfter(::String afterId,::String afterTime, ::Dynamic handler);
+
+		void getMessagesAround(::String aroundId,::String aroundTime, ::Dynamic handler);
+
+		 ::snikket::ChatMessageBuilder prepareIncomingMessage( ::snikket::ChatMessageBuilder message, ::snikket::Stanza stanza);
+
+		 ::snikket::ChatMessageBuilder prepareOutgoingMessage( ::snikket::ChatMessageBuilder message);
+		::Dynamic prepareOutgoingMessage_dyn();
+
+		void correctMessage(::String localId, ::snikket::ChatMessageBuilder message);
+
+		void sendMessage( ::snikket::ChatMessageBuilder message);
+
+		void removeReaction( ::snikket::ChatMessage m, ::snikket::Reaction reaction);
+
+		::String lastMessageId();
+
+		void markReadUpTo( ::snikket::ChatMessage message);
+
+		void bookmark();
+
+		void sendChatState(::String state,::String threadId);
+
+		void close();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_DirectChat */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/Emoji.h b/Sources/c_snikket/iinclude/include/snikket/Emoji.h
new file mode 100644
index 0000000..685d92e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/Emoji.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Emoji
+#define INCLUDED_snikket_Emoji
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_Symbol
+#include <snikket/Symbol.h>
+#endif
+HX_DECLARE_STACK_FRAME(_hx_pos_dd1b4f8973e1f9df_136_new)
+HX_DECLARE_CLASS1(snikket,Emoji)
+HX_DECLARE_CLASS1(snikket,Symbol)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Emoji_obj : public  ::snikket::Symbol_obj
+{
+	public:
+		typedef  ::snikket::Symbol_obj super;
+		typedef Emoji_obj OBJ_;
+		Emoji_obj();
+
+	public:
+		enum { _hx_ClassId = 0x45c9a089 };
+
+		void __construct(::Array< int > codepoints);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Emoji")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Emoji"); }
+
+		inline static ::hx::ObjectPtr< Emoji_obj > __new(::Array< int > codepoints) {
+			::hx::ObjectPtr< Emoji_obj > __this = new Emoji_obj();
+			__this->__construct(codepoints);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Emoji_obj > __alloc(::hx::Ctx *_hx_ctx,::Array< int > codepoints) {
+			Emoji_obj *__this = (Emoji_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Emoji_obj), true, "snikket.Emoji"));
+			*(void **)__this = Emoji_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_dd1b4f8973e1f9df_136_new)
+HXDLIN( 136)		__this->super::__construct(codepoints);
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Emoji_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Emoji",66,df,06,03); }
+
+		bool isEmoji();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Emoji */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/EmojiUtil.h b/Sources/c_snikket/iinclude/include/snikket/EmojiUtil.h
new file mode 100644
index 0000000..f45f679
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/EmojiUtil.h
@@ -0,0 +1,95 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_EmojiUtil
+#define INCLUDED_snikket_EmojiUtil
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,EmojiUtil)
+HX_DECLARE_CLASS1(snikket,Symbol)
+HX_DECLARE_CLASS1(snikket,UnicodeBlocks)
+HX_DECLARE_CLASS1(snikket,UnicodeList)
+HX_DECLARE_CLASS1(snikket,UnicodeRange)
+HX_DECLARE_CLASS1(snikket,UnicodeSet)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES EmojiUtil_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef EmojiUtil_obj OBJ_;
+		EmojiUtil_obj();
+
+	public:
+		enum { _hx_ClassId = 0x636eb1f3 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket.EmojiUtil")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket.EmojiUtil"); }
+
+		inline static ::hx::ObjectPtr< EmojiUtil_obj > __new() {
+			::hx::ObjectPtr< EmojiUtil_obj > __this = new EmojiUtil_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< EmojiUtil_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			EmojiUtil_obj *__this = (EmojiUtil_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(EmojiUtil_obj), false, "snikket.EmojiUtil"));
+			*(void **)__this = EmojiUtil_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~EmojiUtil_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("EmojiUtil",88,0e,c9,4c); }
+
+		static void __boot();
+		static  ::snikket::UnicodeRange MISC_SYMBOLS_AND_PICTOGRAPHS;
+		static  ::snikket::UnicodeRange SUPPLEMENTAL_SYMBOLS;
+		static  ::snikket::UnicodeRange EMOTICONS;
+		static  ::snikket::UnicodeRange MISC_SYMBOLS;
+		static  ::snikket::UnicodeRange DINGBATS;
+		static  ::snikket::UnicodeRange ENCLOSED_ALPHANUMERIC_SUPPLEMENT;
+		static  ::snikket::UnicodeRange ENCLOSED_IDEOGRAPHIC_SUPPLEMENT;
+		static  ::snikket::UnicodeRange REGIONAL_INDICATORS;
+		static  ::snikket::UnicodeRange GEOMETRIC_SHAPES;
+		static  ::snikket::UnicodeRange LATIN_SUPPLEMENT;
+		static  ::snikket::UnicodeRange MISC_TECHNICAL;
+		static  ::snikket::UnicodeRange TAGS;
+		static  ::snikket::UnicodeList CYK_SYMBOLS_AND_PUNCTUATION;
+		static  ::snikket::UnicodeList LETTERLIKE_SYMBOLS;
+		static  ::snikket::UnicodeBlocks KEYCAP_COMBINEABLE;
+		static  ::snikket::UnicodeBlocks SYMBOLIZE;
+		static  ::snikket::UnicodeBlocks EMOJIS;
+		static int ZWJ;
+		static int VARIATION_16;
+		static int COMBINING_ENCLOSING_KEYCAP;
+		static int BLACK_FLAG;
+		static  ::snikket::UnicodeRange FITZPATRICK;
+		static ::Array< ::Dynamic> parse(::String str);
+		static ::Dynamic parse_dyn();
+
+		static bool isEmoji(::String input);
+		static ::Dynamic isEmoji_dyn();
+
+		static bool isOnlyEmoji(::String input);
+		static ::Dynamic isOnlyEmoji_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_EmojiUtil */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/EventEmitter.h b/Sources/c_snikket/iinclude/include/snikket/EventEmitter.h
new file mode 100644
index 0000000..7b9ee4d
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/EventEmitter.h
@@ -0,0 +1,64 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_EventEmitter
+#define INCLUDED_snikket_EventEmitter
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS1(snikket,EventEmitter)
+HX_DECLARE_CLASS1(snikket,EventHandler)
+HX_DECLARE_CLASS1(snikket,EventResult)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES EventEmitter_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef EventEmitter_obj OBJ_;
+		EventEmitter_obj();
+
+	public:
+		enum { _hx_ClassId = 0x6aca71d1 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.EventEmitter")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.EventEmitter"); }
+		static ::hx::ObjectPtr< EventEmitter_obj > __new();
+		static ::hx::ObjectPtr< EventEmitter_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~EventEmitter_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("EventEmitter",94,78,5d,17); }
+
+		 ::haxe::ds::StringMap eventHandlers;
+		 ::snikket::EventHandler on(::String eventName, ::Dynamic callback);
+		::Dynamic on_dyn();
+
+		 ::snikket::EventHandler once(::String eventName, ::Dynamic callback);
+		::Dynamic once_dyn();
+
+		 ::snikket::EventResult trigger(::String eventName, ::Dynamic eventData);
+		::Dynamic trigger_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_EventEmitter */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/EventHandler.h b/Sources/c_snikket/iinclude/include/snikket/EventHandler.h
new file mode 100644
index 0000000..c25353d
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/EventHandler.h
@@ -0,0 +1,64 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_EventHandler
+#define INCLUDED_snikket_EventHandler
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,EventHandler)
+HX_DECLARE_CLASS1(snikket,EventResult)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES EventHandler_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef EventHandler_obj OBJ_;
+		EventHandler_obj();
+
+	public:
+		enum { _hx_ClassId = 0x39717849 };
+
+		void __construct(::Array< ::Dynamic> handlers, ::Dynamic callback, ::Dynamic onlyOnce);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.EventHandler")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.EventHandler"); }
+		static ::hx::ObjectPtr< EventHandler_obj > __new(::Array< ::Dynamic> handlers, ::Dynamic callback, ::Dynamic onlyOnce);
+		static ::hx::ObjectPtr< EventHandler_obj > __alloc(::hx::Ctx *_hx_ctx,::Array< ::Dynamic> handlers, ::Dynamic callback, ::Dynamic onlyOnce);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~EventHandler_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("EventHandler",f0,f2,3c,9e); }
+
+		::Array< ::Dynamic> handlers;
+		 ::Dynamic callback;
+		Dynamic callback_dyn() { return callback;}
+		bool onlyOnce;
+		 ::snikket::EventResult call( ::Dynamic data);
+		::Dynamic call_dyn();
+
+		 ::snikket::EventHandler once();
+		::Dynamic once_dyn();
+
+		void unsubscribe();
+		::Dynamic unsubscribe_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_EventHandler */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/EventResult.h b/Sources/c_snikket/iinclude/include/snikket/EventResult.h
new file mode 100644
index 0000000..b3b5504
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/EventResult.h
@@ -0,0 +1,39 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_EventResult
+#define INCLUDED_snikket_EventResult
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,EventResult)
+namespace snikket{
+
+
+class EventResult_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef EventResult_obj OBJ_;
+
+	public:
+		EventResult_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("snikket.EventResult",06,97,23,e2); }
+		::String __ToString() const { return HX_("EventResult.",d7,9b,be,c3) + _hx_tag; }
+
+		static ::snikket::EventResult EventHandled;
+		static inline ::snikket::EventResult EventHandled_dyn() { return EventHandled; }
+		static ::snikket::EventResult EventStop;
+		static inline ::snikket::EventResult EventStop_dyn() { return EventStop; }
+		static ::snikket::EventResult EventUnhandled;
+		static inline ::snikket::EventResult EventUnhandled_dyn() { return EventUnhandled; }
+		static ::snikket::EventResult EventValue( ::Dynamic result);
+		static ::Dynamic EventValue_dyn();
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_EventResult */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/GenericStream.h b/Sources/c_snikket/iinclude/include/snikket/GenericStream.h
new file mode 100644
index 0000000..50fc0bd
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/GenericStream.h
@@ -0,0 +1,72 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_GenericStream
+#define INCLUDED_snikket_GenericStream
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_EventEmitter
+#include <snikket/EventEmitter.h>
+#endif
+HX_DECLARE_CLASS1(snikket,EventEmitter)
+HX_DECLARE_CLASS1(snikket,GenericStream)
+HX_DECLARE_CLASS1(snikket,IqRequestType)
+HX_DECLARE_CLASS1(snikket,IqResult)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES GenericStream_obj : public  ::snikket::EventEmitter_obj
+{
+	public:
+		typedef  ::snikket::EventEmitter_obj super;
+		typedef GenericStream_obj OBJ_;
+		GenericStream_obj();
+
+	public:
+		enum { _hx_ClassId = 0x785c9e5e };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.GenericStream")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.GenericStream"); }
+
+		//~GenericStream_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("GenericStream",d7,75,9c,45); }
+
+		::String clientId;
+		bool csi;
+		virtual void connect(::String jid,::Array< unsigned char > sm) {}
+		::Dynamic connect_dyn();
+		virtual void disconnect() {}
+		::Dynamic disconnect_dyn();
+		virtual void sendStanza( ::snikket::Stanza stanza) {}
+		::Dynamic sendStanza_dyn();
+		virtual ::String newId() { return 0; }
+		::Dynamic newId_dyn();
+		virtual void onIq( ::snikket::IqRequestType type,::String tag,::String xmlns, ::Dynamic handler) {}
+		::Dynamic onIq_dyn();
+		void sendIq( ::snikket::Stanza stanza, ::Dynamic callback);
+		::Dynamic sendIq_dyn();
+
+		void onStanza( ::snikket::Stanza stanza);
+		::Dynamic onStanza_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_GenericStream */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/Hash.h b/Sources/c_snikket/iinclude/include/snikket/Hash.h
new file mode 100644
index 0000000..8be664d
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/Hash.h
@@ -0,0 +1,89 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Hash
+#define INCLUDED_snikket_Hash
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS1(snikket,Hash)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Hash_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Hash_obj OBJ_;
+		Hash_obj();
+
+	public:
+		enum { _hx_ClassId = 0x05b4502b };
+
+		void __construct(::String algorithm,::Array< unsigned char > hash);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Hash")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Hash"); }
+		static ::hx::ObjectPtr< Hash_obj > __new(::String algorithm,::Array< unsigned char > hash);
+		static ::hx::ObjectPtr< Hash_obj > __alloc(::hx::Ctx *_hx_ctx,::String algorithm,::Array< unsigned char > hash);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Hash_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Hash",ee,5b,e1,2f); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static  ::snikket::Hash fromHex(::String algorithm,::String hash);
+		static ::Dynamic fromHex_dyn();
+
+		static  ::snikket::Hash fromUri(::String uri);
+		static ::Dynamic fromUri_dyn();
+
+		static  ::snikket::Hash sha1( ::haxe::io::Bytes bytes);
+		static ::Dynamic sha1_dyn();
+
+		static  ::snikket::Hash sha256( ::haxe::io::Bytes bytes);
+		static ::Dynamic sha256_dyn();
+
+		::String algorithm;
+		::String algorithm__fromC();
+		::Dynamic algorithm__fromC_dyn();
+
+		::Array< unsigned char > hash;
+		::String toUri();
+		::Dynamic toUri_dyn();
+
+		::String bobUri();
+		::Dynamic bobUri_dyn();
+
+		::String serializeUri();
+		::Dynamic serializeUri_dyn();
+
+		::String toHex();
+		::Dynamic toHex_dyn();
+
+		::String toBase64();
+		::Dynamic toBase64_dyn();
+
+		::String toBase64Url();
+		::Dynamic toBase64Url_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Hash */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/ID.h b/Sources/c_snikket/iinclude/include/snikket/ID.h
new file mode 100644
index 0000000..6d5d8c6
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/ID.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_ID
+#define INCLUDED_snikket_ID
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,ID)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES ID_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef ID_obj OBJ_;
+		ID_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5880bad8 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket.ID")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket.ID"); }
+
+		inline static ::hx::ObjectPtr< ID_obj > __new() {
+			::hx::ObjectPtr< ID_obj > __this = new ID_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< ID_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			ID_obj *__this = (ID_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(ID_obj), false, "snikket.ID"));
+			*(void **)__this = ID_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ID_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ID",db,3f,00,00); }
+
+		static ::String tiny();
+		static ::Dynamic tiny_dyn();
+
+		static ::String _hx_short();
+		static ::Dynamic _hx_short_dyn();
+
+		static ::String medium();
+		static ::Dynamic medium_dyn();
+
+		static ::String _hx_long();
+		static ::Dynamic _hx_long_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_ID */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/Identicon.h b/Sources/c_snikket/iinclude/include/snikket/Identicon.h
new file mode 100644
index 0000000..f440dab
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/Identicon.h
@@ -0,0 +1,60 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Identicon
+#define INCLUDED_snikket_Identicon
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Identicon)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Identicon_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Identicon_obj OBJ_;
+		Identicon_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3ab0d0ec };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket.Identicon")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket.Identicon"); }
+
+		inline static ::hx::ObjectPtr< Identicon_obj > __new() {
+			::hx::ObjectPtr< Identicon_obj > __this = new Identicon_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Identicon_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Identicon_obj *__this = (Identicon_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Identicon_obj), false, "snikket.Identicon"));
+			*(void **)__this = Identicon_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Identicon_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Identicon",49,42,f3,f1); }
+
+		static ::String svg(::String source);
+		static ::Dynamic svg_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Identicon */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/Identity.h b/Sources/c_snikket/iinclude/include/snikket/Identity.h
new file mode 100644
index 0000000..28c9c85
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/Identity.h
@@ -0,0 +1,61 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Identity
+#define INCLUDED_snikket_Identity
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Identity)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Identity_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Identity_obj OBJ_;
+		Identity_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7fcd1307 };
+
+		void __construct(::String category,::String type,::String name);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Identity")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Identity"); }
+		static ::hx::ObjectPtr< Identity_obj > __new(::String category,::String type,::String name);
+		static ::hx::ObjectPtr< Identity_obj > __alloc(::hx::Ctx *_hx_ctx,::String category,::String type,::String name);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Identity_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Identity",5e,01,e1,92); }
+
+		::String category;
+		::String type;
+		::String name;
+		void addToDisco( ::snikket::Stanza stanza);
+		::Dynamic addToDisco_dyn();
+
+		::String ver();
+		::Dynamic ver_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Identity */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/IqRequestType.h b/Sources/c_snikket/iinclude/include/snikket/IqRequestType.h
new file mode 100644
index 0000000..b4f759d
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/IqRequestType.h
@@ -0,0 +1,35 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_IqRequestType
+#define INCLUDED_snikket_IqRequestType
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,IqRequestType)
+namespace snikket{
+
+
+class IqRequestType_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef IqRequestType_obj OBJ_;
+
+	public:
+		IqRequestType_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("snikket.IqRequestType",d0,62,72,94); }
+		::String __ToString() const { return HX_("IqRequestType.",8d,9a,13,cc) + _hx_tag; }
+
+		static ::snikket::IqRequestType Get;
+		static inline ::snikket::IqRequestType Get_dyn() { return Get; }
+		static ::snikket::IqRequestType Set;
+		static inline ::snikket::IqRequestType Set_dyn() { return Set; }
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_IqRequestType */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/IqResult.h b/Sources/c_snikket/iinclude/include/snikket/IqResult.h
new file mode 100644
index 0000000..81b0271
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/IqResult.h
@@ -0,0 +1,39 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_IqResult
+#define INCLUDED_snikket_IqResult
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,IqResult)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+namespace snikket{
+
+
+class IqResult_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef IqResult_obj OBJ_;
+
+	public:
+		IqResult_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("snikket.IqResult",16,e9,a3,c2); }
+		::String __ToString() const { return HX_("IqResult.",89,d1,c3,9e) + _hx_tag; }
+
+		static ::snikket::IqResult IqNoResult;
+		static inline ::snikket::IqResult IqNoResult_dyn() { return IqNoResult; }
+		static ::snikket::IqResult IqResult;
+		static inline ::snikket::IqResult IqResult_dyn() { return IqResult; }
+		static ::snikket::IqResult IqResultElement( ::snikket::Stanza element);
+		static ::Dynamic IqResultElement_dyn();
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_IqResult */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/JID.h b/Sources/c_snikket/iinclude/include/snikket/JID.h
new file mode 100644
index 0000000..c64d0d0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/JID.h
@@ -0,0 +1,78 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_JID
+#define INCLUDED_snikket_JID
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,JID)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES JID_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef JID_obj OBJ_;
+		JID_obj();
+
+	public:
+		enum { _hx_ClassId = 0x18238908 };
+
+		void __construct(::String node,::String domain,::String resource);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.JID")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.JID"); }
+		static ::hx::ObjectPtr< JID_obj > __new(::String node,::String domain,::String resource);
+		static ::hx::ObjectPtr< JID_obj > __alloc(::hx::Ctx *_hx_ctx,::String node,::String domain,::String resource);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~JID_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("JID",a5,66,38,00); }
+
+		static  ::snikket::JID parse(::String jid);
+		static ::Dynamic parse_dyn();
+
+		::String node;
+		::String domain;
+		::String resource;
+		 ::snikket::JID asBare();
+		::Dynamic asBare_dyn();
+
+		 ::snikket::JID withResource(::String resource);
+		::Dynamic withResource_dyn();
+
+		bool isValid();
+		::Dynamic isValid_dyn();
+
+		bool isDomain();
+		::Dynamic isDomain_dyn();
+
+		bool isBare();
+		::Dynamic isBare_dyn();
+
+		bool equals( ::snikket::JID rhs);
+		::Dynamic equals_dyn();
+
+		::String asString();
+		::Dynamic asString_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_JID */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/Message.h b/Sources/c_snikket/iinclude/include/snikket/Message.h
new file mode 100644
index 0000000..931dcc6
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/Message.h
@@ -0,0 +1,63 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Message
+#define INCLUDED_snikket_Message
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,ChatMessageBuilder)
+HX_DECLARE_CLASS1(snikket,JID)
+HX_DECLARE_CLASS1(snikket,Message)
+HX_DECLARE_CLASS1(snikket,MessageStanza)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Message_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Message_obj OBJ_;
+		Message_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7c0c6d2e };
+
+		void __construct(::String chatId,::String senderId,::String threadId, ::snikket::MessageStanza parsed);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Message")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Message"); }
+		static ::hx::ObjectPtr< Message_obj > __new(::String chatId,::String senderId,::String threadId, ::snikket::MessageStanza parsed);
+		static ::hx::ObjectPtr< Message_obj > __alloc(::hx::Ctx *_hx_ctx,::String chatId,::String senderId,::String threadId, ::snikket::MessageStanza parsed);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Message_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Message",a7,5d,62,67); }
+
+		static  ::snikket::Message fromStanza( ::snikket::Stanza stanza, ::snikket::JID localJid, ::Dynamic addContext);
+		static ::Dynamic fromStanza_dyn();
+
+		::String chatId;
+		::String senderId;
+		::String threadId;
+		 ::snikket::MessageStanza parsed;
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Message */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/MessageStanza.h b/Sources/c_snikket/iinclude/include/snikket/MessageStanza.h
new file mode 100644
index 0000000..486e5a6
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/MessageStanza.h
@@ -0,0 +1,46 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_MessageStanza
+#define INCLUDED_snikket_MessageStanza
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,ChatMessage)
+HX_DECLARE_CLASS1(snikket,MessageStanza)
+HX_DECLARE_CLASS1(snikket,ModerationAction)
+HX_DECLARE_CLASS1(snikket,ReactionUpdate)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+namespace snikket{
+
+
+class MessageStanza_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef MessageStanza_obj OBJ_;
+
+	public:
+		MessageStanza_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("snikket.MessageStanza",4b,b3,84,a4); }
+		::String __ToString() const { return HX_("MessageStanza.",b2,b5,07,cc) + _hx_tag; }
+
+		static ::snikket::MessageStanza ChatMessageStanza( ::snikket::ChatMessage message);
+		static ::Dynamic ChatMessageStanza_dyn();
+		static ::snikket::MessageStanza ErrorMessageStanza( ::snikket::Stanza stanza);
+		static ::Dynamic ErrorMessageStanza_dyn();
+		static ::snikket::MessageStanza ModerateMessageStanza( ::snikket::ModerationAction action);
+		static ::Dynamic ModerateMessageStanza_dyn();
+		static ::snikket::MessageStanza ReactionUpdateStanza( ::snikket::ReactionUpdate update);
+		static ::Dynamic ReactionUpdateStanza_dyn();
+		static ::snikket::MessageStanza UnknownMessageStanza( ::snikket::Stanza stanza);
+		static ::Dynamic UnknownMessageStanza_dyn();
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_MessageStanza */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/MessageSync.h b/Sources/c_snikket/iinclude/include/snikket/MessageSync.h
new file mode 100644
index 0000000..7469276
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/MessageSync.h
@@ -0,0 +1,91 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_MessageSync
+#define INCLUDED_snikket_MessageSync
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS1(snikket,ChatMessageBuilder)
+HX_DECLARE_CLASS1(snikket,Client)
+HX_DECLARE_CLASS1(snikket,EventEmitter)
+HX_DECLARE_CLASS1(snikket,GenericStream)
+HX_DECLARE_CLASS1(snikket,MessageSync)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES MessageSync_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef MessageSync_obj OBJ_;
+		MessageSync_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0c8e50c1 };
+
+		void __construct( ::snikket::Client client, ::snikket::GenericStream stream, ::Dynamic filter,::String serviceJID);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.MessageSync")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.MessageSync"); }
+		static ::hx::ObjectPtr< MessageSync_obj > __new( ::snikket::Client client, ::snikket::GenericStream stream, ::Dynamic filter,::String serviceJID);
+		static ::hx::ObjectPtr< MessageSync_obj > __alloc(::hx::Ctx *_hx_ctx, ::snikket::Client client, ::snikket::GenericStream stream, ::Dynamic filter,::String serviceJID);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~MessageSync_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("MessageSync",a2,a3,78,63); }
+
+		 ::snikket::Client client;
+		 ::snikket::GenericStream stream;
+		 ::Dynamic filter;
+		::String serviceJID;
+		 ::Dynamic handler;
+		Dynamic handler_dyn() { return handler;}
+		 ::Dynamic contextHandler;
+		Dynamic contextHandler_dyn() { return contextHandler;}
+		 ::Dynamic errorHandler;
+		Dynamic errorHandler_dyn() { return errorHandler;}
+		 ::Dynamic lastPage;
+		int progress;
+		bool complete;
+		bool newestPageFirst;
+		 ::haxe::ds::StringMap jmi;
+		void fetchNext();
+		::Dynamic fetchNext_dyn();
+
+		bool hasMore();
+		::Dynamic hasMore_dyn();
+
+		void addContext( ::Dynamic handler);
+		::Dynamic addContext_dyn();
+
+		void onMessages( ::Dynamic handler);
+		::Dynamic onMessages_dyn();
+
+		void onError( ::Dynamic handler);
+		::Dynamic onError_dyn();
+
+		void setNewestPageFirst(bool newestPageFirst);
+		::Dynamic setNewestPageFirst_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_MessageSync */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/ModerationAction.h b/Sources/c_snikket/iinclude/include/snikket/ModerationAction.h
new file mode 100644
index 0000000..16f7e22
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/ModerationAction.h
@@ -0,0 +1,76 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_ModerationAction
+#define INCLUDED_snikket_ModerationAction
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_cab007b58fe42bf8_10_new)
+HX_DECLARE_CLASS1(snikket,ModerationAction)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES ModerationAction_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef ModerationAction_obj OBJ_;
+		ModerationAction_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2ac69cd9 };
+
+		void __construct(::String chatId,::String moderateServerId,::String timestamp,::String moderatorId,::String reason);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.ModerationAction")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.ModerationAction"); }
+
+		inline static ::hx::ObjectPtr< ModerationAction_obj > __new(::String chatId,::String moderateServerId,::String timestamp,::String moderatorId,::String reason) {
+			::hx::ObjectPtr< ModerationAction_obj > __this = new ModerationAction_obj();
+			__this->__construct(chatId,moderateServerId,timestamp,moderatorId,reason);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< ModerationAction_obj > __alloc(::hx::Ctx *_hx_ctx,::String chatId,::String moderateServerId,::String timestamp,::String moderatorId,::String reason) {
+			ModerationAction_obj *__this = (ModerationAction_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(ModerationAction_obj), true, "snikket.ModerationAction"));
+			*(void **)__this = ModerationAction_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_cab007b58fe42bf8_10_new)
+HXLINE(  11)		( ( ::snikket::ModerationAction)(__this) )->chatId = chatId;
+HXLINE(  12)		( ( ::snikket::ModerationAction)(__this) )->moderateServerId = moderateServerId;
+HXLINE(  13)		( ( ::snikket::ModerationAction)(__this) )->timestamp = timestamp;
+HXLINE(  14)		( ( ::snikket::ModerationAction)(__this) )->moderatorId = moderatorId;
+HXLINE(  15)		( ( ::snikket::ModerationAction)(__this) )->reason = reason;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ModerationAction_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ModerationAction",1c,c1,77,cb); }
+
+		::String chatId;
+		::String moderateServerId;
+		::String timestamp;
+		::String moderatorId;
+		::String reason;
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_ModerationAction */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/Node.h b/Sources/c_snikket/iinclude/include/snikket/Node.h
new file mode 100644
index 0000000..31bf990
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/Node.h
@@ -0,0 +1,38 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Node
+#define INCLUDED_snikket_Node
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Node)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS1(snikket,TextNode)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+namespace snikket{
+
+
+class Node_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef Node_obj OBJ_;
+
+	public:
+		Node_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("snikket.Node",b3,af,c7,53); }
+		::String __ToString() const { return HX_("Node.",cc,27,ec,32) + _hx_tag; }
+
+		static ::snikket::Node CData( ::snikket::TextNode textNode);
+		static ::Dynamic CData_dyn();
+		static ::snikket::Node Element( ::snikket::Stanza stanza);
+		static ::Dynamic Element_dyn();
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Node */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/Notification.h b/Sources/c_snikket/iinclude/include/snikket/Notification.h
new file mode 100644
index 0000000..d41f56b
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/Notification.h
@@ -0,0 +1,98 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Notification
+#define INCLUDED_snikket_Notification
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_b0a79cae3ba17812_21_new)
+HX_DECLARE_CLASS1(snikket,ChatMessage)
+HX_DECLARE_CLASS1(snikket,Notification)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Notification_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Notification_obj OBJ_;
+		Notification_obj();
+
+	public:
+		enum { _hx_ClassId = 0x778a3c48 };
+
+		void __construct(::String title,::String body,::String accountId,::String chatId,::String messageId,int type,::String callStatus,::String callSid,::String imageUri,::String lang,::String timestamp);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Notification")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Notification"); }
+
+		inline static ::hx::ObjectPtr< Notification_obj > __new(::String title,::String body,::String accountId,::String chatId,::String messageId,int type,::String callStatus,::String callSid,::String imageUri,::String lang,::String timestamp) {
+			::hx::ObjectPtr< Notification_obj > __this = new Notification_obj();
+			__this->__construct(title,body,accountId,chatId,messageId,type,callStatus,callSid,imageUri,lang,timestamp);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Notification_obj > __alloc(::hx::Ctx *_hx_ctx,::String title,::String body,::String accountId,::String chatId,::String messageId,int type,::String callStatus,::String callSid,::String imageUri,::String lang,::String timestamp) {
+			Notification_obj *__this = (Notification_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Notification_obj), true, "snikket.Notification"));
+			*(void **)__this = Notification_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_b0a79cae3ba17812_21_new)
+HXLINE(  22)		( ( ::snikket::Notification)(__this) )->title = title;
+HXLINE(  23)		( ( ::snikket::Notification)(__this) )->body = body;
+HXLINE(  24)		( ( ::snikket::Notification)(__this) )->accountId = accountId;
+HXLINE(  25)		( ( ::snikket::Notification)(__this) )->chatId = chatId;
+HXLINE(  26)		( ( ::snikket::Notification)(__this) )->messageId = messageId;
+HXLINE(  27)		( ( ::snikket::Notification)(__this) )->type = type;
+HXLINE(  28)		( ( ::snikket::Notification)(__this) )->callStatus = callStatus;
+HXLINE(  29)		( ( ::snikket::Notification)(__this) )->callSid = callSid;
+HXLINE(  30)		( ( ::snikket::Notification)(__this) )->imageUri = imageUri;
+HXLINE(  31)		( ( ::snikket::Notification)(__this) )->lang = lang;
+HXLINE(  32)		( ( ::snikket::Notification)(__this) )->timestamp = timestamp;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Notification_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Notification",0b,43,1d,24); }
+
+		static  ::snikket::Notification fromChatMessage( ::snikket::ChatMessage m);
+		static ::Dynamic fromChatMessage_dyn();
+
+		static  ::snikket::Notification fromThinStanza( ::snikket::Stanza stanza);
+		static ::Dynamic fromThinStanza_dyn();
+
+		::String title;
+		::String body;
+		::String accountId;
+		::String chatId;
+		::String messageId;
+		int type;
+		::String callStatus;
+		::String callSid;
+		::String imageUri;
+		::String lang;
+		::String timestamp;
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Notification */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/Other.h b/Sources/c_snikket/iinclude/include/snikket/Other.h
new file mode 100644
index 0000000..500f13e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/Other.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Other
+#define INCLUDED_snikket_Other
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_Symbol
+#include <snikket/Symbol.h>
+#endif
+HX_DECLARE_STACK_FRAME(_hx_pos_aac171f877c525f9_146_new)
+HX_DECLARE_CLASS1(snikket,Other)
+HX_DECLARE_CLASS1(snikket,Symbol)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Other_obj : public  ::snikket::Symbol_obj
+{
+	public:
+		typedef  ::snikket::Symbol_obj super;
+		typedef Other_obj OBJ_;
+		Other_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0c6697d3 };
+
+		void __construct(::Array< int > codepoints);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Other")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Other"); }
+
+		inline static ::hx::ObjectPtr< Other_obj > __new(::Array< int > codepoints) {
+			::hx::ObjectPtr< Other_obj > __this = new Other_obj();
+			__this->__construct(codepoints);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Other_obj > __alloc(::hx::Ctx *_hx_ctx,::Array< int > codepoints) {
+			Other_obj *__this = (Other_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Other_obj), true, "snikket.Other"));
+			*(void **)__this = Other_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_aac171f877c525f9_146_new)
+HXDLIN( 146)		__this->super::__construct(codepoints);
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Other_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Other",b0,d6,a3,c9); }
+
+		bool isEmoji();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Other */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/Participant.h b/Sources/c_snikket/iinclude/include/snikket/Participant.h
new file mode 100644
index 0000000..5317907
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/Participant.h
@@ -0,0 +1,88 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Participant
+#define INCLUDED_snikket_Participant
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_33195ab9b813f4c6_20_new)
+HX_DECLARE_CLASS1(snikket,Participant)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Participant_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Participant_obj OBJ_;
+		Participant_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7d555cf6 };
+
+		void __construct(::String displayName,::String photoUri,::String placeholderUri,bool isSelf);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Participant")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Participant"); }
+
+		inline static ::hx::ObjectPtr< Participant_obj > __new(::String displayName,::String photoUri,::String placeholderUri,bool isSelf) {
+			::hx::ObjectPtr< Participant_obj > __this = new Participant_obj();
+			__this->__construct(displayName,photoUri,placeholderUri,isSelf);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Participant_obj > __alloc(::hx::Ctx *_hx_ctx,::String displayName,::String photoUri,::String placeholderUri,bool isSelf) {
+			Participant_obj *__this = (Participant_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Participant_obj), true, "snikket.Participant"));
+			*(void **)__this = Participant_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_33195ab9b813f4c6_20_new)
+HXLINE(  21)		( ( ::snikket::Participant)(__this) )->displayName = displayName;
+HXLINE(  22)		( ( ::snikket::Participant)(__this) )->photoUri = photoUri;
+HXLINE(  23)		( ( ::snikket::Participant)(__this) )->placeholderUri = placeholderUri;
+HXLINE(  24)		( ( ::snikket::Participant)(__this) )->isSelf = isSelf;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Participant_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Participant",93,9f,1c,5f); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		::String displayName;
+		::String displayName__fromC();
+		::Dynamic displayName__fromC_dyn();
+
+		::String photoUri;
+		::String photoUri__fromC();
+		::Dynamic photoUri__fromC_dyn();
+
+		::String placeholderUri;
+		::String placeholderUri__fromC();
+		::Dynamic placeholderUri__fromC_dyn();
+
+		bool isSelf;
+		bool isSelf__fromC();
+		::Dynamic isSelf__fromC_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Participant */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/Persistence.h b/Sources/c_snikket/iinclude/include/snikket/Persistence.h
new file mode 100644
index 0000000..b3621d1
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/Persistence.h
@@ -0,0 +1,129 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Persistence
+#define INCLUDED_snikket_Persistence
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Caps)
+HX_DECLARE_CLASS1(snikket,Chat)
+HX_DECLARE_CLASS1(snikket,ChatMessage)
+HX_DECLARE_CLASS1(snikket,Persistence)
+HX_DECLARE_CLASS1(snikket,ReactionUpdate)
+HX_DECLARE_CLASS1(snikket,SerializedChat)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Persistence_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		static void __boot();
+		void (::hx::Object :: *_hx_lastId)(::String accountId,::String chatId, ::Dynamic callback); 
+		static inline void lastId( ::Dynamic _hx_,::String accountId,::String chatId, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_lastId)(accountId,chatId,callback);
+		}
+		void (::hx::Object :: *_hx_storeChats)(::String accountId,::Array< ::Dynamic> chats); 
+		static inline void storeChats( ::Dynamic _hx_,::String accountId,::Array< ::Dynamic> chats) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_storeChats)(accountId,chats);
+		}
+		void (::hx::Object :: *_hx_getChats)(::String accountId, ::Dynamic callback); 
+		static inline void getChats( ::Dynamic _hx_,::String accountId, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_getChats)(accountId,callback);
+		}
+		void (::hx::Object :: *_hx_getChatsUnreadDetails)(::String accountId,::Array< ::Dynamic> chats, ::Dynamic callback); 
+		static inline void getChatsUnreadDetails( ::Dynamic _hx_,::String accountId,::Array< ::Dynamic> chats, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_getChatsUnreadDetails)(accountId,chats,callback);
+		}
+		void (::hx::Object :: *_hx_storeReaction)(::String accountId, ::snikket::ReactionUpdate update, ::Dynamic callback); 
+		static inline void storeReaction( ::Dynamic _hx_,::String accountId, ::snikket::ReactionUpdate update, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_storeReaction)(accountId,update,callback);
+		}
+		void (::hx::Object :: *_hx_storeMessages)(::String accountId,::Array< ::Dynamic> message, ::Dynamic callback); 
+		static inline void storeMessages( ::Dynamic _hx_,::String accountId,::Array< ::Dynamic> message, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_storeMessages)(accountId,message,callback);
+		}
+		void (::hx::Object :: *_hx_updateMessage)(::String accountId, ::snikket::ChatMessage message); 
+		static inline void updateMessage( ::Dynamic _hx_,::String accountId, ::snikket::ChatMessage message) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_updateMessage)(accountId,message);
+		}
+		void (::hx::Object :: *_hx_updateMessageStatus)(::String accountId,::String localId,int status, ::Dynamic callback); 
+		static inline void updateMessageStatus( ::Dynamic _hx_,::String accountId,::String localId,int status, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_updateMessageStatus)(accountId,localId,status,callback);
+		}
+		void (::hx::Object :: *_hx_getMessage)(::String accountId,::String chatId,::String serverId,::String localId, ::Dynamic callback); 
+		static inline void getMessage( ::Dynamic _hx_,::String accountId,::String chatId,::String serverId,::String localId, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_getMessage)(accountId,chatId,serverId,localId,callback);
+		}
+		void (::hx::Object :: *_hx_getMessagesBefore)(::String accountId,::String chatId,::String beforeId,::String beforeTime, ::Dynamic callback); 
+		static inline void getMessagesBefore( ::Dynamic _hx_,::String accountId,::String chatId,::String beforeId,::String beforeTime, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_getMessagesBefore)(accountId,chatId,beforeId,beforeTime,callback);
+		}
+		void (::hx::Object :: *_hx_getMessagesAfter)(::String accountId,::String chatId,::String afterId,::String afterTime, ::Dynamic callback); 
+		static inline void getMessagesAfter( ::Dynamic _hx_,::String accountId,::String chatId,::String afterId,::String afterTime, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_getMessagesAfter)(accountId,chatId,afterId,afterTime,callback);
+		}
+		void (::hx::Object :: *_hx_getMessagesAround)(::String accountId,::String chatId,::String aroundId,::String aroundTime, ::Dynamic callback); 
+		static inline void getMessagesAround( ::Dynamic _hx_,::String accountId,::String chatId,::String aroundId,::String aroundTime, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_getMessagesAround)(accountId,chatId,aroundId,aroundTime,callback);
+		}
+		void (::hx::Object :: *_hx_hasMedia)(::String hashAlgorithm,::Array< unsigned char > hash, ::Dynamic callback); 
+		static inline void hasMedia( ::Dynamic _hx_,::String hashAlgorithm,::Array< unsigned char > hash, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_hasMedia)(hashAlgorithm,hash,callback);
+		}
+		void (::hx::Object :: *_hx_storeMedia)(::String mime,::Array< unsigned char > bytes, ::Dynamic callback); 
+		static inline void storeMedia( ::Dynamic _hx_,::String mime,::Array< unsigned char > bytes, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_storeMedia)(mime,bytes,callback);
+		}
+		void (::hx::Object :: *_hx_removeMedia)(::String hashAlgorithm,::Array< unsigned char > hash); 
+		static inline void removeMedia( ::Dynamic _hx_,::String hashAlgorithm,::Array< unsigned char > hash) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_removeMedia)(hashAlgorithm,hash);
+		}
+		void (::hx::Object :: *_hx_storeCaps)( ::snikket::Caps caps); 
+		static inline void storeCaps( ::Dynamic _hx_, ::snikket::Caps caps) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_storeCaps)(caps);
+		}
+		void (::hx::Object :: *_hx_getCaps)(::String ver, ::Dynamic callback); 
+		static inline void getCaps( ::Dynamic _hx_,::String ver, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_getCaps)(ver,callback);
+		}
+		void (::hx::Object :: *_hx_storeLogin)(::String login,::String clientId,::String displayName,::String token); 
+		static inline void storeLogin( ::Dynamic _hx_,::String login,::String clientId,::String displayName,::String token) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_storeLogin)(login,clientId,displayName,token);
+		}
+		void (::hx::Object :: *_hx_getLogin)(::String login, ::Dynamic callback); 
+		static inline void getLogin( ::Dynamic _hx_,::String login, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_getLogin)(login,callback);
+		}
+		void (::hx::Object :: *_hx_removeAccount)(::String accountId,bool completely); 
+		static inline void removeAccount( ::Dynamic _hx_,::String accountId,bool completely) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_removeAccount)(accountId,completely);
+		}
+		void (::hx::Object :: *_hx_listAccounts)( ::Dynamic callback); 
+		static inline void listAccounts( ::Dynamic _hx_, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_listAccounts)(callback);
+		}
+		void (::hx::Object :: *_hx_storeStreamManagement)(::String accountId,::Array< unsigned char > data); 
+		static inline void storeStreamManagement( ::Dynamic _hx_,::String accountId,::Array< unsigned char > data) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_storeStreamManagement)(accountId,data);
+		}
+		void (::hx::Object :: *_hx_getStreamManagement)(::String accountId, ::Dynamic callback); 
+		static inline void getStreamManagement( ::Dynamic _hx_,::String accountId, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_getStreamManagement)(accountId,callback);
+		}
+		void (::hx::Object :: *_hx_storeService)(::String accountId,::String serviceId,::String name,::String node, ::snikket::Caps caps); 
+		static inline void storeService( ::Dynamic _hx_,::String accountId,::String serviceId,::String name,::String node, ::snikket::Caps caps) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_storeService)(accountId,serviceId,name,node,caps);
+		}
+		void (::hx::Object :: *_hx_findServicesWithFeature)(::String accountId,::String feature, ::Dynamic callback); 
+		static inline void findServicesWithFeature( ::Dynamic _hx_,::String accountId,::String feature, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_findServicesWithFeature)(accountId,feature,callback);
+		}
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Persistence */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/Presence.h b/Sources/c_snikket/iinclude/include/snikket/Presence.h
new file mode 100644
index 0000000..ac48ae8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/Presence.h
@@ -0,0 +1,55 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Presence
+#define INCLUDED_snikket_Presence
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Caps)
+HX_DECLARE_CLASS1(snikket,Presence)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Presence_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Presence_obj OBJ_;
+		Presence_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4c576518 };
+
+		void __construct( ::snikket::Caps caps, ::snikket::Stanza mucUser);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Presence")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Presence"); }
+		static ::hx::ObjectPtr< Presence_obj > __new( ::snikket::Caps caps, ::snikket::Stanza mucUser);
+		static ::hx::ObjectPtr< Presence_obj > __alloc(::hx::Ctx *_hx_ctx, ::snikket::Caps caps, ::snikket::Stanza mucUser);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Presence_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Presence",5b,0e,89,40); }
+
+		 ::snikket::Caps caps;
+		 ::snikket::Stanza mucUser;
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Presence */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/PubsubEvent.h b/Sources/c_snikket/iinclude/include/snikket/PubsubEvent.h
new file mode 100644
index 0000000..555e1cd
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/PubsubEvent.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_PubsubEvent
+#define INCLUDED_snikket_PubsubEvent
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,PubsubEvent)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES PubsubEvent_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef PubsubEvent_obj OBJ_;
+		PubsubEvent_obj();
+
+	public:
+		enum { _hx_ClassId = 0x04e7c6de };
+
+		void __construct(::String from,::String to,::String node,::Array< ::Dynamic> items);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.PubsubEvent")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.PubsubEvent"); }
+		static ::hx::ObjectPtr< PubsubEvent_obj > __new(::String from,::String to,::String node,::Array< ::Dynamic> items);
+		static ::hx::ObjectPtr< PubsubEvent_obj > __alloc(::hx::Ctx *_hx_ctx,::String from,::String to,::String node,::Array< ::Dynamic> items);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~PubsubEvent_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("PubsubEvent",17,9e,d8,d2); }
+
+		static  ::snikket::PubsubEvent fromStanza( ::snikket::Stanza stanza);
+		static ::Dynamic fromStanza_dyn();
+
+		::String from;
+		::String to;
+		::String node;
+		::Array< ::Dynamic> items;
+		::String getFrom();
+		::Dynamic getFrom_dyn();
+
+		::String getNode();
+		::Dynamic getNode_dyn();
+
+		::Array< ::Dynamic> getItems();
+		::Dynamic getItems_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_PubsubEvent */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/Reaction.h b/Sources/c_snikket/iinclude/include/snikket/Reaction.h
new file mode 100644
index 0000000..5c77199
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/Reaction.h
@@ -0,0 +1,75 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Reaction
+#define INCLUDED_snikket_Reaction
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Reaction)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Reaction_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Reaction_obj OBJ_;
+		Reaction_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7f8e2b4a };
+
+		void __construct(::String senderId,::String timestamp,::String text,::String envelopeId,::String key);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Reaction")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Reaction"); }
+		static ::hx::ObjectPtr< Reaction_obj > __new(::String senderId,::String timestamp,::String text,::String envelopeId,::String key);
+		static ::hx::ObjectPtr< Reaction_obj > __alloc(::hx::Ctx *_hx_ctx,::String senderId,::String timestamp,::String text,::String envelopeId,::String key);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Reaction_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Reaction",c9,a3,66,d0); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		::String senderId;
+		::String senderId__fromC();
+		::Dynamic senderId__fromC_dyn();
+
+		::String timestamp;
+		::String timestamp__fromC();
+		::Dynamic timestamp__fromC_dyn();
+
+		::String text;
+		::String text__fromC();
+		::Dynamic text__fromC_dyn();
+
+		::String key;
+		::String key__fromC();
+		::Dynamic key__fromC_dyn();
+
+		::String envelopeId;
+		::String envelopeId__fromC();
+		::Dynamic envelopeId__fromC_dyn();
+
+		virtual  ::Dynamic render( ::Dynamic forText, ::Dynamic forImage);
+		::Dynamic render_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Reaction */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/ReactionUpdate.h b/Sources/c_snikket/iinclude/include/snikket/ReactionUpdate.h
new file mode 100644
index 0000000..79c5a2a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/ReactionUpdate.h
@@ -0,0 +1,72 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_ReactionUpdate
+#define INCLUDED_snikket_ReactionUpdate
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Hash)
+HX_DECLARE_CLASS1(snikket,Reaction)
+HX_DECLARE_CLASS1(snikket,ReactionUpdate)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES ReactionUpdate_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef ReactionUpdate_obj OBJ_;
+		ReactionUpdate_obj();
+
+	public:
+		enum { _hx_ClassId = 0x71029d2f };
+
+		void __construct(::String updateId,::String serverId,::String serverIdBy,::String localId,::String chatId,::String senderId,::String timestamp,::Array< ::Dynamic> reactions,int kind);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.ReactionUpdate")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.ReactionUpdate"); }
+		static ::hx::ObjectPtr< ReactionUpdate_obj > __new(::String updateId,::String serverId,::String serverIdBy,::String localId,::String chatId,::String senderId,::String timestamp,::Array< ::Dynamic> reactions,int kind);
+		static ::hx::ObjectPtr< ReactionUpdate_obj > __alloc(::hx::Ctx *_hx_ctx,::String updateId,::String serverId,::String serverIdBy,::String localId,::String chatId,::String senderId,::String timestamp,::Array< ::Dynamic> reactions,int kind);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ReactionUpdate_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ReactionUpdate",b2,1a,77,ad); }
+
+		::String updateId;
+		::String serverId;
+		::String serverIdBy;
+		::String localId;
+		::String chatId;
+		::String senderId;
+		::String timestamp;
+		::Array< ::Dynamic> reactions;
+		int kind;
+		::Array< ::Dynamic> getReactions(::Array< ::Dynamic> existingReactions);
+		::Dynamic getReactions_dyn();
+
+		::Array< ::Dynamic> inlineHashReferences();
+		::Dynamic inlineHashReferences_dyn();
+
+		 ::snikket::Stanza asStanza();
+		::Dynamic asStanza_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_ReactionUpdate */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/SerializedChat.h b/Sources/c_snikket/iinclude/include/snikket/SerializedChat.h
new file mode 100644
index 0000000..80ed386
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/SerializedChat.h
@@ -0,0 +1,76 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_SerializedChat
+#define INCLUDED_snikket_SerializedChat
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS1(snikket,Caps)
+HX_DECLARE_CLASS1(snikket,Chat)
+HX_DECLARE_CLASS1(snikket,Client)
+HX_DECLARE_CLASS1(snikket,EventEmitter)
+HX_DECLARE_CLASS1(snikket,GenericStream)
+HX_DECLARE_CLASS1(snikket,Persistence)
+HX_DECLARE_CLASS1(snikket,SerializedChat)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES SerializedChat_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef SerializedChat_obj OBJ_;
+		SerializedChat_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3eb0c535 };
+
+		void __construct(::String chatId,bool trusted,::Array< unsigned char > avatarSha1, ::haxe::ds::StringMap presence,::String displayName, ::Dynamic uiState, ::Dynamic isBlocked,::String extensions,::String readUpToId,::String readUpToBy, ::Dynamic notificationsFiltered,bool notifyMention,bool notifyReply, ::snikket::Caps disco,::String klass);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.SerializedChat")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.SerializedChat"); }
+		static ::hx::ObjectPtr< SerializedChat_obj > __new(::String chatId,bool trusted,::Array< unsigned char > avatarSha1, ::haxe::ds::StringMap presence,::String displayName, ::Dynamic uiState, ::Dynamic isBlocked,::String extensions,::String readUpToId,::String readUpToBy, ::Dynamic notificationsFiltered,bool notifyMention,bool notifyReply, ::snikket::Caps disco,::String klass);
+		static ::hx::ObjectPtr< SerializedChat_obj > __alloc(::hx::Ctx *_hx_ctx,::String chatId,bool trusted,::Array< unsigned char > avatarSha1, ::haxe::ds::StringMap presence,::String displayName, ::Dynamic uiState, ::Dynamic isBlocked,::String extensions,::String readUpToId,::String readUpToBy, ::Dynamic notificationsFiltered,bool notifyMention,bool notifyReply, ::snikket::Caps disco,::String klass);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SerializedChat_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SerializedChat",9c,77,4d,09); }
+
+		::String chatId;
+		bool trusted;
+		::Array< unsigned char > avatarSha1;
+		 ::haxe::ds::StringMap presence;
+		::String displayName;
+		int uiState;
+		bool isBlocked;
+		::String extensions;
+		::String readUpToId;
+		::String readUpToBy;
+		 ::snikket::Caps disco;
+		::String klass;
+		 ::Dynamic notificationsFiltered;
+		bool notifyMention;
+		bool notifyReply;
+		 ::snikket::Chat toChat( ::snikket::Client client, ::snikket::GenericStream stream,::Dynamic persistence);
+		::Dynamic toChat_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_SerializedChat */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/Stanza.h b/Sources/c_snikket/iinclude/include/snikket/Stanza.h
new file mode 100644
index 0000000..7c79f8c
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/Stanza.h
@@ -0,0 +1,149 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Stanza
+#define INCLUDED_snikket_Stanza
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket__Stanza_NodeInterface
+#include <snikket/_Stanza/NodeInterface.h>
+#endif
+HX_DECLARE_CLASS0(Xml)
+HX_DECLARE_CLASS1(snikket,Node)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS1(snikket,StanzaError)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Stanza_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Stanza_obj OBJ_;
+		Stanza_obj();
+
+	public:
+		enum { _hx_ClassId = 0x62320f92 };
+
+		void __construct(::String name, ::Dynamic attr);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Stanza")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Stanza"); }
+		static ::hx::ObjectPtr< Stanza_obj > __new(::String name, ::Dynamic attr);
+		static ::hx::ObjectPtr< Stanza_obj > __alloc(::hx::Ctx *_hx_ctx,::String name, ::Dynamic attr);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Stanza_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::Dynamic traverse_881a854a( ::Dynamic f);
+		::String __ToString() const { return HX_("Stanza",15,d2,8b,3a); }
+
+		static  ::snikket::Stanza parse(::String s);
+		static ::Dynamic parse_dyn();
+
+		static  ::snikket::Stanza fromXml( ::Xml el);
+		static ::Dynamic fromXml_dyn();
+
+		static bool parseXmlBool(::String x);
+		static ::Dynamic parseXmlBool_dyn();
+
+		::String name;
+		 ::Dynamic attr;
+		::Array< ::Dynamic> children;
+		 ::snikket::Stanza last_added;
+		::Array< ::Dynamic> last_added_stack;
+		::String serialize();
+		::Dynamic serialize_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+		 ::snikket::Stanza tag(::String name, ::Dynamic attr);
+		::Dynamic tag_dyn();
+
+		 ::snikket::Stanza text(::String content);
+		::Dynamic text_dyn();
+
+		 ::snikket::Stanza textTag(::String tagName,::String textContent, ::Dynamic attr);
+		::Dynamic textTag_dyn();
+
+		 ::snikket::Stanza up();
+		::Dynamic up_dyn();
+
+		 ::snikket::Stanza reset();
+		::Dynamic reset_dyn();
+
+		 ::snikket::Stanza addChildren( ::Dynamic children);
+		::Dynamic addChildren_dyn();
+
+		 ::snikket::Stanza addChildNodes( ::Dynamic children);
+		::Dynamic addChildNodes_dyn();
+
+		 ::snikket::Stanza addChild( ::snikket::Stanza stanza);
+		::Dynamic addChild_dyn();
+
+		 ::snikket::Stanza addDirectChild( ::snikket::Node child);
+		::Dynamic addDirectChild_dyn();
+
+		 ::snikket::Stanza clone();
+		::Dynamic clone_dyn();
+
+		::Array< ::Dynamic> allTags(::String name,::String xmlns);
+		::Dynamic allTags_dyn();
+
+		::Array< ::String > allText();
+		::Dynamic allText_dyn();
+
+		 ::snikket::Stanza getFirstChild();
+		::Dynamic getFirstChild_dyn();
+
+		::Array< ::Dynamic> getChildren();
+		::Dynamic getChildren_dyn();
+
+		 ::snikket::Stanza getChild(::String name,::String xmlns);
+		::Dynamic getChild_dyn();
+
+		::String getChildText(::String name,::String xmlns);
+		::Dynamic getChildText_dyn();
+
+		::String getText();
+		::Dynamic getText_dyn();
+
+		 ::snikket::Node find(::String path);
+		::Dynamic find_dyn();
+
+		 ::snikket::Stanza findChild(::String path);
+		::Dynamic findChild_dyn();
+
+		::String findText(::String path);
+		::Dynamic findText_dyn();
+
+		 ::snikket::Stanza traverse( ::Dynamic f);
+		::Dynamic traverse_dyn();
+
+		 ::snikket::StanzaError getError();
+		::Dynamic getError_dyn();
+
+		void removeChildren(::String name,::String xmlns_);
+		::Dynamic removeChildren_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Stanza */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/StanzaError.h b/Sources/c_snikket/iinclude/include/snikket/StanzaError.h
new file mode 100644
index 0000000..a16d52c
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/StanzaError.h
@@ -0,0 +1,72 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_StanzaError
+#define INCLUDED_snikket_StanzaError
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_ba7467be1e1fd22b_46_new)
+HX_DECLARE_CLASS1(snikket,StanzaError)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES StanzaError_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef StanzaError_obj OBJ_;
+		StanzaError_obj();
+
+	public:
+		enum { _hx_ClassId = 0x29697ad6 };
+
+		void __construct(::String type_,::String condition_,::String text_);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.StanzaError")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.StanzaError"); }
+
+		inline static ::hx::ObjectPtr< StanzaError_obj > __new(::String type_,::String condition_,::String text_) {
+			::hx::ObjectPtr< StanzaError_obj > __this = new StanzaError_obj();
+			__this->__construct(type_,condition_,text_);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< StanzaError_obj > __alloc(::hx::Ctx *_hx_ctx,::String type_,::String condition_,::String text_) {
+			StanzaError_obj *__this = (StanzaError_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(StanzaError_obj), true, "snikket.StanzaError"));
+			*(void **)__this = StanzaError_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_ba7467be1e1fd22b_46_new)
+HXLINE(  47)		( ( ::snikket::StanzaError)(__this) )->type = type_;
+HXLINE(  48)		( ( ::snikket::StanzaError)(__this) )->condition = condition_;
+HXLINE(  49)		( ( ::snikket::StanzaError)(__this) )->text = text_;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~StanzaError_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("StanzaError",73,bd,30,0b); }
+
+		::String type;
+		::String condition;
+		::String text;
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_StanzaError */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/StringUtil.h b/Sources/c_snikket/iinclude/include/snikket/StringUtil.h
new file mode 100644
index 0000000..2aba5bb
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/StringUtil.h
@@ -0,0 +1,63 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_StringUtil
+#define INCLUDED_snikket_StringUtil
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,StringUtil)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES StringUtil_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef StringUtil_obj OBJ_;
+		StringUtil_obj();
+
+	public:
+		enum { _hx_ClassId = 0x537b2d90 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket.StringUtil")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket.StringUtil"); }
+
+		inline static ::hx::ObjectPtr< StringUtil_obj > __new() {
+			::hx::ObjectPtr< StringUtil_obj > __this = new StringUtil_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< StringUtil_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			StringUtil_obj *__this = (StringUtil_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(StringUtil_obj), false, "snikket.StringUtil"));
+			*(void **)__this = StringUtil_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~StringUtil_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("StringUtil",93,ed,5b,f6); }
+
+		static ::Array< ::String > codepointArray(::String s);
+		static ::Dynamic codepointArray_dyn();
+
+		static ::Array< int > rawCodepointArray(::String s);
+		static ::Dynamic rawCodepointArray_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_StringUtil */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/Symbol.h b/Sources/c_snikket/iinclude/include/snikket/Symbol.h
new file mode 100644
index 0000000..a0c352f
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/Symbol.h
@@ -0,0 +1,49 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Symbol
+#define INCLUDED_snikket_Symbol
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Symbol)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Symbol_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Symbol_obj OBJ_;
+		Symbol_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4b1860f5 };
+
+		void __construct(::Array< int > codepoints);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Symbol")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Symbol"); }
+
+		//~Symbol_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Symbol",78,23,72,23); }
+
+		::String value;
+		virtual bool isEmoji() { return 0; }
+		::Dynamic isEmoji_dyn();
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Symbol */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/TextNode.h b/Sources/c_snikket/iinclude/include/snikket/TextNode.h
new file mode 100644
index 0000000..f290844
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/TextNode.h
@@ -0,0 +1,67 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_TextNode
+#define INCLUDED_snikket_TextNode
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket__Stanza_NodeInterface
+#include <snikket/_Stanza/NodeInterface.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS1(snikket,TextNode)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES TextNode_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef TextNode_obj OBJ_;
+		TextNode_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3185702c };
+
+		void __construct(::String content);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.TextNode")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.TextNode"); }
+		static ::hx::ObjectPtr< TextNode_obj > __new(::String content);
+		static ::hx::ObjectPtr< TextNode_obj > __alloc(::hx::Ctx *_hx_ctx,::String content);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~TextNode_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::Dynamic traverse_881a854a( ::Dynamic f);
+		::String __ToString() const { return HX_("TextNode",6f,19,b7,25); }
+
+		::String content;
+		::String serialize();
+		::Dynamic serialize_dyn();
+
+		 ::snikket::TextNode clone();
+		::Dynamic clone_dyn();
+
+		 ::snikket::TextNode traverse( ::Dynamic f);
+		::Dynamic traverse_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_TextNode */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/UnicodeBlocks.h b/Sources/c_snikket/iinclude/include/snikket/UnicodeBlocks.h
new file mode 100644
index 0000000..0038254
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/UnicodeBlocks.h
@@ -0,0 +1,59 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_UnicodeBlocks
+#define INCLUDED_snikket_UnicodeBlocks
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_UnicodeSet
+#include <snikket/UnicodeSet.h>
+#endif
+HX_DECLARE_CLASS1(snikket,UnicodeBlocks)
+HX_DECLARE_CLASS1(snikket,UnicodeSet)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES UnicodeBlocks_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef UnicodeBlocks_obj OBJ_;
+		UnicodeBlocks_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5ff5d386 };
+
+		void __construct(::Array< ::Dynamic> sets);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.UnicodeBlocks")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.UnicodeBlocks"); }
+		static ::hx::ObjectPtr< UnicodeBlocks_obj > __new(::Array< ::Dynamic> sets);
+		static ::hx::ObjectPtr< UnicodeBlocks_obj > __alloc(::hx::Ctx *_hx_ctx,::Array< ::Dynamic> sets);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~UnicodeBlocks_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("UnicodeBlocks",63,b7,08,b4); }
+
+		::Array< ::Dynamic> unicodeSets;
+		bool contains(int codepoint);
+		::Dynamic contains_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_UnicodeBlocks */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/UnicodeList.h b/Sources/c_snikket/iinclude/include/snikket/UnicodeList.h
new file mode 100644
index 0000000..4ae5d96
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/UnicodeList.h
@@ -0,0 +1,59 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_UnicodeList
+#define INCLUDED_snikket_UnicodeList
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_UnicodeSet
+#include <snikket/UnicodeSet.h>
+#endif
+HX_DECLARE_CLASS1(snikket,UnicodeList)
+HX_DECLARE_CLASS1(snikket,UnicodeSet)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES UnicodeList_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef UnicodeList_obj OBJ_;
+		UnicodeList_obj();
+
+	public:
+		enum { _hx_ClassId = 0x002205b6 };
+
+		void __construct(::Array< int > codes);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.UnicodeList")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.UnicodeList"); }
+		static ::hx::ObjectPtr< UnicodeList_obj > __new(::Array< int > codes);
+		static ::hx::ObjectPtr< UnicodeList_obj > __alloc(::hx::Ctx *_hx_ctx,::Array< int > codes);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~UnicodeList_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("UnicodeList",fb,c3,e2,6a); }
+
+		::Array< int > list;
+		bool contains(int codepoint);
+		::Dynamic contains_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_UnicodeList */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/UnicodeRange.h b/Sources/c_snikket/iinclude/include/snikket/UnicodeRange.h
new file mode 100644
index 0000000..538a195
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/UnicodeRange.h
@@ -0,0 +1,58 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_UnicodeRange
+#define INCLUDED_snikket_UnicodeRange
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_UnicodeSet
+#include <snikket/UnicodeSet.h>
+#endif
+HX_DECLARE_CLASS1(snikket,UnicodeRange)
+HX_DECLARE_CLASS1(snikket,UnicodeSet)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES UnicodeRange_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef UnicodeRange_obj OBJ_;
+		UnicodeRange_obj();
+
+	public:
+		enum { _hx_ClassId = 0x25d72cd9 };
+
+		void __construct(int lower,int upper);
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket.UnicodeRange")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket.UnicodeRange"); }
+		static ::hx::ObjectPtr< UnicodeRange_obj > __new(int lower,int upper);
+		static ::hx::ObjectPtr< UnicodeRange_obj > __alloc(::hx::Ctx *_hx_ctx,int lower,int upper);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~UnicodeRange_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("UnicodeRange",80,a7,a2,8a); }
+
+		int lower;
+		int upper;
+		bool contains(int codePoint);
+		::Dynamic contains_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_UnicodeRange */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/UnicodeSet.h b/Sources/c_snikket/iinclude/include/snikket/UnicodeSet.h
new file mode 100644
index 0000000..1f6c00a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/UnicodeSet.h
@@ -0,0 +1,27 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_UnicodeSet
+#define INCLUDED_snikket_UnicodeSet
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,UnicodeSet)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES UnicodeSet_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		bool (::hx::Object :: *_hx_contains)(int codepoint); 
+		static inline bool contains( ::Dynamic _hx_,int codepoint) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::snikket::UnicodeSet_obj *>(_hx_.mPtr->_hx_getInterface(0x29205162)))->_hx_contains)(codepoint);
+		}
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_UnicodeSet */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/XEP0393.h b/Sources/c_snikket/iinclude/include/snikket/XEP0393.h
new file mode 100644
index 0000000..3af9b96
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/XEP0393.h
@@ -0,0 +1,84 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_XEP0393
+#define INCLUDED_snikket_XEP0393
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Node)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS1(snikket,XEP0393)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES XEP0393_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef XEP0393_obj OBJ_;
+		XEP0393_obj();
+
+	public:
+		enum { _hx_ClassId = 0x794b61b7 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket.XEP0393")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket.XEP0393"); }
+
+		inline static ::hx::ObjectPtr< XEP0393_obj > __new() {
+			::hx::ObjectPtr< XEP0393_obj > __this = new XEP0393_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< XEP0393_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			XEP0393_obj *__this = (XEP0393_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(XEP0393_obj), false, "snikket.XEP0393"));
+			*(void **)__this = XEP0393_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~XEP0393_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("XEP0393",e0,42,f0,11); }
+
+		static  ::Dynamic parse(::String styled);
+		static ::Dynamic parse_dyn();
+
+		static ::String render( ::snikket::Stanza xhtml);
+		static ::Dynamic render_dyn();
+
+		static ::String renderNode( ::snikket::Node xhtml);
+		static ::Dynamic renderNode_dyn();
+
+		static  ::Dynamic parseSpans(::String styled);
+		static ::Dynamic parseSpans_dyn();
+
+		static  ::Dynamic parseSpan(::String tagName,::String marker,::String styled,int start);
+		static ::Dynamic parseSpan_dyn();
+
+		static  ::Dynamic parseBlock(::String styled);
+		static ::Dynamic parseBlock_dyn();
+
+		static  ::Dynamic parseQuote(::String styled);
+		static ::Dynamic parseQuote_dyn();
+
+		static  ::Dynamic parsePreformatted(::String styled);
+		static ::Dynamic parsePreformatted_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_XEP0393 */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/_Push/Push_Fields_.h b/Sources/c_snikket/iinclude/include/snikket/_Push/Push_Fields_.h
new file mode 100644
index 0000000..27e14f5
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/_Push/Push_Fields_.h
@@ -0,0 +1,64 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket__Push_Push_Fields_
+#define INCLUDED_snikket__Push_Push_Fields_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Notification)
+HX_DECLARE_CLASS1(snikket,Persistence)
+HX_DECLARE_CLASS2(snikket,_Push,Push_Fields_)
+
+namespace snikket{
+namespace _Push{
+
+
+class HXCPP_CLASS_ATTRIBUTES Push_Fields__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Push_Fields__obj OBJ_;
+		Push_Fields__obj();
+
+	public:
+		enum { _hx_ClassId = 0x1c9e72a5 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket._Push.Push_Fields_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket._Push.Push_Fields_"); }
+
+		inline static ::hx::ObjectPtr< Push_Fields__obj > __new() {
+			::hx::ObjectPtr< Push_Fields__obj > __this = new Push_Fields__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Push_Fields__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Push_Fields__obj *__this = (Push_Fields__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Push_Fields__obj), false, "snikket._Push.Push_Fields_"));
+			*(void **)__this = Push_Fields__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Push_Fields__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Push_Fields_",21,65,37,88); }
+
+		static  ::snikket::Notification receive(::String data,::Dynamic persistence);
+		static ::Dynamic receive_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace _Push
+
+#endif /* INCLUDED_snikket__Push_Push_Fields_ */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/_Stanza/NodeInterface.h b/Sources/c_snikket/iinclude/include/snikket/_Stanza/NodeInterface.h
new file mode 100644
index 0000000..8a96ae8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/_Stanza/NodeInterface.h
@@ -0,0 +1,34 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket__Stanza_NodeInterface
+#define INCLUDED_snikket__Stanza_NodeInterface
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+namespace _Stanza{
+
+
+class HXCPP_CLASS_ATTRIBUTES NodeInterface_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		::String (::hx::Object :: *_hx_serialize)(); 
+		static inline ::String serialize( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::snikket::_Stanza::NodeInterface_obj *>(_hx_.mPtr->_hx_getInterface(0xc837e580)))->_hx_serialize)();
+		}
+		::Dynamic (::hx::Object :: *_hx_traverse)( ::Dynamic f); 
+		static inline ::Dynamic traverse( ::Dynamic _hx_, ::Dynamic f) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::snikket::_Stanza::NodeInterface_obj *>(_hx_.mPtr->_hx_getInterface(0xc837e580)))->_hx_traverse)(f);
+		}
+};
+
+} // end namespace snikket
+} // end namespace _Stanza
+
+#endif /* INCLUDED_snikket__Stanza_NodeInterface */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/_Util/Util_Fields_.h b/Sources/c_snikket/iinclude/include/snikket/_Util/Util_Fields_.h
new file mode 100644
index 0000000..a5a7fd3
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/_Util/Util_Fields_.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket__Util_Util_Fields_
+#define INCLUDED_snikket__Util_Util_Fields_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(snikket,_Util,Util_Fields_)
+
+namespace snikket{
+namespace _Util{
+
+
+class HXCPP_CLASS_ATTRIBUTES Util_Fields__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Util_Fields__obj OBJ_;
+		Util_Fields__obj();
+
+	public:
+		enum { _hx_ClassId = 0x1266dcf5 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket._Util.Util_Fields_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket._Util.Util_Fields_"); }
+
+		inline static ::hx::ObjectPtr< Util_Fields__obj > __new() {
+			::hx::ObjectPtr< Util_Fields__obj > __this = new Util_Fields__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Util_Fields__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Util_Fields__obj *__this = (Util_Fields__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Util_Fields__obj), false, "snikket._Util.Util_Fields_"));
+			*(void **)__this = Util_Fields__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Util_Fields__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Util_Fields_",49,13,f3,18); }
+
+		static void setupTrace();
+		static ::Dynamic setupTrace_dyn();
+
+		static  ::Dynamic downcast( ::Dynamic value,::hx::Class c);
+		static ::Dynamic downcast_dyn();
+
+		static ::String xmlEscape(::String s);
+		static ::Dynamic xmlEscape_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace _Util
+
+#endif /* INCLUDED_snikket__Util_Util_Fields_ */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/jingle/Attribute.h b/Sources/c_snikket/iinclude/include/snikket/jingle/Attribute.h
new file mode 100644
index 0000000..ab36337
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/jingle/Attribute.h
@@ -0,0 +1,79 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_Attribute
+#define INCLUDED_snikket_jingle_Attribute
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_3dd2db7f2124ae96_624_new)
+HX_DECLARE_CLASS2(snikket,jingle,Attribute)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES Attribute_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Attribute_obj OBJ_;
+		Attribute_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0704634e };
+
+		void __construct(::String key,::String value);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.Attribute")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.Attribute"); }
+
+		inline static ::hx::ObjectPtr< Attribute_obj > __new(::String key,::String value) {
+			::hx::ObjectPtr< Attribute_obj > __this = new Attribute_obj();
+			__this->__construct(key,value);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Attribute_obj > __alloc(::hx::Ctx *_hx_ctx,::String key,::String value) {
+			Attribute_obj *__this = (Attribute_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Attribute_obj), true, "snikket.jingle.Attribute"));
+			*(void **)__this = Attribute_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_3dd2db7f2124ae96_624_new)
+HXLINE( 625)		( ( ::snikket::jingle::Attribute)(__this) )->key = key;
+HXLINE( 626)		( ( ::snikket::jingle::Attribute)(__this) )->value = value;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Attribute_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Attribute",fc,4f,c3,9c); }
+
+		static  ::snikket::jingle::Attribute parse(::String input);
+		static ::Dynamic parse_dyn();
+
+		::String key;
+		::String value;
+		::String toSdp();
+		::Dynamic toSdp_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_Attribute */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/jingle/AudioFormat.h b/Sources/c_snikket/iinclude/include/snikket/jingle/AudioFormat.h
new file mode 100644
index 0000000..5a01544
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/jingle/AudioFormat.h
@@ -0,0 +1,84 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_AudioFormat
+#define INCLUDED_snikket_jingle_AudioFormat
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_1f09f7dcf750977c_327_new)
+HX_DECLARE_CLASS2(snikket,jingle,AudioFormat)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES AudioFormat_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef AudioFormat_obj OBJ_;
+		AudioFormat_obj();
+
+	public:
+		enum { _hx_ClassId = 0x22a1d3c3 };
+
+		void __construct(::String format,unsigned char payloadType,int clockRate,int channels);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.AudioFormat")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.AudioFormat"); }
+
+		inline static ::hx::ObjectPtr< AudioFormat_obj > __new(::String format,unsigned char payloadType,int clockRate,int channels) {
+			::hx::ObjectPtr< AudioFormat_obj > __this = new AudioFormat_obj();
+			__this->__construct(format,payloadType,clockRate,channels);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< AudioFormat_obj > __alloc(::hx::Ctx *_hx_ctx,::String format,unsigned char payloadType,int clockRate,int channels) {
+			AudioFormat_obj *__this = (AudioFormat_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(AudioFormat_obj), true, "snikket.jingle.AudioFormat"));
+			*(void **)__this = AudioFormat_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_1f09f7dcf750977c_327_new)
+HXLINE( 328)		( ( ::snikket::jingle::AudioFormat)(__this) )->format = format;
+HXLINE( 329)		( ( ::snikket::jingle::AudioFormat)(__this) )->payloadType = payloadType;
+HXLINE( 330)		( ( ::snikket::jingle::AudioFormat)(__this) )->clockRate = clockRate;
+HXLINE( 331)		( ( ::snikket::jingle::AudioFormat)(__this) )->channels = channels;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~AudioFormat_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("AudioFormat",8d,58,71,b0); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		::String format;
+		unsigned char payloadType;
+		int clockRate;
+		int clockRate__fromC();
+		::Dynamic clockRate__fromC_dyn();
+
+		int channels;
+		int channels__fromC();
+		::Dynamic channels__fromC_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_AudioFormat */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/jingle/DTMFSender.h b/Sources/c_snikket/iinclude/include/snikket/jingle/DTMFSender.h
new file mode 100644
index 0000000..ac11f9b
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/jingle/DTMFSender.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_DTMFSender
+#define INCLUDED_snikket_jingle_DTMFSender
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS1(haxe,Timer)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS2(snikket,jingle,DTMFSender)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStreamTrack)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES DTMFSender_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef DTMFSender_obj OBJ_;
+		DTMFSender_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0cd227ec };
+
+		void __construct( ::snikket::jingle::MediaStreamTrack track);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.DTMFSender")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.DTMFSender"); }
+		static ::hx::ObjectPtr< DTMFSender_obj > __new( ::snikket::jingle::MediaStreamTrack track);
+		static ::hx::ObjectPtr< DTMFSender_obj > __alloc(::hx::Ctx *_hx_ctx, ::snikket::jingle::MediaStreamTrack track);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~DTMFSender_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DTMFSender",7e,53,22,7e); }
+
+		static void __boot();
+		static  ::haxe::ds::StringMap TONES;
+		 ::snikket::jingle::MediaStreamTrack track;
+		 ::haxe::Timer timer;
+		::Array< unsigned char > tones;
+		void insertDTMF(::String tones);
+		::Dynamic insertDTMF_dyn();
+
+		void insertOneTone(unsigned char tone);
+		::Dynamic insertOneTone_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_DTMFSender */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/jingle/Group.h b/Sources/c_snikket/iinclude/include/snikket/jingle/Group.h
new file mode 100644
index 0000000..e94b018
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/jingle/Group.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_Group
+#define INCLUDED_snikket_jingle_Group
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,jingle,Group)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES Group_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Group_obj OBJ_;
+		Group_obj();
+
+	public:
+		enum { _hx_ClassId = 0x21f1b1d5 };
+
+		void __construct(::String semantics,::Array< ::String > identificationTags);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.Group")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.Group"); }
+		static ::hx::ObjectPtr< Group_obj > __new(::String semantics,::Array< ::String > identificationTags);
+		static ::hx::ObjectPtr< Group_obj > __alloc(::hx::Ctx *_hx_ctx,::String semantics,::Array< ::String > identificationTags);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Group_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Group",1f,23,22,2d); }
+
+		static  ::snikket::jingle::Group parse(::String input);
+		static ::Dynamic parse_dyn();
+
+		static  ::snikket::jingle::Group fromElement( ::snikket::Stanza el);
+		static ::Dynamic fromElement_dyn();
+
+		::String semantics;
+		::Array< ::String > identificationTags;
+		::String toSdp();
+		::Dynamic toSdp_dyn();
+
+		 ::snikket::Stanza toElement();
+		::Dynamic toElement_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_Group */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/jingle/IceCandidate.h b/Sources/c_snikket/iinclude/include/snikket/jingle/IceCandidate.h
new file mode 100644
index 0000000..3f6d0f8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/jingle/IceCandidate.h
@@ -0,0 +1,84 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_IceCandidate
+#define INCLUDED_snikket_jingle_IceCandidate
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,jingle,IceCandidate)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES IceCandidate_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef IceCandidate_obj OBJ_;
+		IceCandidate_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5f466786 };
+
+		void __construct(::String sdpMid,::String ufrag,::String foundation,::String component,::String transport,::String priority,::String connectionAddress,::String port, ::haxe::ds::StringMap parameters);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.IceCandidate")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.IceCandidate"); }
+		static ::hx::ObjectPtr< IceCandidate_obj > __new(::String sdpMid,::String ufrag,::String foundation,::String component,::String transport,::String priority,::String connectionAddress,::String port, ::haxe::ds::StringMap parameters);
+		static ::hx::ObjectPtr< IceCandidate_obj > __alloc(::hx::Ctx *_hx_ctx,::String sdpMid,::String ufrag,::String foundation,::String component,::String transport,::String priority,::String connectionAddress,::String port, ::haxe::ds::StringMap parameters);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~IceCandidate_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("IceCandidate",98,1b,a6,e5); }
+
+		static  ::snikket::jingle::IceCandidate fromElement( ::snikket::Stanza candidate,::String sdpMid,::String ufrag);
+		static ::Dynamic fromElement_dyn();
+
+		static ::Array< ::Dynamic> fromTransport( ::snikket::Stanza transport,::String sdpMid);
+		static ::Dynamic fromTransport_dyn();
+
+		static ::Array< ::Dynamic> fromStanza( ::snikket::Stanza iq);
+		static ::Dynamic fromStanza_dyn();
+
+		static  ::snikket::jingle::IceCandidate parse(::String input,::String sdpMid,::String ufrag);
+		static ::Dynamic parse_dyn();
+
+		::String sdpMid;
+		::String ufrag;
+		::String foundation;
+		::String component;
+		::String transport;
+		::String priority;
+		::String connectionAddress;
+		::String port;
+		 ::haxe::ds::StringMap parameters;
+		 ::snikket::Stanza toElement();
+		::Dynamic toElement_dyn();
+
+		::String toSdp();
+		::Dynamic toSdp_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_IceCandidate */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/jingle/IncomingProposedSession.h b/Sources/c_snikket/iinclude/include/snikket/jingle/IncomingProposedSession.h
new file mode 100644
index 0000000..ba3b24a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/jingle/IncomingProposedSession.h
@@ -0,0 +1,114 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_IncomingProposedSession
+#define INCLUDED_snikket_jingle_IncomingProposedSession
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_jingle_Session
+#include <snikket/jingle/Session.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Client)
+HX_DECLARE_CLASS1(snikket,EventEmitter)
+HX_DECLARE_CLASS1(snikket,JID)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,jingle,DTMFSender)
+HX_DECLARE_CLASS2(snikket,jingle,IncomingProposedSession)
+HX_DECLARE_CLASS2(snikket,jingle,InitiatedSession)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStream)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStreamTrack)
+HX_DECLARE_CLASS2(snikket,jingle,Session)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES IncomingProposedSession_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef IncomingProposedSession_obj OBJ_;
+		IncomingProposedSession_obj();
+
+	public:
+		enum { _hx_ClassId = 0x409e1620 };
+
+		void __construct( ::snikket::Client client, ::snikket::JID from,::String sid);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.IncomingProposedSession")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.IncomingProposedSession"); }
+		static ::hx::ObjectPtr< IncomingProposedSession_obj > __new( ::snikket::Client client, ::snikket::JID from,::String sid);
+		static ::hx::ObjectPtr< IncomingProposedSession_obj > __alloc(::hx::Ctx *_hx_ctx, ::snikket::Client client, ::snikket::JID from,::String sid);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~IncomingProposedSession_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("IncomingProposedSession",ea,a1,86,13); }
+
+		::String sid;
+		 ::snikket::Client client;
+		 ::snikket::JID from;
+		::String _sid;
+		bool accepted;
+		void ring();
+		::Dynamic ring_dyn();
+
+		void hangup();
+		::Dynamic hangup_dyn();
+
+		void retract();
+		::Dynamic retract_dyn();
+
+		void terminate();
+		::Dynamic terminate_dyn();
+
+		void contentAdd( ::snikket::Stanza _);
+		::Dynamic contentAdd_dyn();
+
+		void contentAccept( ::snikket::Stanza _);
+		::Dynamic contentAccept_dyn();
+
+		::Dynamic transportInfo( ::snikket::Stanza _);
+		::Dynamic transportInfo_dyn();
+
+		void accept();
+		::Dynamic accept_dyn();
+
+		 ::snikket::jingle::InitiatedSession initiate( ::snikket::Stanza stanza);
+		::Dynamic initiate_dyn();
+
+		void addMedia(::Array< ::Dynamic> _);
+		::Dynamic addMedia_dyn();
+
+		::String callStatus();
+		::Dynamic callStatus_dyn();
+
+		::Array< ::Dynamic> videoTracks();
+		::Dynamic videoTracks_dyn();
+
+		 ::snikket::jingle::DTMFSender dtmf();
+		::Dynamic dtmf_dyn();
+
+		::String get_sid();
+		::Dynamic get_sid_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_IncomingProposedSession */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/jingle/InitiatedSession.h b/Sources/c_snikket/iinclude/include/snikket/jingle/InitiatedSession.h
new file mode 100644
index 0000000..569256c
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/jingle/InitiatedSession.h
@@ -0,0 +1,160 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_InitiatedSession
+#define INCLUDED_snikket_jingle_InitiatedSession
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_jingle_Session
+#include <snikket/jingle/Session.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Client)
+HX_DECLARE_CLASS1(snikket,EventEmitter)
+HX_DECLARE_CLASS1(snikket,JID)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,jingle,DTMFSender)
+HX_DECLARE_CLASS2(snikket,jingle,InitiatedSession)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStream)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStreamTrack)
+HX_DECLARE_CLASS2(snikket,jingle,OutgoingSession)
+HX_DECLARE_CLASS2(snikket,jingle,PeerConnection)
+HX_DECLARE_CLASS2(snikket,jingle,Session)
+HX_DECLARE_CLASS2(snikket,jingle,SessionDescription)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES InitiatedSession_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef InitiatedSession_obj OBJ_;
+		InitiatedSession_obj();
+
+	public:
+		enum { _hx_ClassId = 0x050f75b9 };
+
+		void __construct( ::snikket::Client client, ::snikket::JID counterpart,::String sid, ::snikket::jingle::SessionDescription remoteDescription);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.InitiatedSession")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.InitiatedSession"); }
+		static ::hx::ObjectPtr< InitiatedSession_obj > __new( ::snikket::Client client, ::snikket::JID counterpart,::String sid, ::snikket::jingle::SessionDescription remoteDescription);
+		static ::hx::ObjectPtr< InitiatedSession_obj > __alloc(::hx::Ctx *_hx_ctx, ::snikket::Client client, ::snikket::JID counterpart,::String sid, ::snikket::jingle::SessionDescription remoteDescription);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~InitiatedSession_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		 ::snikket::jingle::InitiatedSession initiate_ef691953( ::snikket::Stanza stanza);
+		::String __ToString() const { return HX_("InitiatedSession",cb,9a,8f,24); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static  ::snikket::jingle::InitiatedSession fromSessionInitiate( ::snikket::Client client, ::snikket::Stanza stanza);
+		static ::Dynamic fromSessionInitiate_dyn();
+
+		::String sid;
+		::String sid__fromC();
+		::Dynamic sid__fromC_dyn();
+
+		 ::snikket::Client client;
+		 ::snikket::JID counterpart;
+		::String _sid;
+		 ::snikket::jingle::SessionDescription remoteDescription;
+		 ::snikket::jingle::SessionDescription localDescription;
+		 ::snikket::jingle::PeerConnection pc;
+		::String peerDtlsSetup;
+		::Array< ::Dynamic> queuedInboundTransportInfo;
+		::Array< ::Dynamic> queuedOutboundCandidate;
+		bool accepted;
+		 ::Dynamic afterMedia;
+		Dynamic afterMedia_dyn() { return afterMedia;}
+		bool initiator;
+		 ::Dynamic candidatesDone;
+		Dynamic candidatesDone_dyn() { return candidatesDone;}
+		::String get_sid();
+		::Dynamic get_sid_dyn();
+
+		void ring();
+		::Dynamic ring_dyn();
+
+		void retract();
+		::Dynamic retract_dyn();
+
+		void accept();
+		::Dynamic accept_dyn();
+
+		void hangup();
+		::Dynamic hangup_dyn();
+
+		virtual  ::snikket::jingle::OutgoingSession initiate( ::snikket::Stanza stanza);
+		::Dynamic initiate_dyn();
+
+		void terminate();
+		::Dynamic terminate_dyn();
+
+		void contentAdd( ::snikket::Stanza stanza);
+		::Dynamic contentAdd_dyn();
+
+		void contentAccept( ::snikket::Stanza stanza);
+		::Dynamic contentAccept_dyn();
+
+		::Dynamic transportInfo( ::snikket::Stanza stanza);
+		::Dynamic transportInfo_dyn();
+
+		void addMedia(::Array< ::Dynamic> streams);
+		::Dynamic addMedia_dyn();
+
+		void addMedia__fromC(::cpp::Pointer< void* > streams,size_t streams__len);
+		::Dynamic addMedia__fromC_dyn();
+
+		::String callStatus();
+		::Dynamic callStatus_dyn();
+
+		::Array< ::Dynamic> videoTracks();
+		::Dynamic videoTracks_dyn();
+
+		size_t videoTracks__fromC(void*** outPtr);
+
+		 ::snikket::jingle::DTMFSender dtmf();
+		::Dynamic dtmf_dyn();
+
+		void sendIceCandidate( ::Dynamic candidate);
+		::Dynamic sendIceCandidate_dyn();
+
+		void supplyMedia(::Array< ::Dynamic> streams);
+		::Dynamic supplyMedia_dyn();
+
+		void supplyMedia__fromC(::cpp::Pointer< void* > streams,size_t streams__len);
+		::Dynamic supplyMedia__fromC_dyn();
+
+		void setupPeerConnection( ::Dynamic callback);
+		::Dynamic setupPeerConnection_dyn();
+
+		::Dynamic setupLocalDescription(::String type,::Array< ::String > filterMedia, ::Dynamic filterOut, ::Dynamic beforeSend);
+		::Dynamic setupLocalDescription_dyn();
+
+		virtual ::Dynamic onPeerConnection();
+		::Dynamic onPeerConnection_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_InitiatedSession */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/jingle/Media.h b/Sources/c_snikket/iinclude/include/snikket/jingle/Media.h
new file mode 100644
index 0000000..139653a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/jingle/Media.h
@@ -0,0 +1,82 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_Media
+#define INCLUDED_snikket_jingle_Media
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,jingle,Attribute)
+HX_DECLARE_CLASS2(snikket,jingle,Media)
+HX_DECLARE_CLASS2(snikket,jingle,SessionDescription)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES Media_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Media_obj OBJ_;
+		Media_obj();
+
+	public:
+		enum { _hx_ClassId = 0x06e5f716 };
+
+		void __construct(::String mid,::String media,::String connectionData,::String port,::String protocol,::Array< ::Dynamic> attributes,::Array< int > formats);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.Media")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.Media"); }
+		static ::hx::ObjectPtr< Media_obj > __new(::String mid,::String media,::String connectionData,::String port,::String protocol,::Array< ::Dynamic> attributes,::Array< int > formats);
+		static ::hx::ObjectPtr< Media_obj > __alloc(::hx::Ctx *_hx_ctx,::String mid,::String media,::String connectionData,::String port,::String protocol,::Array< ::Dynamic> attributes,::Array< int > formats);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Media_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Media",c4,74,e9,98); }
+
+		static  ::snikket::jingle::Media fromElement( ::snikket::Stanza content,bool initiator,bool hasGroup, ::snikket::jingle::SessionDescription existingDescription);
+		static ::Dynamic fromElement_dyn();
+
+		::String mid;
+		::String media;
+		::String connectionData;
+		::String port;
+		::String protocol;
+		::Array< ::Dynamic> attributes;
+		::Array< int > formats;
+		::String toSdp();
+		::Dynamic toSdp_dyn();
+
+		 ::snikket::Stanza contentElement(bool initiator);
+		::Dynamic contentElement_dyn();
+
+		 ::snikket::Stanza toElement(::Array< ::Dynamic> sessionAttributes,bool initiator);
+		::Dynamic toElement_dyn();
+
+		 ::Dynamic getUfragPwd(::Array< ::Dynamic> sessionAttributes);
+		::Dynamic getUfragPwd_dyn();
+
+		 ::snikket::Stanza toTransportElement(::Array< ::Dynamic> sessionAttributes);
+		::Dynamic toTransportElement_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_Media */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/jingle/MediaStream.h b/Sources/c_snikket/iinclude/include/snikket/jingle/MediaStream.h
new file mode 100644
index 0000000..1e4bb42
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/jingle/MediaStream.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_MediaStream
+#define INCLUDED_snikket_jingle_MediaStream
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(snikket,jingle,MediaStream)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStreamTrack)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES MediaStream_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef MediaStream_obj OBJ_;
+		MediaStream_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1cdfd2fe };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.MediaStream")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.MediaStream"); }
+		static ::hx::ObjectPtr< MediaStream_obj > __new();
+		static ::hx::ObjectPtr< MediaStream_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~MediaStream_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("MediaStream",64,e8,a8,83); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static  ::snikket::jingle::MediaStream makeAudio();
+		static ::Dynamic makeAudio_dyn();
+
+		::Array< ::Dynamic> tracks;
+		void addTrack( ::snikket::jingle::MediaStreamTrack track);
+		::Dynamic addTrack_dyn();
+
+		::Array< ::Dynamic> getTracks();
+		::Dynamic getTracks_dyn();
+
+		size_t getTracks__fromC(void*** outPtr);
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_MediaStream */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/jingle/MediaStreamTrack.h b/Sources/c_snikket/iinclude/include/snikket/jingle/MediaStreamTrack.h
new file mode 100644
index 0000000..368efe0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/jingle/MediaStreamTrack.h
@@ -0,0 +1,159 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_MediaStreamTrack
+#define INCLUDED_snikket_jingle_MediaStreamTrack
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_f561c66e4c8ac38c
+#define INCLUDED_f561c66e4c8ac38c
+#include "fstream"
+#endif
+#ifndef INCLUDED_c2bfbc5a172f2993
+#define INCLUDED_c2bfbc5a172f2993
+#include "opus.h"
+#endif
+#ifndef INCLUDED_639eed8ef5b51d52
+#define INCLUDED_639eed8ef5b51d52
+#include "rtc/frameinfo.hpp"
+#endif
+#ifndef INCLUDED_0e487a29b6aa8a9b
+#define INCLUDED_0e487a29b6aa8a9b
+#include "rtc/rtc.hpp"
+#endif
+HX_DECLARE_CLASS1(haxe,Timer)
+HX_DECLARE_CLASS2(snikket,jingle,AudioFormat)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStreamTrack)
+HX_DECLARE_CLASS2(sys,thread,EventLoop)
+HX_DECLARE_CLASS2(sys,thread,Mutex)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES MediaStreamTrack_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef MediaStreamTrack_obj OBJ_;
+		MediaStreamTrack_obj();
+
+	public:
+		enum { _hx_ClassId = 0x047992ad };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.MediaStreamTrack")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.MediaStreamTrack"); }
+		static ::hx::ObjectPtr< MediaStreamTrack_obj > __new();
+		static ::hx::ObjectPtr< MediaStreamTrack_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~MediaStreamTrack_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("MediaStreamTrack",87,2b,0b,ac); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static  ::snikket::jingle::MediaStreamTrack fromTrack( std::shared_ptr<  rtc::Track > t);
+
+		static ::Array< short > ULAW_DECODE;
+		static ::Array< unsigned char > ULAW_EXP;
+		static unsigned char pcmToUlaw(short sample);
+		static ::Dynamic pcmToUlaw_dyn();
+
+		::String id__fromC();
+		::Dynamic id__fromC_dyn();
+
+		bool muted__fromC();
+		::Dynamic muted__fromC_dyn();
+
+		::String kind__fromC();
+		::Dynamic kind__fromC_dyn();
+
+		size_t supportedAudioFormats__fromC(void*** outPtr);
+
+		 ::Dynamic pcmCallback;
+		Dynamic pcmCallback_dyn() { return pcmCallback;}
+		 ::Dynamic readyForPCMCallback;
+		Dynamic readyForPCMCallback_dyn() { return readyForPCMCallback;}
+		cpp::Struct<  OpusDecoder* > opus;
+		cpp::Struct<  OpusEncoder* > opusEncoder;
+		 std::shared_ptr<  rtc::RtpPacketizationConfig > rtpPacketizationConfig;
+		 ::sys::thread::EventLoop eventLoop;
+		 ::haxe::Timer timer;
+		::Array< ::Dynamic> audioQ;
+		bool alive;
+		bool waitForQ;
+		Float bufferSizeInSeconds;
+		 ::sys::thread::Mutex mutex;
+		 std::optional<  rtc::Description::Media > media;
+		 std::shared_ptr<  rtc::Track > track;
+		 std::optional<  rtc::Description::Media > get_media();
+
+		::String get_id();
+		::Dynamic get_id_dyn();
+
+		::String get_kind();
+		::Dynamic get_kind_dyn();
+
+		bool get_muted();
+		::Dynamic get_muted_dyn();
+
+		::Array< ::Dynamic> get_supportedAudioFormats();
+		::Dynamic get_supportedAudioFormats_dyn();
+
+		 std::shared_ptr<  rtc::Track > set_track( std::shared_ptr<  rtc::Track > newTrack);
+
+		void addPCMListener( ::Dynamic callback);
+		::Dynamic addPCMListener_dyn();
+
+		void addPCMListener__fromC(::cpp::Function< void  (short*,size_t,int,int,void*) > callback,void* callback__context);
+
+		void onFrame( std::vector<  std::byte > msg, rtc::FrameInfo frameInfo);
+
+		void addReadyForPCMListener( ::Dynamic callback);
+		::Dynamic addReadyForPCMListener_dyn();
+
+		void addReadyForPCMListener__fromC(::cpp::Function< void  (void*) > callback,void* callback__context);
+
+		void notifyReadyForData(bool fromCPP);
+		::Dynamic notifyReadyForData_dyn();
+
+		void writePCM(::Array< short > pcm,int clockRate,int channels);
+		::Dynamic writePCM_dyn();
+
+		void writePCM__fromC(::cpp::Pointer< short > pcm,size_t pcm__len,int clockRate,int channels);
+		::Dynamic writePCM__fromC_dyn();
+
+		void onAudioLoop( ::Dynamic callback);
+		::Dynamic onAudioLoop_dyn();
+
+		void write(::Array< unsigned char > payload,unsigned char payloadType,int clockRate);
+		::Dynamic write_dyn();
+
+		void advanceTimestamp(int samples);
+		::Dynamic advanceTimestamp_dyn();
+
+		void stop();
+		::Dynamic stop_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_MediaStreamTrack */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/jingle/OutgoingProposedSession.h b/Sources/c_snikket/iinclude/include/snikket/jingle/OutgoingProposedSession.h
new file mode 100644
index 0000000..04be360
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/jingle/OutgoingProposedSession.h
@@ -0,0 +1,117 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_OutgoingProposedSession
+#define INCLUDED_snikket_jingle_OutgoingProposedSession
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_jingle_Session
+#include <snikket/jingle/Session.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Client)
+HX_DECLARE_CLASS1(snikket,EventEmitter)
+HX_DECLARE_CLASS1(snikket,JID)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,jingle,DTMFSender)
+HX_DECLARE_CLASS2(snikket,jingle,InitiatedSession)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStream)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStreamTrack)
+HX_DECLARE_CLASS2(snikket,jingle,OutgoingProposedSession)
+HX_DECLARE_CLASS2(snikket,jingle,OutgoingSession)
+HX_DECLARE_CLASS2(snikket,jingle,Session)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES OutgoingProposedSession_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef OutgoingProposedSession_obj OBJ_;
+		OutgoingProposedSession_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4349a55a };
+
+		void __construct( ::snikket::Client client, ::snikket::JID to);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.OutgoingProposedSession")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.OutgoingProposedSession"); }
+		static ::hx::ObjectPtr< OutgoingProposedSession_obj > __new( ::snikket::Client client, ::snikket::JID to);
+		static ::hx::ObjectPtr< OutgoingProposedSession_obj > __alloc(::hx::Ctx *_hx_ctx, ::snikket::Client client, ::snikket::JID to);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~OutgoingProposedSession_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		 ::snikket::jingle::InitiatedSession initiate_ef691953( ::snikket::Stanza stanza);
+		::String __ToString() const { return HX_("OutgoingProposedSession",24,31,32,16); }
+
+		::String sid;
+		 ::snikket::Client client;
+		 ::snikket::JID to;
+		::String _sid;
+		bool audio;
+		bool video;
+		void propose(bool audio,bool video);
+		::Dynamic propose_dyn();
+
+		void hangup();
+		::Dynamic hangup_dyn();
+
+		void retract();
+		::Dynamic retract_dyn();
+
+		void terminate();
+		::Dynamic terminate_dyn();
+
+		void contentAdd( ::snikket::Stanza _);
+		::Dynamic contentAdd_dyn();
+
+		void contentAccept( ::snikket::Stanza _);
+		::Dynamic contentAccept_dyn();
+
+		::Dynamic transportInfo( ::snikket::Stanza _);
+		::Dynamic transportInfo_dyn();
+
+		void accept();
+		::Dynamic accept_dyn();
+
+		 ::snikket::jingle::OutgoingSession initiate( ::snikket::Stanza stanza);
+		::Dynamic initiate_dyn();
+
+		void addMedia(::Array< ::Dynamic> _);
+		::Dynamic addMedia_dyn();
+
+		::String callStatus();
+		::Dynamic callStatus_dyn();
+
+		::Array< ::Dynamic> videoTracks();
+		::Dynamic videoTracks_dyn();
+
+		 ::snikket::jingle::DTMFSender dtmf();
+		::Dynamic dtmf_dyn();
+
+		::String get_sid();
+		::Dynamic get_sid_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_OutgoingProposedSession */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/jingle/OutgoingSession.h b/Sources/c_snikket/iinclude/include/snikket/jingle/OutgoingSession.h
new file mode 100644
index 0000000..80cffde
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/jingle/OutgoingSession.h
@@ -0,0 +1,63 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_OutgoingSession
+#define INCLUDED_snikket_jingle_OutgoingSession
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_jingle_InitiatedSession
+#include <snikket/jingle/InitiatedSession.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Client)
+HX_DECLARE_CLASS1(snikket,EventEmitter)
+HX_DECLARE_CLASS1(snikket,JID)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,jingle,InitiatedSession)
+HX_DECLARE_CLASS2(snikket,jingle,OutgoingSession)
+HX_DECLARE_CLASS2(snikket,jingle,Session)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES OutgoingSession_obj : public  ::snikket::jingle::InitiatedSession_obj
+{
+	public:
+		typedef  ::snikket::jingle::InitiatedSession_obj super;
+		typedef OutgoingSession_obj OBJ_;
+		OutgoingSession_obj();
+
+	public:
+		enum { _hx_ClassId = 0x43b8b0fc };
+
+		void __construct( ::snikket::Client client, ::snikket::JID counterpart,::String sid);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.OutgoingSession")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.OutgoingSession"); }
+		static ::hx::ObjectPtr< OutgoingSession_obj > __new( ::snikket::Client client, ::snikket::JID counterpart,::String sid);
+		static ::hx::ObjectPtr< OutgoingSession_obj > __alloc(::hx::Ctx *_hx_ctx, ::snikket::Client client, ::snikket::JID counterpart,::String sid);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~OutgoingSession_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("OutgoingSession",2a,54,07,c9); }
+
+		::Dynamic onPeerConnection();
+
+		 ::snikket::jingle::OutgoingSession initiate( ::snikket::Stanza stanza);
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_OutgoingSession */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/jingle/PeerConnection.h b/Sources/c_snikket/iinclude/include/snikket/jingle/PeerConnection.h
new file mode 100644
index 0000000..44a1ee9
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/jingle/PeerConnection.h
@@ -0,0 +1,119 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_PeerConnection
+#define INCLUDED_snikket_jingle_PeerConnection
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_0e487a29b6aa8a9b
+#define INCLUDED_0e487a29b6aa8a9b
+#include "rtc/rtc.hpp"
+#endif
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStream)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStreamTrack)
+HX_DECLARE_CLASS2(snikket,jingle,PeerConnection)
+HX_DECLARE_CLASS2(sys,thread,EventLoop)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES PeerConnection_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef PeerConnection_obj OBJ_;
+		PeerConnection_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1731230a };
+
+		void __construct( ::Dynamic configuration, ::Dynamic constraints);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.PeerConnection")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.PeerConnection"); }
+		static ::hx::ObjectPtr< PeerConnection_obj > __new( ::Dynamic configuration, ::Dynamic constraints);
+		static ::hx::ObjectPtr< PeerConnection_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic configuration, ::Dynamic constraints);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~PeerConnection_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("PeerConnection",80,38,71,9a); }
+
+		 ::Dynamic localDescription;
+		::String connectionState;
+		 std::shared_ptr<  rtc::PeerConnection > _pc;
+		::cpp::Pointer<  rtc::PeerConnection > pc;
+		 ::Dynamic waitingOnLocal;
+		Dynamic waitingOnLocal_dyn() { return waitingOnLocal;}
+		 ::haxe::ds::StringMap tracks;
+		::Array< ::Dynamic> trackListeners;
+		::Array< ::Dynamic> localCandidateListeners;
+		::Array< ::Dynamic> stateChangeListeners;
+		 ::sys::thread::EventLoop mainLoop;
+		bool hasLocal;
+		bool hasRemote;
+		::Array< ::Dynamic> pendingTracks;
+		void onLocalDescription();
+		::Dynamic onLocalDescription_dyn();
+
+		void onLocalCandidate( rtc::Candidate candidate);
+
+		void onStateChange(cpp::Struct<  rtc::PeerConnection::State > state);
+		::Dynamic onStateChange_dyn();
+
+		void onGatheringStateChange(cpp::Struct<  rtc::PeerConnection::GatheringState > state);
+		::Dynamic onGatheringStateChange_dyn();
+
+		void onTrack( std::shared_ptr<  rtc::Track > track);
+
+		::String get_connectionState();
+		::Dynamic get_connectionState_dyn();
+
+		 ::Dynamic get_localDescription();
+		::Dynamic get_localDescription_dyn();
+
+		::Dynamic setLocalDescription(cpp::Struct<  rtc::Description::Type > sdpType);
+		::Dynamic setLocalDescription_dyn();
+
+		::Dynamic setRemoteDescription( ::Dynamic description);
+		::Dynamic setRemoteDescription_dyn();
+
+		::Dynamic addIceCandidate( ::Dynamic candidate);
+		::Dynamic addIceCandidate_dyn();
+
+		void addPendingTracks();
+		::Dynamic addPendingTracks_dyn();
+
+		void addTrack( ::snikket::jingle::MediaStreamTrack track, ::snikket::jingle::MediaStream stream);
+		::Dynamic addTrack_dyn();
+
+		::Array< ::Dynamic> getTransceivers();
+		::Dynamic getTransceivers_dyn();
+
+		void close();
+		::Dynamic close_dyn();
+
+		void addEventListener(::String event, ::Dynamic callback);
+		::Dynamic addEventListener_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_PeerConnection */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/jingle/Session.h b/Sources/c_snikket/iinclude/include/snikket/jingle/Session.h
new file mode 100644
index 0000000..306298c
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/jingle/Session.h
@@ -0,0 +1,84 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_Session
+#define INCLUDED_snikket_jingle_Session
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,jingle,DTMFSender)
+HX_DECLARE_CLASS2(snikket,jingle,InitiatedSession)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStream)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStreamTrack)
+HX_DECLARE_CLASS2(snikket,jingle,Session)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES Session_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		::String (::hx::Object :: *_hx_get_sid)(); 
+		static inline ::String get_sid( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::snikket::jingle::Session_obj *>(_hx_.mPtr->_hx_getInterface(0x79d60748)))->_hx_get_sid)();
+		}
+		 ::snikket::jingle::InitiatedSession (::hx::Object :: *_hx_initiate)( ::snikket::Stanza stanza); 
+		static inline  ::snikket::jingle::InitiatedSession initiate( ::Dynamic _hx_, ::snikket::Stanza stanza) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::snikket::jingle::Session_obj *>(_hx_.mPtr->_hx_getInterface(0x79d60748)))->_hx_initiate)(stanza);
+		}
+		void (::hx::Object :: *_hx_accept)(); 
+		static inline void accept( ::Dynamic _hx_) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::jingle::Session_obj *>(_hx_.mPtr->_hx_getInterface(0x79d60748)))->_hx_accept)();
+		}
+		void (::hx::Object :: *_hx_hangup)(); 
+		static inline void hangup( ::Dynamic _hx_) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::jingle::Session_obj *>(_hx_.mPtr->_hx_getInterface(0x79d60748)))->_hx_hangup)();
+		}
+		void (::hx::Object :: *_hx_retract)(); 
+		static inline void retract( ::Dynamic _hx_) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::jingle::Session_obj *>(_hx_.mPtr->_hx_getInterface(0x79d60748)))->_hx_retract)();
+		}
+		void (::hx::Object :: *_hx_terminate)(); 
+		static inline void terminate( ::Dynamic _hx_) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::jingle::Session_obj *>(_hx_.mPtr->_hx_getInterface(0x79d60748)))->_hx_terminate)();
+		}
+		void (::hx::Object :: *_hx_contentAdd)( ::snikket::Stanza stanza); 
+		static inline void contentAdd( ::Dynamic _hx_, ::snikket::Stanza stanza) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::jingle::Session_obj *>(_hx_.mPtr->_hx_getInterface(0x79d60748)))->_hx_contentAdd)(stanza);
+		}
+		void (::hx::Object :: *_hx_contentAccept)( ::snikket::Stanza stanza); 
+		static inline void contentAccept( ::Dynamic _hx_, ::snikket::Stanza stanza) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::jingle::Session_obj *>(_hx_.mPtr->_hx_getInterface(0x79d60748)))->_hx_contentAccept)(stanza);
+		}
+		::Dynamic (::hx::Object :: *_hx_transportInfo)( ::snikket::Stanza stanza); 
+		static inline ::Dynamic transportInfo( ::Dynamic _hx_, ::snikket::Stanza stanza) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::snikket::jingle::Session_obj *>(_hx_.mPtr->_hx_getInterface(0x79d60748)))->_hx_transportInfo)(stanza);
+		}
+		void (::hx::Object :: *_hx_addMedia)(::Array< ::Dynamic> streams); 
+		static inline void addMedia( ::Dynamic _hx_,::Array< ::Dynamic> streams) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::jingle::Session_obj *>(_hx_.mPtr->_hx_getInterface(0x79d60748)))->_hx_addMedia)(streams);
+		}
+		::String (::hx::Object :: *_hx_callStatus)(); 
+		static inline ::String callStatus( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::snikket::jingle::Session_obj *>(_hx_.mPtr->_hx_getInterface(0x79d60748)))->_hx_callStatus)();
+		}
+		::Array< ::Dynamic> (::hx::Object :: *_hx_videoTracks)(); 
+		static inline ::Array< ::Dynamic> videoTracks( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::snikket::jingle::Session_obj *>(_hx_.mPtr->_hx_getInterface(0x79d60748)))->_hx_videoTracks)();
+		}
+		 ::snikket::jingle::DTMFSender (::hx::Object :: *_hx_dtmf)(); 
+		static inline  ::snikket::jingle::DTMFSender dtmf( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::snikket::jingle::Session_obj *>(_hx_.mPtr->_hx_getInterface(0x79d60748)))->_hx_dtmf)();
+		}
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_Session */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/jingle/SessionDescription.h b/Sources/c_snikket/iinclude/include/snikket/jingle/SessionDescription.h
new file mode 100644
index 0000000..4529362
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/jingle/SessionDescription.h
@@ -0,0 +1,86 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_SessionDescription
+#define INCLUDED_snikket_jingle_SessionDescription
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,jingle,Attribute)
+HX_DECLARE_CLASS2(snikket,jingle,Media)
+HX_DECLARE_CLASS2(snikket,jingle,SessionDescription)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES SessionDescription_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef SessionDescription_obj OBJ_;
+		SessionDescription_obj();
+
+	public:
+		enum { _hx_ClassId = 0x24aad8f0 };
+
+		void __construct(int version,::String name,::Array< ::Dynamic> media,::Array< ::Dynamic> attributes,::Array< ::String > identificationTags);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.SessionDescription")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.SessionDescription"); }
+		static ::hx::ObjectPtr< SessionDescription_obj > __new(int version,::String name,::Array< ::Dynamic> media,::Array< ::Dynamic> attributes,::Array< ::String > identificationTags);
+		static ::hx::ObjectPtr< SessionDescription_obj > __alloc(::hx::Ctx *_hx_ctx,int version,::String name,::Array< ::Dynamic> media,::Array< ::Dynamic> attributes,::Array< ::String > identificationTags);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SessionDescription_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SessionDescription",66,e1,61,a3); }
+
+		static  ::snikket::jingle::SessionDescription parse(::String input);
+		static ::Dynamic parse_dyn();
+
+		static  ::snikket::jingle::SessionDescription fromStanza( ::snikket::Stanza iq,bool initiator, ::snikket::jingle::SessionDescription existingDescription);
+		static ::Dynamic fromStanza_dyn();
+
+		int version;
+		::String name;
+		::Array< ::Dynamic> media;
+		::Array< ::Dynamic> attributes;
+		::Array< ::String > identificationTags;
+		 ::Dynamic getUfragPwd();
+		::Dynamic getUfragPwd_dyn();
+
+		 ::snikket::jingle::Attribute getFingerprint();
+		::Dynamic getFingerprint_dyn();
+
+		::String getDtlsSetup();
+		::Dynamic getDtlsSetup_dyn();
+
+		 ::snikket::jingle::SessionDescription addContent( ::snikket::jingle::SessionDescription newDescription);
+		::Dynamic addContent_dyn();
+
+		::String toSdp();
+		::Dynamic toSdp_dyn();
+
+		 ::snikket::Stanza toStanza(::String action,::String sid,bool initiator);
+		::Dynamic toStanza_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_SessionDescription */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/jingle/TransportInfo.h b/Sources/c_snikket/iinclude/include/snikket/jingle/TransportInfo.h
new file mode 100644
index 0000000..1af9d00
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/jingle/TransportInfo.h
@@ -0,0 +1,60 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_TransportInfo
+#define INCLUDED_snikket_jingle_TransportInfo
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,jingle,Media)
+HX_DECLARE_CLASS2(snikket,jingle,TransportInfo)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES TransportInfo_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef TransportInfo_obj OBJ_;
+		TransportInfo_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4c85e215 };
+
+		void __construct( ::snikket::jingle::Media media,::String sid);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.TransportInfo")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.TransportInfo"); }
+		static ::hx::ObjectPtr< TransportInfo_obj > __new( ::snikket::jingle::Media media,::String sid);
+		static ::hx::ObjectPtr< TransportInfo_obj > __alloc(::hx::Ctx *_hx_ctx, ::snikket::jingle::Media media,::String sid);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~TransportInfo_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("TransportInfo",97,8c,bf,fe); }
+
+		 ::snikket::jingle::Media media;
+		::String sid;
+		 ::snikket::Stanza toStanza(bool initiator);
+		::Dynamic toStanza_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_TransportInfo */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/jingle/_Session/Session_Fields_.h b/Sources/c_snikket/iinclude/include/snikket/jingle/_Session/Session_Fields_.h
new file mode 100644
index 0000000..5690ec1
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/jingle/_Session/Session_Fields_.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle__Session_Session_Fields_
+#define INCLUDED_snikket_jingle__Session_Session_Fields_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,ChatMessage)
+HX_DECLARE_CLASS1(snikket,JID)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS3(snikket,jingle,_Session,Session_Fields_)
+
+namespace snikket{
+namespace jingle{
+namespace _Session{
+
+
+class HXCPP_CLASS_ATTRIBUTES Session_Fields__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Session_Fields__obj OBJ_;
+		Session_Fields__obj();
+
+	public:
+		enum { _hx_ClassId = 0x4b7e6858 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket.jingle._Session.Session_Fields_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket.jingle._Session.Session_Fields_"); }
+
+		inline static ::hx::ObjectPtr< Session_Fields__obj > __new() {
+			::hx::ObjectPtr< Session_Fields__obj > __this = new Session_Fields__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Session_Fields__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Session_Fields__obj *__this = (Session_Fields__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Session_Fields__obj), false, "snikket.jingle._Session.Session_Fields_"));
+			*(void **)__this = Session_Fields__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Session_Fields__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Session_Fields_",5d,02,e4,dc); }
+
+		static  ::snikket::ChatMessage mkCallMessage( ::snikket::JID to, ::snikket::JID from, ::snikket::Stanza event);
+		static ::Dynamic mkCallMessage_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+} // end namespace _Session
+
+#endif /* INCLUDED_snikket_jingle__Session_Session_Fields_ */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/persistence/Dummy.h b/Sources/c_snikket/iinclude/include/snikket/persistence/Dummy.h
new file mode 100644
index 0000000..6b7e275
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/persistence/Dummy.h
@@ -0,0 +1,138 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_persistence_Dummy
+#define INCLUDED_snikket_persistence_Dummy
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_Persistence
+#include <snikket/Persistence.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Caps)
+HX_DECLARE_CLASS1(snikket,Chat)
+HX_DECLARE_CLASS1(snikket,ChatMessage)
+HX_DECLARE_CLASS1(snikket,Persistence)
+HX_DECLARE_CLASS1(snikket,ReactionUpdate)
+HX_DECLARE_CLASS1(snikket,SerializedChat)
+HX_DECLARE_CLASS2(snikket,persistence,Dummy)
+
+namespace snikket{
+namespace persistence{
+
+
+class HXCPP_CLASS_ATTRIBUTES Dummy_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Dummy_obj OBJ_;
+		Dummy_obj();
+
+	public:
+		enum { _hx_ClassId = 0x130a03e2 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket.persistence.Dummy")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket.persistence.Dummy"); }
+		static ::hx::ObjectPtr< Dummy_obj > __new();
+		static ::hx::ObjectPtr< Dummy_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Dummy_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("Dummy",08,7e,e8,74); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		void lastId(::String accountId,::String chatId, ::Dynamic callback);
+		::Dynamic lastId_dyn();
+
+		void storeChats(::String accountId,::Array< ::Dynamic> chat);
+		::Dynamic storeChats_dyn();
+
+		void getChats(::String accountId, ::Dynamic callback);
+		::Dynamic getChats_dyn();
+
+		void storeMessages(::String accountId,::Array< ::Dynamic> messages, ::Dynamic callback);
+		::Dynamic storeMessages_dyn();
+
+		void updateMessage(::String accountId, ::snikket::ChatMessage message);
+		::Dynamic updateMessage_dyn();
+
+		void getMessage(::String accountId,::String chatId,::String serverId,::String localId, ::Dynamic callback);
+		::Dynamic getMessage_dyn();
+
+		void getMessagesBefore(::String accountId,::String chatId,::String beforeId,::String beforeTime, ::Dynamic callback);
+		::Dynamic getMessagesBefore_dyn();
+
+		void getMessagesAfter(::String accountId,::String chatId,::String afterId,::String afterTime, ::Dynamic callback);
+		::Dynamic getMessagesAfter_dyn();
+
+		void getMessagesAround(::String accountId,::String chatId,::String aroundId,::String aroundTime, ::Dynamic callback);
+		::Dynamic getMessagesAround_dyn();
+
+		void getChatsUnreadDetails(::String accountId,::Array< ::Dynamic> chats, ::Dynamic callback);
+		::Dynamic getChatsUnreadDetails_dyn();
+
+		void storeReaction(::String accountId, ::snikket::ReactionUpdate update, ::Dynamic callback);
+		::Dynamic storeReaction_dyn();
+
+		void updateMessageStatus(::String accountId,::String localId,int status, ::Dynamic callback);
+		::Dynamic updateMessageStatus_dyn();
+
+		void getMediaUri(::String hashAlgorithm,::Array< unsigned char > hash, ::Dynamic callback);
+		::Dynamic getMediaUri_dyn();
+
+		void hasMedia(::String hashAlgorithm,::Array< unsigned char > hash, ::Dynamic callback);
+		::Dynamic hasMedia_dyn();
+
+		void storeMedia(::String mime,::Array< unsigned char > bd, ::Dynamic callback);
+		::Dynamic storeMedia_dyn();
+
+		void removeMedia(::String hashAlgorithm,::Array< unsigned char > hash);
+		::Dynamic removeMedia_dyn();
+
+		void storeCaps( ::snikket::Caps caps);
+		::Dynamic storeCaps_dyn();
+
+		void getCaps(::String ver, ::Dynamic callback);
+		::Dynamic getCaps_dyn();
+
+		void storeLogin(::String login,::String clientId,::String displayName,::String token);
+		::Dynamic storeLogin_dyn();
+
+		void getLogin(::String login, ::Dynamic callback);
+		::Dynamic getLogin_dyn();
+
+		void removeAccount(::String accountId,bool completely);
+		::Dynamic removeAccount_dyn();
+
+		void listAccounts( ::Dynamic callback);
+		::Dynamic listAccounts_dyn();
+
+		void storeStreamManagement(::String accountId,::Array< unsigned char > sm);
+		::Dynamic storeStreamManagement_dyn();
+
+		void getStreamManagement(::String accountId, ::Dynamic callback);
+		::Dynamic getStreamManagement_dyn();
+
+		void storeService(::String accountId,::String serviceId,::String name,::String node, ::snikket::Caps caps);
+		::Dynamic storeService_dyn();
+
+		void findServicesWithFeature(::String accountId,::String feature, ::Dynamic callback);
+		::Dynamic findServicesWithFeature_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace persistence
+
+#endif /* INCLUDED_snikket_persistence_Dummy */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/persistence/KeyValueStore.h b/Sources/c_snikket/iinclude/include/snikket/persistence/KeyValueStore.h
new file mode 100644
index 0000000..33fa468
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/persistence/KeyValueStore.h
@@ -0,0 +1,33 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_persistence_KeyValueStore
+#define INCLUDED_snikket_persistence_KeyValueStore
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(snikket,persistence,KeyValueStore)
+
+namespace snikket{
+namespace persistence{
+
+
+class HXCPP_CLASS_ATTRIBUTES KeyValueStore_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		void (::hx::Object :: *_hx_get)(::String k, ::Dynamic callback); 
+		static inline void get( ::Dynamic _hx_,::String k, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::persistence::KeyValueStore_obj *>(_hx_.mPtr->_hx_getInterface(0x42160a8d)))->_hx_get)(k,callback);
+		}
+		void (::hx::Object :: *_hx_set)(::String k,::String v, ::Dynamic callback); 
+		static inline void set( ::Dynamic _hx_,::String k,::String v, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::persistence::KeyValueStore_obj *>(_hx_.mPtr->_hx_getInterface(0x42160a8d)))->_hx_set)(k,v,callback);
+		}
+};
+
+} // end namespace snikket
+} // end namespace persistence
+
+#endif /* INCLUDED_snikket_persistence_KeyValueStore */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/persistence/MediaStore.h b/Sources/c_snikket/iinclude/include/snikket/persistence/MediaStore.h
new file mode 100644
index 0000000..911ceff
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/persistence/MediaStore.h
@@ -0,0 +1,42 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_persistence_MediaStore
+#define INCLUDED_snikket_persistence_MediaStore
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(snikket,persistence,KeyValueStore)
+HX_DECLARE_CLASS2(snikket,persistence,MediaStore)
+
+namespace snikket{
+namespace persistence{
+
+
+class HXCPP_CLASS_ATTRIBUTES MediaStore_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		void (::hx::Object :: *_hx_hasMedia)(::String hashAlgorithm,::Array< unsigned char > hash, ::Dynamic callback); 
+		static inline void hasMedia( ::Dynamic _hx_,::String hashAlgorithm,::Array< unsigned char > hash, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::persistence::MediaStore_obj *>(_hx_.mPtr->_hx_getInterface(0x2952283f)))->_hx_hasMedia)(hashAlgorithm,hash,callback);
+		}
+		void (::hx::Object :: *_hx_removeMedia)(::String hashAlgorithm,::Array< unsigned char > hash); 
+		static inline void removeMedia( ::Dynamic _hx_,::String hashAlgorithm,::Array< unsigned char > hash) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::persistence::MediaStore_obj *>(_hx_.mPtr->_hx_getInterface(0x2952283f)))->_hx_removeMedia)(hashAlgorithm,hash);
+		}
+		void (::hx::Object :: *_hx_storeMedia)(::String mime,::Array< unsigned char > bytes, ::Dynamic callback); 
+		static inline void storeMedia( ::Dynamic _hx_,::String mime,::Array< unsigned char > bytes, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::persistence::MediaStore_obj *>(_hx_.mPtr->_hx_getInterface(0x2952283f)))->_hx_storeMedia)(mime,bytes,callback);
+		}
+		void (::hx::Object :: *_hx_setKV)(::Dynamic kv); 
+		static inline void setKV( ::Dynamic _hx_,::Dynamic kv) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::persistence::MediaStore_obj *>(_hx_.mPtr->_hx_getInterface(0x2952283f)))->_hx_setKV)(kv);
+		}
+};
+
+} // end namespace snikket
+} // end namespace persistence
+
+#endif /* INCLUDED_snikket_persistence_MediaStore */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/persistence/MediaStoreFS.h b/Sources/c_snikket/iinclude/include/snikket/persistence/MediaStoreFS.h
new file mode 100644
index 0000000..7ceaaa8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/persistence/MediaStoreFS.h
@@ -0,0 +1,86 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_persistence_MediaStoreFS
+#define INCLUDED_snikket_persistence_MediaStoreFS
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_persistence_MediaStore
+#include <snikket/persistence/MediaStore.h>
+#endif
+HX_DECLARE_CLASS2(snikket,persistence,KeyValueStore)
+HX_DECLARE_CLASS2(snikket,persistence,MediaStore)
+HX_DECLARE_CLASS2(snikket,persistence,MediaStoreFS)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+
+namespace snikket{
+namespace persistence{
+
+
+class HXCPP_CLASS_ATTRIBUTES MediaStoreFS_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef MediaStoreFS_obj OBJ_;
+		MediaStoreFS_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3993cd38 };
+
+		void __construct(::String path);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.persistence.MediaStoreFS")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.persistence.MediaStoreFS"); }
+		static ::hx::ObjectPtr< MediaStoreFS_obj > __new(::String path);
+		static ::hx::ObjectPtr< MediaStoreFS_obj > __alloc(::hx::Ctx *_hx_ctx,::String path);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~MediaStoreFS_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("MediaStoreFS",0a,5f,89,fe); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		::String blobpath;
+		::Dynamic kv;
+		void setKV(::Dynamic kv);
+		::Dynamic setKV_dyn();
+
+		void getMediaPath(::String uri, ::Dynamic callback);
+		::Dynamic getMediaPath_dyn();
+
+		void getMediaPath__fromC(::String uri,::cpp::Function< void  (const char*,void*) > callback,void* callback__context);
+
+		void hasMedia(::String hashAlgorithm,::Array< unsigned char > hash, ::Dynamic callback);
+		::Dynamic hasMedia_dyn();
+
+		void removeMedia(::String hashAlgorithm,::Array< unsigned char > hash);
+		::Dynamic removeMedia_dyn();
+
+		void storeMedia(::String mime,::Array< unsigned char > bd, ::Dynamic callback);
+		::Dynamic storeMedia_dyn();
+
+		::Dynamic set(::String k,::String v);
+		::Dynamic set_dyn();
+
+		::Dynamic get(::String k);
+		::Dynamic get_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace persistence
+
+#endif /* INCLUDED_snikket_persistence_MediaStoreFS */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/persistence/Sqlite.h b/Sources/c_snikket/iinclude/include/snikket/persistence/Sqlite.h
new file mode 100644
index 0000000..8418150
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/persistence/Sqlite.h
@@ -0,0 +1,180 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_persistence_Sqlite
+#define INCLUDED_snikket_persistence_Sqlite
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_persistence_KeyValueStore
+#include <snikket/persistence/KeyValueStore.h>
+#endif
+#ifndef INCLUDED_snikket_Persistence
+#include <snikket/Persistence.h>
+#endif
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS1(haxe,Timer)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS1(snikket,Caps)
+HX_DECLARE_CLASS1(snikket,Chat)
+HX_DECLARE_CLASS1(snikket,ChatMessage)
+HX_DECLARE_CLASS1(snikket,Persistence)
+HX_DECLARE_CLASS1(snikket,ReactionUpdate)
+HX_DECLARE_CLASS1(snikket,SerializedChat)
+HX_DECLARE_CLASS2(snikket,persistence,KeyValueStore)
+HX_DECLARE_CLASS2(snikket,persistence,MediaStore)
+HX_DECLARE_CLASS2(snikket,persistence,Sqlite)
+HX_DECLARE_CLASS2(snikket,persistence,SqliteDriver)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+
+namespace snikket{
+namespace persistence{
+
+
+class HXCPP_CLASS_ATTRIBUTES Sqlite_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Sqlite_obj OBJ_;
+		Sqlite_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1fc6c66e };
+
+		void __construct(::String dbfile,::Dynamic media);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.persistence.Sqlite")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.persistence.Sqlite"); }
+		static ::hx::ObjectPtr< Sqlite_obj > __new(::String dbfile,::Dynamic media);
+		static ::hx::ObjectPtr< Sqlite_obj > __alloc(::hx::Ctx *_hx_ctx,::String dbfile,::Dynamic media);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Sqlite_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("Sqlite",ec,9c,99,87); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		 ::snikket::persistence::SqliteDriver db;
+		::Dynamic media;
+		void get(::String k, ::Dynamic callback);
+		::Dynamic get_dyn();
+
+		void set(::String k,::String v, ::Dynamic callback);
+		::Dynamic set_dyn();
+
+		void lastId(::String accountId,::String chatId, ::Dynamic callback);
+		::Dynamic lastId_dyn();
+
+		 ::haxe::ds::StringMap storeChatBuffer;
+		 ::haxe::Timer storeChatTimer;
+		void storeChats(::String accountId,::Array< ::Dynamic> chats);
+		::Dynamic storeChats_dyn();
+
+		void getChats(::String accountId, ::Dynamic callback);
+		::Dynamic getChats_dyn();
+
+		void storeMessages(::String accountId,::Array< ::Dynamic> messages, ::Dynamic callback);
+		::Dynamic storeMessages_dyn();
+
+		void updateMessage(::String accountId, ::snikket::ChatMessage message);
+		::Dynamic updateMessage_dyn();
+
+		void getMessage(::String accountId,::String chatId,::String serverId,::String localId, ::Dynamic callback);
+		::Dynamic getMessage_dyn();
+
+		void getMessage__fromC(::String accountId,::String chatId,::String serverId,::String localId,::cpp::Function< void  (void*,void*) > callback,void* callback__context);
+
+		::Dynamic getMessages(::String accountId,::String chatId,::String time,::String op);
+		::Dynamic getMessages_dyn();
+
+		void getMessagesBefore(::String accountId,::String chatId,::String beforeId,::String beforeTime, ::Dynamic callback);
+		::Dynamic getMessagesBefore_dyn();
+
+		void getMessagesAfter(::String accountId,::String chatId,::String afterId,::String afterTime, ::Dynamic callback);
+		::Dynamic getMessagesAfter_dyn();
+
+		void getMessagesAround(::String accountId,::String chatId,::String aroundId,::String aroundTime, ::Dynamic callback);
+		::Dynamic getMessagesAround_dyn();
+
+		void getChatsUnreadDetails(::String accountId,::Array< ::Dynamic> chats, ::Dynamic callback);
+		::Dynamic getChatsUnreadDetails_dyn();
+
+		void storeReaction(::String accountId, ::snikket::ReactionUpdate update, ::Dynamic callback);
+		::Dynamic storeReaction_dyn();
+
+		void updateMessageStatus(::String accountId,::String localId,int status, ::Dynamic callback);
+		::Dynamic updateMessageStatus_dyn();
+
+		void hasMedia(::String hashAlgorithm,::Array< unsigned char > hash, ::Dynamic callback);
+		::Dynamic hasMedia_dyn();
+
+		void removeMedia(::String hashAlgorithm,::Array< unsigned char > hash);
+		::Dynamic removeMedia_dyn();
+
+		void storeMedia(::String mime,::Array< unsigned char > bd, ::Dynamic callback);
+		::Dynamic storeMedia_dyn();
+
+		void storeCaps( ::snikket::Caps caps);
+		::Dynamic storeCaps_dyn();
+
+		void getCaps(::String ver, ::Dynamic callback);
+		::Dynamic getCaps_dyn();
+
+		void storeLogin(::String accountId,::String clientId,::String displayName,::String token);
+		::Dynamic storeLogin_dyn();
+
+		void getLogin(::String accountId, ::Dynamic callback);
+		::Dynamic getLogin_dyn();
+
+		void removeAccount(::String accountId,bool completely);
+		::Dynamic removeAccount_dyn();
+
+		void listAccounts( ::Dynamic callback);
+		::Dynamic listAccounts_dyn();
+
+		void listAccounts__fromC(::cpp::Function< void  (const char**,size_t,void*) > callback,void* callback__context);
+
+		bool smStoreInProgress;
+		::Array< unsigned char > smStoreNext;
+		void storeStreamManagement(::String accountId,::Array< unsigned char > sm);
+		::Dynamic storeStreamManagement_dyn();
+
+		void getStreamManagement(::String accountId, ::Dynamic callback);
+		::Dynamic getStreamManagement_dyn();
+
+		void storeService(::String accountId,::String serviceId,::String name,::String node, ::snikket::Caps caps);
+		::Dynamic storeService_dyn();
+
+		void findServicesWithFeature(::String accountId,::String feature, ::Dynamic callback);
+		::Dynamic findServicesWithFeature_dyn();
+
+		::Dynamic hydrateReactions(::String accountId,::Array< ::Dynamic> messages);
+		::Dynamic hydrateReactions_dyn();
+
+		::Dynamic fetchReactions(::String accountId,::Array< ::Dynamic> ids);
+		::Dynamic fetchReactions_dyn();
+
+		::Dynamic hydrateReplyTo(::String accountId,::Array< ::Dynamic> messages,::Array< ::Dynamic> replyTos);
+		::Dynamic hydrateReplyTo_dyn();
+
+		::Array< ::Dynamic> hydrateMessages(::String accountId, ::Dynamic rows);
+		::Dynamic hydrateMessages_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace persistence
+
+#endif /* INCLUDED_snikket_persistence_Sqlite */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/persistence/SqliteDriver.h b/Sources/c_snikket/iinclude/include/snikket/persistence/SqliteDriver.h
new file mode 100644
index 0000000..d13d4d8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/persistence/SqliteDriver.h
@@ -0,0 +1,61 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_persistence_SqliteDriver
+#define INCLUDED_snikket_persistence_SqliteDriver
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(snikket,persistence,SqliteDriver)
+HX_DECLARE_CLASS2(sys,db,Connection)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+
+namespace snikket{
+namespace persistence{
+
+
+class HXCPP_CLASS_ATTRIBUTES SqliteDriver_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef SqliteDriver_obj OBJ_;
+		SqliteDriver_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0672539a };
+
+		void __construct(::String dbfile);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.persistence.SqliteDriver")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.persistence.SqliteDriver"); }
+		static ::hx::ObjectPtr< SqliteDriver_obj > __new(::String dbfile);
+		static ::hx::ObjectPtr< SqliteDriver_obj > __alloc(::hx::Ctx *_hx_ctx,::String dbfile);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SqliteDriver_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SqliteDriver",34,0a,34,44); }
+
+		::Dynamic db;
+		::Dynamic exec( ::Dynamic sql,::cpp::VirtualArray params);
+		::Dynamic exec_dyn();
+
+		::String prepare(::String sql,::cpp::VirtualArray params);
+		::Dynamic prepare_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace persistence
+
+#endif /* INCLUDED_snikket_persistence_SqliteDriver */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/queries/BlocklistGet.h b/Sources/c_snikket/iinclude/include/snikket/queries/BlocklistGet.h
new file mode 100644
index 0000000..ab498fe
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/queries/BlocklistGet.h
@@ -0,0 +1,67 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_queries_BlocklistGet
+#define INCLUDED_snikket_queries_BlocklistGet
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#include <snikket/queries/GenericQuery.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,queries,BlocklistGet)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+
+namespace snikket{
+namespace queries{
+
+
+class HXCPP_CLASS_ATTRIBUTES BlocklistGet_obj : public  ::snikket::queries::GenericQuery_obj
+{
+	public:
+		typedef  ::snikket::queries::GenericQuery_obj super;
+		typedef BlocklistGet_obj OBJ_;
+		BlocklistGet_obj();
+
+	public:
+		enum { _hx_ClassId = 0x60103714 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.queries.BlocklistGet")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.queries.BlocklistGet"); }
+		static ::hx::ObjectPtr< BlocklistGet_obj > __new();
+		static ::hx::ObjectPtr< BlocklistGet_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~BlocklistGet_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("BlocklistGet",4b,75,69,37); }
+
+		::String xmlns;
+		::String queryId;
+		 ::snikket::Stanza responseStanza;
+		::Array< ::String > result;
+		void handleResponse( ::snikket::Stanza stanza);
+
+		::Array< ::String > getResult();
+		::Dynamic getResult_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace queries
+
+#endif /* INCLUDED_snikket_queries_BlocklistGet */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/queries/BoB.h b/Sources/c_snikket/iinclude/include/snikket/queries/BoB.h
new file mode 100644
index 0000000..a2bd8ec
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/queries/BoB.h
@@ -0,0 +1,72 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_queries_BoB
+#define INCLUDED_snikket_queries_BoB
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#include <snikket/queries/GenericQuery.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Hash)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,queries,BoB)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+
+namespace snikket{
+namespace queries{
+
+
+class HXCPP_CLASS_ATTRIBUTES BoB_obj : public  ::snikket::queries::GenericQuery_obj
+{
+	public:
+		typedef  ::snikket::queries::GenericQuery_obj super;
+		typedef BoB_obj OBJ_;
+		BoB_obj();
+
+	public:
+		enum { _hx_ClassId = 0x6fef110c };
+
+		void __construct(::String to,::String uri);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.queries.BoB")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.queries.BoB"); }
+		static ::hx::ObjectPtr< BoB_obj > __new(::String to,::String uri);
+		static ::hx::ObjectPtr< BoB_obj > __alloc(::hx::Ctx *_hx_ctx,::String to,::String uri);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~BoB_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("BoB",b5,75,32,00); }
+
+		static  ::snikket::queries::BoB forHash(::String to, ::snikket::Hash hash);
+		static ::Dynamic forHash_dyn();
+
+		::String xmlns;
+		::String queryId;
+		 ::snikket::Stanza responseStanza;
+		 ::Dynamic result;
+		void handleResponse( ::snikket::Stanza stanza);
+
+		 ::Dynamic getResult();
+		::Dynamic getResult_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace queries
+
+#endif /* INCLUDED_snikket_queries_BoB */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/queries/DiscoInfoGet.h b/Sources/c_snikket/iinclude/include/snikket/queries/DiscoInfoGet.h
new file mode 100644
index 0000000..cb69a82
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/queries/DiscoInfoGet.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_queries_DiscoInfoGet
+#define INCLUDED_snikket_queries_DiscoInfoGet
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#include <snikket/queries/GenericQuery.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Caps)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,queries,DiscoInfoGet)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+
+namespace snikket{
+namespace queries{
+
+
+class HXCPP_CLASS_ATTRIBUTES DiscoInfoGet_obj : public  ::snikket::queries::GenericQuery_obj
+{
+	public:
+		typedef  ::snikket::queries::GenericQuery_obj super;
+		typedef DiscoInfoGet_obj OBJ_;
+		DiscoInfoGet_obj();
+
+	public:
+		enum { _hx_ClassId = 0x17bd6e57 };
+
+		void __construct(::String to,::String node);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.queries.DiscoInfoGet")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.queries.DiscoInfoGet"); }
+		static ::hx::ObjectPtr< DiscoInfoGet_obj > __new(::String to,::String node);
+		static ::hx::ObjectPtr< DiscoInfoGet_obj > __alloc(::hx::Ctx *_hx_ctx,::String to,::String node);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~DiscoInfoGet_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DiscoInfoGet",8e,ac,16,ef); }
+
+		::String xmlns;
+		::String queryId;
+		 ::snikket::Stanza responseStanza;
+		 ::snikket::Caps result;
+		void handleResponse( ::snikket::Stanza stanza);
+
+		 ::snikket::Caps getResult();
+		::Dynamic getResult_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace queries
+
+#endif /* INCLUDED_snikket_queries_DiscoInfoGet */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/queries/DiscoItemsGet.h b/Sources/c_snikket/iinclude/include/snikket/queries/DiscoItemsGet.h
new file mode 100644
index 0000000..8096b9e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/queries/DiscoItemsGet.h
@@ -0,0 +1,67 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_queries_DiscoItemsGet
+#define INCLUDED_snikket_queries_DiscoItemsGet
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#include <snikket/queries/GenericQuery.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,queries,DiscoItemsGet)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+
+namespace snikket{
+namespace queries{
+
+
+class HXCPP_CLASS_ATTRIBUTES DiscoItemsGet_obj : public  ::snikket::queries::GenericQuery_obj
+{
+	public:
+		typedef  ::snikket::queries::GenericQuery_obj super;
+		typedef DiscoItemsGet_obj OBJ_;
+		DiscoItemsGet_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3759f407 };
+
+		void __construct(::String to,::String node);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.queries.DiscoItemsGet")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.queries.DiscoItemsGet"); }
+		static ::hx::ObjectPtr< DiscoItemsGet_obj > __new(::String to,::String node);
+		static ::hx::ObjectPtr< DiscoItemsGet_obj > __alloc(::hx::Ctx *_hx_ctx,::String to,::String node);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~DiscoItemsGet_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DiscoItemsGet",f0,25,17,ce); }
+
+		::String xmlns;
+		::String queryId;
+		 ::snikket::Stanza responseStanza;
+		::Array< ::Dynamic> result;
+		void handleResponse( ::snikket::Stanza stanza);
+
+		::Array< ::Dynamic> getResult();
+		::Dynamic getResult_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace queries
+
+#endif /* INCLUDED_snikket_queries_DiscoItemsGet */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/queries/ExtDiscoGet.h b/Sources/c_snikket/iinclude/include/snikket/queries/ExtDiscoGet.h
new file mode 100644
index 0000000..7f2afdc
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/queries/ExtDiscoGet.h
@@ -0,0 +1,67 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_queries_ExtDiscoGet
+#define INCLUDED_snikket_queries_ExtDiscoGet
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#include <snikket/queries/GenericQuery.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,queries,ExtDiscoGet)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+
+namespace snikket{
+namespace queries{
+
+
+class HXCPP_CLASS_ATTRIBUTES ExtDiscoGet_obj : public  ::snikket::queries::GenericQuery_obj
+{
+	public:
+		typedef  ::snikket::queries::GenericQuery_obj super;
+		typedef ExtDiscoGet_obj OBJ_;
+		ExtDiscoGet_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5f97d134 };
+
+		void __construct(::String to);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.queries.ExtDiscoGet")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.queries.ExtDiscoGet"); }
+		static ::hx::ObjectPtr< ExtDiscoGet_obj > __new(::String to);
+		static ::hx::ObjectPtr< ExtDiscoGet_obj > __alloc(::hx::Ctx *_hx_ctx,::String to);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ExtDiscoGet_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ExtDiscoGet",dd,86,3d,f9); }
+
+		::String xmlns;
+		::String queryId;
+		 ::snikket::Stanza responseStanza;
+		::Array< ::Dynamic> result;
+		void handleResponse( ::snikket::Stanza stanza);
+
+		::Array< ::Dynamic> getResult();
+		::Dynamic getResult_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace queries
+
+#endif /* INCLUDED_snikket_queries_ExtDiscoGet */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/queries/GenericQuery.h b/Sources/c_snikket/iinclude/include/snikket/queries/GenericQuery.h
new file mode 100644
index 0000000..b2b72e1
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/queries/GenericQuery.h
@@ -0,0 +1,65 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#define INCLUDED_snikket_queries_GenericQuery
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+
+namespace snikket{
+namespace queries{
+
+
+class HXCPP_CLASS_ATTRIBUTES GenericQuery_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef GenericQuery_obj OBJ_;
+		GenericQuery_obj();
+
+	public:
+		enum { _hx_ClassId = 0x22eda35a };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.queries.GenericQuery")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.queries.GenericQuery"); }
+
+		//~GenericQuery_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("GenericQuery",91,e1,46,fa); }
+
+		 ::snikket::Stanza queryStanza;
+		 ::Dynamic handleFinished;
+		Dynamic handleFinished_dyn() { return handleFinished;}
+		bool isFinished;
+		 ::snikket::Stanza getQueryStanza();
+		::Dynamic getQueryStanza_dyn();
+
+		void finish();
+		::Dynamic finish_dyn();
+
+		virtual void handleResponse( ::snikket::Stanza response) {}
+		::Dynamic handleResponse_dyn();
+		void onFinished( ::Dynamic handler);
+		::Dynamic onFinished_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace queries
+
+#endif /* INCLUDED_snikket_queries_GenericQuery */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/queries/HttpUploadSlot.h b/Sources/c_snikket/iinclude/include/snikket/queries/HttpUploadSlot.h
new file mode 100644
index 0000000..883512b
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/queries/HttpUploadSlot.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_queries_HttpUploadSlot
+#define INCLUDED_snikket_queries_HttpUploadSlot
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#include <snikket/queries/GenericQuery.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Hash)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+HX_DECLARE_CLASS2(snikket,queries,HttpUploadSlot)
+
+namespace snikket{
+namespace queries{
+
+
+class HXCPP_CLASS_ATTRIBUTES HttpUploadSlot_obj : public  ::snikket::queries::GenericQuery_obj
+{
+	public:
+		typedef  ::snikket::queries::GenericQuery_obj super;
+		typedef HttpUploadSlot_obj OBJ_;
+		HttpUploadSlot_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1883dc70 };
+
+		void __construct(::String to,::String filename,int size,::String mime,::Array< ::Dynamic> hashes);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.queries.HttpUploadSlot")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.queries.HttpUploadSlot"); }
+		static ::hx::ObjectPtr< HttpUploadSlot_obj > __new(::String to,::String filename,int size,::String mime,::Array< ::Dynamic> hashes);
+		static ::hx::ObjectPtr< HttpUploadSlot_obj > __alloc(::hx::Ctx *_hx_ctx,::String to,::String filename,int size,::String mime,::Array< ::Dynamic> hashes);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HttpUploadSlot_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HttpUploadSlot",67,56,52,67); }
+
+		::String xmlns;
+		::String queryId;
+		 ::snikket::Stanza responseStanza;
+		 ::Dynamic result;
+		void handleResponse( ::snikket::Stanza stanza);
+
+		 ::Dynamic getResult();
+		::Dynamic getResult_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace queries
+
+#endif /* INCLUDED_snikket_queries_HttpUploadSlot */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/queries/JabberIqGatewayGet.h b/Sources/c_snikket/iinclude/include/snikket/queries/JabberIqGatewayGet.h
new file mode 100644
index 0000000..9c76c99
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/queries/JabberIqGatewayGet.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_queries_JabberIqGatewayGet
+#define INCLUDED_snikket_queries_JabberIqGatewayGet
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#include <snikket/queries/GenericQuery.h>
+#endif
+HX_DECLARE_CLASS2(haxe,ds,Either)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+HX_DECLARE_CLASS2(snikket,queries,JabberIqGatewayGet)
+
+namespace snikket{
+namespace queries{
+
+
+class HXCPP_CLASS_ATTRIBUTES JabberIqGatewayGet_obj : public  ::snikket::queries::GenericQuery_obj
+{
+	public:
+		typedef  ::snikket::queries::GenericQuery_obj super;
+		typedef JabberIqGatewayGet_obj OBJ_;
+		JabberIqGatewayGet_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3942ef8b };
+
+		void __construct(::String to,::String prompt);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.queries.JabberIqGatewayGet")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.queries.JabberIqGatewayGet"); }
+		static ::hx::ObjectPtr< JabberIqGatewayGet_obj > __new(::String to,::String prompt);
+		static ::hx::ObjectPtr< JabberIqGatewayGet_obj > __alloc(::hx::Ctx *_hx_ctx,::String to,::String prompt);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~JabberIqGatewayGet_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("JabberIqGatewayGet",9e,bd,60,0b); }
+
+		::String xmlns;
+		::String queryId;
+		 ::snikket::Stanza responseStanza;
+		 ::haxe::ds::Either result;
+		void handleResponse( ::snikket::Stanza stanza);
+
+		 ::haxe::ds::Either getResult();
+		::Dynamic getResult_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace queries
+
+#endif /* INCLUDED_snikket_queries_JabberIqGatewayGet */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/queries/MAMQuery.h b/Sources/c_snikket/iinclude/include/snikket/queries/MAMQuery.h
new file mode 100644
index 0000000..c3abe95
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/queries/MAMQuery.h
@@ -0,0 +1,73 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_queries_MAMQuery
+#define INCLUDED_snikket_queries_MAMQuery
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#include <snikket/queries/GenericQuery.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+HX_DECLARE_CLASS2(snikket,queries,MAMQuery)
+
+namespace snikket{
+namespace queries{
+
+
+class HXCPP_CLASS_ATTRIBUTES MAMQuery_obj : public  ::snikket::queries::GenericQuery_obj
+{
+	public:
+		typedef  ::snikket::queries::GenericQuery_obj super;
+		typedef MAMQuery_obj OBJ_;
+		MAMQuery_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3d2643e0 };
+
+		void __construct( ::Dynamic params,::String jid);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.queries.MAMQuery")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.queries.MAMQuery"); }
+		static ::hx::ObjectPtr< MAMQuery_obj > __new( ::Dynamic params,::String jid);
+		static ::hx::ObjectPtr< MAMQuery_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic params,::String jid);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~MAMQuery_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("MAMQuery",cf,3d,b2,7d); }
+
+		::String xmlns;
+		::String queryId;
+		 ::snikket::Stanza responseStanza;
+		 ::Dynamic result;
+		void addStringField(::String name,::String value);
+		::Dynamic addStringField_dyn();
+
+		void addArrayField(::String name,::Array< ::String > values);
+		::Dynamic addArrayField_dyn();
+
+		void handleResponse( ::snikket::Stanza stanza);
+
+		 ::Dynamic getResult();
+		::Dynamic getResult_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace queries
+
+#endif /* INCLUDED_snikket_queries_MAMQuery */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/queries/PubsubGet.h b/Sources/c_snikket/iinclude/include/snikket/queries/PubsubGet.h
new file mode 100644
index 0000000..0765cc8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/queries/PubsubGet.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_queries_PubsubGet
+#define INCLUDED_snikket_queries_PubsubGet
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#include <snikket/queries/GenericQuery.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+HX_DECLARE_CLASS2(snikket,queries,PubsubGet)
+
+namespace snikket{
+namespace queries{
+
+
+class HXCPP_CLASS_ATTRIBUTES PubsubGet_obj : public  ::snikket::queries::GenericQuery_obj
+{
+	public:
+		typedef  ::snikket::queries::GenericQuery_obj super;
+		typedef PubsubGet_obj OBJ_;
+		PubsubGet_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1a0e23ea };
+
+		void __construct(::String to,::String node,::String itemId);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.queries.PubsubGet")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.queries.PubsubGet"); }
+		static ::hx::ObjectPtr< PubsubGet_obj > __new(::String to,::String node,::String itemId);
+		static ::hx::ObjectPtr< PubsubGet_obj > __alloc(::hx::Ctx *_hx_ctx,::String to,::String node,::String itemId);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~PubsubGet_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("PubsubGet",53,ed,9f,94); }
+
+		::String xmlns;
+		::String queryId;
+		::String ver;
+		 ::snikket::Stanza responseStanza;
+		::Array< ::Dynamic> result;
+		void handleResponse( ::snikket::Stanza stanza);
+
+		::Array< ::Dynamic> getResult();
+		::Dynamic getResult_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace queries
+
+#endif /* INCLUDED_snikket_queries_PubsubGet */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/queries/Push2Disable.h b/Sources/c_snikket/iinclude/include/snikket/queries/Push2Disable.h
new file mode 100644
index 0000000..19efee6
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/queries/Push2Disable.h
@@ -0,0 +1,63 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_queries_Push2Disable
+#define INCLUDED_snikket_queries_Push2Disable
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#include <snikket/queries/GenericQuery.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+HX_DECLARE_CLASS2(snikket,queries,Push2Disable)
+
+namespace snikket{
+namespace queries{
+
+
+class HXCPP_CLASS_ATTRIBUTES Push2Disable_obj : public  ::snikket::queries::GenericQuery_obj
+{
+	public:
+		typedef  ::snikket::queries::GenericQuery_obj super;
+		typedef Push2Disable_obj OBJ_;
+		Push2Disable_obj();
+
+	public:
+		enum { _hx_ClassId = 0x582a6599 };
+
+		void __construct(::String to);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.queries.Push2Disable")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.queries.Push2Disable"); }
+		static ::hx::ObjectPtr< Push2Disable_obj > __new(::String to);
+		static ::hx::ObjectPtr< Push2Disable_obj > __alloc(::hx::Ctx *_hx_ctx,::String to);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Push2Disable_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Push2Disable",d0,a3,83,2f); }
+
+		::String xmlns;
+		::String queryId;
+		 ::snikket::Stanza responseStanza;
+		void handleResponse( ::snikket::Stanza stanza);
+
+};
+
+} // end namespace snikket
+} // end namespace queries
+
+#endif /* INCLUDED_snikket_queries_Push2Disable */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/queries/RosterGet.h b/Sources/c_snikket/iinclude/include/snikket/queries/RosterGet.h
new file mode 100644
index 0000000..befa38a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/queries/RosterGet.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_queries_RosterGet
+#define INCLUDED_snikket_queries_RosterGet
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#include <snikket/queries/GenericQuery.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+HX_DECLARE_CLASS2(snikket,queries,RosterGet)
+
+namespace snikket{
+namespace queries{
+
+
+class HXCPP_CLASS_ATTRIBUTES RosterGet_obj : public  ::snikket::queries::GenericQuery_obj
+{
+	public:
+		typedef  ::snikket::queries::GenericQuery_obj super;
+		typedef RosterGet_obj OBJ_;
+		RosterGet_obj();
+
+	public:
+		enum { _hx_ClassId = 0x6634aa42 };
+
+		void __construct(::String ver);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.queries.RosterGet")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.queries.RosterGet"); }
+		static ::hx::ObjectPtr< RosterGet_obj > __new(::String ver);
+		static ::hx::ObjectPtr< RosterGet_obj > __alloc(::hx::Ctx *_hx_ctx,::String ver);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~RosterGet_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("RosterGet",ab,73,c6,e0); }
+
+		::String xmlns;
+		::String queryId;
+		::String ver;
+		 ::snikket::Stanza responseStanza;
+		::Array< ::Dynamic> result;
+		void handleResponse( ::snikket::Stanza stanza);
+
+		::Array< ::Dynamic> getResult();
+		::Dynamic getResult_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace queries
+
+#endif /* INCLUDED_snikket_queries_RosterGet */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/queries/VcardTempGet.h b/Sources/c_snikket/iinclude/include/snikket/queries/VcardTempGet.h
new file mode 100644
index 0000000..fea8f62
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/queries/VcardTempGet.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_queries_VcardTempGet
+#define INCLUDED_snikket_queries_VcardTempGet
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#include <snikket/queries/GenericQuery.h>
+#endif
+HX_DECLARE_CLASS1(snikket,JID)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+HX_DECLARE_CLASS2(snikket,queries,VcardTempGet)
+
+namespace snikket{
+namespace queries{
+
+
+class HXCPP_CLASS_ATTRIBUTES VcardTempGet_obj : public  ::snikket::queries::GenericQuery_obj
+{
+	public:
+		typedef  ::snikket::queries::GenericQuery_obj super;
+		typedef VcardTempGet_obj OBJ_;
+		VcardTempGet_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4c679325 };
+
+		void __construct( ::snikket::JID to);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.queries.VcardTempGet")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.queries.VcardTempGet"); }
+		static ::hx::ObjectPtr< VcardTempGet_obj > __new( ::snikket::JID to);
+		static ::hx::ObjectPtr< VcardTempGet_obj > __alloc(::hx::Ctx *_hx_ctx, ::snikket::JID to);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~VcardTempGet_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("VcardTempGet",5c,d1,c0,23); }
+
+		::String xmlns;
+		::String queryId;
+		 ::snikket::Stanza responseStanza;
+		 ::Dynamic result;
+		void handleResponse( ::snikket::Stanza stanza);
+
+		 ::Dynamic getResult();
+		::Dynamic getResult_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace queries
+
+#endif /* INCLUDED_snikket_queries_VcardTempGet */ 
diff --git a/Sources/c_snikket/iinclude/include/snikket/streams/XmppStropheStream.h b/Sources/c_snikket/iinclude/include/snikket/streams/XmppStropheStream.h
new file mode 100644
index 0000000..59b34d0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/snikket/streams/XmppStropheStream.h
@@ -0,0 +1,103 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_streams_XmppStropheStream
+#define INCLUDED_snikket_streams_XmppStropheStream
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_GenericStream
+#include <snikket/GenericStream.h>
+#endif
+#ifndef INCLUDED_18a1146676e1af0b
+#define INCLUDED_18a1146676e1af0b
+#include "strophe.h"
+#endif
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,BalancedTree)
+HX_DECLARE_CLASS2(haxe,ds,EnumValueMap)
+HX_DECLARE_CLASS1(snikket,EventEmitter)
+HX_DECLARE_CLASS1(snikket,GenericStream)
+HX_DECLARE_CLASS1(snikket,IqRequestType)
+HX_DECLARE_CLASS1(snikket,IqResult)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,streams,XmppStropheStream)
+
+#include "strophe.h"
+namespace snikket{
+namespace streams{
+
+
+class HXCPP_CLASS_ATTRIBUTES XmppStropheStream_obj : public  ::snikket::GenericStream_obj
+{
+	public:
+		typedef  ::snikket::GenericStream_obj super;
+		typedef XmppStropheStream_obj OBJ_;
+		XmppStropheStream_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7e6ea620 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.streams.XmppStropheStream")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.streams.XmppStropheStream"); }
+		static ::hx::ObjectPtr< XmppStropheStream_obj > __new();
+		static ::hx::ObjectPtr< XmppStropheStream_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~XmppStropheStream_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("XmppStropheStream",da,d9,8d,8c); }
+
+		static int strophe_certfail_handler( const xmpp_tlscert_t* cert,const char* err);
+
+		static int strophe_stanza( xmpp_conn_t* conn, xmpp_stanza_t* sstanza,void* userdata);
+
+		static void strophe_connect( xmpp_conn_t* conn, xmpp_conn_event_t event,int error, xmpp_stream_error_t* stream_error,void* userdata);
+
+		static  ::snikket::Stanza convertToStanza( xmpp_stanza_t* el,void* dummy);
+
+		 ::haxe::ds::EnumValueMap iqHandlers;
+		::Array< ::Dynamic> pending;
+		bool ready;
+		::String newId();
+
+		void onIq( ::snikket::IqRequestType type,::String tag,::String xmlns, ::Dynamic handler);
+
+		void connect(::String jid,::Array< unsigned char > sm);
+
+		void disconnect();
+
+		void poll();
+		::Dynamic poll_dyn();
+
+		 xmpp_stanza_t* convertFromStanza( ::snikket::Stanza el);
+		::Dynamic convertFromStanza_dyn();
+
+		void sendStanza( ::snikket::Stanza stanza);
+
+		void finalize();
+		::Dynamic finalize_dyn();
+
+
+	private: xmpp_ctx_t *ctx;
+	private: xmpp_conn_t *conn;
+
+};
+
+} // end namespace snikket
+} // end namespace streams
+
+#endif /* INCLUDED_snikket_streams_XmppStropheStream */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/FileSystem.h b/Sources/c_snikket/iinclude/include/sys/FileSystem.h
new file mode 100644
index 0000000..882325d
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/FileSystem.h
@@ -0,0 +1,75 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_FileSystem
+#define INCLUDED_sys_FileSystem
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(sys,FileSystem)
+
+namespace sys{
+
+
+class HXCPP_CLASS_ATTRIBUTES FileSystem_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef FileSystem_obj OBJ_;
+		FileSystem_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2378c654 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="sys.FileSystem")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"sys.FileSystem"); }
+
+		inline static ::hx::ObjectPtr< FileSystem_obj > __new() {
+			::hx::ObjectPtr< FileSystem_obj > __this = new FileSystem_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< FileSystem_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			FileSystem_obj *__this = (FileSystem_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(FileSystem_obj), false, "sys.FileSystem"));
+			*(void **)__this = FileSystem_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~FileSystem_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("FileSystem",ab,e2,17,ca); }
+
+		static bool exists(::String path);
+		static ::Dynamic exists_dyn();
+
+		static  ::Dynamic stat(::String path);
+		static ::Dynamic stat_dyn();
+
+		static ::String fullPath(::String relPath);
+		static ::Dynamic fullPath_dyn();
+
+		static ::String absolutePath(::String relPath);
+		static ::Dynamic absolutePath_dyn();
+
+		static bool isDirectory(::String path);
+		static ::Dynamic isDirectory_dyn();
+
+		static void deleteFile(::String path);
+		static ::Dynamic deleteFile_dyn();
+
+};
+
+} // end namespace sys
+
+#endif /* INCLUDED_sys_FileSystem */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/Http.h b/Sources/c_snikket/iinclude/include/sys/Http.h
new file mode 100644
index 0000000..42e3202
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/Http.h
@@ -0,0 +1,88 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_Http
+#define INCLUDED_sys_Http
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_http_HttpBase
+#include <haxe/http/HttpBase.h>
+#endif
+HX_DECLARE_CLASS0(EReg)
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS2(haxe,http,HttpBase)
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,BytesOutput)
+HX_DECLARE_CLASS2(haxe,io,Input)
+HX_DECLARE_CLASS2(haxe,io,Output)
+HX_DECLARE_CLASS1(sys,Http)
+HX_DECLARE_CLASS2(sys,net,Socket)
+
+namespace sys{
+
+
+class HXCPP_CLASS_ATTRIBUTES Http_obj : public  ::haxe::http::HttpBase_obj
+{
+	public:
+		typedef  ::haxe::http::HttpBase_obj super;
+		typedef Http_obj OBJ_;
+		Http_obj();
+
+	public:
+		enum { _hx_ClassId = 0x02924475 };
+
+		void __construct(::String url);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.Http")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.Http"); }
+		static ::hx::ObjectPtr< Http_obj > __new(::String url);
+		static ::hx::ObjectPtr< Http_obj > __alloc(::hx::Ctx *_hx_ctx,::String url);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Http_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Http",a8,c7,ef,2f); }
+
+		static void __boot();
+		static  ::Dynamic PROXY;
+		bool noShutdown;
+		Float cnxTimeout;
+		 ::haxe::ds::StringMap responseHeaders;
+		 ::haxe::ds::StringMap responseHeadersSameKey;
+		 ::Dynamic chunk_size;
+		 ::haxe::io::Bytes chunk_buf;
+		 ::Dynamic file;
+		void request( ::Dynamic post);
+		::Dynamic request_dyn();
+
+		void customRequest(bool post, ::haxe::io::Output api, ::sys::net::Socket sock,::String method);
+		::Dynamic customRequest_dyn();
+
+		void writeBody( ::haxe::io::BytesOutput body, ::haxe::io::Input fileInput,int fileSize,::String boundary, ::sys::net::Socket sock);
+		::Dynamic writeBody_dyn();
+
+		void readHttpResponse( ::haxe::io::Output api, ::sys::net::Socket sock);
+		::Dynamic readHttpResponse_dyn();
+
+		bool readChunk( ::EReg chunk_re, ::haxe::io::Output api, ::haxe::io::Bytes buf,int len);
+		::Dynamic readChunk_dyn();
+
+};
+
+} // end namespace sys
+
+#endif /* INCLUDED_sys_Http */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/db/Connection.h b/Sources/c_snikket/iinclude/include/sys/db/Connection.h
new file mode 100644
index 0000000..cf46b5f
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/db/Connection.h
@@ -0,0 +1,34 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_db_Connection
+#define INCLUDED_sys_db_Connection
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(sys,db,Connection)
+HX_DECLARE_CLASS2(sys,db,ResultSet)
+
+namespace sys{
+namespace db{
+
+
+class HXCPP_CLASS_ATTRIBUTES Connection_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		::Dynamic (::hx::Object :: *_hx_request)(::String s); 
+		static inline ::Dynamic request( ::Dynamic _hx_,::String s) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::sys::db::Connection_obj *>(_hx_.mPtr->_hx_getInterface(0x6e7a3d49)))->_hx_request)(s);
+		}
+		::String (::hx::Object :: *_hx_quote)(::String s); 
+		static inline ::String quote( ::Dynamic _hx_,::String s) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::sys::db::Connection_obj *>(_hx_.mPtr->_hx_getInterface(0x6e7a3d49)))->_hx_quote)(s);
+		}
+};
+
+} // end namespace sys
+} // end namespace db
+
+#endif /* INCLUDED_sys_db_Connection */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/db/ResultSet.h b/Sources/c_snikket/iinclude/include/sys/db/ResultSet.h
new file mode 100644
index 0000000..6a8d3ca
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/db/ResultSet.h
@@ -0,0 +1,33 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_db_ResultSet
+#define INCLUDED_sys_db_ResultSet
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(sys,db,ResultSet)
+
+namespace sys{
+namespace db{
+
+
+class HXCPP_CLASS_ATTRIBUTES ResultSet_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		bool (::hx::Object :: *_hx_hasNext)(); 
+		static inline bool hasNext( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::sys::db::ResultSet_obj *>(_hx_.mPtr->_hx_getInterface(0xc11b83fa)))->_hx_hasNext)();
+		}
+		 ::Dynamic (::hx::Object :: *_hx_next)(); 
+		static inline  ::Dynamic next( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::sys::db::ResultSet_obj *>(_hx_.mPtr->_hx_getInterface(0xc11b83fa)))->_hx_next)();
+		}
+};
+
+} // end namespace sys
+} // end namespace db
+
+#endif /* INCLUDED_sys_db_ResultSet */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/db/Sqlite.h b/Sources/c_snikket/iinclude/include/sys/db/Sqlite.h
new file mode 100644
index 0000000..ae8bcba
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/db/Sqlite.h
@@ -0,0 +1,63 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_db_Sqlite
+#define INCLUDED_sys_db_Sqlite
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(sys,db,Connection)
+HX_DECLARE_CLASS2(sys,db,Sqlite)
+
+namespace sys{
+namespace db{
+
+
+class HXCPP_CLASS_ATTRIBUTES Sqlite_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Sqlite_obj OBJ_;
+		Sqlite_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1fc648d3 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="sys.db.Sqlite")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"sys.db.Sqlite"); }
+
+		inline static ::hx::ObjectPtr< Sqlite_obj > __new() {
+			::hx::ObjectPtr< Sqlite_obj > __this = new Sqlite_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Sqlite_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Sqlite_obj *__this = (Sqlite_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Sqlite_obj), false, "sys.db.Sqlite"));
+			*(void **)__this = Sqlite_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Sqlite_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Sqlite",ec,9c,99,87); }
+
+		static ::Dynamic open(::String file);
+		static ::Dynamic open_dyn();
+
+};
+
+} // end namespace sys
+} // end namespace db
+
+#endif /* INCLUDED_sys_db_Sqlite */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/db/_Sqlite/SqliteConnection.h b/Sources/c_snikket/iinclude/include/sys/db/_Sqlite/SqliteConnection.h
new file mode 100644
index 0000000..7c154f8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/db/_Sqlite/SqliteConnection.h
@@ -0,0 +1,67 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_db__Sqlite_SqliteConnection
+#define INCLUDED_sys_db__Sqlite_SqliteConnection
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_sys_db_Connection
+#include <sys/db/Connection.h>
+#endif
+HX_DECLARE_CLASS2(sys,db,Connection)
+HX_DECLARE_CLASS2(sys,db,ResultSet)
+HX_DECLARE_CLASS3(sys,db,_Sqlite,SqliteConnection)
+
+namespace sys{
+namespace db{
+namespace _Sqlite{
+
+
+class HXCPP_CLASS_ATTRIBUTES SqliteConnection_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef SqliteConnection_obj OBJ_;
+		SqliteConnection_obj();
+
+	public:
+		enum { _hx_ClassId = 0x26edc0ae };
+
+		void __construct(::String file);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.db._Sqlite.SqliteConnection")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.db._Sqlite.SqliteConnection"); }
+		static ::hx::ObjectPtr< SqliteConnection_obj > __new(::String file);
+		static ::hx::ObjectPtr< SqliteConnection_obj > __alloc(::hx::Ctx *_hx_ctx,::String file);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SqliteConnection_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("SqliteConnection",2a,20,03,a3); }
+
+		 ::Dynamic c;
+		::Dynamic request(::String s);
+		::Dynamic request_dyn();
+
+		::String quote(::String s);
+		::Dynamic quote_dyn();
+
+};
+
+} // end namespace sys
+} // end namespace db
+} // end namespace _Sqlite
+
+#endif /* INCLUDED_sys_db__Sqlite_SqliteConnection */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/db/_Sqlite/SqliteResultSet.h b/Sources/c_snikket/iinclude/include/sys/db/_Sqlite/SqliteResultSet.h
new file mode 100644
index 0000000..3437f67
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/db/_Sqlite/SqliteResultSet.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_db__Sqlite_SqliteResultSet
+#define INCLUDED_sys_db__Sqlite_SqliteResultSet
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_sys_db_ResultSet
+#include <sys/db/ResultSet.h>
+#endif
+HX_DECLARE_CLASS2(haxe,ds,List)
+HX_DECLARE_CLASS2(sys,db,ResultSet)
+HX_DECLARE_CLASS3(sys,db,_Sqlite,SqliteResultSet)
+
+namespace sys{
+namespace db{
+namespace _Sqlite{
+
+
+class HXCPP_CLASS_ATTRIBUTES SqliteResultSet_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef SqliteResultSet_obj OBJ_;
+		SqliteResultSet_obj();
+
+	public:
+		enum { _hx_ClassId = 0x068aee19 };
+
+		void __construct( ::Dynamic r);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.db._Sqlite.SqliteResultSet")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.db._Sqlite.SqliteResultSet"); }
+		static ::hx::ObjectPtr< SqliteResultSet_obj > __new( ::Dynamic r);
+		static ::hx::ObjectPtr< SqliteResultSet_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic r);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SqliteResultSet_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("SqliteResultSet",39,58,4c,f7); }
+
+		 ::Dynamic r;
+		 ::haxe::ds::List cache;
+		bool hasNext();
+		::Dynamic hasNext_dyn();
+
+		 ::Dynamic next();
+		::Dynamic next_dyn();
+
+};
+
+} // end namespace sys
+} // end namespace db
+} // end namespace _Sqlite
+
+#endif /* INCLUDED_sys_db__Sqlite_SqliteResultSet */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/io/File.h b/Sources/c_snikket/iinclude/include/sys/io/File.h
new file mode 100644
index 0000000..11172d1
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/io/File.h
@@ -0,0 +1,73 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_io_File
+#define INCLUDED_sys_io_File
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Input)
+HX_DECLARE_CLASS2(haxe,io,Output)
+HX_DECLARE_CLASS2(sys,io,File)
+HX_DECLARE_CLASS2(sys,io,FileInput)
+HX_DECLARE_CLASS2(sys,io,FileOutput)
+
+namespace sys{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES File_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef File_obj OBJ_;
+		File_obj();
+
+	public:
+		enum { _hx_ClassId = 0x645a6147 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="sys.io.File")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"sys.io.File"); }
+
+		inline static ::hx::ObjectPtr< File_obj > __new() {
+			::hx::ObjectPtr< File_obj > __this = new File_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< File_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			File_obj *__this = (File_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(File_obj), false, "sys.io.File"));
+			*(void **)__this = File_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~File_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("File",9c,fa,94,2e); }
+
+		static void saveBytes(::String path, ::haxe::io::Bytes bytes);
+		static ::Dynamic saveBytes_dyn();
+
+		static  ::sys::io::FileInput read(::String path,::hx::Null< bool >  binary);
+		static ::Dynamic read_dyn();
+
+		static  ::sys::io::FileOutput write(::String path,::hx::Null< bool >  binary);
+		static ::Dynamic write_dyn();
+
+};
+
+} // end namespace sys
+} // end namespace io
+
+#endif /* INCLUDED_sys_io_File */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/io/FileInput.h b/Sources/c_snikket/iinclude/include/sys/io/FileInput.h
new file mode 100644
index 0000000..8cd622d
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/io/FileInput.h
@@ -0,0 +1,64 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_io_FileInput
+#define INCLUDED_sys_io_FileInput
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_io_Input
+#include <haxe/io/Input.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Input)
+HX_DECLARE_CLASS2(sys,io,FileInput)
+
+namespace sys{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES FileInput_obj : public  ::haxe::io::Input_obj
+{
+	public:
+		typedef  ::haxe::io::Input_obj super;
+		typedef FileInput_obj OBJ_;
+		FileInput_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1a1fbc7b };
+
+		void __construct( ::Dynamic f);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.io.FileInput")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.io.FileInput"); }
+		static ::hx::ObjectPtr< FileInput_obj > __new( ::Dynamic f);
+		static ::hx::ObjectPtr< FileInput_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic f);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~FileInput_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("FileInput",ce,43,18,62); }
+
+		 ::Dynamic _hx___f;
+		int readByte();
+
+		int readBytes( ::haxe::io::Bytes s,int p,int l);
+
+		void close();
+
+};
+
+} // end namespace sys
+} // end namespace io
+
+#endif /* INCLUDED_sys_io_FileInput */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/io/FileOutput.h b/Sources/c_snikket/iinclude/include/sys/io/FileOutput.h
new file mode 100644
index 0000000..9bcf940
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/io/FileOutput.h
@@ -0,0 +1,64 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_io_FileOutput
+#define INCLUDED_sys_io_FileOutput
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_io_Output
+#include <haxe/io/Output.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Output)
+HX_DECLARE_CLASS2(sys,io,FileOutput)
+
+namespace sys{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES FileOutput_obj : public  ::haxe::io::Output_obj
+{
+	public:
+		typedef  ::haxe::io::Output_obj super;
+		typedef FileOutput_obj OBJ_;
+		FileOutput_obj();
+
+	public:
+		enum { _hx_ClassId = 0x32387970 };
+
+		void __construct( ::Dynamic f);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.io.FileOutput")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.io.FileOutput"); }
+		static ::hx::ObjectPtr< FileOutput_obj > __new( ::Dynamic f);
+		static ::hx::ObjectPtr< FileOutput_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic f);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~FileOutput_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("FileOutput",bd,5a,b6,e3); }
+
+		 ::Dynamic _hx___f;
+		void writeByte(int c);
+
+		int writeBytes( ::haxe::io::Bytes s,int p,int l);
+
+		void close();
+
+};
+
+} // end namespace sys
+} // end namespace io
+
+#endif /* INCLUDED_sys_io_FileOutput */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/io/Process.h b/Sources/c_snikket/iinclude/include/sys/io/Process.h
new file mode 100644
index 0000000..d4386c5
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/io/Process.h
@@ -0,0 +1,61 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_io_Process
+#define INCLUDED_sys_io_Process
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Input)
+HX_DECLARE_CLASS2(haxe,io,Output)
+HX_DECLARE_CLASS2(sys,io,Process)
+
+namespace sys{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES Process_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Process_obj OBJ_;
+		Process_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7a155cb0 };
+
+		void __construct(::String cmd,::Array< ::String > args, ::Dynamic detached);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.io.Process")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.io.Process"); }
+		static ::hx::ObjectPtr< Process_obj > __new(::String cmd,::Array< ::String > args, ::Dynamic detached);
+		static ::hx::ObjectPtr< Process_obj > __alloc(::hx::Ctx *_hx_ctx,::String cmd,::Array< ::String > args, ::Dynamic detached);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Process_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Process",4f,ca,9b,be); }
+
+		 ::Dynamic p;
+		 ::haxe::io::Input _hx_stdout;
+		 ::haxe::io::Input _hx_stderr;
+		 ::haxe::io::Output _hx_stdin;
+		 ::Dynamic exitCode(::hx::Null< bool >  block);
+		::Dynamic exitCode_dyn();
+
+};
+
+} // end namespace sys
+} // end namespace io
+
+#endif /* INCLUDED_sys_io_Process */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/io/_Process/Stdin.h b/Sources/c_snikket/iinclude/include/sys/io/_Process/Stdin.h
new file mode 100644
index 0000000..473d06a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/io/_Process/Stdin.h
@@ -0,0 +1,67 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_io__Process_Stdin
+#define INCLUDED_sys_io__Process_Stdin
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_io_Output
+#include <haxe/io/Output.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Output)
+HX_DECLARE_CLASS3(sys,io,_Process,Stdin)
+
+namespace sys{
+namespace io{
+namespace _Process{
+
+
+class HXCPP_CLASS_ATTRIBUTES Stdin_obj : public  ::haxe::io::Output_obj
+{
+	public:
+		typedef  ::haxe::io::Output_obj super;
+		typedef Stdin_obj OBJ_;
+		Stdin_obj();
+
+	public:
+		enum { _hx_ClassId = 0x037481cd };
+
+		void __construct( ::Dynamic p);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.io._Process.Stdin")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.io._Process.Stdin"); }
+		static ::hx::ObjectPtr< Stdin_obj > __new( ::Dynamic p);
+		static ::hx::ObjectPtr< Stdin_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic p);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Stdin_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Stdin",28,23,3b,17); }
+
+		 ::Dynamic p;
+		 ::haxe::io::Bytes buf;
+		void close();
+
+		void writeByte(int c);
+
+		int writeBytes( ::haxe::io::Bytes buf,int pos,int len);
+
+};
+
+} // end namespace sys
+} // end namespace io
+} // end namespace _Process
+
+#endif /* INCLUDED_sys_io__Process_Stdin */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/io/_Process/Stdout.h b/Sources/c_snikket/iinclude/include/sys/io/_Process/Stdout.h
new file mode 100644
index 0000000..0533216
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/io/_Process/Stdout.h
@@ -0,0 +1,66 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_io__Process_Stdout
+#define INCLUDED_sys_io__Process_Stdout
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_io_Input
+#include <haxe/io/Input.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Input)
+HX_DECLARE_CLASS3(sys,io,_Process,Stdout)
+
+namespace sys{
+namespace io{
+namespace _Process{
+
+
+class HXCPP_CLASS_ATTRIBUTES Stdout_obj : public  ::haxe::io::Input_obj
+{
+	public:
+		typedef  ::haxe::io::Input_obj super;
+		typedef Stdout_obj OBJ_;
+		Stdout_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2316116e };
+
+		void __construct( ::Dynamic p,bool out);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.io._Process.Stdout")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.io._Process.Stdout"); }
+		static ::hx::ObjectPtr< Stdout_obj > __new( ::Dynamic p,bool out);
+		static ::hx::ObjectPtr< Stdout_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic p,bool out);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Stdout_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Stdout",eb,33,88,3c); }
+
+		 ::Dynamic p;
+		bool out;
+		 ::haxe::io::Bytes buf;
+		int readByte();
+
+		int readBytes( ::haxe::io::Bytes str,int pos,int len);
+
+};
+
+} // end namespace sys
+} // end namespace io
+} // end namespace _Process
+
+#endif /* INCLUDED_sys_io__Process_Stdout */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/net/Host.h b/Sources/c_snikket/iinclude/include/sys/net/Host.h
new file mode 100644
index 0000000..0fe42fa
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/net/Host.h
@@ -0,0 +1,94 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_net_Host
+#define INCLUDED_sys_net_Host
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_87d3457c074e81a3_35_new)
+HX_DECLARE_CLASS2(sys,net,Host)
+
+namespace sys{
+namespace net{
+
+
+class HXCPP_CLASS_ATTRIBUTES Host_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Host_obj OBJ_;
+		Host_obj();
+
+	public:
+		enum { _hx_ClassId = 0x6c3d7e78 };
+
+		void __construct(::String name);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.net.Host")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.net.Host"); }
+
+		inline static ::hx::ObjectPtr< Host_obj > __new(::String name) {
+			::hx::ObjectPtr< Host_obj > __this = new Host_obj();
+			__this->__construct(name);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Host_obj > __alloc(::hx::Ctx *_hx_ctx,::String name) {
+			Host_obj *__this = (Host_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Host_obj), true, "sys.net.Host"));
+			*(void **)__this = Host_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_87d3457c074e81a3_35_new)
+HXLINE(  36)		( ( ::sys::net::Host)(__this) )->host = name;
+HXLINE(  37)		try {
+            			HX_STACK_CATCHABLE( ::Dynamic, 0);
+HXLINE(  38)			( ( ::sys::net::Host)(__this) )->ip = _hx_std_host_resolve(name);
+            		} catch( ::Dynamic _hx_e) {
+            			if (_hx_e.IsClass<  ::Dynamic >() ){
+            				HX_STACK_BEGIN_CATCH
+            				 ::Dynamic _g = _hx_e;
+HXLINE(  39)				{
+HXLINE(  39)					null();
+            				}
+HXLINE(  40)				( ( ::sys::net::Host)(__this) )->ipv6 = _hx_std_host_resolve_ipv6(name);
+            			}
+            			else {
+            				HX_STACK_DO_THROW(_hx_e);
+            			}
+            		}
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Host_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		static void __init__();
+
+		::String __ToString() const { return HX_("Host",88,fb,eb,2f); }
+
+		static void __boot();
+		::String host;
+		int ip;
+		::Array< unsigned char > ipv6;
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+} // end namespace sys
+} // end namespace net
+
+#endif /* INCLUDED_sys_net_Host */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/net/Socket.h b/Sources/c_snikket/iinclude/include/sys/net/Socket.h
new file mode 100644
index 0000000..c1426ac
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/net/Socket.h
@@ -0,0 +1,82 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_net_Socket
+#define INCLUDED_sys_net_Socket
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Input)
+HX_DECLARE_CLASS2(haxe,io,Output)
+HX_DECLARE_CLASS2(sys,net,Host)
+HX_DECLARE_CLASS2(sys,net,Socket)
+
+namespace sys{
+namespace net{
+
+
+class HXCPP_CLASS_ATTRIBUTES Socket_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Socket_obj OBJ_;
+		Socket_obj();
+
+	public:
+		enum { _hx_ClassId = 0x70c71ec3 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.net.Socket")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.net.Socket"); }
+		static ::hx::ObjectPtr< Socket_obj > __new();
+		static ::hx::ObjectPtr< Socket_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Socket_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Socket",d3,ff,da,5a); }
+
+		 ::Dynamic __s;
+		Float _hx___timeout;
+		bool _hx___blocking;
+		bool _hx___fastSend;
+		 ::haxe::io::Input input;
+		 ::haxe::io::Output output;
+		virtual void init();
+		::Dynamic init_dyn();
+
+		virtual void close();
+		::Dynamic close_dyn();
+
+		virtual void connect( ::sys::net::Host host,int port);
+		::Dynamic connect_dyn();
+
+		void shutdown(bool read,bool write);
+		::Dynamic shutdown_dyn();
+
+		void setTimeout(Float timeout);
+		::Dynamic setTimeout_dyn();
+
+		void setBlocking(bool b);
+		::Dynamic setBlocking_dyn();
+
+		void setFastSend(bool b);
+		::Dynamic setFastSend_dyn();
+
+};
+
+} // end namespace sys
+} // end namespace net
+
+#endif /* INCLUDED_sys_net_Socket */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/net/_Socket/SocketInput.h b/Sources/c_snikket/iinclude/include/sys/net/_Socket/SocketInput.h
new file mode 100644
index 0000000..7c6907c
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/net/_Socket/SocketInput.h
@@ -0,0 +1,66 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_net__Socket_SocketInput
+#define INCLUDED_sys_net__Socket_SocketInput
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_io_Input
+#include <haxe/io/Input.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Input)
+HX_DECLARE_CLASS3(sys,net,_Socket,SocketInput)
+
+namespace sys{
+namespace net{
+namespace _Socket{
+
+
+class HXCPP_CLASS_ATTRIBUTES SocketInput_obj : public  ::haxe::io::Input_obj
+{
+	public:
+		typedef  ::haxe::io::Input_obj super;
+		typedef SocketInput_obj OBJ_;
+		SocketInput_obj();
+
+	public:
+		enum { _hx_ClassId = 0x342d0eb5 };
+
+		void __construct( ::Dynamic s);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.net._Socket.SocketInput")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.net._Socket.SocketInput"); }
+		static ::hx::ObjectPtr< SocketInput_obj > __new( ::Dynamic s);
+		static ::hx::ObjectPtr< SocketInput_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic s);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SocketInput_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SocketInput",37,f7,80,be); }
+
+		 ::Dynamic __s;
+		int readByte();
+
+		int readBytes( ::haxe::io::Bytes buf,int pos,int len);
+
+		void close();
+
+};
+
+} // end namespace sys
+} // end namespace net
+} // end namespace _Socket
+
+#endif /* INCLUDED_sys_net__Socket_SocketInput */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/net/_Socket/SocketOutput.h b/Sources/c_snikket/iinclude/include/sys/net/_Socket/SocketOutput.h
new file mode 100644
index 0000000..2c685e5
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/net/_Socket/SocketOutput.h
@@ -0,0 +1,66 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_net__Socket_SocketOutput
+#define INCLUDED_sys_net__Socket_SocketOutput
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_io_Output
+#include <haxe/io/Output.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Output)
+HX_DECLARE_CLASS3(sys,net,_Socket,SocketOutput)
+
+namespace sys{
+namespace net{
+namespace _Socket{
+
+
+class HXCPP_CLASS_ATTRIBUTES SocketOutput_obj : public  ::haxe::io::Output_obj
+{
+	public:
+		typedef  ::haxe::io::Output_obj super;
+		typedef SocketOutput_obj OBJ_;
+		SocketOutput_obj();
+
+	public:
+		enum { _hx_ClassId = 0x05556112 };
+
+		void __construct( ::Dynamic s);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.net._Socket.SocketOutput")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.net._Socket.SocketOutput"); }
+		static ::hx::ObjectPtr< SocketOutput_obj > __new( ::Dynamic s);
+		static ::hx::ObjectPtr< SocketOutput_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic s);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SocketOutput_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SocketOutput",34,a3,ea,62); }
+
+		 ::Dynamic __s;
+		void writeByte(int c);
+
+		int writeBytes( ::haxe::io::Bytes buf,int pos,int len);
+
+		void close();
+
+};
+
+} // end namespace sys
+} // end namespace net
+} // end namespace _Socket
+
+#endif /* INCLUDED_sys_net__Socket_SocketOutput */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/ssl/Certificate.h b/Sources/c_snikket/iinclude/include/sys/ssl/Certificate.h
new file mode 100644
index 0000000..c0b6746
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/ssl/Certificate.h
@@ -0,0 +1,85 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_ssl_Certificate
+#define INCLUDED_sys_ssl_Certificate
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_15e02723fb84005c_33_new)
+HX_DECLARE_CLASS2(sys,ssl,Certificate)
+
+namespace sys{
+namespace ssl{
+
+
+class HXCPP_CLASS_ATTRIBUTES Certificate_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Certificate_obj OBJ_;
+		Certificate_obj();
+
+	public:
+		enum { _hx_ClassId = 0x205b2370 };
+
+		void __construct( ::Dynamic x, ::sys::ssl::Certificate h);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.ssl.Certificate")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.ssl.Certificate"); }
+
+		inline static ::hx::ObjectPtr< Certificate_obj > __new( ::Dynamic x, ::sys::ssl::Certificate h) {
+			::hx::ObjectPtr< Certificate_obj > __this = new Certificate_obj();
+			__this->__construct(x,h);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Certificate_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic x, ::sys::ssl::Certificate h) {
+			Certificate_obj *__this = (Certificate_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Certificate_obj), true, "sys.ssl.Certificate"));
+			*(void **)__this = Certificate_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_15e02723fb84005c_33_new)
+HXLINE(  34)		( ( ::sys::ssl::Certificate)(__this) )->_hx___x = x;
+HXLINE(  35)		( ( ::sys::ssl::Certificate)(__this) )->_hx___h = h;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Certificate_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		static void __init__();
+
+		::String __ToString() const { return HX_("Certificate",f7,60,75,ff); }
+
+		static void __boot();
+		static  ::sys::ssl::Certificate loadFile(::String file);
+		static ::Dynamic loadFile_dyn();
+
+		static  ::sys::ssl::Certificate loadPath(::String path);
+		static ::Dynamic loadPath_dyn();
+
+		static  ::sys::ssl::Certificate loadDefaults();
+		static ::Dynamic loadDefaults_dyn();
+
+		 ::sys::ssl::Certificate _hx___h;
+		 ::Dynamic _hx___x;
+};
+
+} // end namespace sys
+} // end namespace ssl
+
+#endif /* INCLUDED_sys_ssl_Certificate */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/ssl/Key.h b/Sources/c_snikket/iinclude/include/sys/ssl/Key.h
new file mode 100644
index 0000000..68e01fd
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/ssl/Key.h
@@ -0,0 +1,73 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_ssl_Key
+#define INCLUDED_sys_ssl_Key
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_360df8ce648879c1_34_new)
+HX_DECLARE_CLASS2(sys,ssl,Key)
+
+namespace sys{
+namespace ssl{
+
+
+class HXCPP_CLASS_ATTRIBUTES Key_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Key_obj OBJ_;
+		Key_obj();
+
+	public:
+		enum { _hx_ClassId = 0x6dab52dc };
+
+		void __construct( ::Dynamic k);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.ssl.Key")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.ssl.Key"); }
+
+		inline static ::hx::ObjectPtr< Key_obj > __new( ::Dynamic k) {
+			::hx::ObjectPtr< Key_obj > __this = new Key_obj();
+			__this->__construct(k);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Key_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic k) {
+			Key_obj *__this = (Key_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Key_obj), true, "sys.ssl.Key"));
+			*(void **)__this = Key_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_360df8ce648879c1_34_new)
+HXDLIN(  34)		( ( ::sys::ssl::Key)(__this) )->_hx___k = k;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Key_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		static void __init__();
+
+		::String __ToString() const { return HX_("Key",7f,41,39,00); }
+
+		static void __boot();
+		 ::Dynamic _hx___k;
+};
+
+} // end namespace sys
+} // end namespace ssl
+
+#endif /* INCLUDED_sys_ssl_Key */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/ssl/Socket.h b/Sources/c_snikket/iinclude/include/sys/ssl/Socket.h
new file mode 100644
index 0000000..97bacfe
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/ssl/Socket.h
@@ -0,0 +1,88 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_ssl_Socket
+#define INCLUDED_sys_ssl_Socket
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_sys_net_Socket
+#include <sys/net/Socket.h>
+#endif
+HX_DECLARE_CLASS2(sys,net,Host)
+HX_DECLARE_CLASS2(sys,net,Socket)
+HX_DECLARE_CLASS2(sys,ssl,Certificate)
+HX_DECLARE_CLASS2(sys,ssl,Key)
+HX_DECLARE_CLASS2(sys,ssl,Socket)
+
+namespace sys{
+namespace ssl{
+
+
+class HXCPP_CLASS_ATTRIBUTES Socket_obj : public  ::sys::net::Socket_obj
+{
+	public:
+		typedef  ::sys::net::Socket_obj super;
+		typedef Socket_obj OBJ_;
+		Socket_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7a492a0e };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.ssl.Socket")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.ssl.Socket"); }
+		static ::hx::ObjectPtr< Socket_obj > __new();
+		static ::hx::ObjectPtr< Socket_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Socket_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		static void __init__();
+
+		::String __ToString() const { return HX_("Socket",d3,ff,da,5a); }
+
+		static void __boot();
+		static  ::Dynamic DEFAULT_VERIFY_CERT;
+		static  ::sys::ssl::Certificate DEFAULT_CA;
+		 ::Dynamic conf;
+		 ::Dynamic ssl;
+		 ::Dynamic verifyCert;
+		 ::sys::ssl::Certificate caCert;
+		::String hostname;
+		 ::sys::ssl::Certificate ownCert;
+		 ::sys::ssl::Key ownKey;
+		::Array< ::Dynamic> altSNIContexts;
+		 ::Dynamic sniCallback;
+		bool handshakeDone;
+		void init();
+
+		void connect( ::sys::net::Host host,int port);
+
+		void handshake();
+		::Dynamic handshake_dyn();
+
+		void close();
+
+		 ::Dynamic buildSSLConfig(bool server);
+		::Dynamic buildSSLConfig_dyn();
+
+};
+
+} // end namespace sys
+} // end namespace ssl
+
+#endif /* INCLUDED_sys_ssl_Socket */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/ssl/_Socket/SocketInput.h b/Sources/c_snikket/iinclude/include/sys/ssl/_Socket/SocketInput.h
new file mode 100644
index 0000000..7fa83ba
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/ssl/_Socket/SocketInput.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_ssl__Socket_SocketInput
+#define INCLUDED_sys_ssl__Socket_SocketInput
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_io_Input
+#include <haxe/io/Input.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Input)
+HX_DECLARE_CLASS2(sys,net,Socket)
+HX_DECLARE_CLASS2(sys,ssl,Socket)
+HX_DECLARE_CLASS3(sys,ssl,_Socket,SocketInput)
+
+namespace sys{
+namespace ssl{
+namespace _Socket{
+
+
+class HXCPP_CLASS_ATTRIBUTES SocketInput_obj : public  ::haxe::io::Input_obj
+{
+	public:
+		typedef  ::haxe::io::Input_obj super;
+		typedef SocketInput_obj OBJ_;
+		SocketInput_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5d27522c };
+
+		void __construct( ::sys::ssl::Socket s);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.ssl._Socket.SocketInput")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.ssl._Socket.SocketInput"); }
+		static ::hx::ObjectPtr< SocketInput_obj > __new( ::sys::ssl::Socket s);
+		static ::hx::ObjectPtr< SocketInput_obj > __alloc(::hx::Ctx *_hx_ctx, ::sys::ssl::Socket s);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SocketInput_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SocketInput",37,f7,80,be); }
+
+		 ::sys::ssl::Socket __s;
+		int readByte();
+
+		int readBytes( ::haxe::io::Bytes buf,int pos,int len);
+
+		void close();
+
+};
+
+} // end namespace sys
+} // end namespace ssl
+} // end namespace _Socket
+
+#endif /* INCLUDED_sys_ssl__Socket_SocketInput */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/ssl/_Socket/SocketOutput.h b/Sources/c_snikket/iinclude/include/sys/ssl/_Socket/SocketOutput.h
new file mode 100644
index 0000000..6282196
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/ssl/_Socket/SocketOutput.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_ssl__Socket_SocketOutput
+#define INCLUDED_sys_ssl__Socket_SocketOutput
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_io_Output
+#include <haxe/io/Output.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Output)
+HX_DECLARE_CLASS2(sys,net,Socket)
+HX_DECLARE_CLASS2(sys,ssl,Socket)
+HX_DECLARE_CLASS3(sys,ssl,_Socket,SocketOutput)
+
+namespace sys{
+namespace ssl{
+namespace _Socket{
+
+
+class HXCPP_CLASS_ATTRIBUTES SocketOutput_obj : public  ::haxe::io::Output_obj
+{
+	public:
+		typedef  ::haxe::io::Output_obj super;
+		typedef SocketOutput_obj OBJ_;
+		SocketOutput_obj();
+
+	public:
+		enum { _hx_ClassId = 0x52cf5067 };
+
+		void __construct( ::sys::ssl::Socket s);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.ssl._Socket.SocketOutput")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.ssl._Socket.SocketOutput"); }
+		static ::hx::ObjectPtr< SocketOutput_obj > __new( ::sys::ssl::Socket s);
+		static ::hx::ObjectPtr< SocketOutput_obj > __alloc(::hx::Ctx *_hx_ctx, ::sys::ssl::Socket s);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SocketOutput_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SocketOutput",34,a3,ea,62); }
+
+		 ::sys::ssl::Socket __s;
+		void writeByte(int c);
+
+		int writeBytes( ::haxe::io::Bytes buf,int pos,int len);
+
+		void close();
+
+};
+
+} // end namespace sys
+} // end namespace ssl
+} // end namespace _Socket
+
+#endif /* INCLUDED_sys_ssl__Socket_SocketOutput */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/thread/EventLoop.h b/Sources/c_snikket/iinclude/include/sys/thread/EventLoop.h
new file mode 100644
index 0000000..e5d0fee
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/thread/EventLoop.h
@@ -0,0 +1,80 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_thread_EventLoop
+#define INCLUDED_sys_thread_EventLoop
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(sys,thread,EventLoop)
+HX_DECLARE_CLASS2(sys,thread,Lock)
+HX_DECLARE_CLASS2(sys,thread,Mutex)
+HX_DECLARE_CLASS3(sys,thread,_EventLoop,RegularEvent)
+
+namespace sys{
+namespace thread{
+
+
+class HXCPP_CLASS_ATTRIBUTES EventLoop_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef EventLoop_obj OBJ_;
+		EventLoop_obj();
+
+	public:
+		enum { _hx_ClassId = 0x6a581147 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.thread.EventLoop")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.thread.EventLoop"); }
+		static ::hx::ObjectPtr< EventLoop_obj > __new();
+		static ::hx::ObjectPtr< EventLoop_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~EventLoop_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("EventLoop",7e,8f,97,98); }
+
+		static bool CREATED;
+		 ::sys::thread::Mutex mutex;
+		::Array< ::Dynamic> oneTimeEvents;
+		int oneTimeEventsIdx;
+		 ::sys::thread::Lock waitLock;
+		int promisedEventsCount;
+		 ::sys::thread::_EventLoop::RegularEvent regularEvents;
+		bool isMainThread;
+		 ::sys::thread::_EventLoop::RegularEvent repeat( ::Dynamic event,int intervalMs);
+		::Dynamic repeat_dyn();
+
+		void cancel( ::sys::thread::_EventLoop::RegularEvent eventHandler);
+		::Dynamic cancel_dyn();
+
+		void run( ::Dynamic event);
+		::Dynamic run_dyn();
+
+		bool wait( ::Dynamic timeout);
+		::Dynamic wait_dyn();
+
+		void loop();
+		::Dynamic loop_dyn();
+
+};
+
+} // end namespace sys
+} // end namespace thread
+
+#endif /* INCLUDED_sys_thread_EventLoop */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/thread/Lock.h b/Sources/c_snikket/iinclude/include/sys/thread/Lock.h
new file mode 100644
index 0000000..b08cb6e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/thread/Lock.h
@@ -0,0 +1,76 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_thread_Lock
+#define INCLUDED_sys_thread_Lock
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_c256ff93ff467723_30_new)
+HX_DECLARE_CLASS2(sys,thread,Lock)
+
+namespace sys{
+namespace thread{
+
+
+class HXCPP_CLASS_ATTRIBUTES Lock_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Lock_obj OBJ_;
+		Lock_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7fa5e9e6 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.thread.Lock")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.thread.Lock"); }
+
+		inline static ::hx::ObjectPtr< Lock_obj > __new() {
+			::hx::ObjectPtr< Lock_obj > __this = new Lock_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Lock_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Lock_obj *__this = (Lock_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Lock_obj), true, "sys.thread.Lock"));
+			*(void **)__this = Lock_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_c256ff93ff467723_30_new)
+HXDLIN(  30)		( ( ::sys::thread::Lock)(__this) )->l =  ::__hxcpp_lock_create();
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Lock_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Lock",0b,c8,90,32); }
+
+		 ::Dynamic l;
+		bool wait( ::Dynamic timeout);
+		::Dynamic wait_dyn();
+
+		void release();
+		::Dynamic release_dyn();
+
+};
+
+} // end namespace sys
+} // end namespace thread
+
+#endif /* INCLUDED_sys_thread_Lock */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/thread/Mutex.h b/Sources/c_snikket/iinclude/include/sys/thread/Mutex.h
new file mode 100644
index 0000000..7dcf304
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/thread/Mutex.h
@@ -0,0 +1,76 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_thread_Mutex
+#define INCLUDED_sys_thread_Mutex
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_2ef35e640612cac3_30_new)
+HX_DECLARE_CLASS2(sys,thread,Mutex)
+
+namespace sys{
+namespace thread{
+
+
+class HXCPP_CLASS_ATTRIBUTES Mutex_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Mutex_obj OBJ_;
+		Mutex_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5474b30c };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.thread.Mutex")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.thread.Mutex"); }
+
+		inline static ::hx::ObjectPtr< Mutex_obj > __new() {
+			::hx::ObjectPtr< Mutex_obj > __this = new Mutex_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Mutex_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Mutex_obj *__this = (Mutex_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Mutex_obj), true, "sys.thread.Mutex"));
+			*(void **)__this = Mutex_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_2ef35e640612cac3_30_new)
+HXDLIN(  30)		( ( ::sys::thread::Mutex)(__this) )->m =  ::__hxcpp_mutex_create();
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Mutex_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Mutex",5f,ff,88,a3); }
+
+		 ::Dynamic m;
+		void acquire();
+		::Dynamic acquire_dyn();
+
+		void release();
+		::Dynamic release_dyn();
+
+};
+
+} // end namespace sys
+} // end namespace thread
+
+#endif /* INCLUDED_sys_thread_Mutex */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/thread/NoEventLoopException.h b/Sources/c_snikket/iinclude/include/sys/thread/NoEventLoopException.h
new file mode 100644
index 0000000..836f0ff
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/thread/NoEventLoopException.h
@@ -0,0 +1,70 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_thread_NoEventLoopException
+#define INCLUDED_sys_thread_NoEventLoopException
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_Exception
+#include <haxe/Exception.h>
+#endif
+HX_DECLARE_STACK_FRAME(_hx_pos_c0f6a7d563b0a42e_7_new)
+HX_DECLARE_CLASS1(haxe,Exception)
+HX_DECLARE_CLASS2(sys,thread,NoEventLoopException)
+
+namespace sys{
+namespace thread{
+
+
+class HXCPP_CLASS_ATTRIBUTES NoEventLoopException_obj : public  ::haxe::Exception_obj
+{
+	public:
+		typedef  ::haxe::Exception_obj super;
+		typedef NoEventLoopException_obj OBJ_;
+		NoEventLoopException_obj();
+
+	public:
+		enum { _hx_ClassId = 0x00a9e885 };
+
+		void __construct(::String __o_msg, ::haxe::Exception previous);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.thread.NoEventLoopException")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.thread.NoEventLoopException"); }
+
+		inline static ::hx::ObjectPtr< NoEventLoopException_obj > __new(::String __o_msg, ::haxe::Exception previous) {
+			::hx::ObjectPtr< NoEventLoopException_obj > __this = new NoEventLoopException_obj();
+			__this->__construct(__o_msg,previous);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< NoEventLoopException_obj > __alloc(::hx::Ctx *_hx_ctx,::String __o_msg, ::haxe::Exception previous) {
+			NoEventLoopException_obj *__this = (NoEventLoopException_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(NoEventLoopException_obj), true, "sys.thread.NoEventLoopException"));
+			*(void **)__this = NoEventLoopException_obj::_hx_vtable;
+{
+            		::String msg = __o_msg;
+            		if (::hx::IsNull(__o_msg)) msg = HX_("Event loop is not available. Refer to sys.thread.Thread.runWithEventLoop.",89,e6,4c,1c);
+            	HX_STACKFRAME(&_hx_pos_c0f6a7d563b0a42e_7_new)
+HXDLIN(   7)		__this->super::__construct(msg,previous,null());
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~NoEventLoopException_obj();
+
+		HX_DO_RTTI_ALL;
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("NoEventLoopException",92,71,e8,a8); }
+
+};
+
+} // end namespace sys
+} // end namespace thread
+
+#endif /* INCLUDED_sys_thread_NoEventLoopException */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/thread/_EventLoop/RegularEvent.h b/Sources/c_snikket/iinclude/include/sys/thread/_EventLoop/RegularEvent.h
new file mode 100644
index 0000000..e91ddab
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/thread/_EventLoop/RegularEvent.h
@@ -0,0 +1,81 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_thread__EventLoop_RegularEvent
+#define INCLUDED_sys_thread__EventLoop_RegularEvent
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_692c76051dac6459_278_new)
+HX_DECLARE_CLASS3(sys,thread,_EventLoop,RegularEvent)
+
+namespace sys{
+namespace thread{
+namespace _EventLoop{
+
+
+class HXCPP_CLASS_ATTRIBUTES RegularEvent_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef RegularEvent_obj OBJ_;
+		RegularEvent_obj();
+
+	public:
+		enum { _hx_ClassId = 0x13f58728 };
+
+		void __construct( ::Dynamic run,Float nextRunTime,Float interval);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.thread._EventLoop.RegularEvent")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.thread._EventLoop.RegularEvent"); }
+
+		inline static ::hx::ObjectPtr< RegularEvent_obj > __new( ::Dynamic run,Float nextRunTime,Float interval) {
+			::hx::ObjectPtr< RegularEvent_obj > __this = new RegularEvent_obj();
+			__this->__construct(run,nextRunTime,interval);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< RegularEvent_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic run,Float nextRunTime,Float interval) {
+			RegularEvent_obj *__this = (RegularEvent_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(RegularEvent_obj), true, "sys.thread._EventLoop.RegularEvent"));
+			*(void **)__this = RegularEvent_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_692c76051dac6459_278_new)
+HXLINE( 284)		( ( ::sys::thread::_EventLoop::RegularEvent)(__this) )->cancelled = false;
+HXLINE( 287)		( ( ::sys::thread::_EventLoop::RegularEvent)(__this) )->run = run;
+HXLINE( 288)		( ( ::sys::thread::_EventLoop::RegularEvent)(__this) )->nextRunTime = nextRunTime;
+HXLINE( 289)		( ( ::sys::thread::_EventLoop::RegularEvent)(__this) )->interval = interval;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~RegularEvent_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("RegularEvent",3e,24,e8,2d); }
+
+		Float nextRunTime;
+		Float interval;
+		 ::Dynamic run;
+		Dynamic run_dyn() { return run;}
+		 ::sys::thread::_EventLoop::RegularEvent next;
+		 ::sys::thread::_EventLoop::RegularEvent previous;
+		bool cancelled;
+};
+
+} // end namespace sys
+} // end namespace thread
+} // end namespace _EventLoop
+
+#endif /* INCLUDED_sys_thread__EventLoop_RegularEvent */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/thread/_Thread/HaxeThread.h b/Sources/c_snikket/iinclude/include/sys/thread/_Thread/HaxeThread.h
new file mode 100644
index 0000000..80f44f1
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/thread/_Thread/HaxeThread.h
@@ -0,0 +1,76 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_thread__Thread_HaxeThread
+#define INCLUDED_sys_thread__Thread_HaxeThread
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(sys,thread,EventLoop)
+HX_DECLARE_CLASS2(sys,thread,Mutex)
+HX_DECLARE_CLASS3(sys,thread,_Thread,HaxeThread)
+
+namespace sys{
+namespace thread{
+namespace _Thread{
+
+
+class HXCPP_CLASS_ATTRIBUTES HaxeThread_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef HaxeThread_obj OBJ_;
+		HaxeThread_obj();
+
+	public:
+		enum { _hx_ClassId = 0x72cf0b82 };
+
+		void __construct( ::Dynamic h);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.thread._Thread.HaxeThread")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.thread._Thread.HaxeThread"); }
+		static ::hx::ObjectPtr< HaxeThread_obj > __new( ::Dynamic h);
+		static ::hx::ObjectPtr< HaxeThread_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic h);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HaxeThread_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		static void __init__();
+
+		::String __ToString() const { return HX_("HaxeThread",b0,c7,55,fd); }
+
+		static void __boot();
+		static ::Array< ::Dynamic> threads;
+		static  ::sys::thread::Mutex threadsMutex;
+		static  ::Dynamic mainThreadHandle;
+		static  ::sys::thread::_Thread::HaxeThread mainThread;
+		static  ::sys::thread::_Thread::HaxeThread current();
+		static ::Dynamic current_dyn();
+
+		static  ::sys::thread::_Thread::HaxeThread create( ::Dynamic job,bool withEventLoop);
+		static ::Dynamic create_dyn();
+
+		static void dropThread( ::Dynamic item,int probableIndex);
+		static ::Dynamic dropThread_dyn();
+
+		 ::sys::thread::EventLoop events;
+		 ::Dynamic handle;
+};
+
+} // end namespace sys
+} // end namespace thread
+} // end namespace _Thread
+
+#endif /* INCLUDED_sys_thread__Thread_HaxeThread */ 
diff --git a/Sources/c_snikket/iinclude/include/sys/thread/_Thread/Thread_Impl_.h b/Sources/c_snikket/iinclude/include/sys/thread/_Thread/Thread_Impl_.h
new file mode 100644
index 0000000..1d125c1
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/sys/thread/_Thread/Thread_Impl_.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_thread__Thread_Thread_Impl_
+#define INCLUDED_sys_thread__Thread_Thread_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(sys,thread,EventLoop)
+HX_DECLARE_CLASS3(sys,thread,_Thread,HaxeThread)
+HX_DECLARE_CLASS3(sys,thread,_Thread,Thread_Impl_)
+
+namespace sys{
+namespace thread{
+namespace _Thread{
+
+
+class HXCPP_CLASS_ATTRIBUTES Thread_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Thread_Impl__obj OBJ_;
+		Thread_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x3097b824 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="sys.thread._Thread.Thread_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"sys.thread._Thread.Thread_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Thread_Impl__obj > __new() {
+			::hx::ObjectPtr< Thread_Impl__obj > __this = new Thread_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Thread_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Thread_Impl__obj *__this = (Thread_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Thread_Impl__obj), false, "sys.thread._Thread.Thread_Impl_"));
+			*(void **)__this = Thread_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Thread_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Thread_Impl_",0a,37,9c,fe); }
+
+		static  ::sys::thread::EventLoop get_events( ::sys::thread::_Thread::HaxeThread this1);
+		static ::Dynamic get_events_dyn();
+
+		static void processEvents();
+		static ::Dynamic processEvents_dyn();
+
+};
+
+} // end namespace sys
+} // end namespace thread
+} // end namespace _Thread
+
+#endif /* INCLUDED_sys_thread__Thread_Thread_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/include/thenshim/PromiseFactory.h b/Sources/c_snikket/iinclude/include/thenshim/PromiseFactory.h
new file mode 100644
index 0000000..1fd53c5
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/thenshim/PromiseFactory.h
@@ -0,0 +1,36 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_thenshim_PromiseFactory
+#define INCLUDED_thenshim_PromiseFactory
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(thenshim,PromiseFactory)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+
+namespace thenshim{
+
+
+class HXCPP_CLASS_ATTRIBUTES PromiseFactory_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		::Dynamic (::hx::Object :: *_hx_make)( ::Dynamic executor); 
+		static inline ::Dynamic make( ::Dynamic _hx_, ::Dynamic executor) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::thenshim::PromiseFactory_obj *>(_hx_.mPtr->_hx_getInterface(0x93a35865)))->_hx_make)(executor);
+		}
+		::Dynamic (::hx::Object :: *_hx_asResolved)( ::Dynamic object); 
+		static inline ::Dynamic asResolved( ::Dynamic _hx_, ::Dynamic object) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::thenshim::PromiseFactory_obj *>(_hx_.mPtr->_hx_getInterface(0x93a35865)))->_hx_asResolved)(object);
+		}
+		::Dynamic (::hx::Object :: *_hx_asRejected)( ::Dynamic reason); 
+		static inline ::Dynamic asRejected( ::Dynamic _hx_, ::Dynamic reason) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::thenshim::PromiseFactory_obj *>(_hx_.mPtr->_hx_getInterface(0x93a35865)))->_hx_asRejected)(reason);
+		}
+};
+
+} // end namespace thenshim
+
+#endif /* INCLUDED_thenshim_PromiseFactory */ 
diff --git a/Sources/c_snikket/iinclude/include/thenshim/PromiseTools.h b/Sources/c_snikket/iinclude/include/thenshim/PromiseTools.h
new file mode 100644
index 0000000..f854535
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/thenshim/PromiseTools.h
@@ -0,0 +1,64 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_thenshim_PromiseTools
+#define INCLUDED_thenshim_PromiseTools
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(thenshim,PromiseTools)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+
+namespace thenshim{
+
+
+class HXCPP_CLASS_ATTRIBUTES PromiseTools_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef PromiseTools_obj OBJ_;
+		PromiseTools_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1873701a };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="thenshim.PromiseTools")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"thenshim.PromiseTools"); }
+
+		inline static ::hx::ObjectPtr< PromiseTools_obj > __new() {
+			::hx::ObjectPtr< PromiseTools_obj > __this = new PromiseTools_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< PromiseTools_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			PromiseTools_obj *__this = (PromiseTools_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(PromiseTools_obj), false, "thenshim.PromiseTools"));
+			*(void **)__this = PromiseTools_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~PromiseTools_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("PromiseTools",a0,4e,2e,4d); }
+
+		static ::Dynamic all( ::Dynamic promises);
+		static ::Dynamic all_dyn();
+
+		static ::Dynamic catch_(::Dynamic promise, ::Dynamic onRejected);
+		static ::Dynamic catch__dyn();
+
+};
+
+} // end namespace thenshim
+
+#endif /* INCLUDED_thenshim_PromiseTools */ 
diff --git a/Sources/c_snikket/iinclude/include/thenshim/Thenable.h b/Sources/c_snikket/iinclude/include/thenshim/Thenable.h
new file mode 100644
index 0000000..66c521e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/thenshim/Thenable.h
@@ -0,0 +1,27 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_thenshim_Thenable
+#define INCLUDED_thenshim_Thenable
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(thenshim,Thenable)
+
+namespace thenshim{
+
+
+class HXCPP_CLASS_ATTRIBUTES Thenable_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		::Dynamic (::hx::Object :: *_hx_then)( ::Dynamic onFulfilled, ::Dynamic onRejected); 
+		static inline ::Dynamic then( ::Dynamic _hx_, ::Dynamic onFulfilled, ::Dynamic onRejected) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::thenshim::Thenable_obj *>(_hx_.mPtr->_hx_getInterface(0xc019ce6d)))->_hx_then)(onFulfilled,onRejected);
+		}
+};
+
+} // end namespace thenshim
+
+#endif /* INCLUDED_thenshim_Thenable */ 
diff --git a/Sources/c_snikket/iinclude/include/thenshim/_Promise/Promise_Impl_.h b/Sources/c_snikket/iinclude/include/thenshim/_Promise/Promise_Impl_.h
new file mode 100644
index 0000000..266087a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/thenshim/_Promise/Promise_Impl_.h
@@ -0,0 +1,75 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_thenshim__Promise_Promise_Impl_
+#define INCLUDED_thenshim__Promise_Promise_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(thenshim,PromiseFactory)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+HX_DECLARE_CLASS2(thenshim,_Promise,Promise_Impl_)
+
+namespace thenshim{
+namespace _Promise{
+
+
+class HXCPP_CLASS_ATTRIBUTES Promise_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Promise_Impl__obj OBJ_;
+		Promise_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x048c0501 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="thenshim._Promise.Promise_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"thenshim._Promise.Promise_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Promise_Impl__obj > __new() {
+			::hx::ObjectPtr< Promise_Impl__obj > __this = new Promise_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Promise_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Promise_Impl__obj *__this = (Promise_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Promise_Impl__obj), false, "thenshim._Promise.Promise_Impl_"));
+			*(void **)__this = Promise_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Promise_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Promise_Impl_",5b,00,ba,be); }
+
+		static void __boot();
+		static ::Dynamic factory;
+		static ::Dynamic _new( ::Dynamic executor);
+		static ::Dynamic _new_dyn();
+
+		static ::Dynamic resolve( ::Dynamic object);
+		static ::Dynamic resolve_dyn();
+
+		static ::Dynamic reject( ::Dynamic reason);
+		static ::Dynamic reject_dyn();
+
+		static ::Dynamic then(::Dynamic this1, ::Dynamic onFulfilled, ::Dynamic onRejected);
+		static ::Dynamic then_dyn();
+
+};
+
+} // end namespace thenshim
+} // end namespace _Promise
+
+#endif /* INCLUDED_thenshim__Promise_Promise_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/include/thenshim/fallback/FallbackPromise.h b/Sources/c_snikket/iinclude/include/thenshim/fallback/FallbackPromise.h
new file mode 100644
index 0000000..21e2936
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/thenshim/fallback/FallbackPromise.h
@@ -0,0 +1,77 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_thenshim_fallback_FallbackPromise
+#define INCLUDED_thenshim_fallback_FallbackPromise
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_thenshim_Thenable
+#include <thenshim/Thenable.h>
+#endif
+HX_DECLARE_CLASS1(thenshim,Thenable)
+HX_DECLARE_CLASS2(thenshim,fallback,FallbackPromise)
+HX_DECLARE_CLASS2(thenshim,fallback,HandlerSession)
+HX_DECLARE_CLASS2(thenshim,fallback,PromiseState)
+HX_DECLARE_CLASS2(thenshim,fallback,TaskScheduler)
+
+namespace thenshim{
+namespace fallback{
+
+
+class HXCPP_CLASS_ATTRIBUTES FallbackPromise_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef FallbackPromise_obj OBJ_;
+		FallbackPromise_obj();
+
+	public:
+		enum { _hx_ClassId = 0x6da4d981 };
+
+		void __construct( ::thenshim::fallback::TaskScheduler scheduler);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="thenshim.fallback.FallbackPromise")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"thenshim.fallback.FallbackPromise"); }
+		static ::hx::ObjectPtr< FallbackPromise_obj > __new( ::thenshim::fallback::TaskScheduler scheduler);
+		static ::hx::ObjectPtr< FallbackPromise_obj > __alloc(::hx::Ctx *_hx_ctx, ::thenshim::fallback::TaskScheduler scheduler);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~FallbackPromise_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("FallbackPromise",79,35,7a,1c); }
+
+		 ::thenshim::fallback::TaskScheduler scheduler;
+		 ::thenshim::fallback::PromiseState state;
+		 ::Dynamic value;
+		 ::Dynamic reason;
+		::Array< ::Dynamic> sessions;
+		::Dynamic then( ::Dynamic onFulfilled, ::Dynamic onRejected);
+		::Dynamic then_dyn();
+
+		 ::thenshim::fallback::FallbackPromise thenImpl( ::Dynamic onFulfilled, ::Dynamic onRejected);
+		::Dynamic thenImpl_dyn();
+
+		void resolve( ::Dynamic value);
+		::Dynamic resolve_dyn();
+
+		void reject( ::Dynamic reason);
+		::Dynamic reject_dyn();
+
+};
+
+} // end namespace thenshim
+} // end namespace fallback
+
+#endif /* INCLUDED_thenshim_fallback_FallbackPromise */ 
diff --git a/Sources/c_snikket/iinclude/include/thenshim/fallback/FallbackPromiseFactory.h b/Sources/c_snikket/iinclude/include/thenshim/fallback/FallbackPromiseFactory.h
new file mode 100644
index 0000000..ecfa490
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/thenshim/fallback/FallbackPromiseFactory.h
@@ -0,0 +1,75 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_thenshim_fallback_FallbackPromiseFactory
+#define INCLUDED_thenshim_fallback_FallbackPromiseFactory
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_thenshim_PromiseFactory
+#include <thenshim/PromiseFactory.h>
+#endif
+HX_DECLARE_CLASS1(thenshim,PromiseFactory)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+HX_DECLARE_CLASS2(thenshim,fallback,FallbackPromiseFactory)
+HX_DECLARE_CLASS2(thenshim,fallback,TaskScheduler)
+
+namespace thenshim{
+namespace fallback{
+
+
+class HXCPP_CLASS_ATTRIBUTES FallbackPromiseFactory_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef FallbackPromiseFactory_obj OBJ_;
+		FallbackPromiseFactory_obj();
+
+	public:
+		enum { _hx_ClassId = 0x592d0d49 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="thenshim.fallback.FallbackPromiseFactory")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"thenshim.fallback.FallbackPromiseFactory"); }
+		static ::hx::ObjectPtr< FallbackPromiseFactory_obj > __new();
+		static ::hx::ObjectPtr< FallbackPromiseFactory_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~FallbackPromiseFactory_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("FallbackPromiseFactory",51,a0,67,b6); }
+
+		 ::thenshim::fallback::TaskScheduler scheduler;
+		::Dynamic make( ::Dynamic executor);
+		::Dynamic make_dyn();
+
+		::Dynamic asResolved( ::Dynamic object);
+		::Dynamic asResolved_dyn();
+
+		::Dynamic asResolvedThenable(::Dynamic thenable);
+		::Dynamic asResolvedThenable_dyn();
+
+		::Dynamic asResolvedThenProperty( ::Dynamic object);
+		::Dynamic asResolvedThenProperty_dyn();
+
+		::Dynamic asRejected( ::Dynamic reason);
+		::Dynamic asRejected_dyn();
+
+};
+
+} // end namespace thenshim
+} // end namespace fallback
+
+#endif /* INCLUDED_thenshim_fallback_FallbackPromiseFactory */ 
diff --git a/Sources/c_snikket/iinclude/include/thenshim/fallback/HandlerSession.h b/Sources/c_snikket/iinclude/include/thenshim/fallback/HandlerSession.h
new file mode 100644
index 0000000..c9dc287
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/thenshim/fallback/HandlerSession.h
@@ -0,0 +1,84 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_thenshim_fallback_HandlerSession
+#define INCLUDED_thenshim_fallback_HandlerSession
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(thenshim,Thenable)
+HX_DECLARE_CLASS2(thenshim,fallback,FallbackPromise)
+HX_DECLARE_CLASS2(thenshim,fallback,HandlerSession)
+HX_DECLARE_CLASS2(thenshim,fallback,TaskScheduler)
+
+namespace thenshim{
+namespace fallback{
+
+
+class HXCPP_CLASS_ATTRIBUTES HandlerSession_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef HandlerSession_obj OBJ_;
+		HandlerSession_obj();
+
+	public:
+		enum { _hx_ClassId = 0x30baea8c };
+
+		void __construct( ::thenshim::fallback::TaskScheduler scheduler, ::Dynamic fulfilledCallback, ::Dynamic rejectedCallback);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="thenshim.fallback.HandlerSession")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"thenshim.fallback.HandlerSession"); }
+		static ::hx::ObjectPtr< HandlerSession_obj > __new( ::thenshim::fallback::TaskScheduler scheduler, ::Dynamic fulfilledCallback, ::Dynamic rejectedCallback);
+		static ::hx::ObjectPtr< HandlerSession_obj > __alloc(::hx::Ctx *_hx_ctx, ::thenshim::fallback::TaskScheduler scheduler, ::Dynamic fulfilledCallback, ::Dynamic rejectedCallback);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HandlerSession_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HandlerSession",cc,10,db,f7); }
+
+		static void resolvePromise( ::thenshim::fallback::FallbackPromise promise, ::Dynamic value);
+		static ::Dynamic resolvePromise_dyn();
+
+		static bool rejectIfSame( ::thenshim::fallback::FallbackPromise promise, ::Dynamic value);
+		static ::Dynamic rejectIfSame_dyn();
+
+		static void resolvePromiseThenable( ::thenshim::fallback::FallbackPromise promise,::Dynamic thenable);
+		static ::Dynamic resolvePromiseThenable_dyn();
+
+		static void resolvePromiseObject( ::thenshim::fallback::FallbackPromise promise, ::Dynamic object);
+		static ::Dynamic resolvePromiseObject_dyn();
+
+		 ::thenshim::fallback::FallbackPromise promise;
+		 ::thenshim::fallback::TaskScheduler scheduler;
+		 ::Dynamic fulfilledCallback;
+		 ::Dynamic rejectedCallback;
+		void resolve( ::Dynamic value);
+		::Dynamic resolve_dyn();
+
+		void resolveImpl( ::Dynamic value);
+		::Dynamic resolveImpl_dyn();
+
+		void reject( ::Dynamic reason);
+		::Dynamic reject_dyn();
+
+		void rejectImpl( ::Dynamic reason);
+		::Dynamic rejectImpl_dyn();
+
+};
+
+} // end namespace thenshim
+} // end namespace fallback
+
+#endif /* INCLUDED_thenshim_fallback_HandlerSession */ 
diff --git a/Sources/c_snikket/iinclude/include/thenshim/fallback/PromiseState.h b/Sources/c_snikket/iinclude/include/thenshim/fallback/PromiseState.h
new file mode 100644
index 0000000..7e84191
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/thenshim/fallback/PromiseState.h
@@ -0,0 +1,39 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_thenshim_fallback_PromiseState
+#define INCLUDED_thenshim_fallback_PromiseState
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(thenshim,fallback,PromiseState)
+namespace thenshim{
+namespace fallback{
+
+
+class PromiseState_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef PromiseState_obj OBJ_;
+
+	public:
+		PromiseState_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("thenshim.fallback.PromiseState",0a,45,f3,26); }
+		::String __ToString() const { return HX_("PromiseState.",d8,10,c1,ac) + _hx_tag; }
+
+		static ::thenshim::fallback::PromiseState Fulfilled;
+		static inline ::thenshim::fallback::PromiseState Fulfilled_dyn() { return Fulfilled; }
+		static ::thenshim::fallback::PromiseState Pending;
+		static inline ::thenshim::fallback::PromiseState Pending_dyn() { return Pending; }
+		static ::thenshim::fallback::PromiseState Rejected;
+		static inline ::thenshim::fallback::PromiseState Rejected_dyn() { return Rejected; }
+};
+
+} // end namespace thenshim
+} // end namespace fallback
+
+#endif /* INCLUDED_thenshim_fallback_PromiseState */ 
diff --git a/Sources/c_snikket/iinclude/include/thenshim/fallback/TaskScheduler.h b/Sources/c_snikket/iinclude/include/thenshim/fallback/TaskScheduler.h
new file mode 100644
index 0000000..ba47ed8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/thenshim/fallback/TaskScheduler.h
@@ -0,0 +1,72 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_thenshim_fallback_TaskScheduler
+#define INCLUDED_thenshim_fallback_TaskScheduler
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_8fc69505e32be3f2_11_new)
+HX_DECLARE_CLASS2(thenshim,fallback,TaskScheduler)
+
+namespace thenshim{
+namespace fallback{
+
+
+class HXCPP_CLASS_ATTRIBUTES TaskScheduler_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef TaskScheduler_obj OBJ_;
+		TaskScheduler_obj();
+
+	public:
+		enum { _hx_ClassId = 0x23747a3a };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="thenshim.fallback.TaskScheduler")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"thenshim.fallback.TaskScheduler"); }
+
+		inline static ::hx::ObjectPtr< TaskScheduler_obj > __new() {
+			::hx::ObjectPtr< TaskScheduler_obj > __this = new TaskScheduler_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< TaskScheduler_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			TaskScheduler_obj *__this = (TaskScheduler_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(TaskScheduler_obj), true, "thenshim.fallback.TaskScheduler"));
+			*(void **)__this = TaskScheduler_obj::_hx_vtable;
+			thenshim::fallback::TaskScheduler_obj::__alloc_dynamic_functions(_hx_ctx,__this);
+{
+            	HX_STACKFRAME(&_hx_pos_8fc69505e32be3f2_11_new)
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		static void __alloc_dynamic_functions(::hx::Ctx *_hx_alloc,TaskScheduler_obj *_hx_obj);
+		//~TaskScheduler_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("TaskScheduler",16,22,01,bb); }
+
+		::Dynamic addNext;
+		inline ::Dynamic &addNext_dyn() {return addNext; }
+
+};
+
+} // end namespace thenshim
+} // end namespace fallback
+
+#endif /* INCLUDED_thenshim_fallback_TaskScheduler */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/_Chunk/Chunk_Impl_.h b/Sources/c_snikket/iinclude/include/tink/_Chunk/Chunk_Impl_.h
new file mode 100644
index 0000000..567282c
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/_Chunk/Chunk_Impl_.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink__Chunk_Chunk_Impl_
+#define INCLUDED_tink__Chunk_Chunk_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,_Chunk,Chunk_Impl_)
+HX_DECLARE_CLASS2(tink,chunk,ChunkObject)
+
+namespace tink{
+namespace _Chunk{
+
+
+class HXCPP_CLASS_ATTRIBUTES Chunk_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Chunk_Impl__obj OBJ_;
+		Chunk_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x3bb70ded };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink._Chunk.Chunk_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink._Chunk.Chunk_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Chunk_Impl__obj > __new() {
+			::hx::ObjectPtr< Chunk_Impl__obj > __this = new Chunk_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Chunk_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Chunk_Impl__obj *__this = (Chunk_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Chunk_Impl__obj), false, "tink._Chunk.Chunk_Impl_"));
+			*(void **)__this = Chunk_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Chunk_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Chunk_Impl_",ad,aa,7a,82); }
+
+		static void __boot();
+		static ::Dynamic concat(::Dynamic this1,::Dynamic that);
+		static ::Dynamic concat_dyn();
+
+		static ::Dynamic join(::Array< ::Dynamic> chunks);
+		static ::Dynamic join_dyn();
+
+		static ::Dynamic EMPTY;
+};
+
+} // end namespace tink
+} // end namespace _Chunk
+
+#endif /* INCLUDED_tink__Chunk_Chunk_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/_Chunk/EmptyChunk.h b/Sources/c_snikket/iinclude/include/tink/_Chunk/EmptyChunk.h
new file mode 100644
index 0000000..b66b362
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/_Chunk/EmptyChunk.h
@@ -0,0 +1,77 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink__Chunk_EmptyChunk
+#define INCLUDED_tink__Chunk_EmptyChunk
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_chunk_ChunkBase
+#include <tink/chunk/ChunkBase.h>
+#endif
+#ifndef INCLUDED_tink_chunk_ChunkObject
+#include <tink/chunk/ChunkObject.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(tink,_Chunk,EmptyChunk)
+HX_DECLARE_CLASS2(tink,chunk,ChunkBase)
+HX_DECLARE_CLASS2(tink,chunk,ChunkObject)
+
+namespace tink{
+namespace _Chunk{
+
+
+class HXCPP_CLASS_ATTRIBUTES EmptyChunk_obj : public  ::tink::chunk::ChunkBase_obj
+{
+	public:
+		typedef  ::tink::chunk::ChunkBase_obj super;
+		typedef EmptyChunk_obj OBJ_;
+		EmptyChunk_obj();
+
+	public:
+		enum { _hx_ClassId = 0x01566580 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink._Chunk.EmptyChunk")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink._Chunk.EmptyChunk"); }
+		static ::hx::ObjectPtr< EmptyChunk_obj > __new();
+		static ::hx::ObjectPtr< EmptyChunk_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~EmptyChunk_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("EmptyChunk",c0,a0,c6,bc); }
+
+		static void __boot();
+		static  ::haxe::io::Bytes EMPTY;
+		int getLength();
+		::Dynamic getLength_dyn();
+
+		::Dynamic slice(int from,int to);
+		::Dynamic slice_dyn();
+
+		void blitTo( ::haxe::io::Bytes target,int offset);
+		::Dynamic blitTo_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+		 ::haxe::io::Bytes toBytes();
+		::Dynamic toBytes_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace _Chunk
+
+#endif /* INCLUDED_tink__Chunk_EmptyChunk */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/_Url/Url_Impl_.h b/Sources/c_snikket/iinclude/include/tink/_Url/Url_Impl_.h
new file mode 100644
index 0000000..954edfb
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/_Url/Url_Impl_.h
@@ -0,0 +1,80 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink__Url_Url_Impl_
+#define INCLUDED_tink__Url_Url_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,_Url,Url_Impl_)
+
+namespace tink{
+namespace _Url{
+
+
+class HXCPP_CLASS_ATTRIBUTES Url_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Url_Impl__obj OBJ_;
+		Url_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x142a69a5 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink._Url.Url_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink._Url.Url_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Url_Impl__obj > __new() {
+			::hx::ObjectPtr< Url_Impl__obj > __this = new Url_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Url_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Url_Impl__obj *__this = (Url_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Url_Impl__obj), false, "tink._Url.Url_Impl_"));
+			*(void **)__this = Url_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Url_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Url_Impl_",2f,05,36,5a); }
+
+		static  ::Dynamic resolve( ::Dynamic this1, ::Dynamic that);
+		static ::Dynamic resolve_dyn();
+
+		static void makePayload( ::Dynamic parts);
+		static ::Dynamic makePayload_dyn();
+
+		static ::String toString( ::Dynamic this1);
+		static ::Dynamic toString_dyn();
+
+		static  ::Dynamic fromString(::String s);
+		static ::Dynamic fromString_dyn();
+
+		static void noop(::String _);
+		static ::Dynamic noop_dyn();
+
+		static  ::Dynamic parse(::String s, ::Dynamic onError);
+		static ::Dynamic parse_dyn();
+
+		static  ::Dynamic make( ::Dynamic parts);
+		static ::Dynamic make_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace _Url
+
+#endif /* INCLUDED_tink__Url_Url_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/chunk/ByteChunk.h b/Sources/c_snikket/iinclude/include/tink/chunk/ByteChunk.h
new file mode 100644
index 0000000..6fa0b79
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/chunk/ByteChunk.h
@@ -0,0 +1,90 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_chunk_ByteChunk
+#define INCLUDED_tink_chunk_ByteChunk
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_chunk_ChunkBase
+#include <tink/chunk/ChunkBase.h>
+#endif
+#ifndef INCLUDED_tink_chunk_ChunkObject
+#include <tink/chunk/ChunkObject.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(tink,chunk,ByteChunk)
+HX_DECLARE_CLASS2(tink,chunk,ChunkBase)
+HX_DECLARE_CLASS2(tink,chunk,ChunkObject)
+
+namespace tink{
+namespace chunk{
+
+
+class HXCPP_CLASS_ATTRIBUTES ByteChunk_obj : public  ::tink::chunk::ChunkBase_obj
+{
+	public:
+		typedef  ::tink::chunk::ChunkBase_obj super;
+		typedef ByteChunk_obj OBJ_;
+		ByteChunk_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1854896e };
+
+		void __construct(::Array< unsigned char > data,int from,int to);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.chunk.ByteChunk")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.chunk.ByteChunk"); }
+		static ::hx::ObjectPtr< ByteChunk_obj > __new(::Array< unsigned char > data,int from,int to);
+		static ::hx::ObjectPtr< ByteChunk_obj > __alloc(::hx::Ctx *_hx_ctx,::Array< unsigned char > data,int from,int to);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ByteChunk_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("ByteChunk",25,7a,ca,7d); }
+
+		static ::Dynamic of( ::haxe::io::Bytes b);
+		static ::Dynamic of_dyn();
+
+		::Array< unsigned char > data;
+		int from;
+		int to;
+		 ::haxe::io::Bytes wrapped;
+		void flatten(::Array< ::Dynamic> into);
+
+		int getLength();
+		::Dynamic getLength_dyn();
+
+		 ::tink::chunk::ByteChunk getSlice(int from,int to);
+		::Dynamic getSlice_dyn();
+
+		::Dynamic slice(int from,int to);
+		::Dynamic slice_dyn();
+
+		void blitTo( ::haxe::io::Bytes target,int offset);
+		::Dynamic blitTo_dyn();
+
+		 ::haxe::io::Bytes toBytes();
+		::Dynamic toBytes_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace chunk
+
+#endif /* INCLUDED_tink_chunk_ByteChunk */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/chunk/ChunkBase.h b/Sources/c_snikket/iinclude/include/tink/chunk/ChunkBase.h
new file mode 100644
index 0000000..f4af2f3
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/chunk/ChunkBase.h
@@ -0,0 +1,73 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_chunk_ChunkBase
+#define INCLUDED_tink_chunk_ChunkBase
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,chunk,ByteChunk)
+HX_DECLARE_CLASS2(tink,chunk,ChunkBase)
+HX_DECLARE_CLASS2(tink,chunk,ChunkCursor)
+HX_DECLARE_CLASS2(tink,chunk,ChunkObject)
+
+namespace tink{
+namespace chunk{
+
+
+class HXCPP_CLASS_ATTRIBUTES ChunkBase_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef ChunkBase_obj OBJ_;
+		ChunkBase_obj();
+
+	public:
+		enum { _hx_ClassId = 0x49bef7e3 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.chunk.ChunkBase")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.chunk.ChunkBase"); }
+
+		inline static ::hx::ObjectPtr< ChunkBase_obj > __new() {
+			::hx::ObjectPtr< ChunkBase_obj > __this = new ChunkBase_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< ChunkBase_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			ChunkBase_obj *__this = (ChunkBase_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(ChunkBase_obj), true, "tink.chunk.ChunkBase"));
+			*(void **)__this = ChunkBase_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ChunkBase_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ChunkBase",fe,f4,07,36); }
+
+		::Array< ::Dynamic> flattened;
+		 ::tink::chunk::ChunkCursor getCursor();
+		::Dynamic getCursor_dyn();
+
+		virtual void flatten(::Array< ::Dynamic> into);
+		::Dynamic flatten_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace chunk
+
+#endif /* INCLUDED_tink_chunk_ChunkBase */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/chunk/ChunkCursor.h b/Sources/c_snikket/iinclude/include/tink/chunk/ChunkCursor.h
new file mode 100644
index 0000000..338a1b0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/chunk/ChunkCursor.h
@@ -0,0 +1,91 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_chunk_ChunkCursor
+#define INCLUDED_tink_chunk_ChunkCursor
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,chunk,ByteChunk)
+HX_DECLARE_CLASS2(tink,chunk,ChunkBase)
+HX_DECLARE_CLASS2(tink,chunk,ChunkCursor)
+HX_DECLARE_CLASS2(tink,chunk,ChunkObject)
+
+namespace tink{
+namespace chunk{
+
+
+class HXCPP_CLASS_ATTRIBUTES ChunkCursor_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef ChunkCursor_obj OBJ_;
+		ChunkCursor_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5b17b728 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.chunk.ChunkCursor")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.chunk.ChunkCursor"); }
+		static ::hx::ObjectPtr< ChunkCursor_obj > __new();
+		static ::hx::ObjectPtr< ChunkCursor_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ChunkCursor_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ChunkCursor",03,71,6e,a9); }
+
+		static  ::tink::chunk::ChunkCursor create(::Array< ::Dynamic> parts);
+		static ::Dynamic create_dyn();
+
+		::Array< ::Dynamic> parts;
+		 ::tink::chunk::ByteChunk curPart;
+		int curPartIndex;
+		int curOffset;
+		int curLength;
+		int length;
+		int currentPos;
+		int currentByte;
+		void reset();
+		::Dynamic reset_dyn();
+
+		::Dynamic flush();
+		::Dynamic flush_dyn();
+
+		void add(::Dynamic chunk);
+		::Dynamic add_dyn();
+
+		void shift(::Dynamic chunk);
+		::Dynamic shift_dyn();
+
+		::Dynamic left();
+		::Dynamic left_dyn();
+
+		::Dynamic right();
+		::Dynamic right_dyn();
+
+		void ffwd();
+		::Dynamic ffwd_dyn();
+
+		bool next();
+		::Dynamic next_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace chunk
+
+#endif /* INCLUDED_tink_chunk_ChunkCursor */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/chunk/ChunkObject.h b/Sources/c_snikket/iinclude/include/tink/chunk/ChunkObject.h
new file mode 100644
index 0000000..7a4d920
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/chunk/ChunkObject.h
@@ -0,0 +1,57 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_chunk_ChunkObject
+#define INCLUDED_tink_chunk_ChunkObject
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(tink,chunk,ByteChunk)
+HX_DECLARE_CLASS2(tink,chunk,ChunkBase)
+HX_DECLARE_CLASS2(tink,chunk,ChunkCursor)
+HX_DECLARE_CLASS2(tink,chunk,ChunkObject)
+
+namespace tink{
+namespace chunk{
+
+
+class HXCPP_CLASS_ATTRIBUTES ChunkObject_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		 ::tink::chunk::ChunkCursor (::hx::Object :: *_hx_getCursor)(); 
+		static inline  ::tink::chunk::ChunkCursor getCursor( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::chunk::ChunkObject_obj *>(_hx_.mPtr->_hx_getInterface(0x027c3451)))->_hx_getCursor)();
+		}
+		void (::hx::Object :: *_hx_flatten)(::Array< ::Dynamic> into); 
+		static inline void flatten( ::Dynamic _hx_,::Array< ::Dynamic> into) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::tink::chunk::ChunkObject_obj *>(_hx_.mPtr->_hx_getInterface(0x027c3451)))->_hx_flatten)(into);
+		}
+		int (::hx::Object :: *_hx_getLength)(); 
+		static inline int getLength( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::chunk::ChunkObject_obj *>(_hx_.mPtr->_hx_getInterface(0x027c3451)))->_hx_getLength)();
+		}
+		::Dynamic (::hx::Object :: *_hx_slice)(int from,int to); 
+		static inline ::Dynamic slice( ::Dynamic _hx_,int from,int to) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::chunk::ChunkObject_obj *>(_hx_.mPtr->_hx_getInterface(0x027c3451)))->_hx_slice)(from,to);
+		}
+		::String (::hx::Object :: *_hx_toString)(); 
+		static inline ::String toString( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::chunk::ChunkObject_obj *>(_hx_.mPtr->_hx_getInterface(0x027c3451)))->_hx_toString)();
+		}
+		 ::haxe::io::Bytes (::hx::Object :: *_hx_toBytes)(); 
+		static inline  ::haxe::io::Bytes toBytes( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::chunk::ChunkObject_obj *>(_hx_.mPtr->_hx_getInterface(0x027c3451)))->_hx_toBytes)();
+		}
+		void (::hx::Object :: *_hx_blitTo)( ::haxe::io::Bytes target,int offset); 
+		static inline void blitTo( ::Dynamic _hx_, ::haxe::io::Bytes target,int offset) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::tink::chunk::ChunkObject_obj *>(_hx_.mPtr->_hx_getInterface(0x027c3451)))->_hx_blitTo)(target,offset);
+		}
+};
+
+} // end namespace tink
+} // end namespace chunk
+
+#endif /* INCLUDED_tink_chunk_ChunkObject */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/chunk/CompoundChunk.h b/Sources/c_snikket/iinclude/include/tink/chunk/CompoundChunk.h
new file mode 100644
index 0000000..661f924
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/chunk/CompoundChunk.h
@@ -0,0 +1,97 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_chunk_CompoundChunk
+#define INCLUDED_tink_chunk_CompoundChunk
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_chunk_ChunkBase
+#include <tink/chunk/ChunkBase.h>
+#endif
+#ifndef INCLUDED_tink_chunk_ChunkObject
+#include <tink/chunk/ChunkObject.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(tink,chunk,ByteChunk)
+HX_DECLARE_CLASS2(tink,chunk,ChunkBase)
+HX_DECLARE_CLASS2(tink,chunk,ChunkObject)
+HX_DECLARE_CLASS2(tink,chunk,CompoundChunk)
+
+namespace tink{
+namespace chunk{
+
+
+class HXCPP_CLASS_ATTRIBUTES CompoundChunk_obj : public  ::tink::chunk::ChunkBase_obj
+{
+	public:
+		typedef  ::tink::chunk::ChunkBase_obj super;
+		typedef CompoundChunk_obj OBJ_;
+		CompoundChunk_obj();
+
+	public:
+		enum { _hx_ClassId = 0x73605847 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.chunk.CompoundChunk")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.chunk.CompoundChunk"); }
+		static ::hx::ObjectPtr< CompoundChunk_obj > __new();
+		static ::hx::ObjectPtr< CompoundChunk_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~CompoundChunk_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("CompoundChunk",e2,7e,3d,10); }
+
+		static  ::tink::chunk::CompoundChunk asCompound(::Dynamic c);
+		static ::Dynamic asCompound_dyn();
+
+		static ::Dynamic cons(::Dynamic a,::Dynamic b);
+		static ::Dynamic cons_dyn();
+
+		static  ::tink::chunk::CompoundChunk create(::Array< ::Dynamic> chunks,int depth);
+		static ::Dynamic create_dyn();
+
+		::Array< ::Dynamic> chunks;
+		::Array< int > offsets;
+		int length;
+		int depth;
+		int getLength();
+		::Dynamic getLength_dyn();
+
+		int findChunk(int target);
+		::Dynamic findChunk_dyn();
+
+		void flatten(::Array< ::Dynamic> into);
+
+		::Dynamic slice(int from,int to);
+		::Dynamic slice_dyn();
+
+		void blitTo( ::haxe::io::Bytes target,int offset);
+		::Dynamic blitTo_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+		 ::haxe::io::Bytes toBytes();
+		::Dynamic toBytes_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace chunk
+
+#endif /* INCLUDED_tink_chunk_CompoundChunk */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/core/CallbackLinkRef.h b/Sources/c_snikket/iinclude/include/tink/core/CallbackLinkRef.h
new file mode 100644
index 0000000..fb645e0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/core/CallbackLinkRef.h
@@ -0,0 +1,61 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core_CallbackLinkRef
+#define INCLUDED_tink_core_CallbackLinkRef
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_core_LinkObject
+#include <tink/core/LinkObject.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,CallbackLinkRef)
+HX_DECLARE_CLASS2(tink,core,LinkObject)
+
+namespace tink{
+namespace core{
+
+
+class HXCPP_CLASS_ATTRIBUTES CallbackLinkRef_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef CallbackLinkRef_obj OBJ_;
+		CallbackLinkRef_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2af492e3 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.core.CallbackLinkRef")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.core.CallbackLinkRef"); }
+		static ::hx::ObjectPtr< CallbackLinkRef_obj > __new();
+		static ::hx::ObjectPtr< CallbackLinkRef_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~CallbackLinkRef_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("CallbackLinkRef",14,ba,30,89); }
+
+		::Dynamic link;
+		void cancel();
+		::Dynamic cancel_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace core
+
+#endif /* INCLUDED_tink_core_CallbackLinkRef */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/core/CallbackList.h b/Sources/c_snikket/iinclude/include/tink/core/CallbackList.h
new file mode 100644
index 0000000..903c88f
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/core/CallbackList.h
@@ -0,0 +1,81 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core_CallbackList
+#define INCLUDED_tink_core_CallbackList
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_core_SimpleDisposable
+#include <tink/core/SimpleDisposable.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,CallbackList)
+HX_DECLARE_CLASS2(tink,core,Disposable)
+HX_DECLARE_CLASS2(tink,core,LinkObject)
+HX_DECLARE_CLASS2(tink,core,OwnedDisposable)
+HX_DECLARE_CLASS2(tink,core,SimpleDisposable)
+HX_DECLARE_CLASS3(tink,core,_Callback,ListCell)
+
+namespace tink{
+namespace core{
+
+
+class HXCPP_CLASS_ATTRIBUTES CallbackList_obj : public  ::tink::core::SimpleDisposable_obj
+{
+	public:
+		typedef  ::tink::core::SimpleDisposable_obj super;
+		typedef CallbackList_obj OBJ_;
+		CallbackList_obj();
+
+	public:
+		enum { _hx_ClassId = 0x12a8ef7c };
+
+		void __construct(::hx::Null< bool >  __o_destructive);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.core.CallbackList")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.core.CallbackList"); }
+		static ::hx::ObjectPtr< CallbackList_obj > __new(::hx::Null< bool >  __o_destructive);
+		static ::hx::ObjectPtr< CallbackList_obj > __alloc(::hx::Ctx *_hx_ctx,::hx::Null< bool >  __o_destructive);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~CallbackList_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("CallbackList",e3,f4,55,31); }
+
+		bool destructive;
+		::Array< ::Dynamic> cells;
+		int used;
+		::Array< ::Dynamic> queue;
+		bool busy;
+		 ::Dynamic ondrain;
+		Dynamic ondrain_dyn() { return ondrain;}
+		 ::Dynamic onfill;
+		Dynamic onfill_dyn() { return onfill;}
+		void destroy();
+		::Dynamic destroy_dyn();
+
+		void invoke( ::Dynamic data);
+		::Dynamic invoke_dyn();
+
+		void compact();
+		::Dynamic compact_dyn();
+
+		void resize(int length);
+		::Dynamic resize_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace core
+
+#endif /* INCLUDED_tink_core_CallbackList */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/core/Disposable.h b/Sources/c_snikket/iinclude/include/tink/core/Disposable.h
new file mode 100644
index 0000000..bd2c459
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/core/Disposable.h
@@ -0,0 +1,25 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core_Disposable
+#define INCLUDED_tink_core_Disposable
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,Disposable)
+
+namespace tink{
+namespace core{
+
+
+class HXCPP_CLASS_ATTRIBUTES Disposable_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+};
+
+} // end namespace tink
+} // end namespace core
+
+#endif /* INCLUDED_tink_core_Disposable */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/core/FutureStatus.h b/Sources/c_snikket/iinclude/include/tink/core/FutureStatus.h
new file mode 100644
index 0000000..f046dc9
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/core/FutureStatus.h
@@ -0,0 +1,45 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core_FutureStatus
+#define INCLUDED_tink_core_FutureStatus
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,FutureStatus)
+HX_DECLARE_CLASS3(tink,core,_Lazy,Computable)
+HX_DECLARE_CLASS3(tink,core,_Lazy,LazyObject)
+namespace tink{
+namespace core{
+
+
+class FutureStatus_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef FutureStatus_obj OBJ_;
+
+	public:
+		FutureStatus_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.core.FutureStatus",e8,d1,b4,f2); }
+		::String __ToString() const { return HX_("FutureStatus.",99,22,18,ea) + _hx_tag; }
+
+		static ::tink::core::FutureStatus Awaited;
+		static inline ::tink::core::FutureStatus Awaited_dyn() { return Awaited; }
+		static ::tink::core::FutureStatus EagerlyAwaited;
+		static inline ::tink::core::FutureStatus EagerlyAwaited_dyn() { return EagerlyAwaited; }
+		static ::tink::core::FutureStatus NeverEver;
+		static inline ::tink::core::FutureStatus NeverEver_dyn() { return NeverEver; }
+		static ::tink::core::FutureStatus Ready(::Dynamic result);
+		static ::Dynamic Ready_dyn();
+		static ::tink::core::FutureStatus Suspended;
+		static inline ::tink::core::FutureStatus Suspended_dyn() { return Suspended; }
+};
+
+} // end namespace tink
+} // end namespace core
+
+#endif /* INCLUDED_tink_core_FutureStatus */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/core/LinkObject.h b/Sources/c_snikket/iinclude/include/tink/core/LinkObject.h
new file mode 100644
index 0000000..8ad85f0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/core/LinkObject.h
@@ -0,0 +1,29 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core_LinkObject
+#define INCLUDED_tink_core_LinkObject
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,LinkObject)
+
+namespace tink{
+namespace core{
+
+
+class HXCPP_CLASS_ATTRIBUTES LinkObject_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		void (::hx::Object :: *_hx_cancel)(); 
+		static inline void cancel( ::Dynamic _hx_) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::tink::core::LinkObject_obj *>(_hx_.mPtr->_hx_getInterface(0x0d15dd4a)))->_hx_cancel)();
+		}
+};
+
+} // end namespace tink
+} // end namespace core
+
+#endif /* INCLUDED_tink_core_LinkObject */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/core/MPair.h b/Sources/c_snikket/iinclude/include/tink/core/MPair.h
new file mode 100644
index 0000000..5d16a2e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/core/MPair.h
@@ -0,0 +1,72 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core_MPair
+#define INCLUDED_tink_core_MPair
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_7fda083185addcb6_27_new)
+HX_DECLARE_CLASS2(tink,core,MPair)
+
+namespace tink{
+namespace core{
+
+
+class HXCPP_CLASS_ATTRIBUTES MPair_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef MPair_obj OBJ_;
+		MPair_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4cad4316 };
+
+		void __construct( ::Dynamic a, ::Dynamic b);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.core.MPair")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.core.MPair"); }
+
+		inline static ::hx::ObjectPtr< MPair_obj > __new( ::Dynamic a, ::Dynamic b) {
+			::hx::ObjectPtr< MPair_obj > __this = new MPair_obj();
+			__this->__construct(a,b);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< MPair_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic a, ::Dynamic b) {
+			MPair_obj *__this = (MPair_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(MPair_obj), true, "tink.core.MPair"));
+			*(void **)__this = MPair_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_7fda083185addcb6_27_new)
+HXLINE(  28)		( ( ::tink::core::MPair)(__this) )->a = a;
+HXLINE(  29)		( ( ::tink::core::MPair)(__this) )->b = b;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~MPair_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("MPair",07,b3,05,8b); }
+
+		 ::Dynamic a;
+		 ::Dynamic b;
+};
+
+} // end namespace tink
+} // end namespace core
+
+#endif /* INCLUDED_tink_core_MPair */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/core/NamedWith.h b/Sources/c_snikket/iinclude/include/tink/core/NamedWith.h
new file mode 100644
index 0000000..125a8dd
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/core/NamedWith.h
@@ -0,0 +1,72 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core_NamedWith
+#define INCLUDED_tink_core_NamedWith
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_fe49a69a0def38bb_11_new)
+HX_DECLARE_CLASS2(tink,core,NamedWith)
+
+namespace tink{
+namespace core{
+
+
+class HXCPP_CLASS_ATTRIBUTES NamedWith_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef NamedWith_obj OBJ_;
+		NamedWith_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4df025ce };
+
+		void __construct( ::Dynamic name, ::Dynamic value);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.core.NamedWith")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.core.NamedWith"); }
+
+		inline static ::hx::ObjectPtr< NamedWith_obj > __new( ::Dynamic name, ::Dynamic value) {
+			::hx::ObjectPtr< NamedWith_obj > __this = new NamedWith_obj();
+			__this->__construct(name,value);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< NamedWith_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic name, ::Dynamic value) {
+			NamedWith_obj *__this = (NamedWith_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(NamedWith_obj), true, "tink.core.NamedWith"));
+			*(void **)__this = NamedWith_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_fe49a69a0def38bb_11_new)
+HXLINE(  12)		( ( ::tink::core::NamedWith)(__this) )->name = name;
+HXLINE(  13)		( ( ::tink::core::NamedWith)(__this) )->value = value;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~NamedWith_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("NamedWith",3f,e2,3d,d6); }
+
+		 ::Dynamic name;
+		 ::Dynamic value;
+};
+
+} // end namespace tink
+} // end namespace core
+
+#endif /* INCLUDED_tink_core_NamedWith */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/core/Outcome.h b/Sources/c_snikket/iinclude/include/tink/core/Outcome.h
new file mode 100644
index 0000000..8434633
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/core/Outcome.h
@@ -0,0 +1,37 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core_Outcome
+#define INCLUDED_tink_core_Outcome
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,Outcome)
+namespace tink{
+namespace core{
+
+
+class Outcome_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef Outcome_obj OBJ_;
+
+	public:
+		Outcome_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.core.Outcome",5f,27,74,0c); }
+		::String __ToString() const { return HX_("Outcome.",7c,83,a3,53) + _hx_tag; }
+
+		static ::tink::core::Outcome Failure( ::Dynamic failure);
+		static ::Dynamic Failure_dyn();
+		static ::tink::core::Outcome Success( ::Dynamic data);
+		static ::Dynamic Success_dyn();
+};
+
+} // end namespace tink
+} // end namespace core
+
+#endif /* INCLUDED_tink_core_Outcome */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/core/OwnedDisposable.h b/Sources/c_snikket/iinclude/include/tink/core/OwnedDisposable.h
new file mode 100644
index 0000000..fe901cf
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/core/OwnedDisposable.h
@@ -0,0 +1,29 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core_OwnedDisposable
+#define INCLUDED_tink_core_OwnedDisposable
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_core_Disposable
+#include <tink/core/Disposable.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,Disposable)
+HX_DECLARE_CLASS2(tink,core,OwnedDisposable)
+
+namespace tink{
+namespace core{
+
+
+class HXCPP_CLASS_ATTRIBUTES OwnedDisposable_obj {
+	public:
+		typedef  ::tink::core::Disposable_obj super;
+		HX_DO_INTERFACE_RTTI;
+
+};
+
+} // end namespace tink
+} // end namespace core
+
+#endif /* INCLUDED_tink_core_OwnedDisposable */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/core/SimpleDisposable.h b/Sources/c_snikket/iinclude/include/tink/core/SimpleDisposable.h
new file mode 100644
index 0000000..0af4801
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/core/SimpleDisposable.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core_SimpleDisposable
+#define INCLUDED_tink_core_SimpleDisposable
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_core_OwnedDisposable
+#include <tink/core/OwnedDisposable.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,Disposable)
+HX_DECLARE_CLASS2(tink,core,OwnedDisposable)
+HX_DECLARE_CLASS2(tink,core,SimpleDisposable)
+
+namespace tink{
+namespace core{
+
+
+class HXCPP_CLASS_ATTRIBUTES SimpleDisposable_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef SimpleDisposable_obj OBJ_;
+		SimpleDisposable_obj();
+
+	public:
+		enum { _hx_ClassId = 0x11eb7047 };
+
+		void __construct( ::Dynamic dispose);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.core.SimpleDisposable")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.core.SimpleDisposable"); }
+		static ::hx::ObjectPtr< SimpleDisposable_obj > __new( ::Dynamic dispose);
+		static ::hx::ObjectPtr< SimpleDisposable_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic dispose);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SimpleDisposable_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("SimpleDisposable",92,24,4b,01); }
+
+		static void noop();
+		static ::Dynamic noop_dyn();
+
+		 ::Dynamic f;
+		Dynamic f_dyn() { return f;}
+		::Array< ::Dynamic> disposeHandlers;
+		void dispose();
+		::Dynamic dispose_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace core
+
+#endif /* INCLUDED_tink_core_SimpleDisposable */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/core/TypedError.h b/Sources/c_snikket/iinclude/include/tink/core/TypedError.h
new file mode 100644
index 0000000..b359208
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/core/TypedError.h
@@ -0,0 +1,72 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core_TypedError
+#define INCLUDED_tink_core_TypedError
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,StackItem)
+HX_DECLARE_CLASS2(tink,core,TypedError)
+
+namespace tink{
+namespace core{
+
+
+class HXCPP_CLASS_ATTRIBUTES TypedError_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef TypedError_obj OBJ_;
+		TypedError_obj();
+
+	public:
+		enum { _hx_ClassId = 0x07b6f513 };
+
+		void __construct( ::Dynamic __o_code,::String message, ::Dynamic pos);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.core.TypedError")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.core.TypedError"); }
+		static ::hx::ObjectPtr< TypedError_obj > __new( ::Dynamic __o_code,::String message, ::Dynamic pos);
+		static ::hx::ObjectPtr< TypedError_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic __o_code,::String message, ::Dynamic pos);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~TypedError_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("TypedError",1e,0f,9b,3c); }
+
+		static  ::tink::core::TypedError withData( ::Dynamic code,::String message, ::Dynamic data, ::Dynamic pos);
+		static ::Dynamic withData_dyn();
+
+		static  ::tink::core::TypedError typed( ::Dynamic code,::String message, ::Dynamic data, ::Dynamic pos);
+		static ::Dynamic typed_dyn();
+
+		::String message;
+		int code;
+		 ::Dynamic data;
+		 ::Dynamic pos;
+		::Array< ::Dynamic> callStack;
+		::Array< ::Dynamic> exceptionStack;
+		::String printPos();
+		::Dynamic printPos_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace core
+
+#endif /* INCLUDED_tink_core_TypedError */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/core/_Callback/Callback_Impl_.h b/Sources/c_snikket/iinclude/include/tink/core/_Callback/Callback_Impl_.h
new file mode 100644
index 0000000..a7f2a09
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/core/_Callback/Callback_Impl_.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core__Callback_Callback_Impl_
+#define INCLUDED_tink_core__Callback_Callback_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Callback,Callback_Impl_)
+
+namespace tink{
+namespace core{
+namespace _Callback{
+
+
+class HXCPP_CLASS_ATTRIBUTES Callback_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Callback_Impl__obj OBJ_;
+		Callback_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x10af39f4 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.core._Callback.Callback_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.core._Callback.Callback_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Callback_Impl__obj > __new() {
+			::hx::ObjectPtr< Callback_Impl__obj > __this = new Callback_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Callback_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Callback_Impl__obj *__this = (Callback_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Callback_Impl__obj), false, "tink.core._Callback.Callback_Impl_"));
+			*(void **)__this = Callback_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Callback_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Callback_Impl_",45,8c,62,d2); }
+
+		static void __boot();
+		static int depth;
+		static void invoke( ::Dynamic this1, ::Dynamic data);
+		static ::Dynamic invoke_dyn();
+
+		static void defer( ::Dynamic f);
+		static ::Dynamic defer_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace core
+} // end namespace _Callback
+
+#endif /* INCLUDED_tink_core__Callback_Callback_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/core/_Callback/LinkPair.h b/Sources/c_snikket/iinclude/include/tink/core/_Callback/LinkPair.h
new file mode 100644
index 0000000..b86caa5
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/core/_Callback/LinkPair.h
@@ -0,0 +1,65 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core__Callback_LinkPair
+#define INCLUDED_tink_core__Callback_LinkPair
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_core_LinkObject
+#include <tink/core/LinkObject.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,LinkObject)
+HX_DECLARE_CLASS3(tink,core,_Callback,LinkPair)
+
+namespace tink{
+namespace core{
+namespace _Callback{
+
+
+class HXCPP_CLASS_ATTRIBUTES LinkPair_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef LinkPair_obj OBJ_;
+		LinkPair_obj();
+
+	public:
+		enum { _hx_ClassId = 0x01531ffb };
+
+		void __construct(::Dynamic a,::Dynamic b);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.core._Callback.LinkPair")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.core._Callback.LinkPair"); }
+		static ::hx::ObjectPtr< LinkPair_obj > __new(::Dynamic a,::Dynamic b);
+		static ::hx::ObjectPtr< LinkPair_obj > __alloc(::hx::Ctx *_hx_ctx,::Dynamic a,::Dynamic b);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~LinkPair_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("LinkPair",54,61,94,d5); }
+
+		::Dynamic a;
+		::Dynamic b;
+		bool dissolved;
+		void cancel();
+		::Dynamic cancel_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace core
+} // end namespace _Callback
+
+#endif /* INCLUDED_tink_core__Callback_LinkPair */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/core/_Callback/ListCell.h b/Sources/c_snikket/iinclude/include/tink/core/_Callback/ListCell.h
new file mode 100644
index 0000000..1e66518
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/core/_Callback/ListCell.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core__Callback_ListCell
+#define INCLUDED_tink_core__Callback_ListCell
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_core_LinkObject
+#include <tink/core/LinkObject.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,CallbackList)
+HX_DECLARE_CLASS2(tink,core,Disposable)
+HX_DECLARE_CLASS2(tink,core,LinkObject)
+HX_DECLARE_CLASS2(tink,core,OwnedDisposable)
+HX_DECLARE_CLASS2(tink,core,SimpleDisposable)
+HX_DECLARE_CLASS3(tink,core,_Callback,ListCell)
+
+namespace tink{
+namespace core{
+namespace _Callback{
+
+
+class HXCPP_CLASS_ATTRIBUTES ListCell_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef ListCell_obj OBJ_;
+		ListCell_obj();
+
+	public:
+		enum { _hx_ClassId = 0x05a024cb };
+
+		void __construct( ::Dynamic cb, ::tink::core::CallbackList list);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.core._Callback.ListCell")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.core._Callback.ListCell"); }
+		static ::hx::ObjectPtr< ListCell_obj > __new( ::Dynamic cb, ::tink::core::CallbackList list);
+		static ::hx::ObjectPtr< ListCell_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic cb, ::tink::core::CallbackList list);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ListCell_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("ListCell",40,ad,63,fb); }
+
+		 ::Dynamic cb;
+		Dynamic cb_dyn() { return cb;}
+		 ::tink::core::CallbackList list;
+		void cancel();
+		::Dynamic cancel_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace core
+} // end namespace _Callback
+
+#endif /* INCLUDED_tink_core__Callback_ListCell */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/core/_Future/FutureObject.h b/Sources/c_snikket/iinclude/include/tink/core/_Future/FutureObject.h
new file mode 100644
index 0000000..7e4ed1a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/core/_Future/FutureObject.h
@@ -0,0 +1,61 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core__Future_FutureObject
+#define INCLUDED_tink_core__Future_FutureObject
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,FutureStatus)
+HX_DECLARE_CLASS2(tink,core,LinkObject)
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+
+namespace tink{
+namespace core{
+namespace _Future{
+
+
+class HXCPP_CLASS_ATTRIBUTES FutureObject_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef FutureObject_obj OBJ_;
+		FutureObject_obj();
+
+	public:
+		enum { _hx_ClassId = 0x75d0f9d3 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.core._Future.FutureObject")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.core._Future.FutureObject"); }
+		static ::hx::ObjectPtr< FutureObject_obj > __new();
+		static ::hx::ObjectPtr< FutureObject_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~FutureObject_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("FutureObject",82,eb,54,94); }
+
+		virtual  ::tink::core::FutureStatus getStatus();
+		::Dynamic getStatus_dyn();
+
+		virtual ::Dynamic handle( ::Dynamic callback);
+		::Dynamic handle_dyn();
+
+		virtual void eager();
+		::Dynamic eager_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace core
+} // end namespace _Future
+
+#endif /* INCLUDED_tink_core__Future_FutureObject */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/core/_Future/Future_Impl_.h b/Sources/c_snikket/iinclude/include/tink/core/_Future/Future_Impl_.h
new file mode 100644
index 0000000..94ba4b7
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/core/_Future/Future_Impl_.h
@@ -0,0 +1,79 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core__Future_Future_Impl_
+#define INCLUDED_tink_core__Future_Future_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS3(tink,core,_Future,Future_Impl_)
+
+namespace tink{
+namespace core{
+namespace _Future{
+
+
+class HXCPP_CLASS_ATTRIBUTES Future_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Future_Impl__obj OBJ_;
+		Future_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x78864394 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.core._Future.Future_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.core._Future.Future_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Future_Impl__obj > __new() {
+			::hx::ObjectPtr< Future_Impl__obj > __this = new Future_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Future_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Future_Impl__obj *__this = (Future_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Future_Impl__obj), false, "tink.core._Future.Future_Impl_"));
+			*(void **)__this = Future_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Future_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Future_Impl_",43,35,0a,97); }
+
+		static void __boot();
+		static  ::tink::core::_Future::FutureObject NEVER_INST;
+		static  ::tink::core::_Future::FutureObject never();
+		static ::Dynamic never_dyn();
+
+		static  ::tink::core::_Future::FutureObject map( ::tink::core::_Future::FutureObject this1, ::Dynamic f, ::Dynamic gather);
+		static ::Dynamic map_dyn();
+
+		static  ::tink::core::_Future::FutureObject flatMap( ::tink::core::_Future::FutureObject this1, ::Dynamic next, ::Dynamic gather);
+		static ::Dynamic flatMap_dyn();
+
+		static  ::tink::core::_Future::FutureObject async( ::Dynamic init, ::Dynamic lazy);
+		static ::Dynamic async_dyn();
+
+		static  ::tink::core::_Future::FutureObject irreversible( ::Dynamic init);
+		static ::Dynamic irreversible_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace core
+} // end namespace _Future
+
+#endif /* INCLUDED_tink_core__Future_Future_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/core/_Future/SuspendableFuture.h b/Sources/c_snikket/iinclude/include/tink/core/_Future/SuspendableFuture.h
new file mode 100644
index 0000000..358a37e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/core/_Future/SuspendableFuture.h
@@ -0,0 +1,81 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core__Future_SuspendableFuture
+#define INCLUDED_tink_core__Future_SuspendableFuture
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_core__Future_FutureObject
+#include <tink/core/_Future/FutureObject.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,CallbackList)
+HX_DECLARE_CLASS2(tink,core,Disposable)
+HX_DECLARE_CLASS2(tink,core,FutureStatus)
+HX_DECLARE_CLASS2(tink,core,LinkObject)
+HX_DECLARE_CLASS2(tink,core,OwnedDisposable)
+HX_DECLARE_CLASS2(tink,core,SimpleDisposable)
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS3(tink,core,_Future,SuspendableFuture)
+
+namespace tink{
+namespace core{
+namespace _Future{
+
+
+class HXCPP_CLASS_ATTRIBUTES SuspendableFuture_obj : public  ::tink::core::_Future::FutureObject_obj
+{
+	public:
+		typedef  ::tink::core::_Future::FutureObject_obj super;
+		typedef SuspendableFuture_obj OBJ_;
+		SuspendableFuture_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1fbfb7e8 };
+
+		void __construct( ::Dynamic wakeup);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.core._Future.SuspendableFuture")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.core._Future.SuspendableFuture"); }
+		static ::hx::ObjectPtr< SuspendableFuture_obj > __new( ::Dynamic wakeup);
+		static ::hx::ObjectPtr< SuspendableFuture_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic wakeup);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SuspendableFuture_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SuspendableFuture",d9,4b,c6,80); }
+
+		 ::tink::core::CallbackList callbacks;
+		 ::tink::core::FutureStatus status;
+		::Dynamic link;
+		 ::Dynamic wakeup;
+		Dynamic wakeup_dyn() { return wakeup;}
+		 ::tink::core::FutureStatus getStatus();
+
+		void trigger( ::Dynamic value);
+		::Dynamic trigger_dyn();
+
+		::Dynamic handle( ::Dynamic callback);
+
+		void arm();
+		::Dynamic arm_dyn();
+
+		void eager();
+
+};
+
+} // end namespace tink
+} // end namespace core
+} // end namespace _Future
+
+#endif /* INCLUDED_tink_core__Future_SuspendableFuture */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/core/_Future/SyncFuture.h b/Sources/c_snikket/iinclude/include/tink/core/_Future/SyncFuture.h
new file mode 100644
index 0000000..7c3b0d3
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/core/_Future/SyncFuture.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core__Future_SyncFuture
+#define INCLUDED_tink_core__Future_SyncFuture
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_core__Future_FutureObject
+#include <tink/core/_Future/FutureObject.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,FutureStatus)
+HX_DECLARE_CLASS2(tink,core,LinkObject)
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS3(tink,core,_Future,SyncFuture)
+HX_DECLARE_CLASS3(tink,core,_Lazy,Computable)
+HX_DECLARE_CLASS3(tink,core,_Lazy,LazyObject)
+
+namespace tink{
+namespace core{
+namespace _Future{
+
+
+class HXCPP_CLASS_ATTRIBUTES SyncFuture_obj : public  ::tink::core::_Future::FutureObject_obj
+{
+	public:
+		typedef  ::tink::core::_Future::FutureObject_obj super;
+		typedef SyncFuture_obj OBJ_;
+		SyncFuture_obj();
+
+	public:
+		enum { _hx_ClassId = 0x03763767 };
+
+		void __construct(::Dynamic value);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.core._Future.SyncFuture")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.core._Future.SyncFuture"); }
+		static ::hx::ObjectPtr< SyncFuture_obj > __new(::Dynamic value);
+		static ::hx::ObjectPtr< SyncFuture_obj > __alloc(::hx::Ctx *_hx_ctx,::Dynamic value);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SyncFuture_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SyncFuture",1e,81,9c,5c); }
+
+		::Dynamic value;
+		 ::tink::core::FutureStatus getStatus();
+
+		::Dynamic handle( ::Dynamic cb);
+
+		void eager();
+
+};
+
+} // end namespace tink
+} // end namespace core
+} // end namespace _Future
+
+#endif /* INCLUDED_tink_core__Future_SyncFuture */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/core/_Lazy/Computable.h b/Sources/c_snikket/iinclude/include/tink/core/_Lazy/Computable.h
new file mode 100644
index 0000000..7d87bba
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/core/_Lazy/Computable.h
@@ -0,0 +1,39 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core__Lazy_Computable
+#define INCLUDED_tink_core__Lazy_Computable
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Lazy,Computable)
+
+namespace tink{
+namespace core{
+namespace _Lazy{
+
+
+class HXCPP_CLASS_ATTRIBUTES Computable_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		bool (::hx::Object :: *_hx_isComputed)(); 
+		static inline bool isComputed( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::core::_Lazy::Computable_obj *>(_hx_.mPtr->_hx_getInterface(0xd2b592ea)))->_hx_isComputed)();
+		}
+		void (::hx::Object :: *_hx_compute)(); 
+		static inline void compute( ::Dynamic _hx_) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::tink::core::_Lazy::Computable_obj *>(_hx_.mPtr->_hx_getInterface(0xd2b592ea)))->_hx_compute)();
+		}
+		::Dynamic (::hx::Object :: *_hx_underlying)(); 
+		static inline ::Dynamic underlying( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::core::_Lazy::Computable_obj *>(_hx_.mPtr->_hx_getInterface(0xd2b592ea)))->_hx_underlying)();
+		}
+};
+
+} // end namespace tink
+} // end namespace core
+} // end namespace _Lazy
+
+#endif /* INCLUDED_tink_core__Lazy_Computable */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/core/_Lazy/LazyConst.h b/Sources/c_snikket/iinclude/include/tink/core/_Lazy/LazyConst.h
new file mode 100644
index 0000000..8313c7c
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/core/_Lazy/LazyConst.h
@@ -0,0 +1,73 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core__Lazy_LazyConst
+#define INCLUDED_tink_core__Lazy_LazyConst
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_core__Lazy_LazyObject
+#include <tink/core/_Lazy/LazyObject.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Lazy,Computable)
+HX_DECLARE_CLASS3(tink,core,_Lazy,LazyConst)
+HX_DECLARE_CLASS3(tink,core,_Lazy,LazyObject)
+
+namespace tink{
+namespace core{
+namespace _Lazy{
+
+
+class HXCPP_CLASS_ATTRIBUTES LazyConst_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef LazyConst_obj OBJ_;
+		LazyConst_obj();
+
+	public:
+		enum { _hx_ClassId = 0x43104c2d };
+
+		void __construct( ::Dynamic value);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.core._Lazy.LazyConst")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.core._Lazy.LazyConst"); }
+		static ::hx::ObjectPtr< LazyConst_obj > __new( ::Dynamic value);
+		static ::hx::ObjectPtr< LazyConst_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic value);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~LazyConst_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("LazyConst",2f,14,bd,5b); }
+
+		 ::Dynamic value;
+		bool isComputed();
+		::Dynamic isComputed_dyn();
+
+		 ::Dynamic get();
+		::Dynamic get_dyn();
+
+		void compute();
+		::Dynamic compute_dyn();
+
+		::Dynamic underlying();
+		::Dynamic underlying_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace core
+} // end namespace _Lazy
+
+#endif /* INCLUDED_tink_core__Lazy_LazyConst */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/core/_Lazy/LazyFunc.h b/Sources/c_snikket/iinclude/include/tink/core/_Lazy/LazyFunc.h
new file mode 100644
index 0000000..d20b1d8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/core/_Lazy/LazyFunc.h
@@ -0,0 +1,76 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core__Lazy_LazyFunc
+#define INCLUDED_tink_core__Lazy_LazyFunc
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_core__Lazy_LazyObject
+#include <tink/core/_Lazy/LazyObject.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Lazy,Computable)
+HX_DECLARE_CLASS3(tink,core,_Lazy,LazyFunc)
+HX_DECLARE_CLASS3(tink,core,_Lazy,LazyObject)
+
+namespace tink{
+namespace core{
+namespace _Lazy{
+
+
+class HXCPP_CLASS_ATTRIBUTES LazyFunc_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef LazyFunc_obj OBJ_;
+		LazyFunc_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1cb47fba };
+
+		void __construct( ::Dynamic f,::Dynamic from);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.core._Lazy.LazyFunc")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.core._Lazy.LazyFunc"); }
+		static ::hx::ObjectPtr< LazyFunc_obj > __new( ::Dynamic f,::Dynamic from);
+		static ::hx::ObjectPtr< LazyFunc_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic f,::Dynamic from);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~LazyFunc_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("LazyFunc",f8,2d,40,5e); }
+
+		 ::Dynamic f;
+		Dynamic f_dyn() { return f;}
+		::Dynamic from;
+		 ::Dynamic result;
+		::Dynamic underlying();
+		::Dynamic underlying_dyn();
+
+		bool isComputed();
+		::Dynamic isComputed_dyn();
+
+		 ::Dynamic get();
+		::Dynamic get_dyn();
+
+		void compute();
+		::Dynamic compute_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace core
+} // end namespace _Lazy
+
+#endif /* INCLUDED_tink_core__Lazy_LazyFunc */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/core/_Lazy/LazyObject.h b/Sources/c_snikket/iinclude/include/tink/core/_Lazy/LazyObject.h
new file mode 100644
index 0000000..b6ab109
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/core/_Lazy/LazyObject.h
@@ -0,0 +1,47 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core__Lazy_LazyObject
+#define INCLUDED_tink_core__Lazy_LazyObject
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_core__Lazy_Computable
+#include <tink/core/_Lazy/Computable.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Lazy,Computable)
+HX_DECLARE_CLASS3(tink,core,_Lazy,LazyObject)
+
+namespace tink{
+namespace core{
+namespace _Lazy{
+
+
+class HXCPP_CLASS_ATTRIBUTES LazyObject_obj {
+	public:
+		typedef  ::tink::core::_Lazy::Computable_obj super;
+		HX_DO_INTERFACE_RTTI;
+
+		bool (::hx::Object :: *_hx_isComputed)(); 
+		static inline bool isComputed( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::core::_Lazy::LazyObject_obj *>(_hx_.mPtr->_hx_getInterface(0xe1200775)))->_hx_isComputed)();
+		}
+		void (::hx::Object :: *_hx_compute)(); 
+		static inline void compute( ::Dynamic _hx_) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::tink::core::_Lazy::LazyObject_obj *>(_hx_.mPtr->_hx_getInterface(0xe1200775)))->_hx_compute)();
+		}
+		::Dynamic (::hx::Object :: *_hx_underlying)(); 
+		static inline ::Dynamic underlying( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::core::_Lazy::LazyObject_obj *>(_hx_.mPtr->_hx_getInterface(0xe1200775)))->_hx_underlying)();
+		}
+		 ::Dynamic (::hx::Object :: *_hx_get)(); 
+		static inline  ::Dynamic get( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::core::_Lazy::LazyObject_obj *>(_hx_.mPtr->_hx_getInterface(0xe1200775)))->_hx_get)();
+		}
+};
+
+} // end namespace tink
+} // end namespace core
+} // end namespace _Lazy
+
+#endif /* INCLUDED_tink_core__Lazy_LazyObject */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/core/_Lazy/Lazy_Impl_.h b/Sources/c_snikket/iinclude/include/tink/core/_Lazy/Lazy_Impl_.h
new file mode 100644
index 0000000..46a8e46
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/core/_Lazy/Lazy_Impl_.h
@@ -0,0 +1,66 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core__Lazy_Lazy_Impl_
+#define INCLUDED_tink_core__Lazy_Lazy_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Lazy,Computable)
+HX_DECLARE_CLASS3(tink,core,_Lazy,LazyObject)
+HX_DECLARE_CLASS3(tink,core,_Lazy,Lazy_Impl_)
+
+namespace tink{
+namespace core{
+namespace _Lazy{
+
+
+class HXCPP_CLASS_ATTRIBUTES Lazy_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Lazy_Impl__obj OBJ_;
+		Lazy_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x7f55432a };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.core._Lazy.Lazy_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.core._Lazy.Lazy_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Lazy_Impl__obj > __new() {
+			::hx::ObjectPtr< Lazy_Impl__obj > __this = new Lazy_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Lazy_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Lazy_Impl__obj *__this = (Lazy_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Lazy_Impl__obj), false, "tink.core._Lazy.Lazy_Impl_"));
+			*(void **)__this = Lazy_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Lazy_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Lazy_Impl_",34,20,cd,39); }
+
+		static  ::Dynamic get(::Dynamic this1);
+		static ::Dynamic get_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace core
+} // end namespace _Lazy
+
+#endif /* INCLUDED_tink_core__Lazy_Lazy_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/core/_Promise/Promise_Impl_.h b/Sources/c_snikket/iinclude/include/tink/core/_Promise/Promise_Impl_.h
new file mode 100644
index 0000000..74f71a0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/core/_Promise/Promise_Impl_.h
@@ -0,0 +1,65 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core__Promise_Promise_Impl_
+#define INCLUDED_tink_core__Promise_Promise_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS3(tink,core,_Promise,Promise_Impl_)
+
+namespace tink{
+namespace core{
+namespace _Promise{
+
+
+class HXCPP_CLASS_ATTRIBUTES Promise_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Promise_Impl__obj OBJ_;
+		Promise_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x03edc1ee };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.core._Promise.Promise_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.core._Promise.Promise_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Promise_Impl__obj > __new() {
+			::hx::ObjectPtr< Promise_Impl__obj > __this = new Promise_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Promise_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Promise_Impl__obj *__this = (Promise_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Promise_Impl__obj), false, "tink.core._Promise.Promise_Impl_"));
+			*(void **)__this = Promise_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Promise_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Promise_Impl_",5b,00,ba,be); }
+
+		static  ::tink::core::_Future::FutureObject next( ::tink::core::_Future::FutureObject this1, ::Dynamic f, ::Dynamic gather);
+		static ::Dynamic next_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace core
+} // end namespace _Promise
+
+#endif /* INCLUDED_tink_core__Promise_Promise_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/BodyPart.h b/Sources/c_snikket/iinclude/include/tink/http/BodyPart.h
new file mode 100644
index 0000000..29267c0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/BodyPart.h
@@ -0,0 +1,37 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_BodyPart
+#define INCLUDED_tink_http_BodyPart
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,http,BodyPart)
+namespace tink{
+namespace http{
+
+
+class BodyPart_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef BodyPart_obj OBJ_;
+
+	public:
+		BodyPart_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.http.BodyPart",ff,9c,21,13); }
+		::String __ToString() const { return HX_("BodyPart.",b9,9a,30,1f) + _hx_tag; }
+
+		static ::tink::http::BodyPart File( ::Dynamic handle);
+		static ::Dynamic File_dyn();
+		static ::tink::http::BodyPart Value(::String v);
+		static ::Dynamic Value_dyn();
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_BodyPart */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/ClientObject.h b/Sources/c_snikket/iinclude/include/tink/http/ClientObject.h
new file mode 100644
index 0000000..cfa81e2
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/ClientObject.h
@@ -0,0 +1,32 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_ClientObject
+#define INCLUDED_tink_http_ClientObject
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,http,ClientObject)
+HX_DECLARE_CLASS2(tink,http,Message)
+HX_DECLARE_CLASS2(tink,http,OutgoingRequest)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES ClientObject_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		 ::tink::core::_Future::FutureObject (::hx::Object :: *_hx_request)( ::tink::http::OutgoingRequest req); 
+		static inline  ::tink::core::_Future::FutureObject request( ::Dynamic _hx_, ::tink::http::OutgoingRequest req) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::http::ClientObject_obj *>(_hx_.mPtr->_hx_getInterface(0x9c46f484)))->_hx_request)(req);
+		}
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_ClientObject */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/ClientType.h b/Sources/c_snikket/iinclude/include/tink/http/ClientType.h
new file mode 100644
index 0000000..372ee0e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/ClientType.h
@@ -0,0 +1,46 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_ClientType
+#define INCLUDED_tink_http_ClientType
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,http,ClientObject)
+HX_DECLARE_CLASS2(tink,http,ClientType)
+HX_DECLARE_CLASS2(tink,http,Container)
+HX_DECLARE_CLASS3(tink,http,containers,LocalContainer)
+namespace tink{
+namespace http{
+
+
+class ClientType_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef ClientType_obj OBJ_;
+
+	public:
+		ClientType_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.http.ClientType",6f,ea,c8,55); }
+		::String __ToString() const { return HX_("ClientType.",c9,7d,23,dd) + _hx_tag; }
+
+		static ::tink::http::ClientType Curl;
+		static inline ::tink::http::ClientType Curl_dyn() { return Curl; }
+		static ::tink::http::ClientType Custom(::Dynamic v);
+		static ::Dynamic Custom_dyn();
+		static ::tink::http::ClientType Default;
+		static inline ::tink::http::ClientType Default_dyn() { return Default; }
+		static ::tink::http::ClientType Local( ::tink::http::containers::LocalContainer container);
+		static ::Dynamic Local_dyn();
+		static ::tink::http::ClientType StdLib;
+		static inline ::tink::http::ClientType StdLib_dyn() { return StdLib; }
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_ClientType */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/Container.h b/Sources/c_snikket/iinclude/include/tink/http/Container.h
new file mode 100644
index 0000000..e6373c2
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/Container.h
@@ -0,0 +1,25 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_Container
+#define INCLUDED_tink_http_Container
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,http,Container)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES Container_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_Container */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/Fetch.h b/Sources/c_snikket/iinclude/include/tink/http/Fetch.h
new file mode 100644
index 0000000..b965ff4
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/Fetch.h
@@ -0,0 +1,74 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_Fetch
+#define INCLUDED_tink_http_Fetch
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,BalancedTree)
+HX_DECLARE_CLASS2(haxe,ds,EnumValueMap)
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,http,ClientObject)
+HX_DECLARE_CLASS2(tink,http,ClientType)
+HX_DECLARE_CLASS2(tink,http,Fetch)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES Fetch_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Fetch_obj OBJ_;
+		Fetch_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7f806d70 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.http.Fetch")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.http.Fetch"); }
+
+		inline static ::hx::ObjectPtr< Fetch_obj > __new() {
+			::hx::ObjectPtr< Fetch_obj > __this = new Fetch_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Fetch_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Fetch_obj *__this = (Fetch_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Fetch_obj), false, "tink.http.Fetch"));
+			*(void **)__this = Fetch_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Fetch_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Fetch",1a,84,27,91); }
+
+		static void __boot();
+		static  ::haxe::ds::EnumValueMap cache;
+		static  ::tink::core::_Future::FutureObject fetch( ::Dynamic url, ::Dynamic options);
+		static ::Dynamic fetch_dyn();
+
+		static ::Dynamic getClient( ::tink::http::ClientType type);
+		static ::Dynamic getClient_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_Fetch */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/HandlerObject.h b/Sources/c_snikket/iinclude/include/tink/http/HandlerObject.h
new file mode 100644
index 0000000..37c2119
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/HandlerObject.h
@@ -0,0 +1,32 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_HandlerObject
+#define INCLUDED_tink_http_HandlerObject
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,http,HandlerObject)
+HX_DECLARE_CLASS2(tink,http,IncomingRequest)
+HX_DECLARE_CLASS2(tink,http,Message)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES HandlerObject_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		 ::tink::core::_Future::FutureObject (::hx::Object :: *_hx_process)( ::tink::http::IncomingRequest req); 
+		static inline  ::tink::core::_Future::FutureObject process( ::Dynamic _hx_, ::tink::http::IncomingRequest req) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::http::HandlerObject_obj *>(_hx_.mPtr->_hx_getInterface(0xee501fcf)))->_hx_process)(req);
+		}
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_HandlerObject */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/Header.h b/Sources/c_snikket/iinclude/include/tink/http/Header.h
new file mode 100644
index 0000000..8567553
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/Header.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_Header
+#define INCLUDED_tink_http_Header
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,NamedWith)
+HX_DECLARE_CLASS2(tink,core,Outcome)
+HX_DECLARE_CLASS2(tink,http,Header)
+HX_DECLARE_CLASS2(tink,http,HeaderField)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES Header_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Header_obj OBJ_;
+		Header_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4094a9e7 };
+
+		void __construct(::Array< ::Dynamic> fields);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.Header")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.Header"); }
+		static ::hx::ObjectPtr< Header_obj > __new(::Array< ::Dynamic> fields);
+		static ::hx::ObjectPtr< Header_obj > __alloc(::hx::Ctx *_hx_ctx,::Array< ::Dynamic> fields);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Header_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Header",ad,7d,94,31); }
+
+		::Array< ::Dynamic> fields;
+		::Array< ::String > get(::String name);
+		::Dynamic get_dyn();
+
+		 ::tink::core::Outcome byName(::String name);
+		::Dynamic byName_dyn();
+
+		 ::tink::core::Outcome getContentLength();
+		::Dynamic getContentLength_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_Header */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/HeaderField.h b/Sources/c_snikket/iinclude/include/tink/http/HeaderField.h
new file mode 100644
index 0000000..c12456f
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/HeaderField.h
@@ -0,0 +1,76 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_HeaderField
+#define INCLUDED_tink_http_HeaderField
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_core_NamedWith
+#include <tink/core/NamedWith.h>
+#endif
+HX_DECLARE_STACK_FRAME(_hx_pos_80f54cb31df217e8_249_new)
+HX_DECLARE_CLASS2(tink,core,NamedWith)
+HX_DECLARE_CLASS2(tink,http,HeaderField)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES HeaderField_obj : public  ::tink::core::NamedWith_obj
+{
+	public:
+		typedef  ::tink::core::NamedWith_obj super;
+		typedef HeaderField_obj OBJ_;
+		HeaderField_obj();
+
+	public:
+		enum { _hx_ClassId = 0x67181553 };
+
+		void __construct(::String name,::String value);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.HeaderField")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.HeaderField"); }
+
+		inline static ::hx::ObjectPtr< HeaderField_obj > __new(::String name,::String value) {
+			::hx::ObjectPtr< HeaderField_obj > __this = new HeaderField_obj();
+			__this->__construct(name,value);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< HeaderField_obj > __alloc(::hx::Ctx *_hx_ctx,::String name,::String value) {
+			HeaderField_obj *__this = (HeaderField_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(HeaderField_obj), true, "tink.http.HeaderField"));
+			*(void **)__this = HeaderField_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_80f54cb31df217e8_249_new)
+HXDLIN( 249)		__this->super::__construct(name,value);
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HeaderField_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HeaderField",cd,d3,84,f1); }
+
+		static  ::tink::http::HeaderField ofString(::String s);
+		static ::Dynamic ofString_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_HeaderField */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/HeaderParser.h b/Sources/c_snikket/iinclude/include/tink/http/HeaderParser.h
new file mode 100644
index 0000000..a493cba
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/HeaderParser.h
@@ -0,0 +1,73 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_HeaderParser
+#define INCLUDED_tink_http_HeaderParser
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_io_BytewiseParser
+#include <tink/io/BytewiseParser.h>
+#endif
+HX_DECLARE_CLASS0(StringBuf)
+HX_DECLARE_CLASS2(tink,core,NamedWith)
+HX_DECLARE_CLASS2(tink,core,Outcome)
+HX_DECLARE_CLASS2(tink,http,HeaderField)
+HX_DECLARE_CLASS2(tink,http,HeaderParser)
+HX_DECLARE_CLASS2(tink,io,BytewiseParser)
+HX_DECLARE_CLASS2(tink,io,ParseStep)
+HX_DECLARE_CLASS2(tink,io,StreamParserObject)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES HeaderParser_obj : public  ::tink::io::BytewiseParser_obj
+{
+	public:
+		typedef  ::tink::io::BytewiseParser_obj super;
+		typedef HeaderParser_obj OBJ_;
+		HeaderParser_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3af4a226 };
+
+		void __construct( ::Dynamic makeHeader);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.HeaderParser")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.HeaderParser"); }
+		static ::hx::ObjectPtr< HeaderParser_obj > __new( ::Dynamic makeHeader);
+		static ::hx::ObjectPtr< HeaderParser_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic makeHeader);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HeaderParser_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HeaderParser",6c,8e,ae,cf); }
+
+		 ::Dynamic header;
+		::Array< ::Dynamic> fields;
+		 ::StringBuf buf;
+		int last;
+		 ::Dynamic makeHeader;
+		Dynamic makeHeader_dyn() { return makeHeader;}
+		 ::tink::io::ParseStep read(int c);
+
+		 ::tink::io::ParseStep nextLine();
+		::Dynamic nextLine_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_HeaderParser */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/IncomingRequest.h b/Sources/c_snikket/iinclude/include/tink/http/IncomingRequest.h
new file mode 100644
index 0000000..3bdc78d
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/IncomingRequest.h
@@ -0,0 +1,61 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_IncomingRequest
+#define INCLUDED_tink_http_IncomingRequest
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_Message
+#include <tink/http/Message.h>
+#endif
+HX_DECLARE_CLASS2(tink,http,Header)
+HX_DECLARE_CLASS2(tink,http,IncomingRequest)
+HX_DECLARE_CLASS2(tink,http,IncomingRequestBody)
+HX_DECLARE_CLASS2(tink,http,IncomingRequestHeader)
+HX_DECLARE_CLASS2(tink,http,Message)
+HX_DECLARE_CLASS2(tink,http,RequestHeader)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES IncomingRequest_obj : public  ::tink::http::Message_obj
+{
+	public:
+		typedef  ::tink::http::Message_obj super;
+		typedef IncomingRequest_obj OBJ_;
+		IncomingRequest_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0386f7df };
+
+		void __construct(::String clientIp, ::tink::http::IncomingRequestHeader header, ::tink::http::IncomingRequestBody body);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.IncomingRequest")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.IncomingRequest"); }
+		static ::hx::ObjectPtr< IncomingRequest_obj > __new(::String clientIp, ::tink::http::IncomingRequestHeader header, ::tink::http::IncomingRequestBody body);
+		static ::hx::ObjectPtr< IncomingRequest_obj > __alloc(::hx::Ctx *_hx_ctx,::String clientIp, ::tink::http::IncomingRequestHeader header, ::tink::http::IncomingRequestBody body);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~IncomingRequest_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("IncomingRequest",e9,56,c7,13); }
+
+		::String clientIp;
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_IncomingRequest */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/IncomingRequestBody.h b/Sources/c_snikket/iinclude/include/tink/http/IncomingRequestBody.h
new file mode 100644
index 0000000..80b9e97
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/IncomingRequestBody.h
@@ -0,0 +1,39 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_IncomingRequestBody
+#define INCLUDED_tink_http_IncomingRequestBody
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,NamedWith)
+HX_DECLARE_CLASS2(tink,http,IncomingRequestBody)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+namespace tink{
+namespace http{
+
+
+class IncomingRequestBody_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef IncomingRequestBody_obj OBJ_;
+
+	public:
+		IncomingRequestBody_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.http.IncomingRequestBody",41,e5,fc,1f); }
+		::String __ToString() const { return HX_("IncomingRequestBody.",a3,3f,25,ff) + _hx_tag; }
+
+		static ::tink::http::IncomingRequestBody Parsed(::Array< ::Dynamic> parts);
+		static ::Dynamic Parsed_dyn();
+		static ::tink::http::IncomingRequestBody Plain(::Dynamic source);
+		static ::Dynamic Plain_dyn();
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_IncomingRequestBody */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/IncomingRequestHeader.h b/Sources/c_snikket/iinclude/include/tink/http/IncomingRequestHeader.h
new file mode 100644
index 0000000..8f6a9c0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/IncomingRequestHeader.h
@@ -0,0 +1,54 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_IncomingRequestHeader
+#define INCLUDED_tink_http_IncomingRequestHeader
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_RequestHeader
+#include <tink/http/RequestHeader.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,NamedWith)
+HX_DECLARE_CLASS2(tink,http,Header)
+HX_DECLARE_CLASS2(tink,http,HeaderField)
+HX_DECLARE_CLASS2(tink,http,IncomingRequestHeader)
+HX_DECLARE_CLASS2(tink,http,RequestHeader)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES IncomingRequestHeader_obj : public  ::tink::http::RequestHeader_obj
+{
+	public:
+		typedef  ::tink::http::RequestHeader_obj super;
+		typedef IncomingRequestHeader_obj OBJ_;
+		IncomingRequestHeader_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1c840e5c };
+
+		void __construct(::String method, ::Dynamic url,::String __o_protocol,::Array< ::Dynamic> fields);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.IncomingRequestHeader")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.IncomingRequestHeader"); }
+		static ::hx::ObjectPtr< IncomingRequestHeader_obj > __new(::String method, ::Dynamic url,::String __o_protocol,::Array< ::Dynamic> fields);
+		static ::hx::ObjectPtr< IncomingRequestHeader_obj > __alloc(::hx::Ctx *_hx_ctx,::String method, ::Dynamic url,::String __o_protocol,::Array< ::Dynamic> fields);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~IncomingRequestHeader_obj();
+
+		HX_DO_RTTI_ALL;
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("IncomingRequestHeader",56,69,89,e3); }
+
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_IncomingRequestHeader */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/IncomingResponse.h b/Sources/c_snikket/iinclude/include/tink/http/IncomingResponse.h
new file mode 100644
index 0000000..bf1e612
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/IncomingResponse.h
@@ -0,0 +1,54 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_IncomingResponse
+#define INCLUDED_tink_http_IncomingResponse
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_Message
+#include <tink/http/Message.h>
+#endif
+HX_DECLARE_CLASS2(tink,http,Header)
+HX_DECLARE_CLASS2(tink,http,IncomingResponse)
+HX_DECLARE_CLASS2(tink,http,Message)
+HX_DECLARE_CLASS2(tink,http,ResponseHeaderBase)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES IncomingResponse_obj : public  ::tink::http::Message_obj
+{
+	public:
+		typedef  ::tink::http::Message_obj super;
+		typedef IncomingResponse_obj OBJ_;
+		IncomingResponse_obj();
+
+	public:
+		enum { _hx_ClassId = 0x68c65661 };
+
+		void __construct( ::tink::http::ResponseHeaderBase header,::Dynamic body);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.IncomingResponse")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.IncomingResponse"); }
+		static ::hx::ObjectPtr< IncomingResponse_obj > __new( ::tink::http::ResponseHeaderBase header,::Dynamic body);
+		static ::hx::ObjectPtr< IncomingResponse_obj > __alloc(::hx::Ctx *_hx_ctx, ::tink::http::ResponseHeaderBase header,::Dynamic body);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~IncomingResponse_obj();
+
+		HX_DO_RTTI_ALL;
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("IncomingResponse",a7,dd,f2,2c); }
+
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_IncomingResponse */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/Message.h b/Sources/c_snikket/iinclude/include/tink/http/Message.h
new file mode 100644
index 0000000..df01137
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/Message.h
@@ -0,0 +1,72 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_Message
+#define INCLUDED_tink_http_Message
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_bcbf082f6c47a594_8_new)
+HX_DECLARE_CLASS2(tink,http,Message)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES Message_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Message_obj OBJ_;
+		Message_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7888e42d };
+
+		void __construct( ::Dynamic header, ::Dynamic body);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.Message")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.Message"); }
+
+		inline static ::hx::ObjectPtr< Message_obj > __new( ::Dynamic header, ::Dynamic body) {
+			::hx::ObjectPtr< Message_obj > __this = new Message_obj();
+			__this->__construct(header,body);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Message_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic header, ::Dynamic body) {
+			Message_obj *__this = (Message_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Message_obj), true, "tink.http.Message"));
+			*(void **)__this = Message_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_bcbf082f6c47a594_8_new)
+HXLINE(   9)		( ( ::tink::http::Message)(__this) )->header = header;
+HXLINE(  10)		( ( ::tink::http::Message)(__this) )->body = body;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Message_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Message",a7,5d,62,67); }
+
+		 ::Dynamic header;
+		 ::Dynamic body;
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_Message */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/OutgoingRequest.h b/Sources/c_snikket/iinclude/include/tink/http/OutgoingRequest.h
new file mode 100644
index 0000000..cbe4430
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/OutgoingRequest.h
@@ -0,0 +1,55 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_OutgoingRequest
+#define INCLUDED_tink_http_OutgoingRequest
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_Message
+#include <tink/http/Message.h>
+#endif
+HX_DECLARE_CLASS2(tink,http,Header)
+HX_DECLARE_CLASS2(tink,http,Message)
+HX_DECLARE_CLASS2(tink,http,OutgoingRequest)
+HX_DECLARE_CLASS2(tink,http,OutgoingRequestHeader)
+HX_DECLARE_CLASS2(tink,http,RequestHeader)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES OutgoingRequest_obj : public  ::tink::http::Message_obj
+{
+	public:
+		typedef  ::tink::http::Message_obj super;
+		typedef OutgoingRequest_obj OBJ_;
+		OutgoingRequest_obj();
+
+	public:
+		enum { _hx_ClassId = 0x08bf21c5 };
+
+		void __construct( ::tink::http::OutgoingRequestHeader header,::Dynamic body);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.OutgoingRequest")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.OutgoingRequest"); }
+		static ::hx::ObjectPtr< OutgoingRequest_obj > __new( ::tink::http::OutgoingRequestHeader header,::Dynamic body);
+		static ::hx::ObjectPtr< OutgoingRequest_obj > __alloc(::hx::Ctx *_hx_ctx, ::tink::http::OutgoingRequestHeader header,::Dynamic body);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~OutgoingRequest_obj();
+
+		HX_DO_RTTI_ALL;
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("OutgoingRequest",23,1c,f4,79); }
+
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_OutgoingRequest */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/OutgoingRequestHeader.h b/Sources/c_snikket/iinclude/include/tink/http/OutgoingRequestHeader.h
new file mode 100644
index 0000000..89bb40c
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/OutgoingRequestHeader.h
@@ -0,0 +1,63 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_OutgoingRequestHeader
+#define INCLUDED_tink_http_OutgoingRequestHeader
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_RequestHeader
+#include <tink/http/RequestHeader.h>
+#endif
+HX_DECLARE_CLASS2(haxe,ds,Option)
+HX_DECLARE_CLASS2(tink,core,NamedWith)
+HX_DECLARE_CLASS2(tink,http,Header)
+HX_DECLARE_CLASS2(tink,http,HeaderField)
+HX_DECLARE_CLASS2(tink,http,OutgoingRequestHeader)
+HX_DECLARE_CLASS2(tink,http,RequestHeader)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES OutgoingRequestHeader_obj : public  ::tink::http::RequestHeader_obj
+{
+	public:
+		typedef  ::tink::http::RequestHeader_obj super;
+		typedef OutgoingRequestHeader_obj OBJ_;
+		OutgoingRequestHeader_obj();
+
+	public:
+		enum { _hx_ClassId = 0x17e6c132 };
+
+		void __construct(::String method, ::Dynamic url,::String __o_protocol,::Array< ::Dynamic> fields);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.OutgoingRequestHeader")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.OutgoingRequestHeader"); }
+		static ::hx::ObjectPtr< OutgoingRequestHeader_obj > __new(::String method, ::Dynamic url,::String __o_protocol,::Array< ::Dynamic> fields);
+		static ::hx::ObjectPtr< OutgoingRequestHeader_obj > __alloc(::hx::Ctx *_hx_ctx,::String method, ::Dynamic url,::String __o_protocol,::Array< ::Dynamic> fields);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~OutgoingRequestHeader_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("OutgoingRequestHeader",10,d6,f4,a2); }
+
+		static  ::haxe::ds::Option extractAuth( ::Dynamic url);
+		static ::Dynamic extractAuth_dyn();
+
+		 ::tink::http::OutgoingRequestHeader concat(::Array< ::Dynamic> fields);
+		::Dynamic concat_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_OutgoingRequestHeader */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/RequestHeader.h b/Sources/c_snikket/iinclude/include/tink/http/RequestHeader.h
new file mode 100644
index 0000000..465e640
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/RequestHeader.h
@@ -0,0 +1,63 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_RequestHeader
+#define INCLUDED_tink_http_RequestHeader
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_Header
+#include <tink/http/Header.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,NamedWith)
+HX_DECLARE_CLASS2(tink,http,Header)
+HX_DECLARE_CLASS2(tink,http,HeaderField)
+HX_DECLARE_CLASS2(tink,http,RequestHeader)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES RequestHeader_obj : public  ::tink::http::Header_obj
+{
+	public:
+		typedef  ::tink::http::Header_obj super;
+		typedef RequestHeader_obj OBJ_;
+		RequestHeader_obj();
+
+	public:
+		enum { _hx_ClassId = 0x72a5c122 };
+
+		void __construct(::String method, ::Dynamic url,::String __o_protocol,::Array< ::Dynamic> fields);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.RequestHeader")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.RequestHeader"); }
+		static ::hx::ObjectPtr< RequestHeader_obj > __new(::String method, ::Dynamic url,::String __o_protocol,::Array< ::Dynamic> fields);
+		static ::hx::ObjectPtr< RequestHeader_obj > __alloc(::hx::Ctx *_hx_ctx,::String method, ::Dynamic url,::String __o_protocol,::Array< ::Dynamic> fields);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~RequestHeader_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("RequestHeader",1c,92,9a,00); }
+
+		::String method;
+		 ::Dynamic url;
+		::String protocol;
+		virtual ::String toString();
+
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_RequestHeader */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/ResponseHeaderBase.h b/Sources/c_snikket/iinclude/include/tink/http/ResponseHeaderBase.h
new file mode 100644
index 0000000..e02ec11
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/ResponseHeaderBase.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_ResponseHeaderBase
+#define INCLUDED_tink_http_ResponseHeaderBase
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_Header
+#include <tink/http/Header.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,NamedWith)
+HX_DECLARE_CLASS2(tink,http,Header)
+HX_DECLARE_CLASS2(tink,http,HeaderField)
+HX_DECLARE_CLASS2(tink,http,ResponseHeaderBase)
+HX_DECLARE_CLASS2(tink,io,StreamParserObject)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES ResponseHeaderBase_obj : public  ::tink::http::Header_obj
+{
+	public:
+		typedef  ::tink::http::Header_obj super;
+		typedef ResponseHeaderBase_obj OBJ_;
+		ResponseHeaderBase_obj();
+
+	public:
+		enum { _hx_ClassId = 0x68228641 };
+
+		void __construct(int statusCode,::String reason,::Array< ::Dynamic> fields,::String __o_protocol);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.ResponseHeaderBase")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.ResponseHeaderBase"); }
+		static ::hx::ObjectPtr< ResponseHeaderBase_obj > __new(int statusCode,::String reason,::Array< ::Dynamic> fields,::String __o_protocol);
+		static ::hx::ObjectPtr< ResponseHeaderBase_obj > __alloc(::hx::Ctx *_hx_ctx,int statusCode,::String reason,::Array< ::Dynamic> fields,::String __o_protocol);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ResponseHeaderBase_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ResponseHeaderBase",3f,ca,db,63); }
+
+		static ::Dynamic parser();
+		static ::Dynamic parser_dyn();
+
+		int statusCode;
+		::String reason;
+		::String protocol;
+		virtual ::String toString();
+
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_ResponseHeaderBase */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/_Client/CustomClient.h b/Sources/c_snikket/iinclude/include/tink/http/_Client/CustomClient.h
new file mode 100644
index 0000000..75eff5b
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/_Client/CustomClient.h
@@ -0,0 +1,79 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http__Client_CustomClient
+#define INCLUDED_tink_http__Client_CustomClient
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_ClientObject
+#include <tink/http/ClientObject.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,http,ClientObject)
+HX_DECLARE_CLASS2(tink,http,IncomingResponse)
+HX_DECLARE_CLASS2(tink,http,Message)
+HX_DECLARE_CLASS2(tink,http,OutgoingRequest)
+HX_DECLARE_CLASS3(tink,http,_Client,CustomClient)
+
+namespace tink{
+namespace http{
+namespace _Client{
+
+
+class HXCPP_CLASS_ATTRIBUTES CustomClient_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef CustomClient_obj OBJ_;
+		CustomClient_obj();
+
+	public:
+		enum { _hx_ClassId = 0x16257e84 };
+
+		void __construct(::Array< ::Dynamic> preprocessors,::Array< ::Dynamic> postprocessors,::Dynamic real);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http._Client.CustomClient")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http._Client.CustomClient"); }
+		static ::hx::ObjectPtr< CustomClient_obj > __new(::Array< ::Dynamic> preprocessors,::Array< ::Dynamic> postprocessors,::Dynamic real);
+		static ::hx::ObjectPtr< CustomClient_obj > __alloc(::hx::Ctx *_hx_ctx,::Array< ::Dynamic> preprocessors,::Array< ::Dynamic> postprocessors,::Dynamic real);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~CustomClient_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("CustomClient",fc,6c,ff,d1); }
+
+		static ::cpp::VirtualArray concat(::cpp::VirtualArray a,::cpp::VirtualArray b);
+		static ::Dynamic concat_dyn();
+
+		static  ::tink::http::_Client::CustomClient create(::Dynamic c,::Array< ::Dynamic> preprocessors,::Array< ::Dynamic> postprocessors);
+		static ::Dynamic create_dyn();
+
+		::Array< ::Dynamic> preprocessors;
+		::Array< ::Dynamic> postprocessors;
+		::Dynamic real;
+		 ::tink::core::_Future::FutureObject pipe( ::Dynamic value,::Array< ::Dynamic> transforms, ::Dynamic index);
+		::Dynamic pipe_dyn();
+
+		 ::tink::core::_Future::FutureObject request( ::tink::http::OutgoingRequest req);
+		::Dynamic request_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace http
+} // end namespace _Client
+
+#endif /* INCLUDED_tink_http__Client_CustomClient */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/_Fetch/FetchResponse_Impl_.h b/Sources/c_snikket/iinclude/include/tink/http/_Fetch/FetchResponse_Impl_.h
new file mode 100644
index 0000000..0227082
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/_Fetch/FetchResponse_Impl_.h
@@ -0,0 +1,65 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http__Fetch_FetchResponse_Impl_
+#define INCLUDED_tink_http__Fetch_FetchResponse_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS3(tink,http,_Fetch,FetchResponse_Impl_)
+
+namespace tink{
+namespace http{
+namespace _Fetch{
+
+
+class HXCPP_CLASS_ATTRIBUTES FetchResponse_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef FetchResponse_Impl__obj OBJ_;
+		FetchResponse_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x706f0b26 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.http._Fetch.FetchResponse_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.http._Fetch.FetchResponse_Impl_"); }
+
+		inline static ::hx::ObjectPtr< FetchResponse_Impl__obj > __new() {
+			::hx::ObjectPtr< FetchResponse_Impl__obj > __this = new FetchResponse_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< FetchResponse_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			FetchResponse_Impl__obj *__this = (FetchResponse_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(FetchResponse_Impl__obj), false, "tink.http._Fetch.FetchResponse_Impl_"));
+			*(void **)__this = FetchResponse_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~FetchResponse_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("FetchResponse_Impl_",9b,93,47,bc); }
+
+		static  ::tink::core::_Future::FutureObject all( ::tink::core::_Future::FutureObject this1);
+		static ::Dynamic all_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace http
+} // end namespace _Fetch
+
+#endif /* INCLUDED_tink_http__Fetch_FetchResponse_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/_Header/HeaderValue_Impl_.h b/Sources/c_snikket/iinclude/include/tink/http/_Header/HeaderValue_Impl_.h
new file mode 100644
index 0000000..a0fbe32
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/_Header/HeaderValue_Impl_.h
@@ -0,0 +1,67 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http__Header_HeaderValue_Impl_
+#define INCLUDED_tink_http__Header_HeaderValue_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,http,_Header,HeaderValue_Impl_)
+
+namespace tink{
+namespace http{
+namespace _Header{
+
+
+class HXCPP_CLASS_ATTRIBUTES HeaderValue_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef HeaderValue_Impl__obj OBJ_;
+		HeaderValue_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x58df80d2 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.http._Header.HeaderValue_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.http._Header.HeaderValue_Impl_"); }
+
+		inline static ::hx::ObjectPtr< HeaderValue_Impl__obj > __new() {
+			::hx::ObjectPtr< HeaderValue_Impl__obj > __this = new HeaderValue_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< HeaderValue_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			HeaderValue_Impl__obj *__this = (HeaderValue_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(HeaderValue_Impl__obj), false, "tink.http._Header.HeaderValue_Impl_"));
+			*(void **)__this = HeaderValue_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HeaderValue_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HeaderValue_Impl_",24,b6,26,b3); }
+
+		static ::String basicAuth(::String username,::String password);
+		static ::Dynamic basicAuth_dyn();
+
+		static ::String ofInt(int i);
+		static ::Dynamic ofInt_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace http
+} // end namespace _Header
+
+#endif /* INCLUDED_tink_http__Header_HeaderValue_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/_Response/OutgoingResponseData.h b/Sources/c_snikket/iinclude/include/tink/http/_Response/OutgoingResponseData.h
new file mode 100644
index 0000000..7279c3c
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/_Response/OutgoingResponseData.h
@@ -0,0 +1,56 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http__Response_OutgoingResponseData
+#define INCLUDED_tink_http__Response_OutgoingResponseData
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_Message
+#include <tink/http/Message.h>
+#endif
+HX_DECLARE_CLASS2(tink,http,Header)
+HX_DECLARE_CLASS2(tink,http,Message)
+HX_DECLARE_CLASS2(tink,http,ResponseHeaderBase)
+HX_DECLARE_CLASS3(tink,http,_Response,OutgoingResponseData)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace http{
+namespace _Response{
+
+
+class HXCPP_CLASS_ATTRIBUTES OutgoingResponseData_obj : public  ::tink::http::Message_obj
+{
+	public:
+		typedef  ::tink::http::Message_obj super;
+		typedef OutgoingResponseData_obj OBJ_;
+		OutgoingResponseData_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0dfa253d };
+
+		void __construct( ::tink::http::ResponseHeaderBase header,::Dynamic body);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http._Response.OutgoingResponseData")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http._Response.OutgoingResponseData"); }
+		static ::hx::ObjectPtr< OutgoingResponseData_obj > __new( ::tink::http::ResponseHeaderBase header,::Dynamic body);
+		static ::hx::ObjectPtr< OutgoingResponseData_obj > __alloc(::hx::Ctx *_hx_ctx, ::tink::http::ResponseHeaderBase header,::Dynamic body);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~OutgoingResponseData_obj();
+
+		HX_DO_RTTI_ALL;
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("OutgoingResponseData",f7,c7,68,aa); }
+
+};
+
+} // end namespace tink
+} // end namespace http
+} // end namespace _Response
+
+#endif /* INCLUDED_tink_http__Response_OutgoingResponseData */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/clients/CurlClient.h b/Sources/c_snikket/iinclude/include/tink/http/clients/CurlClient.h
new file mode 100644
index 0000000..f926bf5
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/clients/CurlClient.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_clients_CurlClient
+#define INCLUDED_tink_http_clients_CurlClient
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_ClientObject
+#include <tink/http/ClientObject.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,http,ClientObject)
+HX_DECLARE_CLASS2(tink,http,Message)
+HX_DECLARE_CLASS2(tink,http,OutgoingRequest)
+HX_DECLARE_CLASS3(tink,http,clients,CurlClient)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace http{
+namespace clients{
+
+
+class HXCPP_CLASS_ATTRIBUTES CurlClient_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef CurlClient_obj OBJ_;
+		CurlClient_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1ef1a485 };
+
+		void __construct( ::Dynamic curl);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.clients.CurlClient")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.clients.CurlClient"); }
+		static ::hx::ObjectPtr< CurlClient_obj > __new( ::Dynamic curl);
+		static ::hx::ObjectPtr< CurlClient_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic curl);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		static void __alloc_dynamic_functions(::hx::Ctx *_hx_alloc,CurlClient_obj *_hx_obj);
+		//~CurlClient_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("CurlClient",77,86,3b,fe); }
+
+		 ::tink::core::_Future::FutureObject request( ::tink::http::OutgoingRequest req);
+		::Dynamic request_dyn();
+
+		::Dynamic curl;
+		inline ::Dynamic &curl_dyn() {return curl; }
+
+};
+
+} // end namespace tink
+} // end namespace http
+} // end namespace clients
+
+#endif /* INCLUDED_tink_http_clients_CurlClient */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/clients/Helpers.h b/Sources/c_snikket/iinclude/include/tink/http/clients/Helpers.h
new file mode 100644
index 0000000..ce58cd0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/clients/Helpers.h
@@ -0,0 +1,65 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_clients_Helpers
+#define INCLUDED_tink_http_clients_Helpers
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,ds,Option)
+HX_DECLARE_CLASS3(tink,http,clients,Helpers)
+
+namespace tink{
+namespace http{
+namespace clients{
+
+
+class HXCPP_CLASS_ATTRIBUTES Helpers_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Helpers_obj OBJ_;
+		Helpers_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1dfdf71f };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.http.clients.Helpers")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.http.clients.Helpers"); }
+
+		inline static ::hx::ObjectPtr< Helpers_obj > __new() {
+			::hx::ObjectPtr< Helpers_obj > __this = new Helpers_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Helpers_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Helpers_obj *__this = (Helpers_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Helpers_obj), false, "tink.http.clients.Helpers"));
+			*(void **)__this = Helpers_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Helpers_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Helpers",25,6b,b0,8d); }
+
+		static  ::haxe::ds::Option checkScheme(::String s);
+		static ::Dynamic checkScheme_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace http
+} // end namespace clients
+
+#endif /* INCLUDED_tink_http_clients_Helpers */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/clients/LocalContainerClient.h b/Sources/c_snikket/iinclude/include/tink/http/clients/LocalContainerClient.h
new file mode 100644
index 0000000..6e1785e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/clients/LocalContainerClient.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_clients_LocalContainerClient
+#define INCLUDED_tink_http_clients_LocalContainerClient
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_ClientObject
+#include <tink/http/ClientObject.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,http,ClientObject)
+HX_DECLARE_CLASS2(tink,http,Container)
+HX_DECLARE_CLASS2(tink,http,Message)
+HX_DECLARE_CLASS2(tink,http,OutgoingRequest)
+HX_DECLARE_CLASS3(tink,http,clients,LocalContainerClient)
+HX_DECLARE_CLASS3(tink,http,containers,LocalContainer)
+
+namespace tink{
+namespace http{
+namespace clients{
+
+
+class HXCPP_CLASS_ATTRIBUTES LocalContainerClient_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef LocalContainerClient_obj OBJ_;
+		LocalContainerClient_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4c48d30b };
+
+		void __construct( ::tink::http::containers::LocalContainer container);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.clients.LocalContainerClient")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.clients.LocalContainerClient"); }
+		static ::hx::ObjectPtr< LocalContainerClient_obj > __new( ::tink::http::containers::LocalContainer container);
+		static ::hx::ObjectPtr< LocalContainerClient_obj > __alloc(::hx::Ctx *_hx_ctx, ::tink::http::containers::LocalContainer container);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~LocalContainerClient_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("LocalContainerClient",61,95,42,2f); }
+
+		 ::tink::http::containers::LocalContainer container;
+		 ::tink::core::_Future::FutureObject request( ::tink::http::OutgoingRequest req);
+		::Dynamic request_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace http
+} // end namespace clients
+
+#endif /* INCLUDED_tink_http_clients_LocalContainerClient */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/clients/SocketClient.h b/Sources/c_snikket/iinclude/include/tink/http/clients/SocketClient.h
new file mode 100644
index 0000000..71e2c7f
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/clients/SocketClient.h
@@ -0,0 +1,67 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_clients_SocketClient
+#define INCLUDED_tink_http_clients_SocketClient
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_ClientObject
+#include <tink/http/ClientObject.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,http,ClientObject)
+HX_DECLARE_CLASS2(tink,http,Message)
+HX_DECLARE_CLASS2(tink,http,OutgoingRequest)
+HX_DECLARE_CLASS3(tink,http,clients,SocketClient)
+HX_DECLARE_CLASS2(tink,io,WorkerObject)
+
+namespace tink{
+namespace http{
+namespace clients{
+
+
+class HXCPP_CLASS_ATTRIBUTES SocketClient_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef SocketClient_obj OBJ_;
+		SocketClient_obj();
+
+	public:
+		enum { _hx_ClassId = 0x29ac2844 };
+
+		void __construct(::Dynamic worker);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.clients.SocketClient")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.clients.SocketClient"); }
+		static ::hx::ObjectPtr< SocketClient_obj > __new(::Dynamic worker);
+		static ::hx::ObjectPtr< SocketClient_obj > __alloc(::hx::Ctx *_hx_ctx,::Dynamic worker);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SocketClient_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("SocketClient",7e,5e,b9,60); }
+
+		::Dynamic worker;
+		 ::tink::core::_Future::FutureObject request( ::tink::http::OutgoingRequest req);
+		::Dynamic request_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace http
+} // end namespace clients
+
+#endif /* INCLUDED_tink_http_clients_SocketClient */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/clients/StdClient.h b/Sources/c_snikket/iinclude/include/tink/http/clients/StdClient.h
new file mode 100644
index 0000000..bc59cd0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/clients/StdClient.h
@@ -0,0 +1,67 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_clients_StdClient
+#define INCLUDED_tink_http_clients_StdClient
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_ClientObject
+#include <tink/http/ClientObject.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,http,ClientObject)
+HX_DECLARE_CLASS2(tink,http,Message)
+HX_DECLARE_CLASS2(tink,http,OutgoingRequest)
+HX_DECLARE_CLASS3(tink,http,clients,StdClient)
+HX_DECLARE_CLASS2(tink,io,WorkerObject)
+
+namespace tink{
+namespace http{
+namespace clients{
+
+
+class HXCPP_CLASS_ATTRIBUTES StdClient_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef StdClient_obj OBJ_;
+		StdClient_obj();
+
+	public:
+		enum { _hx_ClassId = 0x6b1f5144 };
+
+		void __construct(::Dynamic worker);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.clients.StdClient")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.clients.StdClient"); }
+		static ::hx::ObjectPtr< StdClient_obj > __new(::Dynamic worker);
+		static ::hx::ObjectPtr< StdClient_obj > __alloc(::hx::Ctx *_hx_ctx,::Dynamic worker);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~StdClient_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("StdClient",2e,63,67,cc); }
+
+		::Dynamic worker;
+		 ::tink::core::_Future::FutureObject request( ::tink::http::OutgoingRequest req);
+		::Dynamic request_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace http
+} // end namespace clients
+
+#endif /* INCLUDED_tink_http_clients_StdClient */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/http/containers/LocalContainer.h b/Sources/c_snikket/iinclude/include/tink/http/containers/LocalContainer.h
new file mode 100644
index 0000000..09cbd34
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/http/containers/LocalContainer.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_containers_LocalContainer
+#define INCLUDED_tink_http_containers_LocalContainer
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_Container
+#include <tink/http/Container.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,http,Container)
+HX_DECLARE_CLASS2(tink,http,HandlerObject)
+HX_DECLARE_CLASS2(tink,http,IncomingRequest)
+HX_DECLARE_CLASS2(tink,http,Message)
+HX_DECLARE_CLASS3(tink,http,containers,LocalContainer)
+
+namespace tink{
+namespace http{
+namespace containers{
+
+
+class HXCPP_CLASS_ATTRIBUTES LocalContainer_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef LocalContainer_obj OBJ_;
+		LocalContainer_obj();
+
+	public:
+		enum { _hx_ClassId = 0x315b134a };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.containers.LocalContainer")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.containers.LocalContainer"); }
+		static ::hx::ObjectPtr< LocalContainer_obj > __new();
+		static ::hx::ObjectPtr< LocalContainer_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~LocalContainer_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("LocalContainer",76,1a,ea,cb); }
+
+		::Dynamic handler;
+		bool running;
+		 ::tink::core::_Future::FutureObject serve( ::tink::http::IncomingRequest req);
+		::Dynamic serve_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace http
+} // end namespace containers
+
+#endif /* INCLUDED_tink_http_containers_LocalContainer */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/io/BytewiseParser.h b/Sources/c_snikket/iinclude/include/tink/io/BytewiseParser.h
new file mode 100644
index 0000000..487c7a1
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/io/BytewiseParser.h
@@ -0,0 +1,76 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io_BytewiseParser
+#define INCLUDED_tink_io_BytewiseParser
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_io_StreamParserObject
+#include <tink/io/StreamParserObject.h>
+#endif
+HX_DECLARE_CLASS2(tink,chunk,ChunkCursor)
+HX_DECLARE_CLASS2(tink,core,Outcome)
+HX_DECLARE_CLASS2(tink,io,BytewiseParser)
+HX_DECLARE_CLASS2(tink,io,ParseStep)
+HX_DECLARE_CLASS2(tink,io,StreamParserObject)
+
+namespace tink{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES BytewiseParser_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef BytewiseParser_obj OBJ_;
+		BytewiseParser_obj();
+
+	public:
+		enum { _hx_ClassId = 0x66915863 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.io.BytewiseParser")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.io.BytewiseParser"); }
+
+		inline static ::hx::ObjectPtr< BytewiseParser_obj > __new() {
+			::hx::ObjectPtr< BytewiseParser_obj > __this = new BytewiseParser_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< BytewiseParser_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			BytewiseParser_obj *__this = (BytewiseParser_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(BytewiseParser_obj), false, "tink.io.BytewiseParser"));
+			*(void **)__this = BytewiseParser_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~BytewiseParser_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("BytewiseParser",4b,c6,88,ee); }
+
+		virtual  ::tink::io::ParseStep read(int _hx_char);
+		::Dynamic read_dyn();
+
+		 ::tink::io::ParseStep progress( ::tink::chunk::ChunkCursor cursor);
+		::Dynamic progress_dyn();
+
+		 ::tink::core::Outcome eof( ::tink::chunk::ChunkCursor rest);
+		::Dynamic eof_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace io
+
+#endif /* INCLUDED_tink_io_BytewiseParser */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/io/IdealSourceTools.h b/Sources/c_snikket/iinclude/include/tink/io/IdealSourceTools.h
new file mode 100644
index 0000000..c7d617b
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/io/IdealSourceTools.h
@@ -0,0 +1,64 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io_IdealSourceTools
+#define INCLUDED_tink_io_IdealSourceTools
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,io,IdealSourceTools)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES IdealSourceTools_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef IdealSourceTools_obj OBJ_;
+		IdealSourceTools_obj();
+
+	public:
+		enum { _hx_ClassId = 0x186409e3 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.io.IdealSourceTools")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.io.IdealSourceTools"); }
+
+		inline static ::hx::ObjectPtr< IdealSourceTools_obj > __new() {
+			::hx::ObjectPtr< IdealSourceTools_obj > __this = new IdealSourceTools_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< IdealSourceTools_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			IdealSourceTools_obj *__this = (IdealSourceTools_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(IdealSourceTools_obj), false, "tink.io.IdealSourceTools"));
+			*(void **)__this = IdealSourceTools_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~IdealSourceTools_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("IdealSourceTools",cb,c1,80,1f); }
+
+		static  ::tink::core::_Future::FutureObject all(::Dynamic s);
+		static ::Dynamic all_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace io
+
+#endif /* INCLUDED_tink_io_IdealSourceTools */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/io/ParseResult.h b/Sources/c_snikket/iinclude/include/tink/io/ParseResult.h
new file mode 100644
index 0000000..49ac084
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/io/ParseResult.h
@@ -0,0 +1,41 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io_ParseResult
+#define INCLUDED_tink_io_ParseResult
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS2(tink,io,ParseResult)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+namespace tink{
+namespace io{
+
+
+class ParseResult_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef ParseResult_obj OBJ_;
+
+	public:
+		ParseResult_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.io.ParseResult",c4,44,ed,6f); }
+		::String __ToString() const { return HX_("ParseResult.",de,f8,43,8d) + _hx_tag; }
+
+		static ::tink::io::ParseResult Broke( ::tink::core::TypedError e);
+		static ::Dynamic Broke_dyn();
+		static ::tink::io::ParseResult Invalid( ::tink::core::TypedError e,::Dynamic rest);
+		static ::Dynamic Invalid_dyn();
+		static ::tink::io::ParseResult Parsed( ::Dynamic data,::Dynamic rest);
+		static ::Dynamic Parsed_dyn();
+};
+
+} // end namespace tink
+} // end namespace io
+
+#endif /* INCLUDED_tink_io_ParseResult */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/io/ParseStep.h b/Sources/c_snikket/iinclude/include/tink/io/ParseStep.h
new file mode 100644
index 0000000..05a3784
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/io/ParseStep.h
@@ -0,0 +1,40 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io_ParseStep
+#define INCLUDED_tink_io_ParseStep
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS2(tink,io,ParseStep)
+namespace tink{
+namespace io{
+
+
+class ParseStep_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef ParseStep_obj OBJ_;
+
+	public:
+		ParseStep_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.io.ParseStep",73,2b,8e,cf); }
+		::String __ToString() const { return HX_("ParseStep.",4f,c6,a0,a4) + _hx_tag; }
+
+		static ::tink::io::ParseStep Done( ::Dynamic r);
+		static ::Dynamic Done_dyn();
+		static ::tink::io::ParseStep Failed( ::tink::core::TypedError e);
+		static ::Dynamic Failed_dyn();
+		static ::tink::io::ParseStep Progressed;
+		static inline ::tink::io::ParseStep Progressed_dyn() { return Progressed; }
+};
+
+} // end namespace tink
+} // end namespace io
+
+#endif /* INCLUDED_tink_io_ParseStep */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/io/PipeResult.h b/Sources/c_snikket/iinclude/include/tink/io/PipeResult.h
new file mode 100644
index 0000000..167b3e7
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/io/PipeResult.h
@@ -0,0 +1,43 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io_PipeResult
+#define INCLUDED_tink_io_PipeResult
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS2(tink,io,PipeResult)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+namespace tink{
+namespace io{
+
+
+class PipeResult_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef PipeResult_obj OBJ_;
+
+	public:
+		PipeResult_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.io.PipeResult",d7,3e,a3,6f); }
+		::String __ToString() const { return HX_("PipeResult.",03,26,3a,37) + _hx_tag; }
+
+		static ::tink::io::PipeResult AllWritten;
+		static inline ::tink::io::PipeResult AllWritten_dyn() { return AllWritten; }
+		static ::tink::io::PipeResult SinkEnded( ::Dynamic result,::Dynamic rest);
+		static ::Dynamic SinkEnded_dyn();
+		static ::tink::io::PipeResult SinkFailed( ::tink::core::TypedError e,::Dynamic rest);
+		static ::Dynamic SinkFailed_dyn();
+		static ::tink::io::PipeResult SourceFailed( ::tink::core::TypedError e);
+		static ::Dynamic SourceFailed_dyn();
+};
+
+} // end namespace tink
+} // end namespace io
+
+#endif /* INCLUDED_tink_io_PipeResult */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/io/PipeResultTools.h b/Sources/c_snikket/iinclude/include/tink/io/PipeResultTools.h
new file mode 100644
index 0000000..de6e225
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/io/PipeResultTools.h
@@ -0,0 +1,65 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io_PipeResultTools
+#define INCLUDED_tink_io_PipeResultTools
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,chunk,ChunkObject)
+HX_DECLARE_CLASS2(tink,io,PipeResult)
+HX_DECLARE_CLASS2(tink,io,PipeResultTools)
+HX_DECLARE_CLASS2(tink,streams,Conclusion)
+
+namespace tink{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES PipeResultTools_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef PipeResultTools_obj OBJ_;
+		PipeResultTools_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0add7938 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.io.PipeResultTools")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.io.PipeResultTools"); }
+
+		inline static ::hx::ObjectPtr< PipeResultTools_obj > __new() {
+			::hx::ObjectPtr< PipeResultTools_obj > __this = new PipeResultTools_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< PipeResultTools_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			PipeResultTools_obj *__this = (PipeResultTools_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(PipeResultTools_obj), false, "tink.io.PipeResultTools"));
+			*(void **)__this = PipeResultTools_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~PipeResultTools_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("PipeResultTools",50,36,66,7b); }
+
+		static  ::tink::io::PipeResult toResult( ::tink::streams::Conclusion c, ::Dynamic result,::Dynamic buffered);
+		static ::Dynamic toResult_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace io
+
+#endif /* INCLUDED_tink_io_PipeResultTools */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/io/RealSourceTools.h b/Sources/c_snikket/iinclude/include/tink/io/RealSourceTools.h
new file mode 100644
index 0000000..40852fc
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/io/RealSourceTools.h
@@ -0,0 +1,72 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io_RealSourceTools
+#define INCLUDED_tink_io_RealSourceTools
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,io,RealSourceTools)
+HX_DECLARE_CLASS2(tink,io,StreamParserObject)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES RealSourceTools_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef RealSourceTools_obj OBJ_;
+		RealSourceTools_obj();
+
+	public:
+		enum { _hx_ClassId = 0x688b0f4a };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.io.RealSourceTools")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.io.RealSourceTools"); }
+
+		inline static ::hx::ObjectPtr< RealSourceTools_obj > __new() {
+			::hx::ObjectPtr< RealSourceTools_obj > __this = new RealSourceTools_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< RealSourceTools_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			RealSourceTools_obj *__this = (RealSourceTools_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(RealSourceTools_obj), false, "tink.io.RealSourceTools"));
+			*(void **)__this = RealSourceTools_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~RealSourceTools_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("RealSourceTools",62,cc,13,d9); }
+
+		static  ::tink::core::_Future::FutureObject all(::Dynamic s);
+		static ::Dynamic all_dyn();
+
+		static  ::tink::core::_Future::FutureObject parse(::Dynamic s,::Dynamic p);
+		static ::Dynamic parse_dyn();
+
+		static ::Dynamic idealize(::Dynamic s, ::Dynamic rescue);
+		static ::Dynamic idealize_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace io
+
+#endif /* INCLUDED_tink_io_RealSourceTools */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/io/SinkBase.h b/Sources/c_snikket/iinclude/include/tink/io/SinkBase.h
new file mode 100644
index 0000000..30475bb
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/io/SinkBase.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io_SinkBase
+#define INCLUDED_tink_io_SinkBase
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_io_SinkObject
+#include <tink/io/SinkObject.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,io,SinkBase)
+HX_DECLARE_CLASS2(tink,io,SinkObject)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES SinkBase_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef SinkBase_obj OBJ_;
+		SinkBase_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1efa06a0 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.io.SinkBase")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.io.SinkBase"); }
+
+		inline static ::hx::ObjectPtr< SinkBase_obj > __new() {
+			::hx::ObjectPtr< SinkBase_obj > __this = new SinkBase_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< SinkBase_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			SinkBase_obj *__this = (SinkBase_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(SinkBase_obj), false, "tink.io.SinkBase"));
+			*(void **)__this = SinkBase_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SinkBase_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("SinkBase",24,8c,b4,5c); }
+
+		virtual  ::tink::core::_Future::FutureObject consume(::Dynamic source, ::Dynamic options);
+		::Dynamic consume_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace io
+
+#endif /* INCLUDED_tink_io_SinkBase */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/io/SinkObject.h b/Sources/c_snikket/iinclude/include/tink/io/SinkObject.h
new file mode 100644
index 0000000..bf9b6e3
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/io/SinkObject.h
@@ -0,0 +1,31 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io_SinkObject
+#define INCLUDED_tink_io_SinkObject
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,io,SinkObject)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES SinkObject_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		 ::tink::core::_Future::FutureObject (::hx::Object :: *_hx_consume)(::Dynamic source, ::Dynamic options); 
+		static inline  ::tink::core::_Future::FutureObject consume( ::Dynamic _hx_,::Dynamic source, ::Dynamic options) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::io::SinkObject_obj *>(_hx_.mPtr->_hx_getInterface(0x483020ea)))->_hx_consume)(source,options);
+		}
+};
+
+} // end namespace tink
+} // end namespace io
+
+#endif /* INCLUDED_tink_io_SinkObject */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/io/StreamParserObject.h b/Sources/c_snikket/iinclude/include/tink/io/StreamParserObject.h
new file mode 100644
index 0000000..290d16b
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/io/StreamParserObject.h
@@ -0,0 +1,36 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io_StreamParserObject
+#define INCLUDED_tink_io_StreamParserObject
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,chunk,ChunkCursor)
+HX_DECLARE_CLASS2(tink,core,Outcome)
+HX_DECLARE_CLASS2(tink,io,ParseStep)
+HX_DECLARE_CLASS2(tink,io,StreamParserObject)
+
+namespace tink{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES StreamParserObject_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		 ::tink::io::ParseStep (::hx::Object :: *_hx_progress)( ::tink::chunk::ChunkCursor cursor); 
+		static inline  ::tink::io::ParseStep progress( ::Dynamic _hx_, ::tink::chunk::ChunkCursor cursor) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::io::StreamParserObject_obj *>(_hx_.mPtr->_hx_getInterface(0x048ef116)))->_hx_progress)(cursor);
+		}
+		 ::tink::core::Outcome (::hx::Object :: *_hx_eof)( ::tink::chunk::ChunkCursor rest); 
+		static inline  ::tink::core::Outcome eof( ::Dynamic _hx_, ::tink::chunk::ChunkCursor rest) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::io::StreamParserObject_obj *>(_hx_.mPtr->_hx_getInterface(0x048ef116)))->_hx_eof)(rest);
+		}
+};
+
+} // end namespace tink
+} // end namespace io
+
+#endif /* INCLUDED_tink_io_StreamParserObject */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/io/WorkerObject.h b/Sources/c_snikket/iinclude/include/tink/io/WorkerObject.h
new file mode 100644
index 0000000..152ff58
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/io/WorkerObject.h
@@ -0,0 +1,32 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io_WorkerObject
+#define INCLUDED_tink_io_WorkerObject
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS3(tink,core,_Lazy,Computable)
+HX_DECLARE_CLASS3(tink,core,_Lazy,LazyObject)
+HX_DECLARE_CLASS2(tink,io,WorkerObject)
+
+namespace tink{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES WorkerObject_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		 ::tink::core::_Future::FutureObject (::hx::Object :: *_hx_work)(::Dynamic task); 
+		static inline  ::tink::core::_Future::FutureObject work( ::Dynamic _hx_,::Dynamic task) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::io::WorkerObject_obj *>(_hx_.mPtr->_hx_getInterface(0xdcf3fb55)))->_hx_work)(task);
+		}
+};
+
+} // end namespace tink
+} // end namespace io
+
+#endif /* INCLUDED_tink_io_WorkerObject */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/io/_Sink/SinkYielding_Impl_.h b/Sources/c_snikket/iinclude/include/tink/io/_Sink/SinkYielding_Impl_.h
new file mode 100644
index 0000000..2e51a31
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/io/_Sink/SinkYielding_Impl_.h
@@ -0,0 +1,66 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io__Sink_SinkYielding_Impl_
+#define INCLUDED_tink_io__Sink_SinkYielding_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Output)
+HX_DECLARE_CLASS2(tink,io,SinkObject)
+HX_DECLARE_CLASS3(tink,io,_Sink,SinkYielding_Impl_)
+
+namespace tink{
+namespace io{
+namespace _Sink{
+
+
+class HXCPP_CLASS_ATTRIBUTES SinkYielding_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef SinkYielding_Impl__obj OBJ_;
+		SinkYielding_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x1dd8821a };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.io._Sink.SinkYielding_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.io._Sink.SinkYielding_Impl_"); }
+
+		inline static ::hx::ObjectPtr< SinkYielding_Impl__obj > __new() {
+			::hx::ObjectPtr< SinkYielding_Impl__obj > __this = new SinkYielding_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< SinkYielding_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			SinkYielding_Impl__obj *__this = (SinkYielding_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(SinkYielding_Impl__obj), false, "tink.io._Sink.SinkYielding_Impl_"));
+			*(void **)__this = SinkYielding_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SinkYielding_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SinkYielding_Impl_",e8,ec,49,5e); }
+
+		static ::Dynamic ofOutput(::String name, ::haxe::io::Output target, ::Dynamic options);
+		static ::Dynamic ofOutput_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace io
+} // end namespace _Sink
+
+#endif /* INCLUDED_tink_io__Sink_SinkYielding_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/io/_Source/Source_Impl_.h b/Sources/c_snikket/iinclude/include/tink/io/_Source/Source_Impl_.h
new file mode 100644
index 0000000..d119491
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/io/_Source/Source_Impl_.h
@@ -0,0 +1,82 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io__Source_Source_Impl_
+#define INCLUDED_tink_io__Source_Source_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,io,SinkObject)
+HX_DECLARE_CLASS3(tink,io,_Source,Source_Impl_)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace io{
+namespace _Source{
+
+
+class HXCPP_CLASS_ATTRIBUTES Source_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Source_Impl__obj OBJ_;
+		Source_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x52c5539d };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.io._Source.Source_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.io._Source.Source_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Source_Impl__obj > __new() {
+			::hx::ObjectPtr< Source_Impl__obj > __this = new Source_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Source_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Source_Impl__obj *__this = (Source_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Source_Impl__obj), false, "tink.io._Source.Source_Impl_"));
+			*(void **)__this = Source_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Source_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Source_Impl_",db,cf,0d,d6); }
+
+		static void __boot();
+		static ::Dynamic EMPTY;
+		static ::Dynamic chunked(::Dynamic this1);
+		static ::Dynamic chunked_dyn();
+
+		static  ::tink::core::_Future::FutureObject concatAll(::Dynamic s);
+		static ::Dynamic concatAll_dyn();
+
+		static  ::tink::core::_Future::FutureObject pipeTo(::Dynamic this1,::Dynamic target, ::Dynamic options);
+		static ::Dynamic pipeTo_dyn();
+
+		static ::Dynamic limit(::Dynamic this1,int len);
+		static ::Dynamic limit_dyn();
+
+		static ::Dynamic ofError( ::tink::core::TypedError e);
+		static ::Dynamic ofError_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace io
+} // end namespace _Source
+
+#endif /* INCLUDED_tink_io__Source_Source_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/io/_StreamParser/StreamParser_Impl_.h b/Sources/c_snikket/iinclude/include/tink/io/_StreamParser/StreamParser_Impl_.h
new file mode 100644
index 0000000..357b028
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/io/_StreamParser/StreamParser_Impl_.h
@@ -0,0 +1,70 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io__StreamParser_StreamParser_Impl_
+#define INCLUDED_tink_io__StreamParser_StreamParser_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,io,StreamParserObject)
+HX_DECLARE_CLASS3(tink,io,_StreamParser,StreamParser_Impl_)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace io{
+namespace _StreamParser{
+
+
+class HXCPP_CLASS_ATTRIBUTES StreamParser_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef StreamParser_Impl__obj OBJ_;
+		StreamParser_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x18cfe7c1 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.io._StreamParser.StreamParser_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.io._StreamParser.StreamParser_Impl_"); }
+
+		inline static ::hx::ObjectPtr< StreamParser_Impl__obj > __new() {
+			::hx::ObjectPtr< StreamParser_Impl__obj > __this = new StreamParser_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< StreamParser_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			StreamParser_Impl__obj *__this = (StreamParser_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(StreamParser_Impl__obj), false, "tink.io._StreamParser.StreamParser_Impl_"));
+			*(void **)__this = StreamParser_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~StreamParser_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("StreamParser_Impl_",7f,8f,ef,63); }
+
+		static  ::tink::core::_Future::FutureObject doParse(::Dynamic source,::Dynamic p, ::Dynamic consume, ::Dynamic finish);
+		static ::Dynamic doParse_dyn();
+
+		static  ::tink::core::_Future::FutureObject parse(::Dynamic s,::Dynamic p);
+		static ::Dynamic parse_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace io
+} // end namespace _StreamParser
+
+#endif /* INCLUDED_tink_io__StreamParser_StreamParser_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/io/_Worker/EagerWorker.h b/Sources/c_snikket/iinclude/include/tink/io/_Worker/EagerWorker.h
new file mode 100644
index 0000000..0529ae7
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/io/_Worker/EagerWorker.h
@@ -0,0 +1,61 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io__Worker_EagerWorker
+#define INCLUDED_tink_io__Worker_EagerWorker
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_io_WorkerObject
+#include <tink/io/WorkerObject.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS3(tink,core,_Lazy,Computable)
+HX_DECLARE_CLASS3(tink,core,_Lazy,LazyObject)
+HX_DECLARE_CLASS2(tink,io,WorkerObject)
+HX_DECLARE_CLASS3(tink,io,_Worker,EagerWorker)
+
+namespace tink{
+namespace io{
+namespace _Worker{
+
+
+class HXCPP_CLASS_ATTRIBUTES EagerWorker_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef EagerWorker_obj OBJ_;
+		EagerWorker_obj();
+
+	public:
+		enum { _hx_ClassId = 0x49fe0131 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.io._Worker.EagerWorker")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.io._Worker.EagerWorker"); }
+		static ::hx::ObjectPtr< EagerWorker_obj > __new();
+		static ::hx::ObjectPtr< EagerWorker_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~EagerWorker_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("EagerWorker",36,20,f4,8a); }
+
+		 ::tink::core::_Future::FutureObject work(::Dynamic task);
+		::Dynamic work_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace io
+} // end namespace _Worker
+
+#endif /* INCLUDED_tink_io__Worker_EagerWorker */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/io/_Worker/Worker_Impl_.h b/Sources/c_snikket/iinclude/include/tink/io/_Worker/Worker_Impl_.h
new file mode 100644
index 0000000..76182c0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/io/_Worker/Worker_Impl_.h
@@ -0,0 +1,77 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io__Worker_Worker_Impl_
+#define INCLUDED_tink_io__Worker_Worker_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS3(tink,core,_Lazy,Computable)
+HX_DECLARE_CLASS3(tink,core,_Lazy,LazyObject)
+HX_DECLARE_CLASS2(tink,io,WorkerObject)
+HX_DECLARE_CLASS3(tink,io,_Worker,Worker_Impl_)
+
+namespace tink{
+namespace io{
+namespace _Worker{
+
+
+class HXCPP_CLASS_ATTRIBUTES Worker_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Worker_Impl__obj OBJ_;
+		Worker_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x132db49b };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.io._Worker.Worker_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.io._Worker.Worker_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Worker_Impl__obj > __new() {
+			::hx::ObjectPtr< Worker_Impl__obj > __this = new Worker_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Worker_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Worker_Impl__obj *__this = (Worker_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Worker_Impl__obj), false, "tink.io._Worker.Worker_Impl_"));
+			*(void **)__this = Worker_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Worker_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Worker_Impl_",be,2b,8e,66); }
+
+		static void __boot();
+		static ::Dynamic EAGER;
+		static ::Array< ::Dynamic> pool;
+		static ::Dynamic ensure(::Dynamic this1);
+		static ::Dynamic ensure_dyn();
+
+		static ::Dynamic get();
+		static ::Dynamic get_dyn();
+
+		static  ::tink::core::_Future::FutureObject work(::Dynamic this1,::Dynamic task);
+		static ::Dynamic work_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace io
+} // end namespace _Worker
+
+#endif /* INCLUDED_tink_io__Worker_Worker_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/io/std/InputSource.h b/Sources/c_snikket/iinclude/include/tink/io/std/InputSource.h
new file mode 100644
index 0000000..0a66a9d
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/io/std/InputSource.h
@@ -0,0 +1,58 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io_std_InputSource
+#define INCLUDED_tink_io_std_InputSource
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_streams_Generator
+#include <tink/streams/Generator.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Input)
+HX_DECLARE_CLASS2(tink,io,WorkerObject)
+HX_DECLARE_CLASS3(tink,io,std,InputSource)
+HX_DECLARE_CLASS2(tink,streams,Generator)
+HX_DECLARE_CLASS2(tink,streams,StreamBase)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace io{
+namespace std{
+
+
+class HXCPP_CLASS_ATTRIBUTES InputSource_obj : public  ::tink::streams::Generator_obj
+{
+	public:
+		typedef  ::tink::streams::Generator_obj super;
+		typedef InputSource_obj OBJ_;
+		InputSource_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0f2d2d9e };
+
+		void __construct(::String name, ::haxe::io::Input target,::Dynamic worker, ::haxe::io::Bytes buf,int offset);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.io.std.InputSource")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.io.std.InputSource"); }
+		static ::hx::ObjectPtr< InputSource_obj > __new(::String name, ::haxe::io::Input target,::Dynamic worker, ::haxe::io::Bytes buf,int offset);
+		static ::hx::ObjectPtr< InputSource_obj > __alloc(::hx::Ctx *_hx_ctx,::String name, ::haxe::io::Input target,::Dynamic worker, ::haxe::io::Bytes buf,int offset);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~InputSource_obj();
+
+		HX_DO_RTTI_ALL;
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("InputSource",65,24,98,0b); }
+
+};
+
+} // end namespace tink
+} // end namespace io
+} // end namespace std
+
+#endif /* INCLUDED_tink_io_std_InputSource */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/io/std/OutputSink.h b/Sources/c_snikket/iinclude/include/tink/io/std/OutputSink.h
new file mode 100644
index 0000000..56470b3
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/io/std/OutputSink.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io_std_OutputSink
+#define INCLUDED_tink_io_std_OutputSink
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_io_SinkBase
+#include <tink/io/SinkBase.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Output)
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,io,SinkBase)
+HX_DECLARE_CLASS2(tink,io,SinkObject)
+HX_DECLARE_CLASS2(tink,io,WorkerObject)
+HX_DECLARE_CLASS3(tink,io,std,OutputSink)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace io{
+namespace std{
+
+
+class HXCPP_CLASS_ATTRIBUTES OutputSink_obj : public  ::tink::io::SinkBase_obj
+{
+	public:
+		typedef  ::tink::io::SinkBase_obj super;
+		typedef OutputSink_obj OBJ_;
+		OutputSink_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1eacaafb };
+
+		void __construct(::String name, ::haxe::io::Output target,::Dynamic worker);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.io.std.OutputSink")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.io.std.OutputSink"); }
+		static ::hx::ObjectPtr< OutputSink_obj > __new(::String name, ::haxe::io::Output target,::Dynamic worker);
+		static ::hx::ObjectPtr< OutputSink_obj > __alloc(::hx::Ctx *_hx_ctx,::String name, ::haxe::io::Output target,::Dynamic worker);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~OutputSink_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("OutputSink",14,ea,f8,a4); }
+
+		::String name;
+		 ::haxe::io::Output target;
+		::Dynamic worker;
+		 ::tink::core::_Future::FutureObject consume(::Dynamic source, ::Dynamic options);
+
+};
+
+} // end namespace tink
+} // end namespace io
+} // end namespace std
+
+#endif /* INCLUDED_tink_io_std_OutputSink */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/streams/Conclusion.h b/Sources/c_snikket/iinclude/include/tink/streams/Conclusion.h
new file mode 100644
index 0000000..94b9893
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/streams/Conclusion.h
@@ -0,0 +1,43 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_Conclusion
+#define INCLUDED_tink_streams_Conclusion
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS2(tink,streams,Conclusion)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+namespace tink{
+namespace streams{
+
+
+class Conclusion_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef Conclusion_obj OBJ_;
+
+	public:
+		Conclusion_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.streams.Conclusion",96,99,43,ae); }
+		::String __ToString() const { return HX_("Conclusion.",4f,54,5d,ac) + _hx_tag; }
+
+		static ::tink::streams::Conclusion Clogged( ::tink::core::TypedError error,::Dynamic at);
+		static ::Dynamic Clogged_dyn();
+		static ::tink::streams::Conclusion Depleted;
+		static inline ::tink::streams::Conclusion Depleted_dyn() { return Depleted; }
+		static ::tink::streams::Conclusion Failed( ::tink::core::TypedError error);
+		static ::Dynamic Failed_dyn();
+		static ::tink::streams::Conclusion Halted(::Dynamic rest);
+		static ::Dynamic Halted_dyn();
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_Conclusion */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/streams/Empty.h b/Sources/c_snikket/iinclude/include/tink/streams/Empty.h
new file mode 100644
index 0000000..c56d215
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/streams/Empty.h
@@ -0,0 +1,65 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_Empty
+#define INCLUDED_tink_streams_Empty
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_streams_StreamBase
+#include <tink/streams/StreamBase.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,streams,Empty)
+HX_DECLARE_CLASS2(tink,streams,StreamBase)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace streams{
+
+
+class HXCPP_CLASS_ATTRIBUTES Empty_obj : public  ::tink::streams::StreamBase_obj
+{
+	public:
+		typedef  ::tink::streams::StreamBase_obj super;
+		typedef Empty_obj OBJ_;
+		Empty_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0b521554 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.streams.Empty")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.streams.Empty"); }
+		static ::hx::ObjectPtr< Empty_obj > __new();
+		static ::hx::ObjectPtr< Empty_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Empty_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Empty",6d,aa,07,03); }
+
+		static void __boot();
+		static  ::tink::streams::Empty inst;
+		static ::Dynamic make();
+		static ::Dynamic make_dyn();
+
+		bool get_depleted();
+
+		 ::tink::core::_Future::FutureObject forEach( ::Dynamic handler);
+
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_Empty */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/streams/FutureStream.h b/Sources/c_snikket/iinclude/include/tink/streams/FutureStream.h
new file mode 100644
index 0000000..6e2ba9d
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/streams/FutureStream.h
@@ -0,0 +1,61 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_FutureStream
+#define INCLUDED_tink_streams_FutureStream
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_streams_StreamBase
+#include <tink/streams/StreamBase.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,streams,FutureStream)
+HX_DECLARE_CLASS2(tink,streams,StreamBase)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace streams{
+
+
+class HXCPP_CLASS_ATTRIBUTES FutureStream_obj : public  ::tink::streams::StreamBase_obj
+{
+	public:
+		typedef  ::tink::streams::StreamBase_obj super;
+		typedef FutureStream_obj OBJ_;
+		FutureStream_obj();
+
+	public:
+		enum { _hx_ClassId = 0x04fe513c };
+
+		void __construct( ::tink::core::_Future::FutureObject f);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.streams.FutureStream")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.streams.FutureStream"); }
+		static ::hx::ObjectPtr< FutureStream_obj > __new( ::tink::core::_Future::FutureObject f);
+		static ::hx::ObjectPtr< FutureStream_obj > __alloc(::hx::Ctx *_hx_ctx, ::tink::core::_Future::FutureObject f);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~FutureStream_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("FutureStream",43,81,42,90); }
+
+		 ::tink::core::_Future::FutureObject f;
+		 ::tink::core::_Future::FutureObject forEach( ::Dynamic handler);
+
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_FutureStream */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/streams/Generator.h b/Sources/c_snikket/iinclude/include/tink/streams/Generator.h
new file mode 100644
index 0000000..62a0082
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/streams/Generator.h
@@ -0,0 +1,61 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_Generator
+#define INCLUDED_tink_streams_Generator
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_streams_StreamBase
+#include <tink/streams/StreamBase.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,streams,Generator)
+HX_DECLARE_CLASS2(tink,streams,StreamBase)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace streams{
+
+
+class HXCPP_CLASS_ATTRIBUTES Generator_obj : public  ::tink::streams::StreamBase_obj
+{
+	public:
+		typedef  ::tink::streams::StreamBase_obj super;
+		typedef Generator_obj OBJ_;
+		Generator_obj();
+
+	public:
+		enum { _hx_ClassId = 0x50a767d2 };
+
+		void __construct( ::tink::core::_Future::FutureObject upcoming);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.streams.Generator")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.streams.Generator"); }
+		static ::hx::ObjectPtr< Generator_obj > __new( ::tink::core::_Future::FutureObject upcoming);
+		static ::hx::ObjectPtr< Generator_obj > __alloc(::hx::Ctx *_hx_ctx, ::tink::core::_Future::FutureObject upcoming);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Generator_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Generator",33,d8,43,36); }
+
+		 ::tink::core::_Future::FutureObject upcoming;
+		 ::tink::core::_Future::FutureObject forEach( ::Dynamic handler);
+
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_Generator */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/streams/Handled.h b/Sources/c_snikket/iinclude/include/tink/streams/Handled.h
new file mode 100644
index 0000000..f35f350
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/streams/Handled.h
@@ -0,0 +1,42 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_Handled
+#define INCLUDED_tink_streams_Handled
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS2(tink,streams,Handled)
+namespace tink{
+namespace streams{
+
+
+class Handled_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef Handled_obj OBJ_;
+
+	public:
+		Handled_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.streams.Handled",a5,94,ee,d9); }
+		::String __ToString() const { return HX_("Handled.",12,d1,d5,ae) + _hx_tag; }
+
+		static ::tink::streams::Handled BackOff;
+		static inline ::tink::streams::Handled BackOff_dyn() { return BackOff; }
+		static ::tink::streams::Handled Clog( ::tink::core::TypedError e);
+		static ::Dynamic Clog_dyn();
+		static ::tink::streams::Handled Finish;
+		static inline ::tink::streams::Handled Finish_dyn() { return Finish; }
+		static ::tink::streams::Handled Resume;
+		static inline ::tink::streams::Handled Resume_dyn() { return Resume; }
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_Handled */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/streams/IdealStreamBase.h b/Sources/c_snikket/iinclude/include/tink/streams/IdealStreamBase.h
new file mode 100644
index 0000000..6d2b2da
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/streams/IdealStreamBase.h
@@ -0,0 +1,56 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_IdealStreamBase
+#define INCLUDED_tink_streams_IdealStreamBase
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_streams_StreamBase
+#include <tink/streams/StreamBase.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS2(tink,streams,IdealStreamBase)
+HX_DECLARE_CLASS2(tink,streams,StreamBase)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace streams{
+
+
+class HXCPP_CLASS_ATTRIBUTES IdealStreamBase_obj : public  ::tink::streams::StreamBase_obj
+{
+	public:
+		typedef  ::tink::streams::StreamBase_obj super;
+		typedef IdealStreamBase_obj OBJ_;
+		IdealStreamBase_obj();
+
+	public:
+		enum { _hx_ClassId = 0x79ca79c9 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.streams.IdealStreamBase")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.streams.IdealStreamBase"); }
+		static ::hx::ObjectPtr< IdealStreamBase_obj > __new();
+		static ::hx::ObjectPtr< IdealStreamBase_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~IdealStreamBase_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("IdealStreamBase",86,d8,f0,d8); }
+
+		::Dynamic idealize( ::Dynamic _tmp_rescue);
+
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_IdealStreamBase */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/streams/IdealizeStream.h b/Sources/c_snikket/iinclude/include/tink/streams/IdealizeStream.h
new file mode 100644
index 0000000..ef12b38
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/streams/IdealizeStream.h
@@ -0,0 +1,67 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_IdealizeStream
+#define INCLUDED_tink_streams_IdealizeStream
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_streams_IdealStreamBase
+#include <tink/streams/IdealStreamBase.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,streams,IdealStreamBase)
+HX_DECLARE_CLASS2(tink,streams,IdealizeStream)
+HX_DECLARE_CLASS2(tink,streams,StreamBase)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace streams{
+
+
+class HXCPP_CLASS_ATTRIBUTES IdealizeStream_obj : public  ::tink::streams::IdealStreamBase_obj
+{
+	public:
+		typedef  ::tink::streams::IdealStreamBase_obj super;
+		typedef IdealizeStream_obj OBJ_;
+		IdealizeStream_obj();
+
+	public:
+		enum { _hx_ClassId = 0x15b188e0 };
+
+		void __construct(::Dynamic target, ::Dynamic rescue);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.streams.IdealizeStream")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.streams.IdealizeStream"); }
+		static ::hx::ObjectPtr< IdealizeStream_obj > __new(::Dynamic target, ::Dynamic rescue);
+		static ::hx::ObjectPtr< IdealizeStream_obj > __alloc(::hx::Ctx *_hx_ctx,::Dynamic target, ::Dynamic rescue);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~IdealizeStream_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("IdealizeStream",df,18,9d,1b); }
+
+		::Dynamic target;
+		 ::Dynamic rescue;
+		Dynamic rescue_dyn() { return rescue;}
+		bool get_depleted();
+
+		 ::tink::core::_Future::FutureObject forEach( ::Dynamic handler);
+
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_IdealizeStream */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/streams/Reduction.h b/Sources/c_snikket/iinclude/include/tink/streams/Reduction.h
new file mode 100644
index 0000000..5d8fe33
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/streams/Reduction.h
@@ -0,0 +1,41 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_Reduction
+#define INCLUDED_tink_streams_Reduction
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS2(tink,streams,Reduction)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+namespace tink{
+namespace streams{
+
+
+class Reduction_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef Reduction_obj OBJ_;
+
+	public:
+		Reduction_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.streams.Reduction",5c,50,fe,4b); }
+		::String __ToString() const { return HX_("Reduction.",bb,b1,a8,cf) + _hx_tag; }
+
+		static ::tink::streams::Reduction Crashed( ::tink::core::TypedError error,::Dynamic at);
+		static ::Dynamic Crashed_dyn();
+		static ::tink::streams::Reduction Failed( ::tink::core::TypedError error);
+		static ::Dynamic Failed_dyn();
+		static ::tink::streams::Reduction Reduced( ::Dynamic result);
+		static ::Dynamic Reduced_dyn();
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_Reduction */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/streams/ReductionStep.h b/Sources/c_snikket/iinclude/include/tink/streams/ReductionStep.h
new file mode 100644
index 0000000..a20fdfd
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/streams/ReductionStep.h
@@ -0,0 +1,38 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_ReductionStep
+#define INCLUDED_tink_streams_ReductionStep
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS2(tink,streams,ReductionStep)
+namespace tink{
+namespace streams{
+
+
+class ReductionStep_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef ReductionStep_obj OBJ_;
+
+	public:
+		ReductionStep_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.streams.ReductionStep",c8,c1,78,61); }
+		::String __ToString() const { return HX_("ReductionStep.",4f,e7,10,f7) + _hx_tag; }
+
+		static ::tink::streams::ReductionStep Crash( ::tink::core::TypedError e);
+		static ::Dynamic Crash_dyn();
+		static ::tink::streams::ReductionStep Progress( ::Dynamic result);
+		static ::Dynamic Progress_dyn();
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_ReductionStep */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/streams/RegroupResult.h b/Sources/c_snikket/iinclude/include/tink/streams/RegroupResult.h
new file mode 100644
index 0000000..d8b27a2
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/streams/RegroupResult.h
@@ -0,0 +1,44 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_RegroupResult
+#define INCLUDED_tink_streams_RegroupResult
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,ds,Option)
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS2(tink,streams,RegroupResult)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+namespace tink{
+namespace streams{
+
+
+class RegroupResult_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef RegroupResult_obj OBJ_;
+
+	public:
+		RegroupResult_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.streams.RegroupResult",52,26,01,31); }
+		::String __ToString() const { return HX_("RegroupResult.",85,7b,e0,be) + _hx_tag; }
+
+		static ::tink::streams::RegroupResult Converted(::Dynamic data,::cpp::VirtualArray untouched);
+		static ::Dynamic Converted_dyn();
+		static ::tink::streams::RegroupResult Errored( ::tink::core::TypedError e);
+		static ::Dynamic Errored_dyn();
+		static ::tink::streams::RegroupResult Terminated( ::haxe::ds::Option data);
+		static ::Dynamic Terminated_dyn();
+		static ::tink::streams::RegroupResult Untouched;
+		static inline ::tink::streams::RegroupResult Untouched_dyn() { return Untouched; }
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_RegroupResult */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/streams/RegroupStatus.h b/Sources/c_snikket/iinclude/include/tink/streams/RegroupStatus.h
new file mode 100644
index 0000000..7177b22
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/streams/RegroupStatus.h
@@ -0,0 +1,40 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_RegroupStatus
+#define INCLUDED_tink_streams_RegroupStatus
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS2(tink,streams,RegroupStatus)
+namespace tink{
+namespace streams{
+
+
+class RegroupStatus_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef RegroupStatus_obj OBJ_;
+
+	public:
+		RegroupStatus_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.streams.RegroupStatus",a7,a4,78,2e); }
+		::String __ToString() const { return HX_("RegroupStatus.",90,87,f7,89) + _hx_tag; }
+
+		static ::tink::streams::RegroupStatus Ended;
+		static inline ::tink::streams::RegroupStatus Ended_dyn() { return Ended; }
+		static ::tink::streams::RegroupStatus Errored( ::tink::core::TypedError e);
+		static ::Dynamic Errored_dyn();
+		static ::tink::streams::RegroupStatus Flowing;
+		static inline ::tink::streams::RegroupStatus Flowing_dyn() { return Flowing; }
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_RegroupStatus */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/streams/Single.h b/Sources/c_snikket/iinclude/include/tink/streams/Single.h
new file mode 100644
index 0000000..fc74928
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/streams/Single.h
@@ -0,0 +1,63 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_Single
+#define INCLUDED_tink_streams_Single
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_streams_StreamBase
+#include <tink/streams/StreamBase.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS3(tink,core,_Lazy,Computable)
+HX_DECLARE_CLASS3(tink,core,_Lazy,LazyObject)
+HX_DECLARE_CLASS2(tink,streams,Single)
+HX_DECLARE_CLASS2(tink,streams,StreamBase)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace streams{
+
+
+class HXCPP_CLASS_ATTRIBUTES Single_obj : public  ::tink::streams::StreamBase_obj
+{
+	public:
+		typedef  ::tink::streams::StreamBase_obj super;
+		typedef Single_obj OBJ_;
+		Single_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2688f9e1 };
+
+		void __construct(::Dynamic value);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.streams.Single")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.streams.Single"); }
+		static ::hx::ObjectPtr< Single_obj > __new(::Dynamic value);
+		static ::hx::ObjectPtr< Single_obj > __alloc(::hx::Ctx *_hx_ctx,::Dynamic value);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Single_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Single",a8,da,b5,ed); }
+
+		::Dynamic value;
+		 ::tink::core::_Future::FutureObject forEach( ::Dynamic handle);
+
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_Single */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/streams/Step.h b/Sources/c_snikket/iinclude/include/tink/streams/Step.h
new file mode 100644
index 0000000..e200806
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/streams/Step.h
@@ -0,0 +1,41 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_Step
+#define INCLUDED_tink_streams_Step
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS2(tink,streams,Step)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+namespace tink{
+namespace streams{
+
+
+class Step_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef Step_obj OBJ_;
+
+	public:
+		Step_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.streams.Step",c3,c6,00,cc); }
+		::String __ToString() const { return HX_("Step.",42,eb,3b,17) + _hx_tag; }
+
+		static ::tink::streams::Step End;
+		static inline ::tink::streams::Step End_dyn() { return End; }
+		static ::tink::streams::Step Fail( ::tink::core::TypedError e);
+		static ::Dynamic Fail_dyn();
+		static ::tink::streams::Step Link( ::Dynamic value,::Dynamic next);
+		static ::Dynamic Link_dyn();
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_Step */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/streams/StreamBase.h b/Sources/c_snikket/iinclude/include/tink/streams/StreamBase.h
new file mode 100644
index 0000000..92259cf
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/streams/StreamBase.h
@@ -0,0 +1,77 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_StreamBase
+#define INCLUDED_tink_streams_StreamBase
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_streams_StreamObject
+#include <tink/streams/StreamObject.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,streams,StreamBase)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace streams{
+
+
+class HXCPP_CLASS_ATTRIBUTES StreamBase_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef StreamBase_obj OBJ_;
+		StreamBase_obj();
+
+	public:
+		enum { _hx_ClassId = 0x61521c8a };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.streams.StreamBase")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.streams.StreamBase"); }
+		static ::hx::ObjectPtr< StreamBase_obj > __new();
+		static ::hx::ObjectPtr< StreamBase_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~StreamBase_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("StreamBase",d1,6c,2c,85); }
+
+		virtual bool get_depleted();
+		::Dynamic get_depleted_dyn();
+
+		::Dynamic regroup( ::Dynamic f);
+		::Dynamic regroup_dyn();
+
+		::Dynamic prepend(::Dynamic other);
+		::Dynamic prepend_dyn();
+
+		virtual void decompose(::Array< ::Dynamic> into);
+		::Dynamic decompose_dyn();
+
+		virtual ::Dynamic idealize( ::Dynamic rescue);
+		::Dynamic idealize_dyn();
+
+		 ::tink::core::_Future::FutureObject reduce( ::Dynamic initial, ::Dynamic reducer);
+		::Dynamic reduce_dyn();
+
+		virtual  ::tink::core::_Future::FutureObject forEach( ::Dynamic handler);
+		::Dynamic forEach_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_StreamBase */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/streams/StreamObject.h b/Sources/c_snikket/iinclude/include/tink/streams/StreamObject.h
new file mode 100644
index 0000000..5a2bbc9
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/streams/StreamObject.h
@@ -0,0 +1,55 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_StreamObject
+#define INCLUDED_tink_streams_StreamObject
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace streams{
+
+
+class HXCPP_CLASS_ATTRIBUTES StreamObject_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		bool (::hx::Object :: *_hx_get_depleted)(); 
+		static inline bool get_depleted( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::streams::StreamObject_obj *>(_hx_.mPtr->_hx_getInterface(0x6164ac00)))->_hx_get_depleted)();
+		}
+		::Dynamic (::hx::Object :: *_hx_regroup)( ::Dynamic f); 
+		static inline ::Dynamic regroup( ::Dynamic _hx_, ::Dynamic f) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::streams::StreamObject_obj *>(_hx_.mPtr->_hx_getInterface(0x6164ac00)))->_hx_regroup)(f);
+		}
+		::Dynamic (::hx::Object :: *_hx_idealize)( ::Dynamic rescue); 
+		static inline ::Dynamic idealize( ::Dynamic _hx_, ::Dynamic rescue) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::streams::StreamObject_obj *>(_hx_.mPtr->_hx_getInterface(0x6164ac00)))->_hx_idealize)(rescue);
+		}
+		::Dynamic (::hx::Object :: *_hx_prepend)(::Dynamic other); 
+		static inline ::Dynamic prepend( ::Dynamic _hx_,::Dynamic other) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::streams::StreamObject_obj *>(_hx_.mPtr->_hx_getInterface(0x6164ac00)))->_hx_prepend)(other);
+		}
+		void (::hx::Object :: *_hx_decompose)(::Array< ::Dynamic> into); 
+		static inline void decompose( ::Dynamic _hx_,::Array< ::Dynamic> into) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::tink::streams::StreamObject_obj *>(_hx_.mPtr->_hx_getInterface(0x6164ac00)))->_hx_decompose)(into);
+		}
+		 ::tink::core::_Future::FutureObject (::hx::Object :: *_hx_forEach)( ::Dynamic handle); 
+		static inline  ::tink::core::_Future::FutureObject forEach( ::Dynamic _hx_, ::Dynamic handle) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::streams::StreamObject_obj *>(_hx_.mPtr->_hx_getInterface(0x6164ac00)))->_hx_forEach)(handle);
+		}
+		 ::tink::core::_Future::FutureObject (::hx::Object :: *_hx_reduce)( ::Dynamic initial, ::Dynamic reducer); 
+		static inline  ::tink::core::_Future::FutureObject reduce( ::Dynamic _hx_, ::Dynamic initial, ::Dynamic reducer) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::streams::StreamObject_obj *>(_hx_.mPtr->_hx_getInterface(0x6164ac00)))->_hx_reduce)(initial,reducer);
+		}
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_StreamObject */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/streams/_Stream/CompoundStream.h b/Sources/c_snikket/iinclude/include/tink/streams/_Stream/CompoundStream.h
new file mode 100644
index 0000000..529a9c5
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/streams/_Stream/CompoundStream.h
@@ -0,0 +1,75 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams__Stream_CompoundStream
+#define INCLUDED_tink_streams__Stream_CompoundStream
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_streams_StreamBase
+#include <tink/streams/StreamBase.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,streams,Conclusion)
+HX_DECLARE_CLASS2(tink,streams,StreamBase)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+HX_DECLARE_CLASS3(tink,streams,_Stream,CompoundStream)
+
+namespace tink{
+namespace streams{
+namespace _Stream{
+
+
+class HXCPP_CLASS_ATTRIBUTES CompoundStream_obj : public  ::tink::streams::StreamBase_obj
+{
+	public:
+		typedef  ::tink::streams::StreamBase_obj super;
+		typedef CompoundStream_obj OBJ_;
+		CompoundStream_obj();
+
+	public:
+		enum { _hx_ClassId = 0x56b49549 };
+
+		void __construct(::Array< ::Dynamic> parts);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.streams._Stream.CompoundStream")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.streams._Stream.CompoundStream"); }
+		static ::hx::ObjectPtr< CompoundStream_obj > __new(::Array< ::Dynamic> parts);
+		static ::hx::ObjectPtr< CompoundStream_obj > __alloc(::hx::Ctx *_hx_ctx,::Array< ::Dynamic> parts);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~CompoundStream_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("CompoundStream",6b,c2,13,72); }
+
+		static void consumeParts(::Array< ::Dynamic> parts, ::Dynamic handler, ::Dynamic cb);
+		static ::Dynamic consumeParts_dyn();
+
+		static ::Dynamic of(::Array< ::Dynamic> streams);
+		static ::Dynamic of_dyn();
+
+		::Array< ::Dynamic> parts;
+		bool get_depleted();
+
+		void decompose(::Array< ::Dynamic> into);
+
+		 ::tink::core::_Future::FutureObject forEach( ::Dynamic handler);
+
+};
+
+} // end namespace tink
+} // end namespace streams
+} // end namespace _Stream
+
+#endif /* INCLUDED_tink_streams__Stream_CompoundStream */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/streams/_Stream/ErrorStream.h b/Sources/c_snikket/iinclude/include/tink/streams/_Stream/ErrorStream.h
new file mode 100644
index 0000000..609ab95
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/streams/_Stream/ErrorStream.h
@@ -0,0 +1,64 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams__Stream_ErrorStream
+#define INCLUDED_tink_streams__Stream_ErrorStream
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_streams_StreamBase
+#include <tink/streams/StreamBase.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,streams,StreamBase)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+HX_DECLARE_CLASS3(tink,streams,_Stream,ErrorStream)
+
+namespace tink{
+namespace streams{
+namespace _Stream{
+
+
+class HXCPP_CLASS_ATTRIBUTES ErrorStream_obj : public  ::tink::streams::StreamBase_obj
+{
+	public:
+		typedef  ::tink::streams::StreamBase_obj super;
+		typedef ErrorStream_obj OBJ_;
+		ErrorStream_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1afcc8aa };
+
+		void __construct( ::tink::core::TypedError error);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.streams._Stream.ErrorStream")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.streams._Stream.ErrorStream"); }
+		static ::hx::ObjectPtr< ErrorStream_obj > __new( ::tink::core::TypedError error);
+		static ::hx::ObjectPtr< ErrorStream_obj > __alloc(::hx::Ctx *_hx_ctx, ::tink::core::TypedError error);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ErrorStream_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ErrorStream",48,f2,cc,e3); }
+
+		 ::tink::core::TypedError error;
+		 ::tink::core::_Future::FutureObject forEach( ::Dynamic handler);
+
+};
+
+} // end namespace tink
+} // end namespace streams
+} // end namespace _Stream
+
+#endif /* INCLUDED_tink_streams__Stream_ErrorStream */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/streams/_Stream/Handler_Impl_.h b/Sources/c_snikket/iinclude/include/tink/streams/_Stream/Handler_Impl_.h
new file mode 100644
index 0000000..2e0cf9a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/streams/_Stream/Handler_Impl_.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams__Stream_Handler_Impl_
+#define INCLUDED_tink_streams__Stream_Handler_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,streams,Handled)
+HX_DECLARE_CLASS3(tink,streams,_Stream,Handler_Impl_)
+
+namespace tink{
+namespace streams{
+namespace _Stream{
+
+
+class HXCPP_CLASS_ATTRIBUTES Handler_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Handler_Impl__obj OBJ_;
+		Handler_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x065ceae4 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.streams._Stream.Handler_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.streams._Stream.Handler_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Handler_Impl__obj > __new() {
+			::hx::ObjectPtr< Handler_Impl__obj > __this = new Handler_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Handler_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Handler_Impl__obj *__this = (Handler_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Handler_Impl__obj), false, "tink.streams._Stream.Handler_Impl_"));
+			*(void **)__this = Handler_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Handler_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Handler_Impl_",ca,2f,2c,64); }
+
+		static  ::Dynamic ofSafeSync( ::Dynamic f);
+		static ::Dynamic ofSafeSync_dyn();
+
+		static  ::Dynamic ofUnknown( ::Dynamic f);
+		static ::Dynamic ofUnknown_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace streams
+} // end namespace _Stream
+
+#endif /* INCLUDED_tink_streams__Stream_Handler_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/streams/_Stream/Reducer_Impl_.h b/Sources/c_snikket/iinclude/include/tink/streams/_Stream/Reducer_Impl_.h
new file mode 100644
index 0000000..3308ef5
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/streams/_Stream/Reducer_Impl_.h
@@ -0,0 +1,66 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams__Stream_Reducer_Impl_
+#define INCLUDED_tink_streams__Stream_Reducer_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,streams,ReductionStep)
+HX_DECLARE_CLASS3(tink,streams,_Stream,Reducer_Impl_)
+
+namespace tink{
+namespace streams{
+namespace _Stream{
+
+
+class HXCPP_CLASS_ATTRIBUTES Reducer_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Reducer_Impl__obj OBJ_;
+		Reducer_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x18a49ca6 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.streams._Stream.Reducer_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.streams._Stream.Reducer_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Reducer_Impl__obj > __new() {
+			::hx::ObjectPtr< Reducer_Impl__obj > __this = new Reducer_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Reducer_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Reducer_Impl__obj *__this = (Reducer_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Reducer_Impl__obj), false, "tink.streams._Stream.Reducer_Impl_"));
+			*(void **)__this = Reducer_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Reducer_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Reducer_Impl_",8c,e1,73,76); }
+
+		static  ::Dynamic ofSafeSync( ::Dynamic f);
+		static ::Dynamic ofSafeSync_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace streams
+} // end namespace _Stream
+
+#endif /* INCLUDED_tink_streams__Stream_Reducer_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/streams/_Stream/RegroupStream.h b/Sources/c_snikket/iinclude/include/tink/streams/_Stream/RegroupStream.h
new file mode 100644
index 0000000..b268759
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/streams/_Stream/RegroupStream.h
@@ -0,0 +1,55 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams__Stream_RegroupStream
+#define INCLUDED_tink_streams__Stream_RegroupStream
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_streams__Stream_CompoundStream
+#include <tink/streams/_Stream/CompoundStream.h>
+#endif
+HX_DECLARE_CLASS2(tink,streams,StreamBase)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+HX_DECLARE_CLASS3(tink,streams,_Stream,CompoundStream)
+HX_DECLARE_CLASS3(tink,streams,_Stream,RegroupStream)
+
+namespace tink{
+namespace streams{
+namespace _Stream{
+
+
+class HXCPP_CLASS_ATTRIBUTES RegroupStream_obj : public  ::tink::streams::_Stream::CompoundStream_obj
+{
+	public:
+		typedef  ::tink::streams::_Stream::CompoundStream_obj super;
+		typedef RegroupStream_obj OBJ_;
+		RegroupStream_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1850db0e };
+
+		void __construct(::Dynamic source, ::Dynamic f,::Dynamic prev,::cpp::VirtualArray buf);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.streams._Stream.RegroupStream")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.streams._Stream.RegroupStream"); }
+		static ::hx::ObjectPtr< RegroupStream_obj > __new(::Dynamic source, ::Dynamic f,::Dynamic prev,::cpp::VirtualArray buf);
+		static ::hx::ObjectPtr< RegroupStream_obj > __alloc(::hx::Ctx *_hx_ctx,::Dynamic source, ::Dynamic f,::Dynamic prev,::cpp::VirtualArray buf);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~RegroupStream_obj();
+
+		HX_DO_RTTI_ALL;
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("RegroupStream",2c,28,b5,d4); }
+
+};
+
+} // end namespace tink
+} // end namespace streams
+} // end namespace _Stream
+
+#endif /* INCLUDED_tink_streams__Stream_RegroupStream */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/streams/_Stream/Regrouper_Impl_.h b/Sources/c_snikket/iinclude/include/tink/streams/_Stream/Regrouper_Impl_.h
new file mode 100644
index 0000000..72afba4
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/streams/_Stream/Regrouper_Impl_.h
@@ -0,0 +1,65 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams__Stream_Regrouper_Impl_
+#define INCLUDED_tink_streams__Stream_Regrouper_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,streams,RegroupResult)
+HX_DECLARE_CLASS3(tink,streams,_Stream,Regrouper_Impl_)
+
+namespace tink{
+namespace streams{
+namespace _Stream{
+
+
+class HXCPP_CLASS_ATTRIBUTES Regrouper_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Regrouper_Impl__obj OBJ_;
+		Regrouper_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x74da6ebb };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.streams._Stream.Regrouper_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.streams._Stream.Regrouper_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Regrouper_Impl__obj > __new() {
+			::hx::ObjectPtr< Regrouper_Impl__obj > __this = new Regrouper_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Regrouper_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Regrouper_Impl__obj *__this = (Regrouper_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Regrouper_Impl__obj), false, "tink.streams._Stream.Regrouper_Impl_"));
+			*(void **)__this = Regrouper_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Regrouper_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Regrouper_Impl_",59,bf,c2,4c); }
+
+		static  ::Dynamic ofIgnoranceSync( ::Dynamic f);
+		static ::Dynamic ofIgnoranceSync_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace streams
+} // end namespace _Stream
+
+#endif /* INCLUDED_tink_streams__Stream_Regrouper_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/streams/_Stream/Stream_Impl_.h b/Sources/c_snikket/iinclude/include/tink/streams/_Stream/Stream_Impl_.h
new file mode 100644
index 0000000..776c5cc
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/streams/_Stream/Stream_Impl_.h
@@ -0,0 +1,73 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams__Stream_Stream_Impl_
+#define INCLUDED_tink_streams__Stream_Stream_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+HX_DECLARE_CLASS3(tink,streams,_Stream,Stream_Impl_)
+
+namespace tink{
+namespace streams{
+namespace _Stream{
+
+
+class HXCPP_CLASS_ATTRIBUTES Stream_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Stream_Impl__obj OBJ_;
+		Stream_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x5036bc9e };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.streams._Stream.Stream_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.streams._Stream.Stream_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Stream_Impl__obj > __new() {
+			::hx::ObjectPtr< Stream_Impl__obj > __this = new Stream_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Stream_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Stream_Impl__obj *__this = (Stream_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Stream_Impl__obj), false, "tink.streams._Stream.Stream_Impl_"));
+			*(void **)__this = Stream_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Stream_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Stream_Impl_",40,fd,8a,3d); }
+
+		static ::Dynamic single( ::Dynamic i);
+		static ::Dynamic single_dyn();
+
+		static ::Dynamic future( ::tink::core::_Future::FutureObject f);
+		static ::Dynamic future_dyn();
+
+		static ::Dynamic ofError( ::tink::core::TypedError e);
+		static ::Dynamic ofError_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace streams
+} // end namespace _Stream
+
+#endif /* INCLUDED_tink_streams__Stream_Stream_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/url/_Host/Host_Impl_.h b/Sources/c_snikket/iinclude/include/tink/url/_Host/Host_Impl_.h
new file mode 100644
index 0000000..3db7153
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/url/_Host/Host_Impl_.h
@@ -0,0 +1,70 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_url__Host_Host_Impl_
+#define INCLUDED_tink_url__Host_Host_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,url,_Host,Host_Impl_)
+
+namespace tink{
+namespace url{
+namespace _Host{
+
+
+class HXCPP_CLASS_ATTRIBUTES Host_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Host_Impl__obj OBJ_;
+		Host_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x20d53a72 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.url._Host.Host_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.url._Host.Host_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Host_Impl__obj > __new() {
+			::hx::ObjectPtr< Host_Impl__obj > __this = new Host_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Host_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Host_Impl__obj *__this = (Host_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Host_Impl__obj), false, "tink.url._Host.Host_Impl_"));
+			*(void **)__this = Host_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Host_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Host_Impl_",28,8e,8a,61); }
+
+		static ::String _new(::String name, ::Dynamic port);
+		static ::Dynamic _new_dyn();
+
+		static ::String get_name(::String this1);
+		static ::Dynamic get_name_dyn();
+
+		static  ::Dynamic get_port(::String this1);
+		static ::Dynamic get_port_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace url
+} // end namespace _Host
+
+#endif /* INCLUDED_tink_url__Host_Host_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/include/tink/url/_Path/Path_Impl_.h b/Sources/c_snikket/iinclude/include/tink/url/_Path/Path_Impl_.h
new file mode 100644
index 0000000..25b6b43
--- /dev/null
+++ b/Sources/c_snikket/iinclude/include/tink/url/_Path/Path_Impl_.h
@@ -0,0 +1,70 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_url__Path_Path_Impl_
+#define INCLUDED_tink_url__Path_Path_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,url,_Path,Path_Impl_)
+
+namespace tink{
+namespace url{
+namespace _Path{
+
+
+class HXCPP_CLASS_ATTRIBUTES Path_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Path_Impl__obj OBJ_;
+		Path_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x718c1a2c };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.url._Path.Path_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.url._Path.Path_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Path_Impl__obj > __new() {
+			::hx::ObjectPtr< Path_Impl__obj > __this = new Path_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Path_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Path_Impl__obj *__this = (Path_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Path_Impl__obj), false, "tink.url._Path.Path_Impl_"));
+			*(void **)__this = Path_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Path_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Path_Impl_",25,70,db,20); }
+
+		static ::String join(::String this1,::String that);
+		static ::Dynamic join_dyn();
+
+		static ::String ofString(::String s);
+		static ::Dynamic ofString_dyn();
+
+		static ::String normalize(::String s);
+		static ::Dynamic normalize_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace url
+} // end namespace _Path
+
+#endif /* INCLUDED_tink_url__Path_Path_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/null.h b/Sources/c_snikket/iinclude/null.h
new file mode 100644
index 0000000..396dc74
--- /dev/null
+++ b/Sources/c_snikket/iinclude/null.h
@@ -0,0 +1,236 @@
+#ifndef HX_NULL_H
+#define HX_NULL_H
+
+
+
+// --- null value  ---------------------------------------------------------
+//
+// This is used by external operatator and return statments - Most will
+//  use operator overloading to convert to the null pointer
+
+
+// Forward declare ...
+class String;
+class null;
+namespace hx { template<typename O> class ObjectPtr; }
+
+namespace hx { null NullArithmetic(const char *inText); }
+
+#define HX_NULL_COMPARE_OP(op,type,value) \
+			bool operator op (const type &inRHS) const { return value; }
+
+#define HX_NULL_COMPARE_OPS(type) \
+	HX_NULL_COMPARE_OP(<,type,false) \
+	HX_NULL_COMPARE_OP(<=,type,false) \
+	HX_NULL_COMPARE_OP(>,type,false) \
+	HX_NULL_COMPARE_OP(>=,type,false) \
+	HX_NULL_COMPARE_OP(==,type,false) \
+	HX_NULL_COMPARE_OP(!=,type,true)
+
+#define HX_NULL_COMPARE_MOST_OPS(type) \
+	HX_NULL_COMPARE_OP(<,type,false) \
+	HX_NULL_COMPARE_OP(<=,type,false) \
+	HX_NULL_COMPARE_OP(>,type,false) \
+	HX_NULL_COMPARE_OP(>=,type,false)
+
+#define HX_COMPARE_NULL_OP(op,type,value) \
+	   inline bool operator op (type inLHS, const null &) { return value; }
+
+#define HX_COMPARE_NULL_OPS(type) \
+	HX_COMPARE_NULL_OP(<,type,false) \
+	HX_COMPARE_NULL_OP(<=,type,false) \
+	HX_COMPARE_NULL_OP(>,type,false) \
+	HX_COMPARE_NULL_OP(>=,type,false) \
+	HX_COMPARE_NULL_OP(==,type,false) \
+	HX_COMPARE_NULL_OP(!=,type,true)
+
+#define HX_COMPARE_NULL_MOST_OPS(type) \
+	HX_COMPARE_NULL_OP(<,type,false) \
+	HX_COMPARE_NULL_OP(<=,type,false) \
+	HX_COMPARE_NULL_OP(>,type,false) \
+	HX_COMPARE_NULL_OP(>=,type,false)
+
+
+#define HX_NULL_ARITHMETIC_OP(op) \
+template<typename T> inline null operator op (T t) const \
+   { return hx::NullArithmetic(#op); } \
+inline null operator op (const null &) const \
+   { return hx::NullArithmetic(#op); }
+
+#define HX_ARITHMETIC_NULL_OP(op) \
+template<typename T> inline null operator op (const T &, const null &) \
+   { return hx::NullArithmetic(#op); }
+
+
+class null
+{
+   struct AnyArg
+   {
+      template<typename T>
+      inline AnyArg(const T&) { }
+   };
+   public:
+     inline null(){ } 
+
+     template<typename T> explicit inline null(const hx::ObjectPtr<T> &){ } 
+     template<typename T> explicit inline null(const String &){ } 
+     explicit inline null(double){ } 
+     explicit inline null(float){ } 
+     explicit inline null(int){ } 
+     explicit inline null(bool){ } 
+
+     template<typename T>
+     T StaticCast() { return null(); }
+
+     operator bool () { return false; }
+     operator int () { return 0; }
+     operator unsigned int () { return 0; }
+     operator double () { return 0; }
+     operator float () { return 0; }
+     operator char () { return 0; }
+     operator unsigned char () { return 0; }
+     operator signed char () { return 0; }
+     operator short () { return 0; }
+     operator unsigned short () { return 0; }
+     operator unsigned long () { return 0; }
+     operator cpp::UInt64 () { return 0; }
+     operator cpp::Int64 () { return 0; }
+     template<typename T>
+     inline operator typename hx::Native<T *> () const { return 0; }
+
+
+     // Any pointer!
+     //operator char * () { return 0; }
+     //operator wchar_t * () { return 0; }
+     template<typename T> operator T *() { return 0; }
+
+     bool operator == (null inRHS) const { return true; }
+     bool operator != (null inRHS) const { return false; }
+     bool operator == (null inRHS) { return true; }
+     bool operator != (null inRHS) { return false; }
+
+     template<typename T> inline bool operator == (const hx::ObjectPtr<T> &) const;
+     template<typename T> inline bool operator != (const hx::ObjectPtr<T> &) const;
+     template<typename T> inline bool operator == (const Array<T> &) const;
+     template<typename T> inline bool operator != (const Array<T> &) const;
+     inline bool operator == (const hx::FieldRef &) const;
+     inline bool operator != (const hx::FieldRef &) const;
+     inline bool operator == (const hx::IndexRef &) const;
+     inline bool operator != (const hx::IndexRef &) const;
+     inline bool operator == (const Dynamic &) const;
+     inline bool operator != (const Dynamic &) const;
+     inline bool operator == (const String &) const;
+     inline bool operator != (const String &) const;
+     inline bool operator == (const cpp::Variant &v) const { return v.isNull(); }
+     inline bool operator != (const cpp::Variant &v) const{ return !v.isNull(); }
+
+     inline null operator - () const { return hx::NullArithmetic("-"); }
+     inline null operator ! () const { return hx::NullArithmetic("!"); }
+
+     template<class T> T operator()(const AnyArg &a0=0, const AnyArg &a1=0, const AnyArg &a2=0,
+            const AnyArg &a4=0, const AnyArg &a5=0, const AnyArg &a6=0,
+            const AnyArg &a7=0, const AnyArg &a8=0, const AnyArg &a9=0 )
+            {
+                hx::NullReference("Function Call", false);
+                T nullDynamic;
+                return nullDynamic;
+            }
+
+	  HX_NULL_COMPARE_OPS(bool)
+	  HX_NULL_COMPARE_OPS(double)
+	  HX_NULL_COMPARE_OPS(float)
+	  HX_NULL_COMPARE_OPS(int)
+	  HX_NULL_COMPARE_OPS(unsigned int)
+	  HX_NULL_COMPARE_OPS(short)
+	  HX_NULL_COMPARE_OPS(unsigned short)
+	  HX_NULL_COMPARE_OPS(signed char)
+	  HX_NULL_COMPARE_OPS(unsigned char)
+	  HX_NULL_COMPARE_OPS(cpp::Int64)
+	  HX_NULL_COMPARE_OPS(cpp::UInt64)
+	  HX_NULL_COMPARE_MOST_OPS(String)
+	  HX_NULL_COMPARE_MOST_OPS(Dynamic)
+	  HX_NULL_COMPARE_MOST_OPS(hx::FieldRef)
+	  HX_NULL_COMPARE_MOST_OPS(hx::IndexRef)
+
+	  HX_NULL_COMPARE_OP(<,null,false)
+	  HX_NULL_COMPARE_OP(<=,null,true)
+	  HX_NULL_COMPARE_OP(>,null,false)
+	  HX_NULL_COMPARE_OP(>=,null,true)
+
+
+	  HX_NULL_ARITHMETIC_OP(+);
+	  HX_NULL_ARITHMETIC_OP(*);
+	  HX_NULL_ARITHMETIC_OP(-);
+	  HX_NULL_ARITHMETIC_OP(/);
+	  HX_NULL_ARITHMETIC_OP(%);
+	  HX_NULL_ARITHMETIC_OP(&);
+	  HX_NULL_ARITHMETIC_OP(|);
+	  HX_NULL_ARITHMETIC_OP(^);
+	  HX_NULL_ARITHMETIC_OP(>>);
+	  HX_NULL_ARITHMETIC_OP(<<);
+};
+
+namespace hx
+{
+
+template<typename T>
+struct Null
+{
+   inline Null() : isNull(true) { }
+   inline Null(const Null<T> &inOther) : isNull(inOther.isNull), value(inOther.value) { }
+   inline Null(const T& inVal) : isNull(false), value(inVal) { }
+   inline Null(const null &) : isNull(true) { }
+   inline Null(const Dynamic &inVal)
+   {
+      isNull = null() == inVal;
+      if (!isNull)
+         value = inVal;
+   }
+   inline Null(const cpp::Variant &inVal)
+   {
+      isNull = inVal.isNull();
+      if (!isNull)
+         value = inVal;
+   }
+
+   inline operator Dynamic();
+   inline T Default(T inDefault) { return isNull ? inDefault : value; }
+
+   bool isNull;
+   T    value;
+};
+
+} // end namesapce hx
+
+typedef null Void;
+
+HX_COMPARE_NULL_OPS(bool)
+HX_COMPARE_NULL_OPS(double)
+HX_COMPARE_NULL_OPS(float)
+HX_COMPARE_NULL_OPS(int)
+HX_COMPARE_NULL_OPS(unsigned int)
+HX_COMPARE_NULL_OPS(short)
+HX_COMPARE_NULL_OPS(unsigned short)
+HX_COMPARE_NULL_OPS(signed char)
+HX_COMPARE_NULL_OPS(unsigned char)
+HX_COMPARE_NULL_OPS(cpp::UInt64)
+HX_COMPARE_NULL_OPS(cpp::Int64)
+
+HX_ARITHMETIC_NULL_OP(+)
+HX_ARITHMETIC_NULL_OP(*)
+HX_ARITHMETIC_NULL_OP(-)
+HX_ARITHMETIC_NULL_OP(/)
+HX_ARITHMETIC_NULL_OP(%)
+HX_ARITHMETIC_NULL_OP(&)
+HX_ARITHMETIC_NULL_OP(|)
+HX_ARITHMETIC_NULL_OP(^)
+HX_ARITHMETIC_NULL_OP(>>)
+HX_ARITHMETIC_NULL_OP(<<)
+
+// Other ops in Operator.h
+
+inline void *_hx_nullptr() { return 0; }
+
+
+#endif
+
diff --git a/Sources/c_snikket/iinclude/sha/Hash.h b/Sources/c_snikket/iinclude/sha/Hash.h
new file mode 100644
index 0000000..105a34b
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sha/Hash.h
@@ -0,0 +1,60 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sha_Hash
+#define INCLUDED_sha_Hash
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS1(sha,Hash)
+
+namespace sha{
+
+
+class HXCPP_CLASS_ATTRIBUTES Hash_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Hash_obj OBJ_;
+		Hash_obj();
+
+	public:
+		enum { _hx_ClassId = 0x49a7eb1a };
+
+		void __construct(int blockSize,int finalSize);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sha.Hash")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sha.Hash"); }
+
+		//~Hash_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Hash",ee,5b,e1,2f); }
+
+		int finalSize;
+		int length;
+		 ::haxe::io::Bytes block;
+		 ::sha::Hash update( ::haxe::io::Bytes data);
+		::Dynamic update_dyn();
+
+		 ::haxe::io::Bytes digest();
+		::Dynamic digest_dyn();
+
+		virtual void _update( ::haxe::io::Bytes data) {}
+		::Dynamic _update_dyn();
+		virtual  ::haxe::io::Bytes _hash() { return 0; }
+		::Dynamic _hash_dyn();
+};
+
+} // end namespace sha
+
+#endif /* INCLUDED_sha_Hash */ 
diff --git a/Sources/c_snikket/iinclude/sha/SHA256.h b/Sources/c_snikket/iinclude/sha/SHA256.h
new file mode 100644
index 0000000..28722a8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sha/SHA256.h
@@ -0,0 +1,86 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sha_SHA256
+#define INCLUDED_sha_SHA256
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_sha_Hash
+#include <sha/Hash.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS1(sha,Hash)
+HX_DECLARE_CLASS1(sha,SHA256)
+
+namespace sha{
+
+
+class HXCPP_CLASS_ATTRIBUTES SHA256_obj : public  ::sha::Hash_obj
+{
+	public:
+		typedef  ::sha::Hash_obj super;
+		typedef SHA256_obj OBJ_;
+		SHA256_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0251ab23 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sha.SHA256")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sha.SHA256"); }
+		static ::hx::ObjectPtr< SHA256_obj > __new();
+		static ::hx::ObjectPtr< SHA256_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SHA256_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SHA256",87,b4,95,cf); }
+
+		int _a;
+		int _b;
+		int _c;
+		int _d;
+		int _e;
+		int _f;
+		int _g;
+		int _h;
+		::Array< int > _w;
+		int sigma0(int x);
+		::Dynamic sigma0_dyn();
+
+		int sigma1(int x);
+		::Dynamic sigma1_dyn();
+
+		int gamma0(int x);
+		::Dynamic gamma0_dyn();
+
+		int gamma1(int x);
+		::Dynamic gamma1_dyn();
+
+		int ch(int x,int y,int z);
+		::Dynamic ch_dyn();
+
+		int maj(int x,int y,int z);
+		::Dynamic maj_dyn();
+
+		void _update( ::haxe::io::Bytes data);
+
+		 ::haxe::io::Bytes _hash();
+
+};
+
+} // end namespace sha
+
+#endif /* INCLUDED_sha_SHA256 */ 
diff --git a/Sources/c_snikket/iinclude/sha/_SHA256/SHA256_Fields_.h b/Sources/c_snikket/iinclude/sha/_SHA256/SHA256_Fields_.h
new file mode 100644
index 0000000..3d1d69a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sha/_SHA256/SHA256_Fields_.h
@@ -0,0 +1,62 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sha__SHA256_SHA256_Fields_
+#define INCLUDED_sha__SHA256_SHA256_Fields_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(sha,_SHA256,SHA256_Fields_)
+
+namespace sha{
+namespace _SHA256{
+
+
+class HXCPP_CLASS_ATTRIBUTES SHA256_Fields__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef SHA256_Fields__obj OBJ_;
+		SHA256_Fields__obj();
+
+	public:
+		enum { _hx_ClassId = 0x07d39014 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="sha._SHA256.SHA256_Fields_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"sha._SHA256.SHA256_Fields_"); }
+
+		inline static ::hx::ObjectPtr< SHA256_Fields__obj > __new() {
+			::hx::ObjectPtr< SHA256_Fields__obj > __this = new SHA256_Fields__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< SHA256_Fields__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			SHA256_Fields__obj *__this = (SHA256_Fields__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(SHA256_Fields__obj), false, "sha._SHA256.SHA256_Fields_"));
+			*(void **)__this = SHA256_Fields__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SHA256_Fields__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SHA256_Fields_",ae,b0,ef,ea); }
+
+		static void __boot();
+		static ::Array< int > K;
+};
+
+} // end namespace sha
+} // end namespace _SHA256
+
+#endif /* INCLUDED_sha__SHA256_SHA256_Fields_ */ 
diff --git a/Sources/c_snikket/iinclude/snikket/AttachmentSource.h b/Sources/c_snikket/iinclude/snikket/AttachmentSource.h
new file mode 100644
index 0000000..35e0bb9
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/AttachmentSource.h
@@ -0,0 +1,72 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_AttachmentSource
+#define INCLUDED_snikket_AttachmentSource
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,AttachmentSource)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES AttachmentSource_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef AttachmentSource_obj OBJ_;
+		AttachmentSource_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3b403b17 };
+
+		void __construct(::String path,::String mime);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.AttachmentSource")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.AttachmentSource"); }
+		static ::hx::ObjectPtr< AttachmentSource_obj > __new(::String path,::String mime);
+		static ::hx::ObjectPtr< AttachmentSource_obj > __alloc(::hx::Ctx *_hx_ctx,::String path,::String mime);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~AttachmentSource_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("AttachmentSource",3e,95,3b,6c); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		::String path;
+		::String path__fromC();
+		::Dynamic path__fromC_dyn();
+
+		::String type;
+		::String type__fromC();
+		::Dynamic type__fromC_dyn();
+
+		::String name;
+		::String name__fromC();
+		::Dynamic name__fromC_dyn();
+
+		int size;
+		int size__fromC();
+		::Dynamic size__fromC_dyn();
+
+		::Dynamic tinkSource();
+		::Dynamic tinkSource_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_AttachmentSource */ 
diff --git a/Sources/c_snikket/iinclude/snikket/Autolink.h b/Sources/c_snikket/iinclude/snikket/Autolink.h
new file mode 100644
index 0000000..f244927
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/Autolink.h
@@ -0,0 +1,90 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Autolink
+#define INCLUDED_snikket_Autolink
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Autolink)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Autolink_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Autolink_obj OBJ_;
+		Autolink_obj();
+
+	public:
+		enum { _hx_ClassId = 0x257fedc6 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket.Autolink")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket.Autolink"); }
+
+		inline static ::hx::ObjectPtr< Autolink_obj > __new() {
+			::hx::ObjectPtr< Autolink_obj > __this = new Autolink_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Autolink_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Autolink_obj *__this = (Autolink_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Autolink_obj), false, "snikket.Autolink"));
+			*(void **)__this = Autolink_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Autolink_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Autolink",09,97,b1,19); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static ::String IANA_TOP_LEVEL_DOMAINS;
+		static ::String GOOD_IRI_CHAR;
+		static ::String IP_ADDRESS;
+		static ::String IP6_ADDRESS;
+		static ::String UCS_CHAR;
+		static ::String LABEL_CHAR;
+		static ::String IRI_LABEL;
+		static ::String PUNYCODE_TLD;
+		static ::String PROTOCOL;
+		static ::String WORD_BOUNDARY;
+		static ::String USER_INFO;
+		static ::String PORT_NUMBER;
+		static ::String PATH_CHAR;
+		static ::String PATH_AND_QUERY;
+		static ::String STRICT_TLD;
+		static ::String STRICT_HOST_NAME;
+		static ::String STRICT_DOMAIN_NAME;
+		static ::String RELAXED_DOMAIN_NAME;
+		static ::String WEB_URL_WITHOUT_PROTOCOL;
+		static ::String WEB_URL_WITH_PROTOCOL;
+		static ::String AUTOLINK_WEB_URL;
+		static ::String TEL_URI;
+		static ::String SMS_URI;
+		static ::String XMPP_URI;
+		static  ::Dynamic one(::String s,int start);
+		static ::Dynamic one_dyn();
+
+		static  ::Dynamic match(::String s,int start,::String pattern,bool addHttps);
+		static ::Dynamic match_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Autolink */ 
diff --git a/Sources/c_snikket/iinclude/snikket/AvailableChat.h b/Sources/c_snikket/iinclude/snikket/AvailableChat.h
new file mode 100644
index 0000000..80ae01e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/AvailableChat.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_AvailableChat
+#define INCLUDED_snikket_AvailableChat
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,AvailableChat)
+HX_DECLARE_CLASS1(snikket,Caps)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES AvailableChat_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef AvailableChat_obj OBJ_;
+		AvailableChat_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7aa46944 };
+
+		void __construct(::String chatId,::String displayName,::String note, ::snikket::Caps caps);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.AvailableChat")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.AvailableChat"); }
+		static ::hx::ObjectPtr< AvailableChat_obj > __new(::String chatId,::String displayName,::String note, ::snikket::Caps caps);
+		static ::hx::ObjectPtr< AvailableChat_obj > __alloc(::hx::Ctx *_hx_ctx,::String chatId,::String displayName,::String note, ::snikket::Caps caps);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~AvailableChat_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("AvailableChat",21,4d,b7,ce); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		::String chatId;
+		::String chatId__fromC();
+		::Dynamic chatId__fromC_dyn();
+
+		::String displayName;
+		::String displayName__fromC();
+		::Dynamic displayName__fromC_dyn();
+
+		::String note;
+		::String note__fromC();
+		::Dynamic note__fromC_dyn();
+
+		 ::snikket::Caps caps;
+		bool isChannel();
+		::Dynamic isChannel_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_AvailableChat */ 
diff --git a/Sources/c_snikket/iinclude/snikket/Builder.h b/Sources/c_snikket/iinclude/snikket/Builder.h
new file mode 100644
index 0000000..2b371f1
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/Builder.h
@@ -0,0 +1,62 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Builder
+#define INCLUDED_snikket_Builder
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Builder)
+HX_DECLARE_CLASS1(snikket,Symbol)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Builder_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Builder_obj OBJ_;
+		Builder_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7b0e9a2a };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Builder")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Builder"); }
+		static ::hx::ObjectPtr< Builder_obj > __new();
+		static ::hx::ObjectPtr< Builder_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Builder_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Builder",fb,02,0c,3d); }
+
+		static bool isMerger(int codepoint);
+		static ::Dynamic isMerger_dyn();
+
+		::Array< int > codepoints;
+		bool offer(int codepoint);
+		::Dynamic offer_dyn();
+
+		 ::snikket::Symbol build();
+		::Dynamic build_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Builder */ 
diff --git a/Sources/c_snikket/iinclude/snikket/Caps.h b/Sources/c_snikket/iinclude/snikket/Caps.h
new file mode 100644
index 0000000..908402f
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/Caps.h
@@ -0,0 +1,83 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Caps
+#define INCLUDED_snikket_Caps
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Caps)
+HX_DECLARE_CLASS1(snikket,Hash)
+HX_DECLARE_CLASS1(snikket,Identity)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Caps_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Caps_obj OBJ_;
+		Caps_obj();
+
+	public:
+		enum { _hx_ClassId = 0x02663c7e };
+
+		void __construct(::String node,::Array< ::Dynamic> identities,::Array< ::String > features);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Caps")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Caps"); }
+		static ::hx::ObjectPtr< Caps_obj > __new(::String node,::Array< ::Dynamic> identities,::Array< ::String > features);
+		static ::hx::ObjectPtr< Caps_obj > __alloc(::hx::Ctx *_hx_ctx,::String node,::Array< ::Dynamic> identities,::Array< ::String > features);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Caps_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Caps",41,48,93,2c); }
+
+		static ::Array< ::String > withIdentity( ::Dynamic caps,::String category,::String type);
+		static ::Dynamic withIdentity_dyn();
+
+		static ::Array< ::String > withFeature( ::Dynamic caps,::String feature);
+		static ::Dynamic withFeature_dyn();
+
+		::String node;
+		::Array< ::Dynamic> identities;
+		::Array< ::String > features;
+		 ::snikket::Hash _ver;
+		bool isChannel(::String chatId);
+		::Dynamic isChannel_dyn();
+
+		 ::snikket::Stanza discoReply();
+		::Dynamic discoReply_dyn();
+
+		 ::snikket::Stanza addC( ::snikket::Stanza stanza);
+		::Dynamic addC_dyn();
+
+		 ::snikket::Hash computeVer();
+		::Dynamic computeVer_dyn();
+
+		 ::snikket::Hash verRaw();
+		::Dynamic verRaw_dyn();
+
+		::String ver();
+		::Dynamic ver_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Caps */ 
diff --git a/Sources/c_snikket/iinclude/snikket/Channel.h b/Sources/c_snikket/iinclude/snikket/Channel.h
new file mode 100644
index 0000000..74066bc
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/Channel.h
@@ -0,0 +1,144 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Channel
+#define INCLUDED_snikket_Channel
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_Chat
+#include <snikket/Chat.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Caps)
+HX_DECLARE_CLASS1(snikket,Channel)
+HX_DECLARE_CLASS1(snikket,Chat)
+HX_DECLARE_CLASS1(snikket,ChatMessage)
+HX_DECLARE_CLASS1(snikket,ChatMessageBuilder)
+HX_DECLARE_CLASS1(snikket,Client)
+HX_DECLARE_CLASS1(snikket,EventEmitter)
+HX_DECLARE_CLASS1(snikket,GenericStream)
+HX_DECLARE_CLASS1(snikket,JID)
+HX_DECLARE_CLASS1(snikket,MessageSync)
+HX_DECLARE_CLASS1(snikket,Participant)
+HX_DECLARE_CLASS1(snikket,Persistence)
+HX_DECLARE_CLASS1(snikket,Presence)
+HX_DECLARE_CLASS1(snikket,Reaction)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Channel_obj : public  ::snikket::Chat_obj
+{
+	public:
+		typedef  ::snikket::Chat_obj super;
+		typedef Channel_obj OBJ_;
+		Channel_obj();
+
+	public:
+		enum { _hx_ClassId = 0x23f2b886 };
+
+		void __construct( ::snikket::Client client, ::snikket::GenericStream stream,::Dynamic persistence,::String chatId,::hx::Null< int >  __o_uiState,::hx::Null< bool >  __o_isBlocked, ::snikket::Stanza extensions,::String readUpToId,::String readUpToBy, ::snikket::Caps disco);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Channel")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Channel"); }
+		static ::hx::ObjectPtr< Channel_obj > __new( ::snikket::Client client, ::snikket::GenericStream stream,::Dynamic persistence,::String chatId,::hx::Null< int >  __o_uiState,::hx::Null< bool >  __o_isBlocked, ::snikket::Stanza extensions,::String readUpToId,::String readUpToBy, ::snikket::Caps disco);
+		static ::hx::ObjectPtr< Channel_obj > __alloc(::hx::Ctx *_hx_ctx, ::snikket::Client client, ::snikket::GenericStream stream,::Dynamic persistence,::String chatId,::hx::Null< int >  __o_uiState,::hx::Null< bool >  __o_isBlocked, ::snikket::Stanza extensions,::String readUpToId,::String readUpToBy, ::snikket::Caps disco);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Channel_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Channel",a3,28,23,9a); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		 ::snikket::Caps disco;
+		bool inSync;
+		 ::snikket::MessageSync sync;
+		bool forceLive;
+		::String _nickInUse;
+		void selfPing(bool refresh);
+		::Dynamic selfPing_dyn();
+
+		void join();
+		::Dynamic join_dyn();
+
+		void selfPingSuccess();
+		::Dynamic selfPingSuccess_dyn();
+
+		void setPresence(::String resource, ::snikket::Presence presence);
+
+		void doSync(::String lastId);
+		::Dynamic doSync_dyn();
+
+		bool isTrusted();
+
+		bool isPrivate();
+		::Dynamic isPrivate_dyn();
+
+		void refreshDisco( ::Dynamic callback);
+		::Dynamic refreshDisco_dyn();
+
+		::String preview();
+
+		bool livePresence();
+
+		bool syncing();
+
+		bool canAudioCall();
+
+		bool canVideoCall();
+
+		::String nickInUse();
+		::Dynamic nickInUse_dyn();
+
+		 ::snikket::JID getFullJid();
+		::Dynamic getFullJid_dyn();
+
+		::Array< ::String > getParticipants();
+
+		 ::snikket::Participant getParticipantDetails(::String participantId);
+
+		void getMessagesBefore(::String beforeId,::String beforeTime, ::Dynamic handler);
+
+		void getMessagesAfter(::String afterId,::String afterTime, ::Dynamic handler);
+
+		void getMessagesAround(::String aroundId,::String aroundTime, ::Dynamic handler);
+
+		 ::snikket::ChatMessageBuilder prepareIncomingMessage( ::snikket::ChatMessageBuilder message, ::snikket::Stanza stanza);
+
+		 ::snikket::ChatMessageBuilder prepareOutgoingMessage( ::snikket::ChatMessageBuilder message);
+		::Dynamic prepareOutgoingMessage_dyn();
+
+		void correctMessage(::String localId, ::snikket::ChatMessageBuilder message);
+
+		void sendMessage( ::snikket::ChatMessageBuilder message);
+
+		void removeReaction( ::snikket::ChatMessage m, ::snikket::Reaction reaction);
+
+		::String lastMessageId();
+
+		void markReadUpTo( ::snikket::ChatMessage message);
+
+		void bookmark();
+
+		void sendChatState(::String state,::String threadId);
+
+		void close();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Channel */ 
diff --git a/Sources/c_snikket/iinclude/snikket/Chat.h b/Sources/c_snikket/iinclude/snikket/Chat.h
new file mode 100644
index 0000000..244dff4
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/Chat.h
@@ -0,0 +1,295 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Chat
+#define INCLUDED_snikket_Chat
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS1(haxe,Timer)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS1(snikket,Caps)
+HX_DECLARE_CLASS1(snikket,Chat)
+HX_DECLARE_CLASS1(snikket,ChatMessage)
+HX_DECLARE_CLASS1(snikket,ChatMessageBuilder)
+HX_DECLARE_CLASS1(snikket,Client)
+HX_DECLARE_CLASS1(snikket,EventEmitter)
+HX_DECLARE_CLASS1(snikket,GenericStream)
+HX_DECLARE_CLASS1(snikket,MessageSync)
+HX_DECLARE_CLASS1(snikket,Participant)
+HX_DECLARE_CLASS1(snikket,Persistence)
+HX_DECLARE_CLASS1(snikket,Presence)
+HX_DECLARE_CLASS1(snikket,Reaction)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,jingle,DTMFSender)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStream)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStreamTrack)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Chat_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Chat_obj OBJ_;
+		Chat_obj();
+
+	public:
+		enum { _hx_ClassId = 0x026b7f35 };
+
+		void __construct( ::snikket::Client client, ::snikket::GenericStream stream,::Dynamic persistence,::String chatId,::hx::Null< int >  __o_uiState,::hx::Null< bool >  __o_isBlocked, ::snikket::Stanza extensions,::String readUpToId,::String readUpToBy);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Chat")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Chat"); }
+
+		//~Chat_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Chat",f8,8a,98,2c); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		 ::snikket::Client client;
+		 ::snikket::GenericStream stream;
+		::Dynamic persistence;
+		::Array< unsigned char > avatarSha1;
+		 ::haxe::ds::StringMap presence;
+		bool trusted;
+		::String chatId;
+		::String chatId__fromC();
+		::Dynamic chatId__fromC_dyn();
+
+		 ::haxe::ds::StringMap jingleSessions;
+		::String displayName;
+		int uiState;
+		int uiState__fromC();
+		::Dynamic uiState__fromC_dyn();
+
+		bool isBlocked;
+		bool isBlocked__fromC();
+		::Dynamic isBlocked__fromC_dyn();
+
+		 ::snikket::Stanza extensions;
+		int _unreadCount;
+		 ::snikket::ChatMessage lastMessage;
+		::String readUpToId;
+		::String readUpToBy;
+		bool isTyping;
+		::String typingThread;
+		 ::haxe::Timer typingTimer;
+		 ::Dynamic isActive;
+		::String activeThread;
+		 ::Dynamic notificationSettings;
+		virtual  ::snikket::ChatMessageBuilder prepareIncomingMessage( ::snikket::ChatMessageBuilder message, ::snikket::Stanza stanza) { return 0; }
+		::Dynamic prepareIncomingMessage_dyn();
+		virtual void getMessagesBefore(::String beforeId,::String beforeTime, ::Dynamic handler) {}
+		::Dynamic getMessagesBefore_dyn();
+		void getMessagesBefore__fromC(::String beforeId,::String beforeTime,::cpp::Function< void  (void**,size_t,void*) > handler,void* handler__context);
+
+		virtual void getMessagesAfter(::String afterId,::String afterTime, ::Dynamic handler) {}
+		::Dynamic getMessagesAfter_dyn();
+		void getMessagesAfter__fromC(::String afterId,::String afterTime,::cpp::Function< void  (void**,size_t,void*) > handler,void* handler__context);
+
+		virtual void getMessagesAround(::String aroundId,::String aroundTime, ::Dynamic handler) {}
+		::Dynamic getMessagesAround_dyn();
+		void getMessagesAround__fromC(::String aroundId,::String aroundTime,::cpp::Function< void  (void**,size_t,void*) > handler,void* handler__context);
+
+		void fetchFromSync( ::snikket::MessageSync sync, ::Dynamic callback);
+		::Dynamic fetchFromSync_dyn();
+
+		virtual void sendMessage( ::snikket::ChatMessageBuilder message) {}
+		::Dynamic sendMessage_dyn();
+		void sendMessage__fromC( ::snikket::ChatMessageBuilder message);
+		::Dynamic sendMessage__fromC_dyn();
+
+		virtual void markReadUpTo( ::snikket::ChatMessage message) {}
+		::Dynamic markReadUpTo_dyn();
+		void markReadUpTo__fromC( ::snikket::ChatMessage message);
+		::Dynamic markReadUpTo__fromC_dyn();
+
+		virtual void bookmark() {}
+		::Dynamic bookmark_dyn();
+		void bookmark__fromC();
+		::Dynamic bookmark__fromC_dyn();
+
+		virtual ::Array< ::String > getParticipants() { return 0; }
+		::Dynamic getParticipants_dyn();
+		size_t getParticipants__fromC(const char*** outPtr);
+
+		virtual  ::snikket::Participant getParticipantDetails(::String participantId) { return 0; }
+		::Dynamic getParticipantDetails_dyn();
+		 ::snikket::Participant getParticipantDetails__fromC(::String participantId);
+		::Dynamic getParticipantDetails__fromC_dyn();
+
+		virtual void correctMessage(::String localId, ::snikket::ChatMessageBuilder message) {}
+		::Dynamic correctMessage_dyn();
+		void correctMessage__fromC(::String localId, ::snikket::ChatMessageBuilder message);
+		::Dynamic correctMessage__fromC_dyn();
+
+		void addReaction( ::snikket::ChatMessage m, ::snikket::Reaction reaction);
+		::Dynamic addReaction_dyn();
+
+		virtual void removeReaction( ::snikket::ChatMessage m, ::snikket::Reaction reaction) {}
+		::Dynamic removeReaction_dyn();
+		void removeReaction__fromC( ::snikket::ChatMessage m, ::snikket::Reaction reaction);
+		::Dynamic removeReaction__fromC_dyn();
+
+		virtual void sendChatState(::String state,::String threadId) {}
+		::Dynamic sendChatState_dyn();
+		void typing(::String threadId,::String content);
+		::Dynamic typing_dyn();
+
+		void setActive(bool active,::String threadId);
+		::Dynamic setActive_dyn();
+
+		virtual void close() {}
+		::Dynamic close_dyn();
+		void close__fromC();
+		::Dynamic close__fromC_dyn();
+
+		void togglePinned();
+		::Dynamic togglePinned_dyn();
+
+		void block( ::snikket::ChatMessage reportSpam,bool onServer);
+		::Dynamic block_dyn();
+
+		void unblock(bool onServer);
+		::Dynamic unblock_dyn();
+
+		void setNotifications(bool filtered,bool mention,bool reply);
+		::Dynamic setNotifications_dyn();
+
+		bool notificationsFiltered();
+		::Dynamic notificationsFiltered_dyn();
+
+		bool notifyMention();
+		::Dynamic notifyMention_dyn();
+
+		bool notifyReply();
+		::Dynamic notifyReply_dyn();
+
+		virtual ::String lastMessageId() { return 0; }
+		::Dynamic lastMessageId_dyn();
+		::String lastMessageId__fromC();
+		::Dynamic lastMessageId__fromC_dyn();
+
+		::String lastMessageTimestamp();
+		::Dynamic lastMessageTimestamp_dyn();
+
+		void updateFromBookmark( ::snikket::Stanza item);
+		::Dynamic updateFromBookmark_dyn();
+
+		void updateFromRoster( ::Dynamic item);
+		::Dynamic updateFromRoster_dyn();
+
+		::String getPhoto();
+		::Dynamic getPhoto_dyn();
+
+		::String getPlaceholder();
+		::Dynamic getPlaceholder_dyn();
+
+		::String readUpTo();
+		::Dynamic readUpTo_dyn();
+
+		int unreadCount();
+		::Dynamic unreadCount_dyn();
+
+		void setUnreadCount(int count);
+		::Dynamic setUnreadCount_dyn();
+
+		virtual ::String preview();
+		::Dynamic preview_dyn();
+
+		void setLastMessage( ::snikket::ChatMessage message);
+		::Dynamic setLastMessage_dyn();
+
+		void setDisplayName(::String fn);
+		::Dynamic setDisplayName_dyn();
+
+		::String getDisplayName();
+		::Dynamic getDisplayName_dyn();
+
+		virtual void setPresence(::String resource, ::snikket::Presence presence);
+		::Dynamic setPresence_dyn();
+
+		void setCaps(::String resource, ::snikket::Caps caps);
+		::Dynamic setCaps_dyn();
+
+		void removePresence(::String resource);
+		::Dynamic removePresence_dyn();
+
+		 ::Dynamic getCaps();
+		::Dynamic getCaps_dyn();
+
+		 ::snikket::Caps getResourceCaps(::String resource);
+		::Dynamic getResourceCaps_dyn();
+
+		void setAvatarSha1(::Array< unsigned char > sha1);
+		::Dynamic setAvatarSha1_dyn();
+
+		void setTrusted(bool trusted);
+		::Dynamic setTrusted_dyn();
+
+		virtual bool isTrusted();
+		::Dynamic isTrusted_dyn();
+
+		virtual bool livePresence();
+		::Dynamic livePresence_dyn();
+
+		virtual bool syncing();
+		::Dynamic syncing_dyn();
+
+		virtual bool canAudioCall();
+		::Dynamic canAudioCall_dyn();
+
+		virtual bool canVideoCall();
+		::Dynamic canVideoCall_dyn();
+
+		void startCall(bool audio,bool video);
+		::Dynamic startCall_dyn();
+
+		void addMedia(::Array< ::Dynamic> streams);
+		::Dynamic addMedia_dyn();
+
+		void acceptCall();
+		::Dynamic acceptCall_dyn();
+
+		void hangup();
+		::Dynamic hangup_dyn();
+
+		::String callStatus();
+		::Dynamic callStatus_dyn();
+
+		 ::snikket::jingle::DTMFSender dtmf();
+		::Dynamic dtmf_dyn();
+
+		::Array< ::Dynamic> videoTracks();
+		::Dynamic videoTracks_dyn();
+
+		size_t videoTracks__fromC(void*** outPtr);
+
+		void markReadUpToId(::String upTo,::String upToBy, ::Dynamic callback);
+		::Dynamic markReadUpToId_dyn();
+
+		void markReadUpToMessage( ::snikket::ChatMessage message, ::Dynamic callback);
+		::Dynamic markReadUpToMessage_dyn();
+
+		void publishMds();
+		::Dynamic publishMds_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Chat */ 
diff --git a/Sources/c_snikket/iinclude/snikket/ChatAttachment.h b/Sources/c_snikket/iinclude/snikket/ChatAttachment.h
new file mode 100644
index 0000000..a22273b
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/ChatAttachment.h
@@ -0,0 +1,75 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_ChatAttachment
+#define INCLUDED_snikket_ChatAttachment
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,ChatAttachment)
+HX_DECLARE_CLASS1(snikket,Hash)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES ChatAttachment_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef ChatAttachment_obj OBJ_;
+		ChatAttachment_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2f907f78 };
+
+		void __construct(::String name,::String mime, ::Dynamic size,::Array< ::String > uris,::Array< ::Dynamic> hashes);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.ChatAttachment")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.ChatAttachment"); }
+		static ::hx::ObjectPtr< ChatAttachment_obj > __new(::String name,::String mime, ::Dynamic size,::Array< ::String > uris,::Array< ::Dynamic> hashes);
+		static ::hx::ObjectPtr< ChatAttachment_obj > __alloc(::hx::Ctx *_hx_ctx,::String name,::String mime, ::Dynamic size,::Array< ::String > uris,::Array< ::Dynamic> hashes);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ChatAttachment_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ChatAttachment",fb,fc,04,6c); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static  ::snikket::ChatAttachment create(::String name,::String mime,int size,::String uri);
+		static ::Dynamic create_dyn();
+
+		::String name;
+		::String name__fromC();
+		::Dynamic name__fromC_dyn();
+
+		::String mime;
+		::String mime__fromC();
+		::Dynamic mime__fromC_dyn();
+
+		 ::Dynamic size;
+		 ::Dynamic size__fromC();
+		::Dynamic size__fromC_dyn();
+
+		::Array< ::String > uris;
+		size_t uris__fromC(const char*** outPtr);
+
+		::Array< ::Dynamic> hashes;
+		size_t hashes__fromC(void*** outPtr);
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_ChatAttachment */ 
diff --git a/Sources/c_snikket/iinclude/snikket/ChatMessage.h b/Sources/c_snikket/iinclude/snikket/ChatMessage.h
new file mode 100644
index 0000000..c2531ac
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/ChatMessage.h
@@ -0,0 +1,172 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_ChatMessage
+#define INCLUDED_snikket_ChatMessage
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS1(snikket,ChatAttachment)
+HX_DECLARE_CLASS1(snikket,ChatMessage)
+HX_DECLARE_CLASS1(snikket,ChatMessageBuilder)
+HX_DECLARE_CLASS1(snikket,Hash)
+HX_DECLARE_CLASS1(snikket,JID)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES ChatMessage_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef ChatMessage_obj OBJ_;
+		ChatMessage_obj();
+
+	public:
+		enum { _hx_ClassId = 0x36665f12 };
+
+		void __construct( ::Dynamic params);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.ChatMessage")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.ChatMessage"); }
+		static ::hx::ObjectPtr< ChatMessage_obj > __new( ::Dynamic params);
+		static ::hx::ObjectPtr< ChatMessage_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic params);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ChatMessage_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ChatMessage",af,a1,2d,18); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static  ::snikket::ChatMessage fromStanza( ::snikket::Stanza stanza, ::snikket::JID localJid, ::Dynamic addContext);
+		static ::Dynamic fromStanza_dyn();
+
+		::String localId;
+		::String localId__fromC();
+		::Dynamic localId__fromC_dyn();
+
+		::String serverId;
+		::String serverId__fromC();
+		::Dynamic serverId__fromC_dyn();
+
+		::String serverIdBy;
+		::String serverIdBy__fromC();
+		::Dynamic serverIdBy__fromC_dyn();
+
+		int type;
+		int type__fromC();
+		::Dynamic type__fromC_dyn();
+
+		bool syncPoint;
+		::String replyId;
+		::String timestamp;
+		::String timestamp__fromC();
+		::Dynamic timestamp__fromC_dyn();
+
+		 ::snikket::JID to;
+		 ::snikket::JID from;
+		::Array< ::Dynamic> recipients;
+		::Array< ::Dynamic> replyTo;
+		::String senderId;
+		::String senderId__fromC();
+		::Dynamic senderId__fromC_dyn();
+
+		 ::snikket::ChatMessage replyToMessage;
+		 ::snikket::ChatMessage replyToMessage__fromC();
+		::Dynamic replyToMessage__fromC_dyn();
+
+		::String threadId;
+		::String threadId__fromC();
+		::Dynamic threadId__fromC_dyn();
+
+		::Array< ::Dynamic> attachments;
+		size_t attachments__fromC(void*** outPtr);
+
+		 ::haxe::ds::StringMap reactions;
+		::String text;
+		::String text__fromC();
+		::Dynamic text__fromC_dyn();
+
+		::String lang;
+		::String lang__fromC();
+		::Dynamic lang__fromC_dyn();
+
+		int direction;
+		int direction__fromC();
+		::Dynamic direction__fromC_dyn();
+
+		int status;
+		int status__fromC();
+		::Dynamic status__fromC_dyn();
+
+		void set_status__fromC(int value);
+		::Dynamic set_status__fromC_dyn();
+
+		::Array< ::Dynamic> versions;
+		size_t versions__fromC(void*** outPtr);
+
+		::Array< ::Dynamic> payloads;
+		 ::snikket::Stanza stanza;
+		 ::snikket::ChatMessageBuilder reply();
+		::Dynamic reply_dyn();
+
+		::String getReplyId();
+		::Dynamic getReplyId_dyn();
+
+		 ::snikket::ChatMessage set_replyToMessage( ::snikket::ChatMessage m);
+		::Dynamic set_replyToMessage_dyn();
+
+		 ::haxe::ds::StringMap set_reactions( ::haxe::ds::StringMap r);
+		::Dynamic set_reactions_dyn();
+
+		::Array< ::Dynamic> inlineHashReferences();
+		::Dynamic inlineHashReferences_dyn();
+
+		::String html();
+		::Dynamic html_dyn();
+
+		::String chatId();
+		::Dynamic chatId_dyn();
+
+		::String account();
+		::Dynamic account_dyn();
+
+		bool isIncoming();
+		::Dynamic isIncoming_dyn();
+
+		::String threadIcon();
+		::Dynamic threadIcon_dyn();
+
+		::String callStatus();
+		::Dynamic callStatus_dyn();
+
+		::String callSid();
+		::Dynamic callSid_dyn();
+
+		::String callDuration();
+		::Dynamic callDuration_dyn();
+
+		 ::snikket::Stanza asStanza();
+		::Dynamic asStanza_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_ChatMessage */ 
diff --git a/Sources/c_snikket/iinclude/snikket/ChatMessageBuilder.h b/Sources/c_snikket/iinclude/snikket/ChatMessageBuilder.h
new file mode 100644
index 0000000..041e48a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/ChatMessageBuilder.h
@@ -0,0 +1,189 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_ChatMessageBuilder
+#define INCLUDED_snikket_ChatMessageBuilder
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS1(htmlparser,HtmlNode)
+HX_DECLARE_CLASS1(snikket,ChatAttachment)
+HX_DECLARE_CLASS1(snikket,ChatMessage)
+HX_DECLARE_CLASS1(snikket,ChatMessageBuilder)
+HX_DECLARE_CLASS1(snikket,JID)
+HX_DECLARE_CLASS1(snikket,Node)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES ChatMessageBuilder_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef ChatMessageBuilder_obj OBJ_;
+		ChatMessageBuilder_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1d9d1345 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.ChatMessageBuilder")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.ChatMessageBuilder"); }
+		static ::hx::ObjectPtr< ChatMessageBuilder_obj > __new();
+		static ::hx::ObjectPtr< ChatMessageBuilder_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ChatMessageBuilder_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ChatMessageBuilder",2c,85,c0,07); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static  ::snikket::ChatMessage makeModerated( ::snikket::ChatMessage m,::String timestamp,::String moderatorId,::String reason);
+		static ::Dynamic makeModerated_dyn();
+
+		::String localId;
+		::String localId__fromC();
+		::Dynamic localId__fromC_dyn();
+
+		void set_localId__fromC(::String value);
+		::Dynamic set_localId__fromC_dyn();
+
+		::String serverId;
+		::String serverId__fromC();
+		::Dynamic serverId__fromC_dyn();
+
+		void set_serverId__fromC(::String value);
+		::Dynamic set_serverId__fromC_dyn();
+
+		::String serverIdBy;
+		::String serverIdBy__fromC();
+		::Dynamic serverIdBy__fromC_dyn();
+
+		void set_serverIdBy__fromC(::String value);
+		::Dynamic set_serverIdBy__fromC_dyn();
+
+		int type;
+		int type__fromC();
+		::Dynamic type__fromC_dyn();
+
+		void set_type__fromC(int value);
+		::Dynamic set_type__fromC_dyn();
+
+		bool syncPoint;
+		::String replyId;
+		::String timestamp;
+		::String timestamp__fromC();
+		::Dynamic timestamp__fromC_dyn();
+
+		void set_timestamp__fromC(::String value);
+		::Dynamic set_timestamp__fromC_dyn();
+
+		 ::snikket::JID to;
+		 ::snikket::JID from;
+		 ::snikket::JID sender;
+		::Array< ::Dynamic> recipients;
+		::Array< ::Dynamic> replyTo;
+		::String senderId;
+		::String senderId__fromC();
+		::Dynamic senderId__fromC_dyn();
+
+		void set_senderId__fromC(::String value);
+		::Dynamic set_senderId__fromC_dyn();
+
+		 ::snikket::ChatMessage replyToMessage;
+		 ::snikket::ChatMessage replyToMessage__fromC();
+		::Dynamic replyToMessage__fromC_dyn();
+
+		void set_replyToMessage__fromC( ::snikket::ChatMessage value);
+		::Dynamic set_replyToMessage__fromC_dyn();
+
+		::String threadId;
+		::String threadId__fromC();
+		::Dynamic threadId__fromC_dyn();
+
+		void set_threadId__fromC(::String value);
+		::Dynamic set_threadId__fromC_dyn();
+
+		::Array< ::Dynamic> attachments;
+		size_t attachments__fromC(void*** outPtr);
+
+		 ::haxe::ds::StringMap reactions;
+		::String text;
+		::String text__fromC();
+		::Dynamic text__fromC_dyn();
+
+		void set_text__fromC(::String value);
+		::Dynamic set_text__fromC_dyn();
+
+		::String lang;
+		::String lang__fromC();
+		::Dynamic lang__fromC_dyn();
+
+		void set_lang__fromC(::String value);
+		::Dynamic set_lang__fromC_dyn();
+
+		int direction;
+		int direction__fromC();
+		::Dynamic direction__fromC_dyn();
+
+		void set_direction__fromC(int value);
+		::Dynamic set_direction__fromC_dyn();
+
+		int status;
+		int status__fromC();
+		::Dynamic status__fromC_dyn();
+
+		void set_status__fromC(int value);
+		::Dynamic set_status__fromC_dyn();
+
+		::Array< ::Dynamic> versions;
+		size_t versions__fromC(void*** outPtr);
+
+		::Array< ::Dynamic> payloads;
+		 ::snikket::Stanza stanza;
+		void attachSims( ::snikket::Stanza sims);
+		::Dynamic attachSims_dyn();
+
+		void addAttachment( ::snikket::ChatAttachment attachment);
+		::Dynamic addAttachment_dyn();
+
+		void setHtml(::String html);
+		::Dynamic setHtml_dyn();
+
+		 ::snikket::Node htmlToNode( ::htmlparser::HtmlNode node);
+		::Dynamic htmlToNode_dyn();
+
+		::String chatId();
+		::Dynamic chatId_dyn();
+
+		::String get_senderId();
+		::Dynamic get_senderId_dyn();
+
+		bool isIncoming();
+		::Dynamic isIncoming_dyn();
+
+		 ::snikket::ChatMessage build();
+		::Dynamic build_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_ChatMessageBuilder */ 
diff --git a/Sources/c_snikket/iinclude/snikket/Client.h b/Sources/c_snikket/iinclude/snikket/Client.h
new file mode 100644
index 0000000..8908f68
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/Client.h
@@ -0,0 +1,279 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Client
+#define INCLUDED_snikket_Client
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_EventEmitter
+#include <snikket/EventEmitter.h>
+#endif
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS1(snikket,AttachmentSource)
+HX_DECLARE_CLASS1(snikket,AvailableChat)
+HX_DECLARE_CLASS1(snikket,Caps)
+HX_DECLARE_CLASS1(snikket,Chat)
+HX_DECLARE_CLASS1(snikket,ChatAttachment)
+HX_DECLARE_CLASS1(snikket,ChatMessage)
+HX_DECLARE_CLASS1(snikket,Client)
+HX_DECLARE_CLASS1(snikket,DirectChat)
+HX_DECLARE_CLASS1(snikket,EventEmitter)
+HX_DECLARE_CLASS1(snikket,EventResult)
+HX_DECLARE_CLASS1(snikket,GenericStream)
+HX_DECLARE_CLASS1(snikket,Hash)
+HX_DECLARE_CLASS1(snikket,JID)
+HX_DECLARE_CLASS1(snikket,ModerationAction)
+HX_DECLARE_CLASS1(snikket,Persistence)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,jingle,InitiatedSession)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStream)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStreamTrack)
+HX_DECLARE_CLASS2(snikket,jingle,Session)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Client_obj : public  ::snikket::EventEmitter_obj
+{
+	public:
+		typedef  ::snikket::EventEmitter_obj super;
+		typedef Client_obj OBJ_;
+		Client_obj();
+
+	public:
+		enum { _hx_ClassId = 0x668a7be8 };
+
+		void __construct(::String address,::Dynamic persistence);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Client")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Client"); }
+		static ::hx::ObjectPtr< Client_obj > __new(::String address,::Dynamic persistence);
+		static ::hx::ObjectPtr< Client_obj > __alloc(::hx::Ctx *_hx_ctx,::String address,::Dynamic persistence);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Client_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Client",6b,3e,e4,3e); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		bool sendAvailable;
+		void set_sendAvailable__fromC(bool value);
+		::Dynamic set_sendAvailable__fromC_dyn();
+
+		 ::snikket::GenericStream stream;
+		::Array< ::Dynamic> chatMessageHandlers;
+		::Array< ::Dynamic> syncMessageHandlers;
+		::Array< ::Dynamic> chatStateHandlers;
+		 ::snikket::JID jid;
+		::Array< ::Dynamic> chats;
+		::Dynamic persistence;
+		 ::snikket::Caps caps;
+		::String _displayName;
+		::String fastMechanism;
+		::String token;
+		 ::haxe::ds::StringMap pendingCaps;
+		bool inSync;
+		void start();
+		::Dynamic start_dyn();
+
+		void logout(bool completely);
+		::Dynamic logout_dyn();
+
+		void usePassword(::String password);
+		::Dynamic usePassword_dyn();
+
+		::String accountId();
+		::Dynamic accountId_dyn();
+
+		::String displayName();
+		::Dynamic displayName_dyn();
+
+		void setDisplayName(::String displayName);
+		::Dynamic setDisplayName_dyn();
+
+		bool updateDisplayName(::String fn);
+		::Dynamic updateDisplayName_dyn();
+
+		 ::snikket::EventResult onConnected( ::Dynamic data);
+		::Dynamic onConnected_dyn();
+
+		void prepareAttachment( ::snikket::AttachmentSource source, ::Dynamic callback);
+		::Dynamic prepareAttachment_dyn();
+
+		void prepareAttachment__fromC( ::snikket::AttachmentSource source,::cpp::Function< void  (void*,void*) > callback,void* callback__context);
+
+		void prepareAttachmentFor( ::snikket::AttachmentSource source,::Array< ::Dynamic> services,::Array< ::Dynamic> hashes, ::Dynamic callback);
+		::Dynamic prepareAttachmentFor_dyn();
+
+		::Array< ::Dynamic> getChats();
+		::Dynamic getChats_dyn();
+
+		size_t getChats__fromC(void*** outPtr);
+
+		void findAvailableChats(::String q, ::Dynamic callback);
+		::Dynamic findAvailableChats_dyn();
+
+		void findAvailableChats__fromC(::String q,::cpp::Function< void  (const char*,void**,size_t,void*) > callback,void* callback__context);
+
+		 ::snikket::Chat startChat( ::snikket::AvailableChat availableChat);
+		::Dynamic startChat_dyn();
+
+		 ::snikket::Chat getChat(::String chatId);
+		::Dynamic getChat_dyn();
+
+		::Dynamic moderateMessage( ::snikket::ModerationAction action);
+		::Dynamic moderateMessage_dyn();
+
+		 ::snikket::DirectChat getDirectChat(::String chatId,::hx::Null< bool >  triggerIfNew);
+		::Dynamic getDirectChat_dyn();
+
+		void addPasswordNeededListener( ::Dynamic handler);
+		::Dynamic addPasswordNeededListener_dyn();
+
+		void addPasswordNeededListener__fromC(::cpp::Function< void  (void*,void*) > handler,void* handler__context);
+
+		void addStatusOnlineListener( ::Dynamic handler);
+		::Dynamic addStatusOnlineListener_dyn();
+
+		void addStatusOnlineListener__fromC(::cpp::Function< void  (void*) > handler,void* handler__context);
+
+		void addStatusOfflineListener( ::Dynamic handler);
+		::Dynamic addStatusOfflineListener_dyn();
+
+		void addStatusOfflineListener__fromC(::cpp::Function< void  (void*) > handler,void* handler__context);
+
+		void addConnectionFailedListener( ::Dynamic handler);
+		::Dynamic addConnectionFailedListener_dyn();
+
+		void addConnectionFailedListener__fromC(::cpp::Function< void  (void*) > handler,void* handler__context);
+
+		void addChatMessageListener( ::Dynamic handler);
+		::Dynamic addChatMessageListener_dyn();
+
+		void addChatMessageListener__fromC(::cpp::Function< void  (void*,int,void*) > handler,void* handler__context);
+
+		void addSyncMessageListener( ::Dynamic handler);
+		::Dynamic addSyncMessageListener_dyn();
+
+		void addSyncMessageListener__fromC(::cpp::Function< void  (void*,void*) > handler,void* handler__context);
+
+		void addChatsUpdatedListener( ::Dynamic handler);
+		::Dynamic addChatsUpdatedListener_dyn();
+
+		void addChatsUpdatedListener__fromC(::cpp::Function< void  (void**,size_t,void*) > handler,void* handler__context);
+
+		void addCallRingListener( ::Dynamic handler);
+		::Dynamic addCallRingListener_dyn();
+
+		void addCallRingListener__fromC(::cpp::Function< void  (void*,const char*,void*) > handler,void* handler__context);
+
+		void addCallRetractListener( ::Dynamic handler);
+		::Dynamic addCallRetractListener_dyn();
+
+		void addCallRetractListener__fromC(::cpp::Function< void  (const char*,void*) > handler,void* handler__context);
+
+		void addCallRingingListener( ::Dynamic handler);
+		::Dynamic addCallRingingListener_dyn();
+
+		void addCallRingingListener__fromC(::cpp::Function< void  (const char*,void*) > handler,void* handler__context);
+
+		void addCallMediaListener( ::Dynamic handler);
+		::Dynamic addCallMediaListener_dyn();
+
+		void addCallMediaListener__fromC(::cpp::Function< void  (void*,bool,bool,void*) > handler,void* handler__context);
+
+		void addCallTrackListener( ::Dynamic handler);
+		::Dynamic addCallTrackListener_dyn();
+
+		void addCallTrackListener__fromC(::cpp::Function< void  (const char*,void*,void**,size_t,void*) > handler,void* handler__context);
+
+		void setInForeground();
+		::Dynamic setInForeground_dyn();
+
+		void setNotInForeground();
+		::Dynamic setNotInForeground_dyn();
+
+		::Dynamic fetchMediaByHash(::Array< ::Dynamic> hashes,::Array< ::Dynamic> counterparts);
+		::Dynamic fetchMediaByHash_dyn();
+
+		::Dynamic fetchMediaByHashOneCounterpart(::Array< ::Dynamic> hashes, ::snikket::JID counterpart);
+		::Dynamic fetchMediaByHashOneCounterpart_dyn();
+
+		void chatActivity( ::snikket::Chat chat,::hx::Null< bool >  trigger);
+		::Dynamic chatActivity_dyn();
+
+		void sortChats();
+		::Dynamic sortChats_dyn();
+
+		void storeMessages(::Array< ::Dynamic> messages, ::Dynamic callback);
+		::Dynamic storeMessages_dyn();
+
+		void sendQuery( ::snikket::queries::GenericQuery query);
+		::Dynamic sendQuery_dyn();
+
+		void sendStanza( ::snikket::Stanza stanza);
+		::Dynamic sendStanza_dyn();
+
+		void sendPresence(::String to, ::Dynamic augment);
+		::Dynamic sendPresence_dyn();
+
+		void getIceServers( ::Dynamic callback);
+		::Dynamic getIceServers_dyn();
+
+		void discoverServices( ::snikket::JID target,::String node, ::Dynamic callback);
+		::Dynamic discoverServices_dyn();
+
+		void notifyMessageHandlers( ::snikket::ChatMessage message,int event);
+		::Dynamic notifyMessageHandlers_dyn();
+
+		void notifySyncMessageHandlers( ::snikket::ChatMessage message);
+		::Dynamic notifySyncMessageHandlers_dyn();
+
+		void rosterGet();
+		::Dynamic rosterGet_dyn();
+
+		void startChatWith(::String jid, ::Dynamic handleCaps, ::Dynamic handleChat);
+		::Dynamic startChatWith_dyn();
+
+		void serverBlocked(::String blocked);
+		::Dynamic serverBlocked_dyn();
+
+		void bookmarksGet( ::Dynamic callback);
+		::Dynamic bookmarksGet_dyn();
+
+		void sync( ::Dynamic callback);
+		::Dynamic sync_dyn();
+
+		void onMAMJMI(::String sid, ::snikket::Stanza stanza);
+		::Dynamic onMAMJMI_dyn();
+
+		void doSync( ::Dynamic callback,::String lastId);
+		::Dynamic doSync_dyn();
+
+		void pingAllChannels(bool refresh);
+		::Dynamic pingAllChannels_dyn();
+
+		void joinAllChannels();
+		::Dynamic joinAllChannels_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Client */ 
diff --git a/Sources/c_snikket/iinclude/snikket/Color.h b/Sources/c_snikket/iinclude/snikket/Color.h
new file mode 100644
index 0000000..074383f
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/Color.h
@@ -0,0 +1,63 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Color
+#define INCLUDED_snikket_Color
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Color)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Color_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Color_obj OBJ_;
+		Color_obj();
+
+	public:
+		enum { _hx_ClassId = 0x204ca266 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket.Color")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket.Color"); }
+
+		inline static ::hx::ObjectPtr< Color_obj > __new() {
+			::hx::ObjectPtr< Color_obj > __this = new Color_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Color_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Color_obj *__this = (Color_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Color_obj), false, "snikket.Color"));
+			*(void **)__this = Color_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Color_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Color",43,e1,89,dd); }
+
+		static ::String forString(::String s);
+		static ::Dynamic forString_dyn();
+
+		static ::String defaultPhoto(::String input,::String letter);
+		static ::Dynamic defaultPhoto_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Color */ 
diff --git a/Sources/c_snikket/iinclude/snikket/Config.h b/Sources/c_snikket/iinclude/snikket/Config.h
new file mode 100644
index 0000000..a987dd2
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/Config.h
@@ -0,0 +1,60 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Config
+#define INCLUDED_snikket_Config
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Config)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Config_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Config_obj OBJ_;
+		Config_obj();
+
+	public:
+		enum { _hx_ClassId = 0x240d085f };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket.Config")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket.Config"); }
+
+		inline static ::hx::ObjectPtr< Config_obj > __new() {
+			::hx::ObjectPtr< Config_obj > __this = new Config_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Config_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Config_obj *__this = (Config_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Config_obj), false, "snikket.Config"));
+			*(void **)__this = Config_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Config_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Config",e2,ca,66,fc); }
+
+		static void __boot();
+		static bool relativeHashUri;
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Config */ 
diff --git a/Sources/c_snikket/iinclude/snikket/CustomEmojiReaction.h b/Sources/c_snikket/iinclude/snikket/CustomEmojiReaction.h
new file mode 100644
index 0000000..304c858
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/CustomEmojiReaction.h
@@ -0,0 +1,62 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_CustomEmojiReaction
+#define INCLUDED_snikket_CustomEmojiReaction
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_Reaction
+#include <snikket/Reaction.h>
+#endif
+HX_DECLARE_CLASS1(snikket,CustomEmojiReaction)
+HX_DECLARE_CLASS1(snikket,Reaction)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES CustomEmojiReaction_obj : public  ::snikket::Reaction_obj
+{
+	public:
+		typedef  ::snikket::Reaction_obj super;
+		typedef CustomEmojiReaction_obj OBJ_;
+		CustomEmojiReaction_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1e93c5e9 };
+
+		void __construct(::String senderId,::String timestamp,::String text,::String uri,::String envelopeId);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.CustomEmojiReaction")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.CustomEmojiReaction"); }
+		static ::hx::ObjectPtr< CustomEmojiReaction_obj > __new(::String senderId,::String timestamp,::String text,::String uri,::String envelopeId);
+		static ::hx::ObjectPtr< CustomEmojiReaction_obj > __alloc(::hx::Ctx *_hx_ctx,::String senderId,::String timestamp,::String text,::String uri,::String envelopeId);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~CustomEmojiReaction_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("CustomEmojiReaction",be,8e,6d,ec); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		::String uri;
+		::String uri__fromC();
+		::Dynamic uri__fromC_dyn();
+
+		 ::Dynamic render( ::Dynamic forText, ::Dynamic forImage);
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_CustomEmojiReaction */ 
diff --git a/Sources/c_snikket/iinclude/snikket/Date.h b/Sources/c_snikket/iinclude/snikket/Date.h
new file mode 100644
index 0000000..19af500
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/Date.h
@@ -0,0 +1,61 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Date
+#define INCLUDED_snikket_Date
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(Date)
+HX_DECLARE_CLASS1(snikket,Date)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Date_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Date_obj OBJ_;
+		Date_obj();
+
+	public:
+		enum { _hx_ClassId = 0x030f768b };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket.Date")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket.Date"); }
+
+		inline static ::hx::ObjectPtr< Date_obj > __new() {
+			::hx::ObjectPtr< Date_obj > __this = new Date_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Date_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Date_obj *__this = (Date_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Date_obj), false, "snikket.Date"));
+			*(void **)__this = Date_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Date_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Date",4e,82,3c,2d); }
+
+		static ::String format( ::Date d);
+		static ::Dynamic format_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Date */ 
diff --git a/Sources/c_snikket/iinclude/snikket/DirectChat.h b/Sources/c_snikket/iinclude/snikket/DirectChat.h
new file mode 100644
index 0000000..e8a37c4
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/DirectChat.h
@@ -0,0 +1,96 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_DirectChat
+#define INCLUDED_snikket_DirectChat
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_Chat
+#include <snikket/Chat.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Chat)
+HX_DECLARE_CLASS1(snikket,ChatMessage)
+HX_DECLARE_CLASS1(snikket,ChatMessageBuilder)
+HX_DECLARE_CLASS1(snikket,Client)
+HX_DECLARE_CLASS1(snikket,DirectChat)
+HX_DECLARE_CLASS1(snikket,EventEmitter)
+HX_DECLARE_CLASS1(snikket,GenericStream)
+HX_DECLARE_CLASS1(snikket,Participant)
+HX_DECLARE_CLASS1(snikket,Persistence)
+HX_DECLARE_CLASS1(snikket,Reaction)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES DirectChat_obj : public  ::snikket::Chat_obj
+{
+	public:
+		typedef  ::snikket::Chat_obj super;
+		typedef DirectChat_obj OBJ_;
+		DirectChat_obj();
+
+	public:
+		enum { _hx_ClassId = 0x62c262be };
+
+		void __construct( ::snikket::Client client, ::snikket::GenericStream stream,::Dynamic persistence,::String chatId,::hx::Null< int >  __o_uiState,::hx::Null< bool >  __o_isBlocked, ::snikket::Stanza extensions,::String readUpToId,::String readUpToBy);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.DirectChat")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.DirectChat"); }
+		static ::hx::ObjectPtr< DirectChat_obj > __new( ::snikket::Client client, ::snikket::GenericStream stream,::Dynamic persistence,::String chatId,::hx::Null< int >  __o_uiState,::hx::Null< bool >  __o_isBlocked, ::snikket::Stanza extensions,::String readUpToId,::String readUpToBy);
+		static ::hx::ObjectPtr< DirectChat_obj > __alloc(::hx::Ctx *_hx_ctx, ::snikket::Client client, ::snikket::GenericStream stream,::Dynamic persistence,::String chatId,::hx::Null< int >  __o_uiState,::hx::Null< bool >  __o_isBlocked, ::snikket::Stanza extensions,::String readUpToId,::String readUpToBy);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~DirectChat_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DirectChat",c1,22,a3,05); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		::Array< ::String > getParticipants();
+
+		::Array< ::String > counterparts();
+		::Dynamic counterparts_dyn();
+
+		 ::snikket::Participant getParticipantDetails(::String participantId);
+
+		void getMessagesBefore(::String beforeId,::String beforeTime, ::Dynamic handler);
+
+		void getMessagesAfter(::String afterId,::String afterTime, ::Dynamic handler);
+
+		void getMessagesAround(::String aroundId,::String aroundTime, ::Dynamic handler);
+
+		 ::snikket::ChatMessageBuilder prepareIncomingMessage( ::snikket::ChatMessageBuilder message, ::snikket::Stanza stanza);
+
+		 ::snikket::ChatMessageBuilder prepareOutgoingMessage( ::snikket::ChatMessageBuilder message);
+		::Dynamic prepareOutgoingMessage_dyn();
+
+		void correctMessage(::String localId, ::snikket::ChatMessageBuilder message);
+
+		void sendMessage( ::snikket::ChatMessageBuilder message);
+
+		void removeReaction( ::snikket::ChatMessage m, ::snikket::Reaction reaction);
+
+		::String lastMessageId();
+
+		void markReadUpTo( ::snikket::ChatMessage message);
+
+		void bookmark();
+
+		void sendChatState(::String state,::String threadId);
+
+		void close();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_DirectChat */ 
diff --git a/Sources/c_snikket/iinclude/snikket/Emoji.h b/Sources/c_snikket/iinclude/snikket/Emoji.h
new file mode 100644
index 0000000..685d92e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/Emoji.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Emoji
+#define INCLUDED_snikket_Emoji
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_Symbol
+#include <snikket/Symbol.h>
+#endif
+HX_DECLARE_STACK_FRAME(_hx_pos_dd1b4f8973e1f9df_136_new)
+HX_DECLARE_CLASS1(snikket,Emoji)
+HX_DECLARE_CLASS1(snikket,Symbol)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Emoji_obj : public  ::snikket::Symbol_obj
+{
+	public:
+		typedef  ::snikket::Symbol_obj super;
+		typedef Emoji_obj OBJ_;
+		Emoji_obj();
+
+	public:
+		enum { _hx_ClassId = 0x45c9a089 };
+
+		void __construct(::Array< int > codepoints);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Emoji")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Emoji"); }
+
+		inline static ::hx::ObjectPtr< Emoji_obj > __new(::Array< int > codepoints) {
+			::hx::ObjectPtr< Emoji_obj > __this = new Emoji_obj();
+			__this->__construct(codepoints);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Emoji_obj > __alloc(::hx::Ctx *_hx_ctx,::Array< int > codepoints) {
+			Emoji_obj *__this = (Emoji_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Emoji_obj), true, "snikket.Emoji"));
+			*(void **)__this = Emoji_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_dd1b4f8973e1f9df_136_new)
+HXDLIN( 136)		__this->super::__construct(codepoints);
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Emoji_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Emoji",66,df,06,03); }
+
+		bool isEmoji();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Emoji */ 
diff --git a/Sources/c_snikket/iinclude/snikket/EmojiUtil.h b/Sources/c_snikket/iinclude/snikket/EmojiUtil.h
new file mode 100644
index 0000000..f45f679
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/EmojiUtil.h
@@ -0,0 +1,95 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_EmojiUtil
+#define INCLUDED_snikket_EmojiUtil
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,EmojiUtil)
+HX_DECLARE_CLASS1(snikket,Symbol)
+HX_DECLARE_CLASS1(snikket,UnicodeBlocks)
+HX_DECLARE_CLASS1(snikket,UnicodeList)
+HX_DECLARE_CLASS1(snikket,UnicodeRange)
+HX_DECLARE_CLASS1(snikket,UnicodeSet)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES EmojiUtil_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef EmojiUtil_obj OBJ_;
+		EmojiUtil_obj();
+
+	public:
+		enum { _hx_ClassId = 0x636eb1f3 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket.EmojiUtil")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket.EmojiUtil"); }
+
+		inline static ::hx::ObjectPtr< EmojiUtil_obj > __new() {
+			::hx::ObjectPtr< EmojiUtil_obj > __this = new EmojiUtil_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< EmojiUtil_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			EmojiUtil_obj *__this = (EmojiUtil_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(EmojiUtil_obj), false, "snikket.EmojiUtil"));
+			*(void **)__this = EmojiUtil_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~EmojiUtil_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("EmojiUtil",88,0e,c9,4c); }
+
+		static void __boot();
+		static  ::snikket::UnicodeRange MISC_SYMBOLS_AND_PICTOGRAPHS;
+		static  ::snikket::UnicodeRange SUPPLEMENTAL_SYMBOLS;
+		static  ::snikket::UnicodeRange EMOTICONS;
+		static  ::snikket::UnicodeRange MISC_SYMBOLS;
+		static  ::snikket::UnicodeRange DINGBATS;
+		static  ::snikket::UnicodeRange ENCLOSED_ALPHANUMERIC_SUPPLEMENT;
+		static  ::snikket::UnicodeRange ENCLOSED_IDEOGRAPHIC_SUPPLEMENT;
+		static  ::snikket::UnicodeRange REGIONAL_INDICATORS;
+		static  ::snikket::UnicodeRange GEOMETRIC_SHAPES;
+		static  ::snikket::UnicodeRange LATIN_SUPPLEMENT;
+		static  ::snikket::UnicodeRange MISC_TECHNICAL;
+		static  ::snikket::UnicodeRange TAGS;
+		static  ::snikket::UnicodeList CYK_SYMBOLS_AND_PUNCTUATION;
+		static  ::snikket::UnicodeList LETTERLIKE_SYMBOLS;
+		static  ::snikket::UnicodeBlocks KEYCAP_COMBINEABLE;
+		static  ::snikket::UnicodeBlocks SYMBOLIZE;
+		static  ::snikket::UnicodeBlocks EMOJIS;
+		static int ZWJ;
+		static int VARIATION_16;
+		static int COMBINING_ENCLOSING_KEYCAP;
+		static int BLACK_FLAG;
+		static  ::snikket::UnicodeRange FITZPATRICK;
+		static ::Array< ::Dynamic> parse(::String str);
+		static ::Dynamic parse_dyn();
+
+		static bool isEmoji(::String input);
+		static ::Dynamic isEmoji_dyn();
+
+		static bool isOnlyEmoji(::String input);
+		static ::Dynamic isOnlyEmoji_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_EmojiUtil */ 
diff --git a/Sources/c_snikket/iinclude/snikket/EventEmitter.h b/Sources/c_snikket/iinclude/snikket/EventEmitter.h
new file mode 100644
index 0000000..7b9ee4d
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/EventEmitter.h
@@ -0,0 +1,64 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_EventEmitter
+#define INCLUDED_snikket_EventEmitter
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS1(snikket,EventEmitter)
+HX_DECLARE_CLASS1(snikket,EventHandler)
+HX_DECLARE_CLASS1(snikket,EventResult)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES EventEmitter_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef EventEmitter_obj OBJ_;
+		EventEmitter_obj();
+
+	public:
+		enum { _hx_ClassId = 0x6aca71d1 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.EventEmitter")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.EventEmitter"); }
+		static ::hx::ObjectPtr< EventEmitter_obj > __new();
+		static ::hx::ObjectPtr< EventEmitter_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~EventEmitter_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("EventEmitter",94,78,5d,17); }
+
+		 ::haxe::ds::StringMap eventHandlers;
+		 ::snikket::EventHandler on(::String eventName, ::Dynamic callback);
+		::Dynamic on_dyn();
+
+		 ::snikket::EventHandler once(::String eventName, ::Dynamic callback);
+		::Dynamic once_dyn();
+
+		 ::snikket::EventResult trigger(::String eventName, ::Dynamic eventData);
+		::Dynamic trigger_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_EventEmitter */ 
diff --git a/Sources/c_snikket/iinclude/snikket/EventHandler.h b/Sources/c_snikket/iinclude/snikket/EventHandler.h
new file mode 100644
index 0000000..c25353d
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/EventHandler.h
@@ -0,0 +1,64 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_EventHandler
+#define INCLUDED_snikket_EventHandler
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,EventHandler)
+HX_DECLARE_CLASS1(snikket,EventResult)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES EventHandler_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef EventHandler_obj OBJ_;
+		EventHandler_obj();
+
+	public:
+		enum { _hx_ClassId = 0x39717849 };
+
+		void __construct(::Array< ::Dynamic> handlers, ::Dynamic callback, ::Dynamic onlyOnce);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.EventHandler")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.EventHandler"); }
+		static ::hx::ObjectPtr< EventHandler_obj > __new(::Array< ::Dynamic> handlers, ::Dynamic callback, ::Dynamic onlyOnce);
+		static ::hx::ObjectPtr< EventHandler_obj > __alloc(::hx::Ctx *_hx_ctx,::Array< ::Dynamic> handlers, ::Dynamic callback, ::Dynamic onlyOnce);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~EventHandler_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("EventHandler",f0,f2,3c,9e); }
+
+		::Array< ::Dynamic> handlers;
+		 ::Dynamic callback;
+		Dynamic callback_dyn() { return callback;}
+		bool onlyOnce;
+		 ::snikket::EventResult call( ::Dynamic data);
+		::Dynamic call_dyn();
+
+		 ::snikket::EventHandler once();
+		::Dynamic once_dyn();
+
+		void unsubscribe();
+		::Dynamic unsubscribe_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_EventHandler */ 
diff --git a/Sources/c_snikket/iinclude/snikket/EventResult.h b/Sources/c_snikket/iinclude/snikket/EventResult.h
new file mode 100644
index 0000000..b3b5504
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/EventResult.h
@@ -0,0 +1,39 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_EventResult
+#define INCLUDED_snikket_EventResult
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,EventResult)
+namespace snikket{
+
+
+class EventResult_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef EventResult_obj OBJ_;
+
+	public:
+		EventResult_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("snikket.EventResult",06,97,23,e2); }
+		::String __ToString() const { return HX_("EventResult.",d7,9b,be,c3) + _hx_tag; }
+
+		static ::snikket::EventResult EventHandled;
+		static inline ::snikket::EventResult EventHandled_dyn() { return EventHandled; }
+		static ::snikket::EventResult EventStop;
+		static inline ::snikket::EventResult EventStop_dyn() { return EventStop; }
+		static ::snikket::EventResult EventUnhandled;
+		static inline ::snikket::EventResult EventUnhandled_dyn() { return EventUnhandled; }
+		static ::snikket::EventResult EventValue( ::Dynamic result);
+		static ::Dynamic EventValue_dyn();
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_EventResult */ 
diff --git a/Sources/c_snikket/iinclude/snikket/GenericStream.h b/Sources/c_snikket/iinclude/snikket/GenericStream.h
new file mode 100644
index 0000000..50fc0bd
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/GenericStream.h
@@ -0,0 +1,72 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_GenericStream
+#define INCLUDED_snikket_GenericStream
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_EventEmitter
+#include <snikket/EventEmitter.h>
+#endif
+HX_DECLARE_CLASS1(snikket,EventEmitter)
+HX_DECLARE_CLASS1(snikket,GenericStream)
+HX_DECLARE_CLASS1(snikket,IqRequestType)
+HX_DECLARE_CLASS1(snikket,IqResult)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES GenericStream_obj : public  ::snikket::EventEmitter_obj
+{
+	public:
+		typedef  ::snikket::EventEmitter_obj super;
+		typedef GenericStream_obj OBJ_;
+		GenericStream_obj();
+
+	public:
+		enum { _hx_ClassId = 0x785c9e5e };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.GenericStream")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.GenericStream"); }
+
+		//~GenericStream_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("GenericStream",d7,75,9c,45); }
+
+		::String clientId;
+		bool csi;
+		virtual void connect(::String jid,::Array< unsigned char > sm) {}
+		::Dynamic connect_dyn();
+		virtual void disconnect() {}
+		::Dynamic disconnect_dyn();
+		virtual void sendStanza( ::snikket::Stanza stanza) {}
+		::Dynamic sendStanza_dyn();
+		virtual ::String newId() { return 0; }
+		::Dynamic newId_dyn();
+		virtual void onIq( ::snikket::IqRequestType type,::String tag,::String xmlns, ::Dynamic handler) {}
+		::Dynamic onIq_dyn();
+		void sendIq( ::snikket::Stanza stanza, ::Dynamic callback);
+		::Dynamic sendIq_dyn();
+
+		void onStanza( ::snikket::Stanza stanza);
+		::Dynamic onStanza_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_GenericStream */ 
diff --git a/Sources/c_snikket/iinclude/snikket/Hash.h b/Sources/c_snikket/iinclude/snikket/Hash.h
new file mode 100644
index 0000000..8be664d
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/Hash.h
@@ -0,0 +1,89 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Hash
+#define INCLUDED_snikket_Hash
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS1(snikket,Hash)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Hash_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Hash_obj OBJ_;
+		Hash_obj();
+
+	public:
+		enum { _hx_ClassId = 0x05b4502b };
+
+		void __construct(::String algorithm,::Array< unsigned char > hash);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Hash")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Hash"); }
+		static ::hx::ObjectPtr< Hash_obj > __new(::String algorithm,::Array< unsigned char > hash);
+		static ::hx::ObjectPtr< Hash_obj > __alloc(::hx::Ctx *_hx_ctx,::String algorithm,::Array< unsigned char > hash);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Hash_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Hash",ee,5b,e1,2f); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static  ::snikket::Hash fromHex(::String algorithm,::String hash);
+		static ::Dynamic fromHex_dyn();
+
+		static  ::snikket::Hash fromUri(::String uri);
+		static ::Dynamic fromUri_dyn();
+
+		static  ::snikket::Hash sha1( ::haxe::io::Bytes bytes);
+		static ::Dynamic sha1_dyn();
+
+		static  ::snikket::Hash sha256( ::haxe::io::Bytes bytes);
+		static ::Dynamic sha256_dyn();
+
+		::String algorithm;
+		::String algorithm__fromC();
+		::Dynamic algorithm__fromC_dyn();
+
+		::Array< unsigned char > hash;
+		::String toUri();
+		::Dynamic toUri_dyn();
+
+		::String bobUri();
+		::Dynamic bobUri_dyn();
+
+		::String serializeUri();
+		::Dynamic serializeUri_dyn();
+
+		::String toHex();
+		::Dynamic toHex_dyn();
+
+		::String toBase64();
+		::Dynamic toBase64_dyn();
+
+		::String toBase64Url();
+		::Dynamic toBase64Url_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Hash */ 
diff --git a/Sources/c_snikket/iinclude/snikket/ID.h b/Sources/c_snikket/iinclude/snikket/ID.h
new file mode 100644
index 0000000..6d5d8c6
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/ID.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_ID
+#define INCLUDED_snikket_ID
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,ID)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES ID_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef ID_obj OBJ_;
+		ID_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5880bad8 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket.ID")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket.ID"); }
+
+		inline static ::hx::ObjectPtr< ID_obj > __new() {
+			::hx::ObjectPtr< ID_obj > __this = new ID_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< ID_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			ID_obj *__this = (ID_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(ID_obj), false, "snikket.ID"));
+			*(void **)__this = ID_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ID_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ID",db,3f,00,00); }
+
+		static ::String tiny();
+		static ::Dynamic tiny_dyn();
+
+		static ::String _hx_short();
+		static ::Dynamic _hx_short_dyn();
+
+		static ::String medium();
+		static ::Dynamic medium_dyn();
+
+		static ::String _hx_long();
+		static ::Dynamic _hx_long_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_ID */ 
diff --git a/Sources/c_snikket/iinclude/snikket/Identicon.h b/Sources/c_snikket/iinclude/snikket/Identicon.h
new file mode 100644
index 0000000..f440dab
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/Identicon.h
@@ -0,0 +1,60 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Identicon
+#define INCLUDED_snikket_Identicon
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Identicon)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Identicon_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Identicon_obj OBJ_;
+		Identicon_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3ab0d0ec };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket.Identicon")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket.Identicon"); }
+
+		inline static ::hx::ObjectPtr< Identicon_obj > __new() {
+			::hx::ObjectPtr< Identicon_obj > __this = new Identicon_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Identicon_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Identicon_obj *__this = (Identicon_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Identicon_obj), false, "snikket.Identicon"));
+			*(void **)__this = Identicon_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Identicon_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Identicon",49,42,f3,f1); }
+
+		static ::String svg(::String source);
+		static ::Dynamic svg_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Identicon */ 
diff --git a/Sources/c_snikket/iinclude/snikket/Identity.h b/Sources/c_snikket/iinclude/snikket/Identity.h
new file mode 100644
index 0000000..28c9c85
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/Identity.h
@@ -0,0 +1,61 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Identity
+#define INCLUDED_snikket_Identity
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Identity)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Identity_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Identity_obj OBJ_;
+		Identity_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7fcd1307 };
+
+		void __construct(::String category,::String type,::String name);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Identity")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Identity"); }
+		static ::hx::ObjectPtr< Identity_obj > __new(::String category,::String type,::String name);
+		static ::hx::ObjectPtr< Identity_obj > __alloc(::hx::Ctx *_hx_ctx,::String category,::String type,::String name);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Identity_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Identity",5e,01,e1,92); }
+
+		::String category;
+		::String type;
+		::String name;
+		void addToDisco( ::snikket::Stanza stanza);
+		::Dynamic addToDisco_dyn();
+
+		::String ver();
+		::Dynamic ver_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Identity */ 
diff --git a/Sources/c_snikket/iinclude/snikket/IqRequestType.h b/Sources/c_snikket/iinclude/snikket/IqRequestType.h
new file mode 100644
index 0000000..b4f759d
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/IqRequestType.h
@@ -0,0 +1,35 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_IqRequestType
+#define INCLUDED_snikket_IqRequestType
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,IqRequestType)
+namespace snikket{
+
+
+class IqRequestType_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef IqRequestType_obj OBJ_;
+
+	public:
+		IqRequestType_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("snikket.IqRequestType",d0,62,72,94); }
+		::String __ToString() const { return HX_("IqRequestType.",8d,9a,13,cc) + _hx_tag; }
+
+		static ::snikket::IqRequestType Get;
+		static inline ::snikket::IqRequestType Get_dyn() { return Get; }
+		static ::snikket::IqRequestType Set;
+		static inline ::snikket::IqRequestType Set_dyn() { return Set; }
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_IqRequestType */ 
diff --git a/Sources/c_snikket/iinclude/snikket/IqResult.h b/Sources/c_snikket/iinclude/snikket/IqResult.h
new file mode 100644
index 0000000..81b0271
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/IqResult.h
@@ -0,0 +1,39 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_IqResult
+#define INCLUDED_snikket_IqResult
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,IqResult)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+namespace snikket{
+
+
+class IqResult_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef IqResult_obj OBJ_;
+
+	public:
+		IqResult_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("snikket.IqResult",16,e9,a3,c2); }
+		::String __ToString() const { return HX_("IqResult.",89,d1,c3,9e) + _hx_tag; }
+
+		static ::snikket::IqResult IqNoResult;
+		static inline ::snikket::IqResult IqNoResult_dyn() { return IqNoResult; }
+		static ::snikket::IqResult IqResult;
+		static inline ::snikket::IqResult IqResult_dyn() { return IqResult; }
+		static ::snikket::IqResult IqResultElement( ::snikket::Stanza element);
+		static ::Dynamic IqResultElement_dyn();
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_IqResult */ 
diff --git a/Sources/c_snikket/iinclude/snikket/JID.h b/Sources/c_snikket/iinclude/snikket/JID.h
new file mode 100644
index 0000000..c64d0d0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/JID.h
@@ -0,0 +1,78 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_JID
+#define INCLUDED_snikket_JID
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,JID)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES JID_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef JID_obj OBJ_;
+		JID_obj();
+
+	public:
+		enum { _hx_ClassId = 0x18238908 };
+
+		void __construct(::String node,::String domain,::String resource);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.JID")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.JID"); }
+		static ::hx::ObjectPtr< JID_obj > __new(::String node,::String domain,::String resource);
+		static ::hx::ObjectPtr< JID_obj > __alloc(::hx::Ctx *_hx_ctx,::String node,::String domain,::String resource);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~JID_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("JID",a5,66,38,00); }
+
+		static  ::snikket::JID parse(::String jid);
+		static ::Dynamic parse_dyn();
+
+		::String node;
+		::String domain;
+		::String resource;
+		 ::snikket::JID asBare();
+		::Dynamic asBare_dyn();
+
+		 ::snikket::JID withResource(::String resource);
+		::Dynamic withResource_dyn();
+
+		bool isValid();
+		::Dynamic isValid_dyn();
+
+		bool isDomain();
+		::Dynamic isDomain_dyn();
+
+		bool isBare();
+		::Dynamic isBare_dyn();
+
+		bool equals( ::snikket::JID rhs);
+		::Dynamic equals_dyn();
+
+		::String asString();
+		::Dynamic asString_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_JID */ 
diff --git a/Sources/c_snikket/iinclude/snikket/Message.h b/Sources/c_snikket/iinclude/snikket/Message.h
new file mode 100644
index 0000000..931dcc6
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/Message.h
@@ -0,0 +1,63 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Message
+#define INCLUDED_snikket_Message
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,ChatMessageBuilder)
+HX_DECLARE_CLASS1(snikket,JID)
+HX_DECLARE_CLASS1(snikket,Message)
+HX_DECLARE_CLASS1(snikket,MessageStanza)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Message_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Message_obj OBJ_;
+		Message_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7c0c6d2e };
+
+		void __construct(::String chatId,::String senderId,::String threadId, ::snikket::MessageStanza parsed);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Message")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Message"); }
+		static ::hx::ObjectPtr< Message_obj > __new(::String chatId,::String senderId,::String threadId, ::snikket::MessageStanza parsed);
+		static ::hx::ObjectPtr< Message_obj > __alloc(::hx::Ctx *_hx_ctx,::String chatId,::String senderId,::String threadId, ::snikket::MessageStanza parsed);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Message_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Message",a7,5d,62,67); }
+
+		static  ::snikket::Message fromStanza( ::snikket::Stanza stanza, ::snikket::JID localJid, ::Dynamic addContext);
+		static ::Dynamic fromStanza_dyn();
+
+		::String chatId;
+		::String senderId;
+		::String threadId;
+		 ::snikket::MessageStanza parsed;
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Message */ 
diff --git a/Sources/c_snikket/iinclude/snikket/MessageStanza.h b/Sources/c_snikket/iinclude/snikket/MessageStanza.h
new file mode 100644
index 0000000..486e5a6
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/MessageStanza.h
@@ -0,0 +1,46 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_MessageStanza
+#define INCLUDED_snikket_MessageStanza
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,ChatMessage)
+HX_DECLARE_CLASS1(snikket,MessageStanza)
+HX_DECLARE_CLASS1(snikket,ModerationAction)
+HX_DECLARE_CLASS1(snikket,ReactionUpdate)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+namespace snikket{
+
+
+class MessageStanza_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef MessageStanza_obj OBJ_;
+
+	public:
+		MessageStanza_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("snikket.MessageStanza",4b,b3,84,a4); }
+		::String __ToString() const { return HX_("MessageStanza.",b2,b5,07,cc) + _hx_tag; }
+
+		static ::snikket::MessageStanza ChatMessageStanza( ::snikket::ChatMessage message);
+		static ::Dynamic ChatMessageStanza_dyn();
+		static ::snikket::MessageStanza ErrorMessageStanza( ::snikket::Stanza stanza);
+		static ::Dynamic ErrorMessageStanza_dyn();
+		static ::snikket::MessageStanza ModerateMessageStanza( ::snikket::ModerationAction action);
+		static ::Dynamic ModerateMessageStanza_dyn();
+		static ::snikket::MessageStanza ReactionUpdateStanza( ::snikket::ReactionUpdate update);
+		static ::Dynamic ReactionUpdateStanza_dyn();
+		static ::snikket::MessageStanza UnknownMessageStanza( ::snikket::Stanza stanza);
+		static ::Dynamic UnknownMessageStanza_dyn();
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_MessageStanza */ 
diff --git a/Sources/c_snikket/iinclude/snikket/MessageSync.h b/Sources/c_snikket/iinclude/snikket/MessageSync.h
new file mode 100644
index 0000000..7469276
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/MessageSync.h
@@ -0,0 +1,91 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_MessageSync
+#define INCLUDED_snikket_MessageSync
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS1(snikket,ChatMessageBuilder)
+HX_DECLARE_CLASS1(snikket,Client)
+HX_DECLARE_CLASS1(snikket,EventEmitter)
+HX_DECLARE_CLASS1(snikket,GenericStream)
+HX_DECLARE_CLASS1(snikket,MessageSync)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES MessageSync_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef MessageSync_obj OBJ_;
+		MessageSync_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0c8e50c1 };
+
+		void __construct( ::snikket::Client client, ::snikket::GenericStream stream, ::Dynamic filter,::String serviceJID);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.MessageSync")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.MessageSync"); }
+		static ::hx::ObjectPtr< MessageSync_obj > __new( ::snikket::Client client, ::snikket::GenericStream stream, ::Dynamic filter,::String serviceJID);
+		static ::hx::ObjectPtr< MessageSync_obj > __alloc(::hx::Ctx *_hx_ctx, ::snikket::Client client, ::snikket::GenericStream stream, ::Dynamic filter,::String serviceJID);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~MessageSync_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("MessageSync",a2,a3,78,63); }
+
+		 ::snikket::Client client;
+		 ::snikket::GenericStream stream;
+		 ::Dynamic filter;
+		::String serviceJID;
+		 ::Dynamic handler;
+		Dynamic handler_dyn() { return handler;}
+		 ::Dynamic contextHandler;
+		Dynamic contextHandler_dyn() { return contextHandler;}
+		 ::Dynamic errorHandler;
+		Dynamic errorHandler_dyn() { return errorHandler;}
+		 ::Dynamic lastPage;
+		int progress;
+		bool complete;
+		bool newestPageFirst;
+		 ::haxe::ds::StringMap jmi;
+		void fetchNext();
+		::Dynamic fetchNext_dyn();
+
+		bool hasMore();
+		::Dynamic hasMore_dyn();
+
+		void addContext( ::Dynamic handler);
+		::Dynamic addContext_dyn();
+
+		void onMessages( ::Dynamic handler);
+		::Dynamic onMessages_dyn();
+
+		void onError( ::Dynamic handler);
+		::Dynamic onError_dyn();
+
+		void setNewestPageFirst(bool newestPageFirst);
+		::Dynamic setNewestPageFirst_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_MessageSync */ 
diff --git a/Sources/c_snikket/iinclude/snikket/ModerationAction.h b/Sources/c_snikket/iinclude/snikket/ModerationAction.h
new file mode 100644
index 0000000..16f7e22
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/ModerationAction.h
@@ -0,0 +1,76 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_ModerationAction
+#define INCLUDED_snikket_ModerationAction
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_cab007b58fe42bf8_10_new)
+HX_DECLARE_CLASS1(snikket,ModerationAction)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES ModerationAction_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef ModerationAction_obj OBJ_;
+		ModerationAction_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2ac69cd9 };
+
+		void __construct(::String chatId,::String moderateServerId,::String timestamp,::String moderatorId,::String reason);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.ModerationAction")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.ModerationAction"); }
+
+		inline static ::hx::ObjectPtr< ModerationAction_obj > __new(::String chatId,::String moderateServerId,::String timestamp,::String moderatorId,::String reason) {
+			::hx::ObjectPtr< ModerationAction_obj > __this = new ModerationAction_obj();
+			__this->__construct(chatId,moderateServerId,timestamp,moderatorId,reason);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< ModerationAction_obj > __alloc(::hx::Ctx *_hx_ctx,::String chatId,::String moderateServerId,::String timestamp,::String moderatorId,::String reason) {
+			ModerationAction_obj *__this = (ModerationAction_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(ModerationAction_obj), true, "snikket.ModerationAction"));
+			*(void **)__this = ModerationAction_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_cab007b58fe42bf8_10_new)
+HXLINE(  11)		( ( ::snikket::ModerationAction)(__this) )->chatId = chatId;
+HXLINE(  12)		( ( ::snikket::ModerationAction)(__this) )->moderateServerId = moderateServerId;
+HXLINE(  13)		( ( ::snikket::ModerationAction)(__this) )->timestamp = timestamp;
+HXLINE(  14)		( ( ::snikket::ModerationAction)(__this) )->moderatorId = moderatorId;
+HXLINE(  15)		( ( ::snikket::ModerationAction)(__this) )->reason = reason;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ModerationAction_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ModerationAction",1c,c1,77,cb); }
+
+		::String chatId;
+		::String moderateServerId;
+		::String timestamp;
+		::String moderatorId;
+		::String reason;
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_ModerationAction */ 
diff --git a/Sources/c_snikket/iinclude/snikket/Node.h b/Sources/c_snikket/iinclude/snikket/Node.h
new file mode 100644
index 0000000..31bf990
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/Node.h
@@ -0,0 +1,38 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Node
+#define INCLUDED_snikket_Node
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Node)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS1(snikket,TextNode)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+namespace snikket{
+
+
+class Node_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef Node_obj OBJ_;
+
+	public:
+		Node_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("snikket.Node",b3,af,c7,53); }
+		::String __ToString() const { return HX_("Node.",cc,27,ec,32) + _hx_tag; }
+
+		static ::snikket::Node CData( ::snikket::TextNode textNode);
+		static ::Dynamic CData_dyn();
+		static ::snikket::Node Element( ::snikket::Stanza stanza);
+		static ::Dynamic Element_dyn();
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Node */ 
diff --git a/Sources/c_snikket/iinclude/snikket/Notification.h b/Sources/c_snikket/iinclude/snikket/Notification.h
new file mode 100644
index 0000000..d41f56b
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/Notification.h
@@ -0,0 +1,98 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Notification
+#define INCLUDED_snikket_Notification
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_b0a79cae3ba17812_21_new)
+HX_DECLARE_CLASS1(snikket,ChatMessage)
+HX_DECLARE_CLASS1(snikket,Notification)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Notification_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Notification_obj OBJ_;
+		Notification_obj();
+
+	public:
+		enum { _hx_ClassId = 0x778a3c48 };
+
+		void __construct(::String title,::String body,::String accountId,::String chatId,::String messageId,int type,::String callStatus,::String callSid,::String imageUri,::String lang,::String timestamp);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Notification")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Notification"); }
+
+		inline static ::hx::ObjectPtr< Notification_obj > __new(::String title,::String body,::String accountId,::String chatId,::String messageId,int type,::String callStatus,::String callSid,::String imageUri,::String lang,::String timestamp) {
+			::hx::ObjectPtr< Notification_obj > __this = new Notification_obj();
+			__this->__construct(title,body,accountId,chatId,messageId,type,callStatus,callSid,imageUri,lang,timestamp);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Notification_obj > __alloc(::hx::Ctx *_hx_ctx,::String title,::String body,::String accountId,::String chatId,::String messageId,int type,::String callStatus,::String callSid,::String imageUri,::String lang,::String timestamp) {
+			Notification_obj *__this = (Notification_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Notification_obj), true, "snikket.Notification"));
+			*(void **)__this = Notification_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_b0a79cae3ba17812_21_new)
+HXLINE(  22)		( ( ::snikket::Notification)(__this) )->title = title;
+HXLINE(  23)		( ( ::snikket::Notification)(__this) )->body = body;
+HXLINE(  24)		( ( ::snikket::Notification)(__this) )->accountId = accountId;
+HXLINE(  25)		( ( ::snikket::Notification)(__this) )->chatId = chatId;
+HXLINE(  26)		( ( ::snikket::Notification)(__this) )->messageId = messageId;
+HXLINE(  27)		( ( ::snikket::Notification)(__this) )->type = type;
+HXLINE(  28)		( ( ::snikket::Notification)(__this) )->callStatus = callStatus;
+HXLINE(  29)		( ( ::snikket::Notification)(__this) )->callSid = callSid;
+HXLINE(  30)		( ( ::snikket::Notification)(__this) )->imageUri = imageUri;
+HXLINE(  31)		( ( ::snikket::Notification)(__this) )->lang = lang;
+HXLINE(  32)		( ( ::snikket::Notification)(__this) )->timestamp = timestamp;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Notification_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Notification",0b,43,1d,24); }
+
+		static  ::snikket::Notification fromChatMessage( ::snikket::ChatMessage m);
+		static ::Dynamic fromChatMessage_dyn();
+
+		static  ::snikket::Notification fromThinStanza( ::snikket::Stanza stanza);
+		static ::Dynamic fromThinStanza_dyn();
+
+		::String title;
+		::String body;
+		::String accountId;
+		::String chatId;
+		::String messageId;
+		int type;
+		::String callStatus;
+		::String callSid;
+		::String imageUri;
+		::String lang;
+		::String timestamp;
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Notification */ 
diff --git a/Sources/c_snikket/iinclude/snikket/Other.h b/Sources/c_snikket/iinclude/snikket/Other.h
new file mode 100644
index 0000000..500f13e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/Other.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Other
+#define INCLUDED_snikket_Other
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_Symbol
+#include <snikket/Symbol.h>
+#endif
+HX_DECLARE_STACK_FRAME(_hx_pos_aac171f877c525f9_146_new)
+HX_DECLARE_CLASS1(snikket,Other)
+HX_DECLARE_CLASS1(snikket,Symbol)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Other_obj : public  ::snikket::Symbol_obj
+{
+	public:
+		typedef  ::snikket::Symbol_obj super;
+		typedef Other_obj OBJ_;
+		Other_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0c6697d3 };
+
+		void __construct(::Array< int > codepoints);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Other")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Other"); }
+
+		inline static ::hx::ObjectPtr< Other_obj > __new(::Array< int > codepoints) {
+			::hx::ObjectPtr< Other_obj > __this = new Other_obj();
+			__this->__construct(codepoints);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Other_obj > __alloc(::hx::Ctx *_hx_ctx,::Array< int > codepoints) {
+			Other_obj *__this = (Other_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Other_obj), true, "snikket.Other"));
+			*(void **)__this = Other_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_aac171f877c525f9_146_new)
+HXDLIN( 146)		__this->super::__construct(codepoints);
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Other_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Other",b0,d6,a3,c9); }
+
+		bool isEmoji();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Other */ 
diff --git a/Sources/c_snikket/iinclude/snikket/Participant.h b/Sources/c_snikket/iinclude/snikket/Participant.h
new file mode 100644
index 0000000..5317907
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/Participant.h
@@ -0,0 +1,88 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Participant
+#define INCLUDED_snikket_Participant
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_33195ab9b813f4c6_20_new)
+HX_DECLARE_CLASS1(snikket,Participant)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Participant_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Participant_obj OBJ_;
+		Participant_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7d555cf6 };
+
+		void __construct(::String displayName,::String photoUri,::String placeholderUri,bool isSelf);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Participant")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Participant"); }
+
+		inline static ::hx::ObjectPtr< Participant_obj > __new(::String displayName,::String photoUri,::String placeholderUri,bool isSelf) {
+			::hx::ObjectPtr< Participant_obj > __this = new Participant_obj();
+			__this->__construct(displayName,photoUri,placeholderUri,isSelf);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Participant_obj > __alloc(::hx::Ctx *_hx_ctx,::String displayName,::String photoUri,::String placeholderUri,bool isSelf) {
+			Participant_obj *__this = (Participant_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Participant_obj), true, "snikket.Participant"));
+			*(void **)__this = Participant_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_33195ab9b813f4c6_20_new)
+HXLINE(  21)		( ( ::snikket::Participant)(__this) )->displayName = displayName;
+HXLINE(  22)		( ( ::snikket::Participant)(__this) )->photoUri = photoUri;
+HXLINE(  23)		( ( ::snikket::Participant)(__this) )->placeholderUri = placeholderUri;
+HXLINE(  24)		( ( ::snikket::Participant)(__this) )->isSelf = isSelf;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Participant_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Participant",93,9f,1c,5f); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		::String displayName;
+		::String displayName__fromC();
+		::Dynamic displayName__fromC_dyn();
+
+		::String photoUri;
+		::String photoUri__fromC();
+		::Dynamic photoUri__fromC_dyn();
+
+		::String placeholderUri;
+		::String placeholderUri__fromC();
+		::Dynamic placeholderUri__fromC_dyn();
+
+		bool isSelf;
+		bool isSelf__fromC();
+		::Dynamic isSelf__fromC_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Participant */ 
diff --git a/Sources/c_snikket/iinclude/snikket/Persistence.h b/Sources/c_snikket/iinclude/snikket/Persistence.h
new file mode 100644
index 0000000..b3621d1
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/Persistence.h
@@ -0,0 +1,129 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Persistence
+#define INCLUDED_snikket_Persistence
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Caps)
+HX_DECLARE_CLASS1(snikket,Chat)
+HX_DECLARE_CLASS1(snikket,ChatMessage)
+HX_DECLARE_CLASS1(snikket,Persistence)
+HX_DECLARE_CLASS1(snikket,ReactionUpdate)
+HX_DECLARE_CLASS1(snikket,SerializedChat)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Persistence_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		static void __boot();
+		void (::hx::Object :: *_hx_lastId)(::String accountId,::String chatId, ::Dynamic callback); 
+		static inline void lastId( ::Dynamic _hx_,::String accountId,::String chatId, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_lastId)(accountId,chatId,callback);
+		}
+		void (::hx::Object :: *_hx_storeChats)(::String accountId,::Array< ::Dynamic> chats); 
+		static inline void storeChats( ::Dynamic _hx_,::String accountId,::Array< ::Dynamic> chats) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_storeChats)(accountId,chats);
+		}
+		void (::hx::Object :: *_hx_getChats)(::String accountId, ::Dynamic callback); 
+		static inline void getChats( ::Dynamic _hx_,::String accountId, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_getChats)(accountId,callback);
+		}
+		void (::hx::Object :: *_hx_getChatsUnreadDetails)(::String accountId,::Array< ::Dynamic> chats, ::Dynamic callback); 
+		static inline void getChatsUnreadDetails( ::Dynamic _hx_,::String accountId,::Array< ::Dynamic> chats, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_getChatsUnreadDetails)(accountId,chats,callback);
+		}
+		void (::hx::Object :: *_hx_storeReaction)(::String accountId, ::snikket::ReactionUpdate update, ::Dynamic callback); 
+		static inline void storeReaction( ::Dynamic _hx_,::String accountId, ::snikket::ReactionUpdate update, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_storeReaction)(accountId,update,callback);
+		}
+		void (::hx::Object :: *_hx_storeMessages)(::String accountId,::Array< ::Dynamic> message, ::Dynamic callback); 
+		static inline void storeMessages( ::Dynamic _hx_,::String accountId,::Array< ::Dynamic> message, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_storeMessages)(accountId,message,callback);
+		}
+		void (::hx::Object :: *_hx_updateMessage)(::String accountId, ::snikket::ChatMessage message); 
+		static inline void updateMessage( ::Dynamic _hx_,::String accountId, ::snikket::ChatMessage message) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_updateMessage)(accountId,message);
+		}
+		void (::hx::Object :: *_hx_updateMessageStatus)(::String accountId,::String localId,int status, ::Dynamic callback); 
+		static inline void updateMessageStatus( ::Dynamic _hx_,::String accountId,::String localId,int status, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_updateMessageStatus)(accountId,localId,status,callback);
+		}
+		void (::hx::Object :: *_hx_getMessage)(::String accountId,::String chatId,::String serverId,::String localId, ::Dynamic callback); 
+		static inline void getMessage( ::Dynamic _hx_,::String accountId,::String chatId,::String serverId,::String localId, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_getMessage)(accountId,chatId,serverId,localId,callback);
+		}
+		void (::hx::Object :: *_hx_getMessagesBefore)(::String accountId,::String chatId,::String beforeId,::String beforeTime, ::Dynamic callback); 
+		static inline void getMessagesBefore( ::Dynamic _hx_,::String accountId,::String chatId,::String beforeId,::String beforeTime, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_getMessagesBefore)(accountId,chatId,beforeId,beforeTime,callback);
+		}
+		void (::hx::Object :: *_hx_getMessagesAfter)(::String accountId,::String chatId,::String afterId,::String afterTime, ::Dynamic callback); 
+		static inline void getMessagesAfter( ::Dynamic _hx_,::String accountId,::String chatId,::String afterId,::String afterTime, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_getMessagesAfter)(accountId,chatId,afterId,afterTime,callback);
+		}
+		void (::hx::Object :: *_hx_getMessagesAround)(::String accountId,::String chatId,::String aroundId,::String aroundTime, ::Dynamic callback); 
+		static inline void getMessagesAround( ::Dynamic _hx_,::String accountId,::String chatId,::String aroundId,::String aroundTime, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_getMessagesAround)(accountId,chatId,aroundId,aroundTime,callback);
+		}
+		void (::hx::Object :: *_hx_hasMedia)(::String hashAlgorithm,::Array< unsigned char > hash, ::Dynamic callback); 
+		static inline void hasMedia( ::Dynamic _hx_,::String hashAlgorithm,::Array< unsigned char > hash, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_hasMedia)(hashAlgorithm,hash,callback);
+		}
+		void (::hx::Object :: *_hx_storeMedia)(::String mime,::Array< unsigned char > bytes, ::Dynamic callback); 
+		static inline void storeMedia( ::Dynamic _hx_,::String mime,::Array< unsigned char > bytes, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_storeMedia)(mime,bytes,callback);
+		}
+		void (::hx::Object :: *_hx_removeMedia)(::String hashAlgorithm,::Array< unsigned char > hash); 
+		static inline void removeMedia( ::Dynamic _hx_,::String hashAlgorithm,::Array< unsigned char > hash) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_removeMedia)(hashAlgorithm,hash);
+		}
+		void (::hx::Object :: *_hx_storeCaps)( ::snikket::Caps caps); 
+		static inline void storeCaps( ::Dynamic _hx_, ::snikket::Caps caps) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_storeCaps)(caps);
+		}
+		void (::hx::Object :: *_hx_getCaps)(::String ver, ::Dynamic callback); 
+		static inline void getCaps( ::Dynamic _hx_,::String ver, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_getCaps)(ver,callback);
+		}
+		void (::hx::Object :: *_hx_storeLogin)(::String login,::String clientId,::String displayName,::String token); 
+		static inline void storeLogin( ::Dynamic _hx_,::String login,::String clientId,::String displayName,::String token) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_storeLogin)(login,clientId,displayName,token);
+		}
+		void (::hx::Object :: *_hx_getLogin)(::String login, ::Dynamic callback); 
+		static inline void getLogin( ::Dynamic _hx_,::String login, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_getLogin)(login,callback);
+		}
+		void (::hx::Object :: *_hx_removeAccount)(::String accountId,bool completely); 
+		static inline void removeAccount( ::Dynamic _hx_,::String accountId,bool completely) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_removeAccount)(accountId,completely);
+		}
+		void (::hx::Object :: *_hx_listAccounts)( ::Dynamic callback); 
+		static inline void listAccounts( ::Dynamic _hx_, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_listAccounts)(callback);
+		}
+		void (::hx::Object :: *_hx_storeStreamManagement)(::String accountId,::Array< unsigned char > data); 
+		static inline void storeStreamManagement( ::Dynamic _hx_,::String accountId,::Array< unsigned char > data) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_storeStreamManagement)(accountId,data);
+		}
+		void (::hx::Object :: *_hx_getStreamManagement)(::String accountId, ::Dynamic callback); 
+		static inline void getStreamManagement( ::Dynamic _hx_,::String accountId, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_getStreamManagement)(accountId,callback);
+		}
+		void (::hx::Object :: *_hx_storeService)(::String accountId,::String serviceId,::String name,::String node, ::snikket::Caps caps); 
+		static inline void storeService( ::Dynamic _hx_,::String accountId,::String serviceId,::String name,::String node, ::snikket::Caps caps) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_storeService)(accountId,serviceId,name,node,caps);
+		}
+		void (::hx::Object :: *_hx_findServicesWithFeature)(::String accountId,::String feature, ::Dynamic callback); 
+		static inline void findServicesWithFeature( ::Dynamic _hx_,::String accountId,::String feature, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::Persistence_obj *>(_hx_.mPtr->_hx_getInterface(0x3e9d59e2)))->_hx_findServicesWithFeature)(accountId,feature,callback);
+		}
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Persistence */ 
diff --git a/Sources/c_snikket/iinclude/snikket/Presence.h b/Sources/c_snikket/iinclude/snikket/Presence.h
new file mode 100644
index 0000000..ac48ae8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/Presence.h
@@ -0,0 +1,55 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Presence
+#define INCLUDED_snikket_Presence
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Caps)
+HX_DECLARE_CLASS1(snikket,Presence)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Presence_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Presence_obj OBJ_;
+		Presence_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4c576518 };
+
+		void __construct( ::snikket::Caps caps, ::snikket::Stanza mucUser);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Presence")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Presence"); }
+		static ::hx::ObjectPtr< Presence_obj > __new( ::snikket::Caps caps, ::snikket::Stanza mucUser);
+		static ::hx::ObjectPtr< Presence_obj > __alloc(::hx::Ctx *_hx_ctx, ::snikket::Caps caps, ::snikket::Stanza mucUser);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Presence_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Presence",5b,0e,89,40); }
+
+		 ::snikket::Caps caps;
+		 ::snikket::Stanza mucUser;
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Presence */ 
diff --git a/Sources/c_snikket/iinclude/snikket/PubsubEvent.h b/Sources/c_snikket/iinclude/snikket/PubsubEvent.h
new file mode 100644
index 0000000..555e1cd
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/PubsubEvent.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_PubsubEvent
+#define INCLUDED_snikket_PubsubEvent
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,PubsubEvent)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES PubsubEvent_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef PubsubEvent_obj OBJ_;
+		PubsubEvent_obj();
+
+	public:
+		enum { _hx_ClassId = 0x04e7c6de };
+
+		void __construct(::String from,::String to,::String node,::Array< ::Dynamic> items);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.PubsubEvent")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.PubsubEvent"); }
+		static ::hx::ObjectPtr< PubsubEvent_obj > __new(::String from,::String to,::String node,::Array< ::Dynamic> items);
+		static ::hx::ObjectPtr< PubsubEvent_obj > __alloc(::hx::Ctx *_hx_ctx,::String from,::String to,::String node,::Array< ::Dynamic> items);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~PubsubEvent_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("PubsubEvent",17,9e,d8,d2); }
+
+		static  ::snikket::PubsubEvent fromStanza( ::snikket::Stanza stanza);
+		static ::Dynamic fromStanza_dyn();
+
+		::String from;
+		::String to;
+		::String node;
+		::Array< ::Dynamic> items;
+		::String getFrom();
+		::Dynamic getFrom_dyn();
+
+		::String getNode();
+		::Dynamic getNode_dyn();
+
+		::Array< ::Dynamic> getItems();
+		::Dynamic getItems_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_PubsubEvent */ 
diff --git a/Sources/c_snikket/iinclude/snikket/Reaction.h b/Sources/c_snikket/iinclude/snikket/Reaction.h
new file mode 100644
index 0000000..5c77199
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/Reaction.h
@@ -0,0 +1,75 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Reaction
+#define INCLUDED_snikket_Reaction
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Reaction)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Reaction_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Reaction_obj OBJ_;
+		Reaction_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7f8e2b4a };
+
+		void __construct(::String senderId,::String timestamp,::String text,::String envelopeId,::String key);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Reaction")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Reaction"); }
+		static ::hx::ObjectPtr< Reaction_obj > __new(::String senderId,::String timestamp,::String text,::String envelopeId,::String key);
+		static ::hx::ObjectPtr< Reaction_obj > __alloc(::hx::Ctx *_hx_ctx,::String senderId,::String timestamp,::String text,::String envelopeId,::String key);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Reaction_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Reaction",c9,a3,66,d0); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		::String senderId;
+		::String senderId__fromC();
+		::Dynamic senderId__fromC_dyn();
+
+		::String timestamp;
+		::String timestamp__fromC();
+		::Dynamic timestamp__fromC_dyn();
+
+		::String text;
+		::String text__fromC();
+		::Dynamic text__fromC_dyn();
+
+		::String key;
+		::String key__fromC();
+		::Dynamic key__fromC_dyn();
+
+		::String envelopeId;
+		::String envelopeId__fromC();
+		::Dynamic envelopeId__fromC_dyn();
+
+		virtual  ::Dynamic render( ::Dynamic forText, ::Dynamic forImage);
+		::Dynamic render_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Reaction */ 
diff --git a/Sources/c_snikket/iinclude/snikket/ReactionUpdate.h b/Sources/c_snikket/iinclude/snikket/ReactionUpdate.h
new file mode 100644
index 0000000..79c5a2a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/ReactionUpdate.h
@@ -0,0 +1,72 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_ReactionUpdate
+#define INCLUDED_snikket_ReactionUpdate
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Hash)
+HX_DECLARE_CLASS1(snikket,Reaction)
+HX_DECLARE_CLASS1(snikket,ReactionUpdate)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES ReactionUpdate_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef ReactionUpdate_obj OBJ_;
+		ReactionUpdate_obj();
+
+	public:
+		enum { _hx_ClassId = 0x71029d2f };
+
+		void __construct(::String updateId,::String serverId,::String serverIdBy,::String localId,::String chatId,::String senderId,::String timestamp,::Array< ::Dynamic> reactions,int kind);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.ReactionUpdate")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.ReactionUpdate"); }
+		static ::hx::ObjectPtr< ReactionUpdate_obj > __new(::String updateId,::String serverId,::String serverIdBy,::String localId,::String chatId,::String senderId,::String timestamp,::Array< ::Dynamic> reactions,int kind);
+		static ::hx::ObjectPtr< ReactionUpdate_obj > __alloc(::hx::Ctx *_hx_ctx,::String updateId,::String serverId,::String serverIdBy,::String localId,::String chatId,::String senderId,::String timestamp,::Array< ::Dynamic> reactions,int kind);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ReactionUpdate_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ReactionUpdate",b2,1a,77,ad); }
+
+		::String updateId;
+		::String serverId;
+		::String serverIdBy;
+		::String localId;
+		::String chatId;
+		::String senderId;
+		::String timestamp;
+		::Array< ::Dynamic> reactions;
+		int kind;
+		::Array< ::Dynamic> getReactions(::Array< ::Dynamic> existingReactions);
+		::Dynamic getReactions_dyn();
+
+		::Array< ::Dynamic> inlineHashReferences();
+		::Dynamic inlineHashReferences_dyn();
+
+		 ::snikket::Stanza asStanza();
+		::Dynamic asStanza_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_ReactionUpdate */ 
diff --git a/Sources/c_snikket/iinclude/snikket/SerializedChat.h b/Sources/c_snikket/iinclude/snikket/SerializedChat.h
new file mode 100644
index 0000000..80ed386
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/SerializedChat.h
@@ -0,0 +1,76 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_SerializedChat
+#define INCLUDED_snikket_SerializedChat
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS1(snikket,Caps)
+HX_DECLARE_CLASS1(snikket,Chat)
+HX_DECLARE_CLASS1(snikket,Client)
+HX_DECLARE_CLASS1(snikket,EventEmitter)
+HX_DECLARE_CLASS1(snikket,GenericStream)
+HX_DECLARE_CLASS1(snikket,Persistence)
+HX_DECLARE_CLASS1(snikket,SerializedChat)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES SerializedChat_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef SerializedChat_obj OBJ_;
+		SerializedChat_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3eb0c535 };
+
+		void __construct(::String chatId,bool trusted,::Array< unsigned char > avatarSha1, ::haxe::ds::StringMap presence,::String displayName, ::Dynamic uiState, ::Dynamic isBlocked,::String extensions,::String readUpToId,::String readUpToBy, ::Dynamic notificationsFiltered,bool notifyMention,bool notifyReply, ::snikket::Caps disco,::String klass);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.SerializedChat")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.SerializedChat"); }
+		static ::hx::ObjectPtr< SerializedChat_obj > __new(::String chatId,bool trusted,::Array< unsigned char > avatarSha1, ::haxe::ds::StringMap presence,::String displayName, ::Dynamic uiState, ::Dynamic isBlocked,::String extensions,::String readUpToId,::String readUpToBy, ::Dynamic notificationsFiltered,bool notifyMention,bool notifyReply, ::snikket::Caps disco,::String klass);
+		static ::hx::ObjectPtr< SerializedChat_obj > __alloc(::hx::Ctx *_hx_ctx,::String chatId,bool trusted,::Array< unsigned char > avatarSha1, ::haxe::ds::StringMap presence,::String displayName, ::Dynamic uiState, ::Dynamic isBlocked,::String extensions,::String readUpToId,::String readUpToBy, ::Dynamic notificationsFiltered,bool notifyMention,bool notifyReply, ::snikket::Caps disco,::String klass);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SerializedChat_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SerializedChat",9c,77,4d,09); }
+
+		::String chatId;
+		bool trusted;
+		::Array< unsigned char > avatarSha1;
+		 ::haxe::ds::StringMap presence;
+		::String displayName;
+		int uiState;
+		bool isBlocked;
+		::String extensions;
+		::String readUpToId;
+		::String readUpToBy;
+		 ::snikket::Caps disco;
+		::String klass;
+		 ::Dynamic notificationsFiltered;
+		bool notifyMention;
+		bool notifyReply;
+		 ::snikket::Chat toChat( ::snikket::Client client, ::snikket::GenericStream stream,::Dynamic persistence);
+		::Dynamic toChat_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_SerializedChat */ 
diff --git a/Sources/c_snikket/iinclude/snikket/Stanza.h b/Sources/c_snikket/iinclude/snikket/Stanza.h
new file mode 100644
index 0000000..7c79f8c
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/Stanza.h
@@ -0,0 +1,149 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Stanza
+#define INCLUDED_snikket_Stanza
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket__Stanza_NodeInterface
+#include <snikket/_Stanza/NodeInterface.h>
+#endif
+HX_DECLARE_CLASS0(Xml)
+HX_DECLARE_CLASS1(snikket,Node)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS1(snikket,StanzaError)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Stanza_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Stanza_obj OBJ_;
+		Stanza_obj();
+
+	public:
+		enum { _hx_ClassId = 0x62320f92 };
+
+		void __construct(::String name, ::Dynamic attr);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Stanza")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Stanza"); }
+		static ::hx::ObjectPtr< Stanza_obj > __new(::String name, ::Dynamic attr);
+		static ::hx::ObjectPtr< Stanza_obj > __alloc(::hx::Ctx *_hx_ctx,::String name, ::Dynamic attr);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Stanza_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::Dynamic traverse_881a854a( ::Dynamic f);
+		::String __ToString() const { return HX_("Stanza",15,d2,8b,3a); }
+
+		static  ::snikket::Stanza parse(::String s);
+		static ::Dynamic parse_dyn();
+
+		static  ::snikket::Stanza fromXml( ::Xml el);
+		static ::Dynamic fromXml_dyn();
+
+		static bool parseXmlBool(::String x);
+		static ::Dynamic parseXmlBool_dyn();
+
+		::String name;
+		 ::Dynamic attr;
+		::Array< ::Dynamic> children;
+		 ::snikket::Stanza last_added;
+		::Array< ::Dynamic> last_added_stack;
+		::String serialize();
+		::Dynamic serialize_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+		 ::snikket::Stanza tag(::String name, ::Dynamic attr);
+		::Dynamic tag_dyn();
+
+		 ::snikket::Stanza text(::String content);
+		::Dynamic text_dyn();
+
+		 ::snikket::Stanza textTag(::String tagName,::String textContent, ::Dynamic attr);
+		::Dynamic textTag_dyn();
+
+		 ::snikket::Stanza up();
+		::Dynamic up_dyn();
+
+		 ::snikket::Stanza reset();
+		::Dynamic reset_dyn();
+
+		 ::snikket::Stanza addChildren( ::Dynamic children);
+		::Dynamic addChildren_dyn();
+
+		 ::snikket::Stanza addChildNodes( ::Dynamic children);
+		::Dynamic addChildNodes_dyn();
+
+		 ::snikket::Stanza addChild( ::snikket::Stanza stanza);
+		::Dynamic addChild_dyn();
+
+		 ::snikket::Stanza addDirectChild( ::snikket::Node child);
+		::Dynamic addDirectChild_dyn();
+
+		 ::snikket::Stanza clone();
+		::Dynamic clone_dyn();
+
+		::Array< ::Dynamic> allTags(::String name,::String xmlns);
+		::Dynamic allTags_dyn();
+
+		::Array< ::String > allText();
+		::Dynamic allText_dyn();
+
+		 ::snikket::Stanza getFirstChild();
+		::Dynamic getFirstChild_dyn();
+
+		::Array< ::Dynamic> getChildren();
+		::Dynamic getChildren_dyn();
+
+		 ::snikket::Stanza getChild(::String name,::String xmlns);
+		::Dynamic getChild_dyn();
+
+		::String getChildText(::String name,::String xmlns);
+		::Dynamic getChildText_dyn();
+
+		::String getText();
+		::Dynamic getText_dyn();
+
+		 ::snikket::Node find(::String path);
+		::Dynamic find_dyn();
+
+		 ::snikket::Stanza findChild(::String path);
+		::Dynamic findChild_dyn();
+
+		::String findText(::String path);
+		::Dynamic findText_dyn();
+
+		 ::snikket::Stanza traverse( ::Dynamic f);
+		::Dynamic traverse_dyn();
+
+		 ::snikket::StanzaError getError();
+		::Dynamic getError_dyn();
+
+		void removeChildren(::String name,::String xmlns_);
+		::Dynamic removeChildren_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Stanza */ 
diff --git a/Sources/c_snikket/iinclude/snikket/StanzaError.h b/Sources/c_snikket/iinclude/snikket/StanzaError.h
new file mode 100644
index 0000000..a16d52c
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/StanzaError.h
@@ -0,0 +1,72 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_StanzaError
+#define INCLUDED_snikket_StanzaError
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_ba7467be1e1fd22b_46_new)
+HX_DECLARE_CLASS1(snikket,StanzaError)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES StanzaError_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef StanzaError_obj OBJ_;
+		StanzaError_obj();
+
+	public:
+		enum { _hx_ClassId = 0x29697ad6 };
+
+		void __construct(::String type_,::String condition_,::String text_);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.StanzaError")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.StanzaError"); }
+
+		inline static ::hx::ObjectPtr< StanzaError_obj > __new(::String type_,::String condition_,::String text_) {
+			::hx::ObjectPtr< StanzaError_obj > __this = new StanzaError_obj();
+			__this->__construct(type_,condition_,text_);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< StanzaError_obj > __alloc(::hx::Ctx *_hx_ctx,::String type_,::String condition_,::String text_) {
+			StanzaError_obj *__this = (StanzaError_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(StanzaError_obj), true, "snikket.StanzaError"));
+			*(void **)__this = StanzaError_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_ba7467be1e1fd22b_46_new)
+HXLINE(  47)		( ( ::snikket::StanzaError)(__this) )->type = type_;
+HXLINE(  48)		( ( ::snikket::StanzaError)(__this) )->condition = condition_;
+HXLINE(  49)		( ( ::snikket::StanzaError)(__this) )->text = text_;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~StanzaError_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("StanzaError",73,bd,30,0b); }
+
+		::String type;
+		::String condition;
+		::String text;
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_StanzaError */ 
diff --git a/Sources/c_snikket/iinclude/snikket/StringUtil.h b/Sources/c_snikket/iinclude/snikket/StringUtil.h
new file mode 100644
index 0000000..2aba5bb
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/StringUtil.h
@@ -0,0 +1,63 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_StringUtil
+#define INCLUDED_snikket_StringUtil
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,StringUtil)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES StringUtil_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef StringUtil_obj OBJ_;
+		StringUtil_obj();
+
+	public:
+		enum { _hx_ClassId = 0x537b2d90 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket.StringUtil")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket.StringUtil"); }
+
+		inline static ::hx::ObjectPtr< StringUtil_obj > __new() {
+			::hx::ObjectPtr< StringUtil_obj > __this = new StringUtil_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< StringUtil_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			StringUtil_obj *__this = (StringUtil_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(StringUtil_obj), false, "snikket.StringUtil"));
+			*(void **)__this = StringUtil_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~StringUtil_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("StringUtil",93,ed,5b,f6); }
+
+		static ::Array< ::String > codepointArray(::String s);
+		static ::Dynamic codepointArray_dyn();
+
+		static ::Array< int > rawCodepointArray(::String s);
+		static ::Dynamic rawCodepointArray_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_StringUtil */ 
diff --git a/Sources/c_snikket/iinclude/snikket/Symbol.h b/Sources/c_snikket/iinclude/snikket/Symbol.h
new file mode 100644
index 0000000..a0c352f
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/Symbol.h
@@ -0,0 +1,49 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_Symbol
+#define INCLUDED_snikket_Symbol
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Symbol)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES Symbol_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Symbol_obj OBJ_;
+		Symbol_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4b1860f5 };
+
+		void __construct(::Array< int > codepoints);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.Symbol")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.Symbol"); }
+
+		//~Symbol_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Symbol",78,23,72,23); }
+
+		::String value;
+		virtual bool isEmoji() { return 0; }
+		::Dynamic isEmoji_dyn();
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_Symbol */ 
diff --git a/Sources/c_snikket/iinclude/snikket/TextNode.h b/Sources/c_snikket/iinclude/snikket/TextNode.h
new file mode 100644
index 0000000..f290844
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/TextNode.h
@@ -0,0 +1,67 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_TextNode
+#define INCLUDED_snikket_TextNode
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket__Stanza_NodeInterface
+#include <snikket/_Stanza/NodeInterface.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS1(snikket,TextNode)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES TextNode_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef TextNode_obj OBJ_;
+		TextNode_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3185702c };
+
+		void __construct(::String content);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.TextNode")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.TextNode"); }
+		static ::hx::ObjectPtr< TextNode_obj > __new(::String content);
+		static ::hx::ObjectPtr< TextNode_obj > __alloc(::hx::Ctx *_hx_ctx,::String content);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~TextNode_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::Dynamic traverse_881a854a( ::Dynamic f);
+		::String __ToString() const { return HX_("TextNode",6f,19,b7,25); }
+
+		::String content;
+		::String serialize();
+		::Dynamic serialize_dyn();
+
+		 ::snikket::TextNode clone();
+		::Dynamic clone_dyn();
+
+		 ::snikket::TextNode traverse( ::Dynamic f);
+		::Dynamic traverse_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_TextNode */ 
diff --git a/Sources/c_snikket/iinclude/snikket/UnicodeBlocks.h b/Sources/c_snikket/iinclude/snikket/UnicodeBlocks.h
new file mode 100644
index 0000000..0038254
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/UnicodeBlocks.h
@@ -0,0 +1,59 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_UnicodeBlocks
+#define INCLUDED_snikket_UnicodeBlocks
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_UnicodeSet
+#include <snikket/UnicodeSet.h>
+#endif
+HX_DECLARE_CLASS1(snikket,UnicodeBlocks)
+HX_DECLARE_CLASS1(snikket,UnicodeSet)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES UnicodeBlocks_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef UnicodeBlocks_obj OBJ_;
+		UnicodeBlocks_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5ff5d386 };
+
+		void __construct(::Array< ::Dynamic> sets);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.UnicodeBlocks")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.UnicodeBlocks"); }
+		static ::hx::ObjectPtr< UnicodeBlocks_obj > __new(::Array< ::Dynamic> sets);
+		static ::hx::ObjectPtr< UnicodeBlocks_obj > __alloc(::hx::Ctx *_hx_ctx,::Array< ::Dynamic> sets);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~UnicodeBlocks_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("UnicodeBlocks",63,b7,08,b4); }
+
+		::Array< ::Dynamic> unicodeSets;
+		bool contains(int codepoint);
+		::Dynamic contains_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_UnicodeBlocks */ 
diff --git a/Sources/c_snikket/iinclude/snikket/UnicodeList.h b/Sources/c_snikket/iinclude/snikket/UnicodeList.h
new file mode 100644
index 0000000..4ae5d96
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/UnicodeList.h
@@ -0,0 +1,59 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_UnicodeList
+#define INCLUDED_snikket_UnicodeList
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_UnicodeSet
+#include <snikket/UnicodeSet.h>
+#endif
+HX_DECLARE_CLASS1(snikket,UnicodeList)
+HX_DECLARE_CLASS1(snikket,UnicodeSet)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES UnicodeList_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef UnicodeList_obj OBJ_;
+		UnicodeList_obj();
+
+	public:
+		enum { _hx_ClassId = 0x002205b6 };
+
+		void __construct(::Array< int > codes);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.UnicodeList")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.UnicodeList"); }
+		static ::hx::ObjectPtr< UnicodeList_obj > __new(::Array< int > codes);
+		static ::hx::ObjectPtr< UnicodeList_obj > __alloc(::hx::Ctx *_hx_ctx,::Array< int > codes);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~UnicodeList_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("UnicodeList",fb,c3,e2,6a); }
+
+		::Array< int > list;
+		bool contains(int codepoint);
+		::Dynamic contains_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_UnicodeList */ 
diff --git a/Sources/c_snikket/iinclude/snikket/UnicodeRange.h b/Sources/c_snikket/iinclude/snikket/UnicodeRange.h
new file mode 100644
index 0000000..538a195
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/UnicodeRange.h
@@ -0,0 +1,58 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_UnicodeRange
+#define INCLUDED_snikket_UnicodeRange
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_UnicodeSet
+#include <snikket/UnicodeSet.h>
+#endif
+HX_DECLARE_CLASS1(snikket,UnicodeRange)
+HX_DECLARE_CLASS1(snikket,UnicodeSet)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES UnicodeRange_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef UnicodeRange_obj OBJ_;
+		UnicodeRange_obj();
+
+	public:
+		enum { _hx_ClassId = 0x25d72cd9 };
+
+		void __construct(int lower,int upper);
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket.UnicodeRange")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket.UnicodeRange"); }
+		static ::hx::ObjectPtr< UnicodeRange_obj > __new(int lower,int upper);
+		static ::hx::ObjectPtr< UnicodeRange_obj > __alloc(::hx::Ctx *_hx_ctx,int lower,int upper);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~UnicodeRange_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("UnicodeRange",80,a7,a2,8a); }
+
+		int lower;
+		int upper;
+		bool contains(int codePoint);
+		::Dynamic contains_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_UnicodeRange */ 
diff --git a/Sources/c_snikket/iinclude/snikket/UnicodeSet.h b/Sources/c_snikket/iinclude/snikket/UnicodeSet.h
new file mode 100644
index 0000000..1f6c00a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/UnicodeSet.h
@@ -0,0 +1,27 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_UnicodeSet
+#define INCLUDED_snikket_UnicodeSet
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,UnicodeSet)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES UnicodeSet_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		bool (::hx::Object :: *_hx_contains)(int codepoint); 
+		static inline bool contains( ::Dynamic _hx_,int codepoint) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::snikket::UnicodeSet_obj *>(_hx_.mPtr->_hx_getInterface(0x29205162)))->_hx_contains)(codepoint);
+		}
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_UnicodeSet */ 
diff --git a/Sources/c_snikket/iinclude/snikket/XEP0393.h b/Sources/c_snikket/iinclude/snikket/XEP0393.h
new file mode 100644
index 0000000..3af9b96
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/XEP0393.h
@@ -0,0 +1,84 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_XEP0393
+#define INCLUDED_snikket_XEP0393
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Node)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS1(snikket,XEP0393)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+
+
+class HXCPP_CLASS_ATTRIBUTES XEP0393_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef XEP0393_obj OBJ_;
+		XEP0393_obj();
+
+	public:
+		enum { _hx_ClassId = 0x794b61b7 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket.XEP0393")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket.XEP0393"); }
+
+		inline static ::hx::ObjectPtr< XEP0393_obj > __new() {
+			::hx::ObjectPtr< XEP0393_obj > __this = new XEP0393_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< XEP0393_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			XEP0393_obj *__this = (XEP0393_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(XEP0393_obj), false, "snikket.XEP0393"));
+			*(void **)__this = XEP0393_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~XEP0393_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("XEP0393",e0,42,f0,11); }
+
+		static  ::Dynamic parse(::String styled);
+		static ::Dynamic parse_dyn();
+
+		static ::String render( ::snikket::Stanza xhtml);
+		static ::Dynamic render_dyn();
+
+		static ::String renderNode( ::snikket::Node xhtml);
+		static ::Dynamic renderNode_dyn();
+
+		static  ::Dynamic parseSpans(::String styled);
+		static ::Dynamic parseSpans_dyn();
+
+		static  ::Dynamic parseSpan(::String tagName,::String marker,::String styled,int start);
+		static ::Dynamic parseSpan_dyn();
+
+		static  ::Dynamic parseBlock(::String styled);
+		static ::Dynamic parseBlock_dyn();
+
+		static  ::Dynamic parseQuote(::String styled);
+		static ::Dynamic parseQuote_dyn();
+
+		static  ::Dynamic parsePreformatted(::String styled);
+		static ::Dynamic parsePreformatted_dyn();
+
+};
+
+} // end namespace snikket
+
+#endif /* INCLUDED_snikket_XEP0393 */ 
diff --git a/Sources/c_snikket/iinclude/snikket/_Push/Push_Fields_.h b/Sources/c_snikket/iinclude/snikket/_Push/Push_Fields_.h
new file mode 100644
index 0000000..27e14f5
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/_Push/Push_Fields_.h
@@ -0,0 +1,64 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket__Push_Push_Fields_
+#define INCLUDED_snikket__Push_Push_Fields_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Notification)
+HX_DECLARE_CLASS1(snikket,Persistence)
+HX_DECLARE_CLASS2(snikket,_Push,Push_Fields_)
+
+namespace snikket{
+namespace _Push{
+
+
+class HXCPP_CLASS_ATTRIBUTES Push_Fields__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Push_Fields__obj OBJ_;
+		Push_Fields__obj();
+
+	public:
+		enum { _hx_ClassId = 0x1c9e72a5 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket._Push.Push_Fields_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket._Push.Push_Fields_"); }
+
+		inline static ::hx::ObjectPtr< Push_Fields__obj > __new() {
+			::hx::ObjectPtr< Push_Fields__obj > __this = new Push_Fields__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Push_Fields__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Push_Fields__obj *__this = (Push_Fields__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Push_Fields__obj), false, "snikket._Push.Push_Fields_"));
+			*(void **)__this = Push_Fields__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Push_Fields__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Push_Fields_",21,65,37,88); }
+
+		static  ::snikket::Notification receive(::String data,::Dynamic persistence);
+		static ::Dynamic receive_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace _Push
+
+#endif /* INCLUDED_snikket__Push_Push_Fields_ */ 
diff --git a/Sources/c_snikket/iinclude/snikket/_Stanza/NodeInterface.h b/Sources/c_snikket/iinclude/snikket/_Stanza/NodeInterface.h
new file mode 100644
index 0000000..8a96ae8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/_Stanza/NodeInterface.h
@@ -0,0 +1,34 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket__Stanza_NodeInterface
+#define INCLUDED_snikket__Stanza_NodeInterface
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+
+namespace snikket{
+namespace _Stanza{
+
+
+class HXCPP_CLASS_ATTRIBUTES NodeInterface_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		::String (::hx::Object :: *_hx_serialize)(); 
+		static inline ::String serialize( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::snikket::_Stanza::NodeInterface_obj *>(_hx_.mPtr->_hx_getInterface(0xc837e580)))->_hx_serialize)();
+		}
+		::Dynamic (::hx::Object :: *_hx_traverse)( ::Dynamic f); 
+		static inline ::Dynamic traverse( ::Dynamic _hx_, ::Dynamic f) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::snikket::_Stanza::NodeInterface_obj *>(_hx_.mPtr->_hx_getInterface(0xc837e580)))->_hx_traverse)(f);
+		}
+};
+
+} // end namespace snikket
+} // end namespace _Stanza
+
+#endif /* INCLUDED_snikket__Stanza_NodeInterface */ 
diff --git a/Sources/c_snikket/iinclude/snikket/_Util/Util_Fields_.h b/Sources/c_snikket/iinclude/snikket/_Util/Util_Fields_.h
new file mode 100644
index 0000000..a5a7fd3
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/_Util/Util_Fields_.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket__Util_Util_Fields_
+#define INCLUDED_snikket__Util_Util_Fields_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(snikket,_Util,Util_Fields_)
+
+namespace snikket{
+namespace _Util{
+
+
+class HXCPP_CLASS_ATTRIBUTES Util_Fields__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Util_Fields__obj OBJ_;
+		Util_Fields__obj();
+
+	public:
+		enum { _hx_ClassId = 0x1266dcf5 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket._Util.Util_Fields_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket._Util.Util_Fields_"); }
+
+		inline static ::hx::ObjectPtr< Util_Fields__obj > __new() {
+			::hx::ObjectPtr< Util_Fields__obj > __this = new Util_Fields__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Util_Fields__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Util_Fields__obj *__this = (Util_Fields__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Util_Fields__obj), false, "snikket._Util.Util_Fields_"));
+			*(void **)__this = Util_Fields__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Util_Fields__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Util_Fields_",49,13,f3,18); }
+
+		static void setupTrace();
+		static ::Dynamic setupTrace_dyn();
+
+		static  ::Dynamic downcast( ::Dynamic value,::hx::Class c);
+		static ::Dynamic downcast_dyn();
+
+		static ::String xmlEscape(::String s);
+		static ::Dynamic xmlEscape_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace _Util
+
+#endif /* INCLUDED_snikket__Util_Util_Fields_ */ 
diff --git a/Sources/c_snikket/iinclude/snikket/jingle/Attribute.h b/Sources/c_snikket/iinclude/snikket/jingle/Attribute.h
new file mode 100644
index 0000000..ab36337
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/jingle/Attribute.h
@@ -0,0 +1,79 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_Attribute
+#define INCLUDED_snikket_jingle_Attribute
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_3dd2db7f2124ae96_624_new)
+HX_DECLARE_CLASS2(snikket,jingle,Attribute)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES Attribute_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Attribute_obj OBJ_;
+		Attribute_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0704634e };
+
+		void __construct(::String key,::String value);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.Attribute")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.Attribute"); }
+
+		inline static ::hx::ObjectPtr< Attribute_obj > __new(::String key,::String value) {
+			::hx::ObjectPtr< Attribute_obj > __this = new Attribute_obj();
+			__this->__construct(key,value);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Attribute_obj > __alloc(::hx::Ctx *_hx_ctx,::String key,::String value) {
+			Attribute_obj *__this = (Attribute_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Attribute_obj), true, "snikket.jingle.Attribute"));
+			*(void **)__this = Attribute_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_3dd2db7f2124ae96_624_new)
+HXLINE( 625)		( ( ::snikket::jingle::Attribute)(__this) )->key = key;
+HXLINE( 626)		( ( ::snikket::jingle::Attribute)(__this) )->value = value;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Attribute_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Attribute",fc,4f,c3,9c); }
+
+		static  ::snikket::jingle::Attribute parse(::String input);
+		static ::Dynamic parse_dyn();
+
+		::String key;
+		::String value;
+		::String toSdp();
+		::Dynamic toSdp_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_Attribute */ 
diff --git a/Sources/c_snikket/iinclude/snikket/jingle/AudioFormat.h b/Sources/c_snikket/iinclude/snikket/jingle/AudioFormat.h
new file mode 100644
index 0000000..5a01544
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/jingle/AudioFormat.h
@@ -0,0 +1,84 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_AudioFormat
+#define INCLUDED_snikket_jingle_AudioFormat
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_1f09f7dcf750977c_327_new)
+HX_DECLARE_CLASS2(snikket,jingle,AudioFormat)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES AudioFormat_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef AudioFormat_obj OBJ_;
+		AudioFormat_obj();
+
+	public:
+		enum { _hx_ClassId = 0x22a1d3c3 };
+
+		void __construct(::String format,unsigned char payloadType,int clockRate,int channels);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.AudioFormat")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.AudioFormat"); }
+
+		inline static ::hx::ObjectPtr< AudioFormat_obj > __new(::String format,unsigned char payloadType,int clockRate,int channels) {
+			::hx::ObjectPtr< AudioFormat_obj > __this = new AudioFormat_obj();
+			__this->__construct(format,payloadType,clockRate,channels);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< AudioFormat_obj > __alloc(::hx::Ctx *_hx_ctx,::String format,unsigned char payloadType,int clockRate,int channels) {
+			AudioFormat_obj *__this = (AudioFormat_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(AudioFormat_obj), true, "snikket.jingle.AudioFormat"));
+			*(void **)__this = AudioFormat_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_1f09f7dcf750977c_327_new)
+HXLINE( 328)		( ( ::snikket::jingle::AudioFormat)(__this) )->format = format;
+HXLINE( 329)		( ( ::snikket::jingle::AudioFormat)(__this) )->payloadType = payloadType;
+HXLINE( 330)		( ( ::snikket::jingle::AudioFormat)(__this) )->clockRate = clockRate;
+HXLINE( 331)		( ( ::snikket::jingle::AudioFormat)(__this) )->channels = channels;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~AudioFormat_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("AudioFormat",8d,58,71,b0); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		::String format;
+		unsigned char payloadType;
+		int clockRate;
+		int clockRate__fromC();
+		::Dynamic clockRate__fromC_dyn();
+
+		int channels;
+		int channels__fromC();
+		::Dynamic channels__fromC_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_AudioFormat */ 
diff --git a/Sources/c_snikket/iinclude/snikket/jingle/DTMFSender.h b/Sources/c_snikket/iinclude/snikket/jingle/DTMFSender.h
new file mode 100644
index 0000000..ac11f9b
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/jingle/DTMFSender.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_DTMFSender
+#define INCLUDED_snikket_jingle_DTMFSender
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS1(haxe,Timer)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS2(snikket,jingle,DTMFSender)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStreamTrack)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES DTMFSender_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef DTMFSender_obj OBJ_;
+		DTMFSender_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0cd227ec };
+
+		void __construct( ::snikket::jingle::MediaStreamTrack track);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.DTMFSender")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.DTMFSender"); }
+		static ::hx::ObjectPtr< DTMFSender_obj > __new( ::snikket::jingle::MediaStreamTrack track);
+		static ::hx::ObjectPtr< DTMFSender_obj > __alloc(::hx::Ctx *_hx_ctx, ::snikket::jingle::MediaStreamTrack track);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~DTMFSender_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DTMFSender",7e,53,22,7e); }
+
+		static void __boot();
+		static  ::haxe::ds::StringMap TONES;
+		 ::snikket::jingle::MediaStreamTrack track;
+		 ::haxe::Timer timer;
+		::Array< unsigned char > tones;
+		void insertDTMF(::String tones);
+		::Dynamic insertDTMF_dyn();
+
+		void insertOneTone(unsigned char tone);
+		::Dynamic insertOneTone_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_DTMFSender */ 
diff --git a/Sources/c_snikket/iinclude/snikket/jingle/Group.h b/Sources/c_snikket/iinclude/snikket/jingle/Group.h
new file mode 100644
index 0000000..e94b018
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/jingle/Group.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_Group
+#define INCLUDED_snikket_jingle_Group
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,jingle,Group)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES Group_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Group_obj OBJ_;
+		Group_obj();
+
+	public:
+		enum { _hx_ClassId = 0x21f1b1d5 };
+
+		void __construct(::String semantics,::Array< ::String > identificationTags);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.Group")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.Group"); }
+		static ::hx::ObjectPtr< Group_obj > __new(::String semantics,::Array< ::String > identificationTags);
+		static ::hx::ObjectPtr< Group_obj > __alloc(::hx::Ctx *_hx_ctx,::String semantics,::Array< ::String > identificationTags);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Group_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Group",1f,23,22,2d); }
+
+		static  ::snikket::jingle::Group parse(::String input);
+		static ::Dynamic parse_dyn();
+
+		static  ::snikket::jingle::Group fromElement( ::snikket::Stanza el);
+		static ::Dynamic fromElement_dyn();
+
+		::String semantics;
+		::Array< ::String > identificationTags;
+		::String toSdp();
+		::Dynamic toSdp_dyn();
+
+		 ::snikket::Stanza toElement();
+		::Dynamic toElement_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_Group */ 
diff --git a/Sources/c_snikket/iinclude/snikket/jingle/IceCandidate.h b/Sources/c_snikket/iinclude/snikket/jingle/IceCandidate.h
new file mode 100644
index 0000000..3f6d0f8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/jingle/IceCandidate.h
@@ -0,0 +1,84 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_IceCandidate
+#define INCLUDED_snikket_jingle_IceCandidate
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,jingle,IceCandidate)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES IceCandidate_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef IceCandidate_obj OBJ_;
+		IceCandidate_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5f466786 };
+
+		void __construct(::String sdpMid,::String ufrag,::String foundation,::String component,::String transport,::String priority,::String connectionAddress,::String port, ::haxe::ds::StringMap parameters);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.IceCandidate")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.IceCandidate"); }
+		static ::hx::ObjectPtr< IceCandidate_obj > __new(::String sdpMid,::String ufrag,::String foundation,::String component,::String transport,::String priority,::String connectionAddress,::String port, ::haxe::ds::StringMap parameters);
+		static ::hx::ObjectPtr< IceCandidate_obj > __alloc(::hx::Ctx *_hx_ctx,::String sdpMid,::String ufrag,::String foundation,::String component,::String transport,::String priority,::String connectionAddress,::String port, ::haxe::ds::StringMap parameters);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~IceCandidate_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("IceCandidate",98,1b,a6,e5); }
+
+		static  ::snikket::jingle::IceCandidate fromElement( ::snikket::Stanza candidate,::String sdpMid,::String ufrag);
+		static ::Dynamic fromElement_dyn();
+
+		static ::Array< ::Dynamic> fromTransport( ::snikket::Stanza transport,::String sdpMid);
+		static ::Dynamic fromTransport_dyn();
+
+		static ::Array< ::Dynamic> fromStanza( ::snikket::Stanza iq);
+		static ::Dynamic fromStanza_dyn();
+
+		static  ::snikket::jingle::IceCandidate parse(::String input,::String sdpMid,::String ufrag);
+		static ::Dynamic parse_dyn();
+
+		::String sdpMid;
+		::String ufrag;
+		::String foundation;
+		::String component;
+		::String transport;
+		::String priority;
+		::String connectionAddress;
+		::String port;
+		 ::haxe::ds::StringMap parameters;
+		 ::snikket::Stanza toElement();
+		::Dynamic toElement_dyn();
+
+		::String toSdp();
+		::Dynamic toSdp_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_IceCandidate */ 
diff --git a/Sources/c_snikket/iinclude/snikket/jingle/IncomingProposedSession.h b/Sources/c_snikket/iinclude/snikket/jingle/IncomingProposedSession.h
new file mode 100644
index 0000000..ba3b24a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/jingle/IncomingProposedSession.h
@@ -0,0 +1,114 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_IncomingProposedSession
+#define INCLUDED_snikket_jingle_IncomingProposedSession
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_jingle_Session
+#include <snikket/jingle/Session.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Client)
+HX_DECLARE_CLASS1(snikket,EventEmitter)
+HX_DECLARE_CLASS1(snikket,JID)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,jingle,DTMFSender)
+HX_DECLARE_CLASS2(snikket,jingle,IncomingProposedSession)
+HX_DECLARE_CLASS2(snikket,jingle,InitiatedSession)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStream)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStreamTrack)
+HX_DECLARE_CLASS2(snikket,jingle,Session)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES IncomingProposedSession_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef IncomingProposedSession_obj OBJ_;
+		IncomingProposedSession_obj();
+
+	public:
+		enum { _hx_ClassId = 0x409e1620 };
+
+		void __construct( ::snikket::Client client, ::snikket::JID from,::String sid);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.IncomingProposedSession")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.IncomingProposedSession"); }
+		static ::hx::ObjectPtr< IncomingProposedSession_obj > __new( ::snikket::Client client, ::snikket::JID from,::String sid);
+		static ::hx::ObjectPtr< IncomingProposedSession_obj > __alloc(::hx::Ctx *_hx_ctx, ::snikket::Client client, ::snikket::JID from,::String sid);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~IncomingProposedSession_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("IncomingProposedSession",ea,a1,86,13); }
+
+		::String sid;
+		 ::snikket::Client client;
+		 ::snikket::JID from;
+		::String _sid;
+		bool accepted;
+		void ring();
+		::Dynamic ring_dyn();
+
+		void hangup();
+		::Dynamic hangup_dyn();
+
+		void retract();
+		::Dynamic retract_dyn();
+
+		void terminate();
+		::Dynamic terminate_dyn();
+
+		void contentAdd( ::snikket::Stanza _);
+		::Dynamic contentAdd_dyn();
+
+		void contentAccept( ::snikket::Stanza _);
+		::Dynamic contentAccept_dyn();
+
+		::Dynamic transportInfo( ::snikket::Stanza _);
+		::Dynamic transportInfo_dyn();
+
+		void accept();
+		::Dynamic accept_dyn();
+
+		 ::snikket::jingle::InitiatedSession initiate( ::snikket::Stanza stanza);
+		::Dynamic initiate_dyn();
+
+		void addMedia(::Array< ::Dynamic> _);
+		::Dynamic addMedia_dyn();
+
+		::String callStatus();
+		::Dynamic callStatus_dyn();
+
+		::Array< ::Dynamic> videoTracks();
+		::Dynamic videoTracks_dyn();
+
+		 ::snikket::jingle::DTMFSender dtmf();
+		::Dynamic dtmf_dyn();
+
+		::String get_sid();
+		::Dynamic get_sid_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_IncomingProposedSession */ 
diff --git a/Sources/c_snikket/iinclude/snikket/jingle/InitiatedSession.h b/Sources/c_snikket/iinclude/snikket/jingle/InitiatedSession.h
new file mode 100644
index 0000000..569256c
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/jingle/InitiatedSession.h
@@ -0,0 +1,160 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_InitiatedSession
+#define INCLUDED_snikket_jingle_InitiatedSession
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_jingle_Session
+#include <snikket/jingle/Session.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Client)
+HX_DECLARE_CLASS1(snikket,EventEmitter)
+HX_DECLARE_CLASS1(snikket,JID)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,jingle,DTMFSender)
+HX_DECLARE_CLASS2(snikket,jingle,InitiatedSession)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStream)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStreamTrack)
+HX_DECLARE_CLASS2(snikket,jingle,OutgoingSession)
+HX_DECLARE_CLASS2(snikket,jingle,PeerConnection)
+HX_DECLARE_CLASS2(snikket,jingle,Session)
+HX_DECLARE_CLASS2(snikket,jingle,SessionDescription)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES InitiatedSession_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef InitiatedSession_obj OBJ_;
+		InitiatedSession_obj();
+
+	public:
+		enum { _hx_ClassId = 0x050f75b9 };
+
+		void __construct( ::snikket::Client client, ::snikket::JID counterpart,::String sid, ::snikket::jingle::SessionDescription remoteDescription);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.InitiatedSession")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.InitiatedSession"); }
+		static ::hx::ObjectPtr< InitiatedSession_obj > __new( ::snikket::Client client, ::snikket::JID counterpart,::String sid, ::snikket::jingle::SessionDescription remoteDescription);
+		static ::hx::ObjectPtr< InitiatedSession_obj > __alloc(::hx::Ctx *_hx_ctx, ::snikket::Client client, ::snikket::JID counterpart,::String sid, ::snikket::jingle::SessionDescription remoteDescription);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~InitiatedSession_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		 ::snikket::jingle::InitiatedSession initiate_ef691953( ::snikket::Stanza stanza);
+		::String __ToString() const { return HX_("InitiatedSession",cb,9a,8f,24); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static  ::snikket::jingle::InitiatedSession fromSessionInitiate( ::snikket::Client client, ::snikket::Stanza stanza);
+		static ::Dynamic fromSessionInitiate_dyn();
+
+		::String sid;
+		::String sid__fromC();
+		::Dynamic sid__fromC_dyn();
+
+		 ::snikket::Client client;
+		 ::snikket::JID counterpart;
+		::String _sid;
+		 ::snikket::jingle::SessionDescription remoteDescription;
+		 ::snikket::jingle::SessionDescription localDescription;
+		 ::snikket::jingle::PeerConnection pc;
+		::String peerDtlsSetup;
+		::Array< ::Dynamic> queuedInboundTransportInfo;
+		::Array< ::Dynamic> queuedOutboundCandidate;
+		bool accepted;
+		 ::Dynamic afterMedia;
+		Dynamic afterMedia_dyn() { return afterMedia;}
+		bool initiator;
+		 ::Dynamic candidatesDone;
+		Dynamic candidatesDone_dyn() { return candidatesDone;}
+		::String get_sid();
+		::Dynamic get_sid_dyn();
+
+		void ring();
+		::Dynamic ring_dyn();
+
+		void retract();
+		::Dynamic retract_dyn();
+
+		void accept();
+		::Dynamic accept_dyn();
+
+		void hangup();
+		::Dynamic hangup_dyn();
+
+		virtual  ::snikket::jingle::OutgoingSession initiate( ::snikket::Stanza stanza);
+		::Dynamic initiate_dyn();
+
+		void terminate();
+		::Dynamic terminate_dyn();
+
+		void contentAdd( ::snikket::Stanza stanza);
+		::Dynamic contentAdd_dyn();
+
+		void contentAccept( ::snikket::Stanza stanza);
+		::Dynamic contentAccept_dyn();
+
+		::Dynamic transportInfo( ::snikket::Stanza stanza);
+		::Dynamic transportInfo_dyn();
+
+		void addMedia(::Array< ::Dynamic> streams);
+		::Dynamic addMedia_dyn();
+
+		void addMedia__fromC(::cpp::Pointer< void* > streams,size_t streams__len);
+		::Dynamic addMedia__fromC_dyn();
+
+		::String callStatus();
+		::Dynamic callStatus_dyn();
+
+		::Array< ::Dynamic> videoTracks();
+		::Dynamic videoTracks_dyn();
+
+		size_t videoTracks__fromC(void*** outPtr);
+
+		 ::snikket::jingle::DTMFSender dtmf();
+		::Dynamic dtmf_dyn();
+
+		void sendIceCandidate( ::Dynamic candidate);
+		::Dynamic sendIceCandidate_dyn();
+
+		void supplyMedia(::Array< ::Dynamic> streams);
+		::Dynamic supplyMedia_dyn();
+
+		void supplyMedia__fromC(::cpp::Pointer< void* > streams,size_t streams__len);
+		::Dynamic supplyMedia__fromC_dyn();
+
+		void setupPeerConnection( ::Dynamic callback);
+		::Dynamic setupPeerConnection_dyn();
+
+		::Dynamic setupLocalDescription(::String type,::Array< ::String > filterMedia, ::Dynamic filterOut, ::Dynamic beforeSend);
+		::Dynamic setupLocalDescription_dyn();
+
+		virtual ::Dynamic onPeerConnection();
+		::Dynamic onPeerConnection_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_InitiatedSession */ 
diff --git a/Sources/c_snikket/iinclude/snikket/jingle/Media.h b/Sources/c_snikket/iinclude/snikket/jingle/Media.h
new file mode 100644
index 0000000..139653a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/jingle/Media.h
@@ -0,0 +1,82 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_Media
+#define INCLUDED_snikket_jingle_Media
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,jingle,Attribute)
+HX_DECLARE_CLASS2(snikket,jingle,Media)
+HX_DECLARE_CLASS2(snikket,jingle,SessionDescription)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES Media_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Media_obj OBJ_;
+		Media_obj();
+
+	public:
+		enum { _hx_ClassId = 0x06e5f716 };
+
+		void __construct(::String mid,::String media,::String connectionData,::String port,::String protocol,::Array< ::Dynamic> attributes,::Array< int > formats);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.Media")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.Media"); }
+		static ::hx::ObjectPtr< Media_obj > __new(::String mid,::String media,::String connectionData,::String port,::String protocol,::Array< ::Dynamic> attributes,::Array< int > formats);
+		static ::hx::ObjectPtr< Media_obj > __alloc(::hx::Ctx *_hx_ctx,::String mid,::String media,::String connectionData,::String port,::String protocol,::Array< ::Dynamic> attributes,::Array< int > formats);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Media_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Media",c4,74,e9,98); }
+
+		static  ::snikket::jingle::Media fromElement( ::snikket::Stanza content,bool initiator,bool hasGroup, ::snikket::jingle::SessionDescription existingDescription);
+		static ::Dynamic fromElement_dyn();
+
+		::String mid;
+		::String media;
+		::String connectionData;
+		::String port;
+		::String protocol;
+		::Array< ::Dynamic> attributes;
+		::Array< int > formats;
+		::String toSdp();
+		::Dynamic toSdp_dyn();
+
+		 ::snikket::Stanza contentElement(bool initiator);
+		::Dynamic contentElement_dyn();
+
+		 ::snikket::Stanza toElement(::Array< ::Dynamic> sessionAttributes,bool initiator);
+		::Dynamic toElement_dyn();
+
+		 ::Dynamic getUfragPwd(::Array< ::Dynamic> sessionAttributes);
+		::Dynamic getUfragPwd_dyn();
+
+		 ::snikket::Stanza toTransportElement(::Array< ::Dynamic> sessionAttributes);
+		::Dynamic toTransportElement_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_Media */ 
diff --git a/Sources/c_snikket/iinclude/snikket/jingle/MediaStream.h b/Sources/c_snikket/iinclude/snikket/jingle/MediaStream.h
new file mode 100644
index 0000000..1e4bb42
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/jingle/MediaStream.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_MediaStream
+#define INCLUDED_snikket_jingle_MediaStream
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(snikket,jingle,MediaStream)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStreamTrack)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES MediaStream_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef MediaStream_obj OBJ_;
+		MediaStream_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1cdfd2fe };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.MediaStream")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.MediaStream"); }
+		static ::hx::ObjectPtr< MediaStream_obj > __new();
+		static ::hx::ObjectPtr< MediaStream_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~MediaStream_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("MediaStream",64,e8,a8,83); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static  ::snikket::jingle::MediaStream makeAudio();
+		static ::Dynamic makeAudio_dyn();
+
+		::Array< ::Dynamic> tracks;
+		void addTrack( ::snikket::jingle::MediaStreamTrack track);
+		::Dynamic addTrack_dyn();
+
+		::Array< ::Dynamic> getTracks();
+		::Dynamic getTracks_dyn();
+
+		size_t getTracks__fromC(void*** outPtr);
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_MediaStream */ 
diff --git a/Sources/c_snikket/iinclude/snikket/jingle/MediaStreamTrack.h b/Sources/c_snikket/iinclude/snikket/jingle/MediaStreamTrack.h
new file mode 100644
index 0000000..368efe0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/jingle/MediaStreamTrack.h
@@ -0,0 +1,159 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_MediaStreamTrack
+#define INCLUDED_snikket_jingle_MediaStreamTrack
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_f561c66e4c8ac38c
+#define INCLUDED_f561c66e4c8ac38c
+#include "fstream"
+#endif
+#ifndef INCLUDED_c2bfbc5a172f2993
+#define INCLUDED_c2bfbc5a172f2993
+#include "opus.h"
+#endif
+#ifndef INCLUDED_639eed8ef5b51d52
+#define INCLUDED_639eed8ef5b51d52
+#include "rtc/frameinfo.hpp"
+#endif
+#ifndef INCLUDED_0e487a29b6aa8a9b
+#define INCLUDED_0e487a29b6aa8a9b
+#include "rtc/rtc.hpp"
+#endif
+HX_DECLARE_CLASS1(haxe,Timer)
+HX_DECLARE_CLASS2(snikket,jingle,AudioFormat)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStreamTrack)
+HX_DECLARE_CLASS2(sys,thread,EventLoop)
+HX_DECLARE_CLASS2(sys,thread,Mutex)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES MediaStreamTrack_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef MediaStreamTrack_obj OBJ_;
+		MediaStreamTrack_obj();
+
+	public:
+		enum { _hx_ClassId = 0x047992ad };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.MediaStreamTrack")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.MediaStreamTrack"); }
+		static ::hx::ObjectPtr< MediaStreamTrack_obj > __new();
+		static ::hx::ObjectPtr< MediaStreamTrack_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~MediaStreamTrack_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("MediaStreamTrack",87,2b,0b,ac); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static  ::snikket::jingle::MediaStreamTrack fromTrack( std::shared_ptr<  rtc::Track > t);
+
+		static ::Array< short > ULAW_DECODE;
+		static ::Array< unsigned char > ULAW_EXP;
+		static unsigned char pcmToUlaw(short sample);
+		static ::Dynamic pcmToUlaw_dyn();
+
+		::String id__fromC();
+		::Dynamic id__fromC_dyn();
+
+		bool muted__fromC();
+		::Dynamic muted__fromC_dyn();
+
+		::String kind__fromC();
+		::Dynamic kind__fromC_dyn();
+
+		size_t supportedAudioFormats__fromC(void*** outPtr);
+
+		 ::Dynamic pcmCallback;
+		Dynamic pcmCallback_dyn() { return pcmCallback;}
+		 ::Dynamic readyForPCMCallback;
+		Dynamic readyForPCMCallback_dyn() { return readyForPCMCallback;}
+		cpp::Struct<  OpusDecoder* > opus;
+		cpp::Struct<  OpusEncoder* > opusEncoder;
+		 std::shared_ptr<  rtc::RtpPacketizationConfig > rtpPacketizationConfig;
+		 ::sys::thread::EventLoop eventLoop;
+		 ::haxe::Timer timer;
+		::Array< ::Dynamic> audioQ;
+		bool alive;
+		bool waitForQ;
+		Float bufferSizeInSeconds;
+		 ::sys::thread::Mutex mutex;
+		 std::optional<  rtc::Description::Media > media;
+		 std::shared_ptr<  rtc::Track > track;
+		 std::optional<  rtc::Description::Media > get_media();
+
+		::String get_id();
+		::Dynamic get_id_dyn();
+
+		::String get_kind();
+		::Dynamic get_kind_dyn();
+
+		bool get_muted();
+		::Dynamic get_muted_dyn();
+
+		::Array< ::Dynamic> get_supportedAudioFormats();
+		::Dynamic get_supportedAudioFormats_dyn();
+
+		 std::shared_ptr<  rtc::Track > set_track( std::shared_ptr<  rtc::Track > newTrack);
+
+		void addPCMListener( ::Dynamic callback);
+		::Dynamic addPCMListener_dyn();
+
+		void addPCMListener__fromC(::cpp::Function< void  (short*,size_t,int,int,void*) > callback,void* callback__context);
+
+		void onFrame( std::vector<  std::byte > msg, rtc::FrameInfo frameInfo);
+
+		void addReadyForPCMListener( ::Dynamic callback);
+		::Dynamic addReadyForPCMListener_dyn();
+
+		void addReadyForPCMListener__fromC(::cpp::Function< void  (void*) > callback,void* callback__context);
+
+		void notifyReadyForData(bool fromCPP);
+		::Dynamic notifyReadyForData_dyn();
+
+		void writePCM(::Array< short > pcm,int clockRate,int channels);
+		::Dynamic writePCM_dyn();
+
+		void writePCM__fromC(::cpp::Pointer< short > pcm,size_t pcm__len,int clockRate,int channels);
+		::Dynamic writePCM__fromC_dyn();
+
+		void onAudioLoop( ::Dynamic callback);
+		::Dynamic onAudioLoop_dyn();
+
+		void write(::Array< unsigned char > payload,unsigned char payloadType,int clockRate);
+		::Dynamic write_dyn();
+
+		void advanceTimestamp(int samples);
+		::Dynamic advanceTimestamp_dyn();
+
+		void stop();
+		::Dynamic stop_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_MediaStreamTrack */ 
diff --git a/Sources/c_snikket/iinclude/snikket/jingle/OutgoingProposedSession.h b/Sources/c_snikket/iinclude/snikket/jingle/OutgoingProposedSession.h
new file mode 100644
index 0000000..04be360
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/jingle/OutgoingProposedSession.h
@@ -0,0 +1,117 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_OutgoingProposedSession
+#define INCLUDED_snikket_jingle_OutgoingProposedSession
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_jingle_Session
+#include <snikket/jingle/Session.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Client)
+HX_DECLARE_CLASS1(snikket,EventEmitter)
+HX_DECLARE_CLASS1(snikket,JID)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,jingle,DTMFSender)
+HX_DECLARE_CLASS2(snikket,jingle,InitiatedSession)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStream)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStreamTrack)
+HX_DECLARE_CLASS2(snikket,jingle,OutgoingProposedSession)
+HX_DECLARE_CLASS2(snikket,jingle,OutgoingSession)
+HX_DECLARE_CLASS2(snikket,jingle,Session)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES OutgoingProposedSession_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef OutgoingProposedSession_obj OBJ_;
+		OutgoingProposedSession_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4349a55a };
+
+		void __construct( ::snikket::Client client, ::snikket::JID to);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.OutgoingProposedSession")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.OutgoingProposedSession"); }
+		static ::hx::ObjectPtr< OutgoingProposedSession_obj > __new( ::snikket::Client client, ::snikket::JID to);
+		static ::hx::ObjectPtr< OutgoingProposedSession_obj > __alloc(::hx::Ctx *_hx_ctx, ::snikket::Client client, ::snikket::JID to);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~OutgoingProposedSession_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		 ::snikket::jingle::InitiatedSession initiate_ef691953( ::snikket::Stanza stanza);
+		::String __ToString() const { return HX_("OutgoingProposedSession",24,31,32,16); }
+
+		::String sid;
+		 ::snikket::Client client;
+		 ::snikket::JID to;
+		::String _sid;
+		bool audio;
+		bool video;
+		void propose(bool audio,bool video);
+		::Dynamic propose_dyn();
+
+		void hangup();
+		::Dynamic hangup_dyn();
+
+		void retract();
+		::Dynamic retract_dyn();
+
+		void terminate();
+		::Dynamic terminate_dyn();
+
+		void contentAdd( ::snikket::Stanza _);
+		::Dynamic contentAdd_dyn();
+
+		void contentAccept( ::snikket::Stanza _);
+		::Dynamic contentAccept_dyn();
+
+		::Dynamic transportInfo( ::snikket::Stanza _);
+		::Dynamic transportInfo_dyn();
+
+		void accept();
+		::Dynamic accept_dyn();
+
+		 ::snikket::jingle::OutgoingSession initiate( ::snikket::Stanza stanza);
+		::Dynamic initiate_dyn();
+
+		void addMedia(::Array< ::Dynamic> _);
+		::Dynamic addMedia_dyn();
+
+		::String callStatus();
+		::Dynamic callStatus_dyn();
+
+		::Array< ::Dynamic> videoTracks();
+		::Dynamic videoTracks_dyn();
+
+		 ::snikket::jingle::DTMFSender dtmf();
+		::Dynamic dtmf_dyn();
+
+		::String get_sid();
+		::Dynamic get_sid_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_OutgoingProposedSession */ 
diff --git a/Sources/c_snikket/iinclude/snikket/jingle/OutgoingSession.h b/Sources/c_snikket/iinclude/snikket/jingle/OutgoingSession.h
new file mode 100644
index 0000000..80cffde
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/jingle/OutgoingSession.h
@@ -0,0 +1,63 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_OutgoingSession
+#define INCLUDED_snikket_jingle_OutgoingSession
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_jingle_InitiatedSession
+#include <snikket/jingle/InitiatedSession.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Client)
+HX_DECLARE_CLASS1(snikket,EventEmitter)
+HX_DECLARE_CLASS1(snikket,JID)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,jingle,InitiatedSession)
+HX_DECLARE_CLASS2(snikket,jingle,OutgoingSession)
+HX_DECLARE_CLASS2(snikket,jingle,Session)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES OutgoingSession_obj : public  ::snikket::jingle::InitiatedSession_obj
+{
+	public:
+		typedef  ::snikket::jingle::InitiatedSession_obj super;
+		typedef OutgoingSession_obj OBJ_;
+		OutgoingSession_obj();
+
+	public:
+		enum { _hx_ClassId = 0x43b8b0fc };
+
+		void __construct( ::snikket::Client client, ::snikket::JID counterpart,::String sid);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.OutgoingSession")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.OutgoingSession"); }
+		static ::hx::ObjectPtr< OutgoingSession_obj > __new( ::snikket::Client client, ::snikket::JID counterpart,::String sid);
+		static ::hx::ObjectPtr< OutgoingSession_obj > __alloc(::hx::Ctx *_hx_ctx, ::snikket::Client client, ::snikket::JID counterpart,::String sid);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~OutgoingSession_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("OutgoingSession",2a,54,07,c9); }
+
+		::Dynamic onPeerConnection();
+
+		 ::snikket::jingle::OutgoingSession initiate( ::snikket::Stanza stanza);
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_OutgoingSession */ 
diff --git a/Sources/c_snikket/iinclude/snikket/jingle/PeerConnection.h b/Sources/c_snikket/iinclude/snikket/jingle/PeerConnection.h
new file mode 100644
index 0000000..44a1ee9
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/jingle/PeerConnection.h
@@ -0,0 +1,119 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_PeerConnection
+#define INCLUDED_snikket_jingle_PeerConnection
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_0e487a29b6aa8a9b
+#define INCLUDED_0e487a29b6aa8a9b
+#include "rtc/rtc.hpp"
+#endif
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStream)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStreamTrack)
+HX_DECLARE_CLASS2(snikket,jingle,PeerConnection)
+HX_DECLARE_CLASS2(sys,thread,EventLoop)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES PeerConnection_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef PeerConnection_obj OBJ_;
+		PeerConnection_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1731230a };
+
+		void __construct( ::Dynamic configuration, ::Dynamic constraints);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.PeerConnection")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.PeerConnection"); }
+		static ::hx::ObjectPtr< PeerConnection_obj > __new( ::Dynamic configuration, ::Dynamic constraints);
+		static ::hx::ObjectPtr< PeerConnection_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic configuration, ::Dynamic constraints);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~PeerConnection_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("PeerConnection",80,38,71,9a); }
+
+		 ::Dynamic localDescription;
+		::String connectionState;
+		 std::shared_ptr<  rtc::PeerConnection > _pc;
+		::cpp::Pointer<  rtc::PeerConnection > pc;
+		 ::Dynamic waitingOnLocal;
+		Dynamic waitingOnLocal_dyn() { return waitingOnLocal;}
+		 ::haxe::ds::StringMap tracks;
+		::Array< ::Dynamic> trackListeners;
+		::Array< ::Dynamic> localCandidateListeners;
+		::Array< ::Dynamic> stateChangeListeners;
+		 ::sys::thread::EventLoop mainLoop;
+		bool hasLocal;
+		bool hasRemote;
+		::Array< ::Dynamic> pendingTracks;
+		void onLocalDescription();
+		::Dynamic onLocalDescription_dyn();
+
+		void onLocalCandidate( rtc::Candidate candidate);
+
+		void onStateChange(cpp::Struct<  rtc::PeerConnection::State > state);
+		::Dynamic onStateChange_dyn();
+
+		void onGatheringStateChange(cpp::Struct<  rtc::PeerConnection::GatheringState > state);
+		::Dynamic onGatheringStateChange_dyn();
+
+		void onTrack( std::shared_ptr<  rtc::Track > track);
+
+		::String get_connectionState();
+		::Dynamic get_connectionState_dyn();
+
+		 ::Dynamic get_localDescription();
+		::Dynamic get_localDescription_dyn();
+
+		::Dynamic setLocalDescription(cpp::Struct<  rtc::Description::Type > sdpType);
+		::Dynamic setLocalDescription_dyn();
+
+		::Dynamic setRemoteDescription( ::Dynamic description);
+		::Dynamic setRemoteDescription_dyn();
+
+		::Dynamic addIceCandidate( ::Dynamic candidate);
+		::Dynamic addIceCandidate_dyn();
+
+		void addPendingTracks();
+		::Dynamic addPendingTracks_dyn();
+
+		void addTrack( ::snikket::jingle::MediaStreamTrack track, ::snikket::jingle::MediaStream stream);
+		::Dynamic addTrack_dyn();
+
+		::Array< ::Dynamic> getTransceivers();
+		::Dynamic getTransceivers_dyn();
+
+		void close();
+		::Dynamic close_dyn();
+
+		void addEventListener(::String event, ::Dynamic callback);
+		::Dynamic addEventListener_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_PeerConnection */ 
diff --git a/Sources/c_snikket/iinclude/snikket/jingle/Session.h b/Sources/c_snikket/iinclude/snikket/jingle/Session.h
new file mode 100644
index 0000000..306298c
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/jingle/Session.h
@@ -0,0 +1,84 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_Session
+#define INCLUDED_snikket_jingle_Session
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,jingle,DTMFSender)
+HX_DECLARE_CLASS2(snikket,jingle,InitiatedSession)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStream)
+HX_DECLARE_CLASS2(snikket,jingle,MediaStreamTrack)
+HX_DECLARE_CLASS2(snikket,jingle,Session)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES Session_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		::String (::hx::Object :: *_hx_get_sid)(); 
+		static inline ::String get_sid( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::snikket::jingle::Session_obj *>(_hx_.mPtr->_hx_getInterface(0x79d60748)))->_hx_get_sid)();
+		}
+		 ::snikket::jingle::InitiatedSession (::hx::Object :: *_hx_initiate)( ::snikket::Stanza stanza); 
+		static inline  ::snikket::jingle::InitiatedSession initiate( ::Dynamic _hx_, ::snikket::Stanza stanza) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::snikket::jingle::Session_obj *>(_hx_.mPtr->_hx_getInterface(0x79d60748)))->_hx_initiate)(stanza);
+		}
+		void (::hx::Object :: *_hx_accept)(); 
+		static inline void accept( ::Dynamic _hx_) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::jingle::Session_obj *>(_hx_.mPtr->_hx_getInterface(0x79d60748)))->_hx_accept)();
+		}
+		void (::hx::Object :: *_hx_hangup)(); 
+		static inline void hangup( ::Dynamic _hx_) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::jingle::Session_obj *>(_hx_.mPtr->_hx_getInterface(0x79d60748)))->_hx_hangup)();
+		}
+		void (::hx::Object :: *_hx_retract)(); 
+		static inline void retract( ::Dynamic _hx_) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::jingle::Session_obj *>(_hx_.mPtr->_hx_getInterface(0x79d60748)))->_hx_retract)();
+		}
+		void (::hx::Object :: *_hx_terminate)(); 
+		static inline void terminate( ::Dynamic _hx_) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::jingle::Session_obj *>(_hx_.mPtr->_hx_getInterface(0x79d60748)))->_hx_terminate)();
+		}
+		void (::hx::Object :: *_hx_contentAdd)( ::snikket::Stanza stanza); 
+		static inline void contentAdd( ::Dynamic _hx_, ::snikket::Stanza stanza) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::jingle::Session_obj *>(_hx_.mPtr->_hx_getInterface(0x79d60748)))->_hx_contentAdd)(stanza);
+		}
+		void (::hx::Object :: *_hx_contentAccept)( ::snikket::Stanza stanza); 
+		static inline void contentAccept( ::Dynamic _hx_, ::snikket::Stanza stanza) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::jingle::Session_obj *>(_hx_.mPtr->_hx_getInterface(0x79d60748)))->_hx_contentAccept)(stanza);
+		}
+		::Dynamic (::hx::Object :: *_hx_transportInfo)( ::snikket::Stanza stanza); 
+		static inline ::Dynamic transportInfo( ::Dynamic _hx_, ::snikket::Stanza stanza) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::snikket::jingle::Session_obj *>(_hx_.mPtr->_hx_getInterface(0x79d60748)))->_hx_transportInfo)(stanza);
+		}
+		void (::hx::Object :: *_hx_addMedia)(::Array< ::Dynamic> streams); 
+		static inline void addMedia( ::Dynamic _hx_,::Array< ::Dynamic> streams) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::jingle::Session_obj *>(_hx_.mPtr->_hx_getInterface(0x79d60748)))->_hx_addMedia)(streams);
+		}
+		::String (::hx::Object :: *_hx_callStatus)(); 
+		static inline ::String callStatus( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::snikket::jingle::Session_obj *>(_hx_.mPtr->_hx_getInterface(0x79d60748)))->_hx_callStatus)();
+		}
+		::Array< ::Dynamic> (::hx::Object :: *_hx_videoTracks)(); 
+		static inline ::Array< ::Dynamic> videoTracks( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::snikket::jingle::Session_obj *>(_hx_.mPtr->_hx_getInterface(0x79d60748)))->_hx_videoTracks)();
+		}
+		 ::snikket::jingle::DTMFSender (::hx::Object :: *_hx_dtmf)(); 
+		static inline  ::snikket::jingle::DTMFSender dtmf( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::snikket::jingle::Session_obj *>(_hx_.mPtr->_hx_getInterface(0x79d60748)))->_hx_dtmf)();
+		}
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_Session */ 
diff --git a/Sources/c_snikket/iinclude/snikket/jingle/SessionDescription.h b/Sources/c_snikket/iinclude/snikket/jingle/SessionDescription.h
new file mode 100644
index 0000000..4529362
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/jingle/SessionDescription.h
@@ -0,0 +1,86 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_SessionDescription
+#define INCLUDED_snikket_jingle_SessionDescription
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,jingle,Attribute)
+HX_DECLARE_CLASS2(snikket,jingle,Media)
+HX_DECLARE_CLASS2(snikket,jingle,SessionDescription)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES SessionDescription_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef SessionDescription_obj OBJ_;
+		SessionDescription_obj();
+
+	public:
+		enum { _hx_ClassId = 0x24aad8f0 };
+
+		void __construct(int version,::String name,::Array< ::Dynamic> media,::Array< ::Dynamic> attributes,::Array< ::String > identificationTags);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.SessionDescription")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.SessionDescription"); }
+		static ::hx::ObjectPtr< SessionDescription_obj > __new(int version,::String name,::Array< ::Dynamic> media,::Array< ::Dynamic> attributes,::Array< ::String > identificationTags);
+		static ::hx::ObjectPtr< SessionDescription_obj > __alloc(::hx::Ctx *_hx_ctx,int version,::String name,::Array< ::Dynamic> media,::Array< ::Dynamic> attributes,::Array< ::String > identificationTags);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SessionDescription_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SessionDescription",66,e1,61,a3); }
+
+		static  ::snikket::jingle::SessionDescription parse(::String input);
+		static ::Dynamic parse_dyn();
+
+		static  ::snikket::jingle::SessionDescription fromStanza( ::snikket::Stanza iq,bool initiator, ::snikket::jingle::SessionDescription existingDescription);
+		static ::Dynamic fromStanza_dyn();
+
+		int version;
+		::String name;
+		::Array< ::Dynamic> media;
+		::Array< ::Dynamic> attributes;
+		::Array< ::String > identificationTags;
+		 ::Dynamic getUfragPwd();
+		::Dynamic getUfragPwd_dyn();
+
+		 ::snikket::jingle::Attribute getFingerprint();
+		::Dynamic getFingerprint_dyn();
+
+		::String getDtlsSetup();
+		::Dynamic getDtlsSetup_dyn();
+
+		 ::snikket::jingle::SessionDescription addContent( ::snikket::jingle::SessionDescription newDescription);
+		::Dynamic addContent_dyn();
+
+		::String toSdp();
+		::Dynamic toSdp_dyn();
+
+		 ::snikket::Stanza toStanza(::String action,::String sid,bool initiator);
+		::Dynamic toStanza_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_SessionDescription */ 
diff --git a/Sources/c_snikket/iinclude/snikket/jingle/TransportInfo.h b/Sources/c_snikket/iinclude/snikket/jingle/TransportInfo.h
new file mode 100644
index 0000000..1af9d00
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/jingle/TransportInfo.h
@@ -0,0 +1,60 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle_TransportInfo
+#define INCLUDED_snikket_jingle_TransportInfo
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,jingle,Media)
+HX_DECLARE_CLASS2(snikket,jingle,TransportInfo)
+
+namespace snikket{
+namespace jingle{
+
+
+class HXCPP_CLASS_ATTRIBUTES TransportInfo_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef TransportInfo_obj OBJ_;
+		TransportInfo_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4c85e215 };
+
+		void __construct( ::snikket::jingle::Media media,::String sid);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.jingle.TransportInfo")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.jingle.TransportInfo"); }
+		static ::hx::ObjectPtr< TransportInfo_obj > __new( ::snikket::jingle::Media media,::String sid);
+		static ::hx::ObjectPtr< TransportInfo_obj > __alloc(::hx::Ctx *_hx_ctx, ::snikket::jingle::Media media,::String sid);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~TransportInfo_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("TransportInfo",97,8c,bf,fe); }
+
+		 ::snikket::jingle::Media media;
+		::String sid;
+		 ::snikket::Stanza toStanza(bool initiator);
+		::Dynamic toStanza_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+
+#endif /* INCLUDED_snikket_jingle_TransportInfo */ 
diff --git a/Sources/c_snikket/iinclude/snikket/jingle/_Session/Session_Fields_.h b/Sources/c_snikket/iinclude/snikket/jingle/_Session/Session_Fields_.h
new file mode 100644
index 0000000..5690ec1
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/jingle/_Session/Session_Fields_.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_jingle__Session_Session_Fields_
+#define INCLUDED_snikket_jingle__Session_Session_Fields_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,ChatMessage)
+HX_DECLARE_CLASS1(snikket,JID)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS3(snikket,jingle,_Session,Session_Fields_)
+
+namespace snikket{
+namespace jingle{
+namespace _Session{
+
+
+class HXCPP_CLASS_ATTRIBUTES Session_Fields__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Session_Fields__obj OBJ_;
+		Session_Fields__obj();
+
+	public:
+		enum { _hx_ClassId = 0x4b7e6858 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket.jingle._Session.Session_Fields_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket.jingle._Session.Session_Fields_"); }
+
+		inline static ::hx::ObjectPtr< Session_Fields__obj > __new() {
+			::hx::ObjectPtr< Session_Fields__obj > __this = new Session_Fields__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Session_Fields__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Session_Fields__obj *__this = (Session_Fields__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Session_Fields__obj), false, "snikket.jingle._Session.Session_Fields_"));
+			*(void **)__this = Session_Fields__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Session_Fields__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Session_Fields_",5d,02,e4,dc); }
+
+		static  ::snikket::ChatMessage mkCallMessage( ::snikket::JID to, ::snikket::JID from, ::snikket::Stanza event);
+		static ::Dynamic mkCallMessage_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace jingle
+} // end namespace _Session
+
+#endif /* INCLUDED_snikket_jingle__Session_Session_Fields_ */ 
diff --git a/Sources/c_snikket/iinclude/snikket/persistence/Dummy.h b/Sources/c_snikket/iinclude/snikket/persistence/Dummy.h
new file mode 100644
index 0000000..6b7e275
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/persistence/Dummy.h
@@ -0,0 +1,138 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_persistence_Dummy
+#define INCLUDED_snikket_persistence_Dummy
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_Persistence
+#include <snikket/Persistence.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Caps)
+HX_DECLARE_CLASS1(snikket,Chat)
+HX_DECLARE_CLASS1(snikket,ChatMessage)
+HX_DECLARE_CLASS1(snikket,Persistence)
+HX_DECLARE_CLASS1(snikket,ReactionUpdate)
+HX_DECLARE_CLASS1(snikket,SerializedChat)
+HX_DECLARE_CLASS2(snikket,persistence,Dummy)
+
+namespace snikket{
+namespace persistence{
+
+
+class HXCPP_CLASS_ATTRIBUTES Dummy_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Dummy_obj OBJ_;
+		Dummy_obj();
+
+	public:
+		enum { _hx_ClassId = 0x130a03e2 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="snikket.persistence.Dummy")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"snikket.persistence.Dummy"); }
+		static ::hx::ObjectPtr< Dummy_obj > __new();
+		static ::hx::ObjectPtr< Dummy_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Dummy_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("Dummy",08,7e,e8,74); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		void lastId(::String accountId,::String chatId, ::Dynamic callback);
+		::Dynamic lastId_dyn();
+
+		void storeChats(::String accountId,::Array< ::Dynamic> chat);
+		::Dynamic storeChats_dyn();
+
+		void getChats(::String accountId, ::Dynamic callback);
+		::Dynamic getChats_dyn();
+
+		void storeMessages(::String accountId,::Array< ::Dynamic> messages, ::Dynamic callback);
+		::Dynamic storeMessages_dyn();
+
+		void updateMessage(::String accountId, ::snikket::ChatMessage message);
+		::Dynamic updateMessage_dyn();
+
+		void getMessage(::String accountId,::String chatId,::String serverId,::String localId, ::Dynamic callback);
+		::Dynamic getMessage_dyn();
+
+		void getMessagesBefore(::String accountId,::String chatId,::String beforeId,::String beforeTime, ::Dynamic callback);
+		::Dynamic getMessagesBefore_dyn();
+
+		void getMessagesAfter(::String accountId,::String chatId,::String afterId,::String afterTime, ::Dynamic callback);
+		::Dynamic getMessagesAfter_dyn();
+
+		void getMessagesAround(::String accountId,::String chatId,::String aroundId,::String aroundTime, ::Dynamic callback);
+		::Dynamic getMessagesAround_dyn();
+
+		void getChatsUnreadDetails(::String accountId,::Array< ::Dynamic> chats, ::Dynamic callback);
+		::Dynamic getChatsUnreadDetails_dyn();
+
+		void storeReaction(::String accountId, ::snikket::ReactionUpdate update, ::Dynamic callback);
+		::Dynamic storeReaction_dyn();
+
+		void updateMessageStatus(::String accountId,::String localId,int status, ::Dynamic callback);
+		::Dynamic updateMessageStatus_dyn();
+
+		void getMediaUri(::String hashAlgorithm,::Array< unsigned char > hash, ::Dynamic callback);
+		::Dynamic getMediaUri_dyn();
+
+		void hasMedia(::String hashAlgorithm,::Array< unsigned char > hash, ::Dynamic callback);
+		::Dynamic hasMedia_dyn();
+
+		void storeMedia(::String mime,::Array< unsigned char > bd, ::Dynamic callback);
+		::Dynamic storeMedia_dyn();
+
+		void removeMedia(::String hashAlgorithm,::Array< unsigned char > hash);
+		::Dynamic removeMedia_dyn();
+
+		void storeCaps( ::snikket::Caps caps);
+		::Dynamic storeCaps_dyn();
+
+		void getCaps(::String ver, ::Dynamic callback);
+		::Dynamic getCaps_dyn();
+
+		void storeLogin(::String login,::String clientId,::String displayName,::String token);
+		::Dynamic storeLogin_dyn();
+
+		void getLogin(::String login, ::Dynamic callback);
+		::Dynamic getLogin_dyn();
+
+		void removeAccount(::String accountId,bool completely);
+		::Dynamic removeAccount_dyn();
+
+		void listAccounts( ::Dynamic callback);
+		::Dynamic listAccounts_dyn();
+
+		void storeStreamManagement(::String accountId,::Array< unsigned char > sm);
+		::Dynamic storeStreamManagement_dyn();
+
+		void getStreamManagement(::String accountId, ::Dynamic callback);
+		::Dynamic getStreamManagement_dyn();
+
+		void storeService(::String accountId,::String serviceId,::String name,::String node, ::snikket::Caps caps);
+		::Dynamic storeService_dyn();
+
+		void findServicesWithFeature(::String accountId,::String feature, ::Dynamic callback);
+		::Dynamic findServicesWithFeature_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace persistence
+
+#endif /* INCLUDED_snikket_persistence_Dummy */ 
diff --git a/Sources/c_snikket/iinclude/snikket/persistence/KeyValueStore.h b/Sources/c_snikket/iinclude/snikket/persistence/KeyValueStore.h
new file mode 100644
index 0000000..33fa468
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/persistence/KeyValueStore.h
@@ -0,0 +1,33 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_persistence_KeyValueStore
+#define INCLUDED_snikket_persistence_KeyValueStore
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(snikket,persistence,KeyValueStore)
+
+namespace snikket{
+namespace persistence{
+
+
+class HXCPP_CLASS_ATTRIBUTES KeyValueStore_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		void (::hx::Object :: *_hx_get)(::String k, ::Dynamic callback); 
+		static inline void get( ::Dynamic _hx_,::String k, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::persistence::KeyValueStore_obj *>(_hx_.mPtr->_hx_getInterface(0x42160a8d)))->_hx_get)(k,callback);
+		}
+		void (::hx::Object :: *_hx_set)(::String k,::String v, ::Dynamic callback); 
+		static inline void set( ::Dynamic _hx_,::String k,::String v, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::persistence::KeyValueStore_obj *>(_hx_.mPtr->_hx_getInterface(0x42160a8d)))->_hx_set)(k,v,callback);
+		}
+};
+
+} // end namespace snikket
+} // end namespace persistence
+
+#endif /* INCLUDED_snikket_persistence_KeyValueStore */ 
diff --git a/Sources/c_snikket/iinclude/snikket/persistence/MediaStore.h b/Sources/c_snikket/iinclude/snikket/persistence/MediaStore.h
new file mode 100644
index 0000000..911ceff
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/persistence/MediaStore.h
@@ -0,0 +1,42 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_persistence_MediaStore
+#define INCLUDED_snikket_persistence_MediaStore
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(snikket,persistence,KeyValueStore)
+HX_DECLARE_CLASS2(snikket,persistence,MediaStore)
+
+namespace snikket{
+namespace persistence{
+
+
+class HXCPP_CLASS_ATTRIBUTES MediaStore_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		void (::hx::Object :: *_hx_hasMedia)(::String hashAlgorithm,::Array< unsigned char > hash, ::Dynamic callback); 
+		static inline void hasMedia( ::Dynamic _hx_,::String hashAlgorithm,::Array< unsigned char > hash, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::persistence::MediaStore_obj *>(_hx_.mPtr->_hx_getInterface(0x2952283f)))->_hx_hasMedia)(hashAlgorithm,hash,callback);
+		}
+		void (::hx::Object :: *_hx_removeMedia)(::String hashAlgorithm,::Array< unsigned char > hash); 
+		static inline void removeMedia( ::Dynamic _hx_,::String hashAlgorithm,::Array< unsigned char > hash) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::persistence::MediaStore_obj *>(_hx_.mPtr->_hx_getInterface(0x2952283f)))->_hx_removeMedia)(hashAlgorithm,hash);
+		}
+		void (::hx::Object :: *_hx_storeMedia)(::String mime,::Array< unsigned char > bytes, ::Dynamic callback); 
+		static inline void storeMedia( ::Dynamic _hx_,::String mime,::Array< unsigned char > bytes, ::Dynamic callback) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::persistence::MediaStore_obj *>(_hx_.mPtr->_hx_getInterface(0x2952283f)))->_hx_storeMedia)(mime,bytes,callback);
+		}
+		void (::hx::Object :: *_hx_setKV)(::Dynamic kv); 
+		static inline void setKV( ::Dynamic _hx_,::Dynamic kv) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::snikket::persistence::MediaStore_obj *>(_hx_.mPtr->_hx_getInterface(0x2952283f)))->_hx_setKV)(kv);
+		}
+};
+
+} // end namespace snikket
+} // end namespace persistence
+
+#endif /* INCLUDED_snikket_persistence_MediaStore */ 
diff --git a/Sources/c_snikket/iinclude/snikket/persistence/MediaStoreFS.h b/Sources/c_snikket/iinclude/snikket/persistence/MediaStoreFS.h
new file mode 100644
index 0000000..7ceaaa8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/persistence/MediaStoreFS.h
@@ -0,0 +1,86 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_persistence_MediaStoreFS
+#define INCLUDED_snikket_persistence_MediaStoreFS
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_persistence_MediaStore
+#include <snikket/persistence/MediaStore.h>
+#endif
+HX_DECLARE_CLASS2(snikket,persistence,KeyValueStore)
+HX_DECLARE_CLASS2(snikket,persistence,MediaStore)
+HX_DECLARE_CLASS2(snikket,persistence,MediaStoreFS)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+
+namespace snikket{
+namespace persistence{
+
+
+class HXCPP_CLASS_ATTRIBUTES MediaStoreFS_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef MediaStoreFS_obj OBJ_;
+		MediaStoreFS_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3993cd38 };
+
+		void __construct(::String path);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.persistence.MediaStoreFS")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.persistence.MediaStoreFS"); }
+		static ::hx::ObjectPtr< MediaStoreFS_obj > __new(::String path);
+		static ::hx::ObjectPtr< MediaStoreFS_obj > __alloc(::hx::Ctx *_hx_ctx,::String path);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~MediaStoreFS_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("MediaStoreFS",0a,5f,89,fe); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		::String blobpath;
+		::Dynamic kv;
+		void setKV(::Dynamic kv);
+		::Dynamic setKV_dyn();
+
+		void getMediaPath(::String uri, ::Dynamic callback);
+		::Dynamic getMediaPath_dyn();
+
+		void getMediaPath__fromC(::String uri,::cpp::Function< void  (const char*,void*) > callback,void* callback__context);
+
+		void hasMedia(::String hashAlgorithm,::Array< unsigned char > hash, ::Dynamic callback);
+		::Dynamic hasMedia_dyn();
+
+		void removeMedia(::String hashAlgorithm,::Array< unsigned char > hash);
+		::Dynamic removeMedia_dyn();
+
+		void storeMedia(::String mime,::Array< unsigned char > bd, ::Dynamic callback);
+		::Dynamic storeMedia_dyn();
+
+		::Dynamic set(::String k,::String v);
+		::Dynamic set_dyn();
+
+		::Dynamic get(::String k);
+		::Dynamic get_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace persistence
+
+#endif /* INCLUDED_snikket_persistence_MediaStoreFS */ 
diff --git a/Sources/c_snikket/iinclude/snikket/persistence/Sqlite.h b/Sources/c_snikket/iinclude/snikket/persistence/Sqlite.h
new file mode 100644
index 0000000..8418150
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/persistence/Sqlite.h
@@ -0,0 +1,180 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_persistence_Sqlite
+#define INCLUDED_snikket_persistence_Sqlite
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_persistence_KeyValueStore
+#include <snikket/persistence/KeyValueStore.h>
+#endif
+#ifndef INCLUDED_snikket_Persistence
+#include <snikket/Persistence.h>
+#endif
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS1(haxe,Timer)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS1(snikket,Caps)
+HX_DECLARE_CLASS1(snikket,Chat)
+HX_DECLARE_CLASS1(snikket,ChatMessage)
+HX_DECLARE_CLASS1(snikket,Persistence)
+HX_DECLARE_CLASS1(snikket,ReactionUpdate)
+HX_DECLARE_CLASS1(snikket,SerializedChat)
+HX_DECLARE_CLASS2(snikket,persistence,KeyValueStore)
+HX_DECLARE_CLASS2(snikket,persistence,MediaStore)
+HX_DECLARE_CLASS2(snikket,persistence,Sqlite)
+HX_DECLARE_CLASS2(snikket,persistence,SqliteDriver)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+
+namespace snikket{
+namespace persistence{
+
+
+class HXCPP_CLASS_ATTRIBUTES Sqlite_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Sqlite_obj OBJ_;
+		Sqlite_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1fc6c66e };
+
+		void __construct(::String dbfile,::Dynamic media);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.persistence.Sqlite")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.persistence.Sqlite"); }
+		static ::hx::ObjectPtr< Sqlite_obj > __new(::String dbfile,::Dynamic media);
+		static ::hx::ObjectPtr< Sqlite_obj > __alloc(::hx::Ctx *_hx_ctx,::String dbfile,::Dynamic media);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Sqlite_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("Sqlite",ec,9c,99,87); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		 ::snikket::persistence::SqliteDriver db;
+		::Dynamic media;
+		void get(::String k, ::Dynamic callback);
+		::Dynamic get_dyn();
+
+		void set(::String k,::String v, ::Dynamic callback);
+		::Dynamic set_dyn();
+
+		void lastId(::String accountId,::String chatId, ::Dynamic callback);
+		::Dynamic lastId_dyn();
+
+		 ::haxe::ds::StringMap storeChatBuffer;
+		 ::haxe::Timer storeChatTimer;
+		void storeChats(::String accountId,::Array< ::Dynamic> chats);
+		::Dynamic storeChats_dyn();
+
+		void getChats(::String accountId, ::Dynamic callback);
+		::Dynamic getChats_dyn();
+
+		void storeMessages(::String accountId,::Array< ::Dynamic> messages, ::Dynamic callback);
+		::Dynamic storeMessages_dyn();
+
+		void updateMessage(::String accountId, ::snikket::ChatMessage message);
+		::Dynamic updateMessage_dyn();
+
+		void getMessage(::String accountId,::String chatId,::String serverId,::String localId, ::Dynamic callback);
+		::Dynamic getMessage_dyn();
+
+		void getMessage__fromC(::String accountId,::String chatId,::String serverId,::String localId,::cpp::Function< void  (void*,void*) > callback,void* callback__context);
+
+		::Dynamic getMessages(::String accountId,::String chatId,::String time,::String op);
+		::Dynamic getMessages_dyn();
+
+		void getMessagesBefore(::String accountId,::String chatId,::String beforeId,::String beforeTime, ::Dynamic callback);
+		::Dynamic getMessagesBefore_dyn();
+
+		void getMessagesAfter(::String accountId,::String chatId,::String afterId,::String afterTime, ::Dynamic callback);
+		::Dynamic getMessagesAfter_dyn();
+
+		void getMessagesAround(::String accountId,::String chatId,::String aroundId,::String aroundTime, ::Dynamic callback);
+		::Dynamic getMessagesAround_dyn();
+
+		void getChatsUnreadDetails(::String accountId,::Array< ::Dynamic> chats, ::Dynamic callback);
+		::Dynamic getChatsUnreadDetails_dyn();
+
+		void storeReaction(::String accountId, ::snikket::ReactionUpdate update, ::Dynamic callback);
+		::Dynamic storeReaction_dyn();
+
+		void updateMessageStatus(::String accountId,::String localId,int status, ::Dynamic callback);
+		::Dynamic updateMessageStatus_dyn();
+
+		void hasMedia(::String hashAlgorithm,::Array< unsigned char > hash, ::Dynamic callback);
+		::Dynamic hasMedia_dyn();
+
+		void removeMedia(::String hashAlgorithm,::Array< unsigned char > hash);
+		::Dynamic removeMedia_dyn();
+
+		void storeMedia(::String mime,::Array< unsigned char > bd, ::Dynamic callback);
+		::Dynamic storeMedia_dyn();
+
+		void storeCaps( ::snikket::Caps caps);
+		::Dynamic storeCaps_dyn();
+
+		void getCaps(::String ver, ::Dynamic callback);
+		::Dynamic getCaps_dyn();
+
+		void storeLogin(::String accountId,::String clientId,::String displayName,::String token);
+		::Dynamic storeLogin_dyn();
+
+		void getLogin(::String accountId, ::Dynamic callback);
+		::Dynamic getLogin_dyn();
+
+		void removeAccount(::String accountId,bool completely);
+		::Dynamic removeAccount_dyn();
+
+		void listAccounts( ::Dynamic callback);
+		::Dynamic listAccounts_dyn();
+
+		void listAccounts__fromC(::cpp::Function< void  (const char**,size_t,void*) > callback,void* callback__context);
+
+		bool smStoreInProgress;
+		::Array< unsigned char > smStoreNext;
+		void storeStreamManagement(::String accountId,::Array< unsigned char > sm);
+		::Dynamic storeStreamManagement_dyn();
+
+		void getStreamManagement(::String accountId, ::Dynamic callback);
+		::Dynamic getStreamManagement_dyn();
+
+		void storeService(::String accountId,::String serviceId,::String name,::String node, ::snikket::Caps caps);
+		::Dynamic storeService_dyn();
+
+		void findServicesWithFeature(::String accountId,::String feature, ::Dynamic callback);
+		::Dynamic findServicesWithFeature_dyn();
+
+		::Dynamic hydrateReactions(::String accountId,::Array< ::Dynamic> messages);
+		::Dynamic hydrateReactions_dyn();
+
+		::Dynamic fetchReactions(::String accountId,::Array< ::Dynamic> ids);
+		::Dynamic fetchReactions_dyn();
+
+		::Dynamic hydrateReplyTo(::String accountId,::Array< ::Dynamic> messages,::Array< ::Dynamic> replyTos);
+		::Dynamic hydrateReplyTo_dyn();
+
+		::Array< ::Dynamic> hydrateMessages(::String accountId, ::Dynamic rows);
+		::Dynamic hydrateMessages_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace persistence
+
+#endif /* INCLUDED_snikket_persistence_Sqlite */ 
diff --git a/Sources/c_snikket/iinclude/snikket/persistence/SqliteDriver.h b/Sources/c_snikket/iinclude/snikket/persistence/SqliteDriver.h
new file mode 100644
index 0000000..d13d4d8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/persistence/SqliteDriver.h
@@ -0,0 +1,61 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_persistence_SqliteDriver
+#define INCLUDED_snikket_persistence_SqliteDriver
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(snikket,persistence,SqliteDriver)
+HX_DECLARE_CLASS2(sys,db,Connection)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+
+namespace snikket{
+namespace persistence{
+
+
+class HXCPP_CLASS_ATTRIBUTES SqliteDriver_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef SqliteDriver_obj OBJ_;
+		SqliteDriver_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0672539a };
+
+		void __construct(::String dbfile);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.persistence.SqliteDriver")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.persistence.SqliteDriver"); }
+		static ::hx::ObjectPtr< SqliteDriver_obj > __new(::String dbfile);
+		static ::hx::ObjectPtr< SqliteDriver_obj > __alloc(::hx::Ctx *_hx_ctx,::String dbfile);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SqliteDriver_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SqliteDriver",34,0a,34,44); }
+
+		::Dynamic db;
+		::Dynamic exec( ::Dynamic sql,::cpp::VirtualArray params);
+		::Dynamic exec_dyn();
+
+		::String prepare(::String sql,::cpp::VirtualArray params);
+		::Dynamic prepare_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace persistence
+
+#endif /* INCLUDED_snikket_persistence_SqliteDriver */ 
diff --git a/Sources/c_snikket/iinclude/snikket/queries/BlocklistGet.h b/Sources/c_snikket/iinclude/snikket/queries/BlocklistGet.h
new file mode 100644
index 0000000..ab498fe
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/queries/BlocklistGet.h
@@ -0,0 +1,67 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_queries_BlocklistGet
+#define INCLUDED_snikket_queries_BlocklistGet
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#include <snikket/queries/GenericQuery.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,queries,BlocklistGet)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+
+namespace snikket{
+namespace queries{
+
+
+class HXCPP_CLASS_ATTRIBUTES BlocklistGet_obj : public  ::snikket::queries::GenericQuery_obj
+{
+	public:
+		typedef  ::snikket::queries::GenericQuery_obj super;
+		typedef BlocklistGet_obj OBJ_;
+		BlocklistGet_obj();
+
+	public:
+		enum { _hx_ClassId = 0x60103714 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.queries.BlocklistGet")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.queries.BlocklistGet"); }
+		static ::hx::ObjectPtr< BlocklistGet_obj > __new();
+		static ::hx::ObjectPtr< BlocklistGet_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~BlocklistGet_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("BlocklistGet",4b,75,69,37); }
+
+		::String xmlns;
+		::String queryId;
+		 ::snikket::Stanza responseStanza;
+		::Array< ::String > result;
+		void handleResponse( ::snikket::Stanza stanza);
+
+		::Array< ::String > getResult();
+		::Dynamic getResult_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace queries
+
+#endif /* INCLUDED_snikket_queries_BlocklistGet */ 
diff --git a/Sources/c_snikket/iinclude/snikket/queries/BoB.h b/Sources/c_snikket/iinclude/snikket/queries/BoB.h
new file mode 100644
index 0000000..a2bd8ec
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/queries/BoB.h
@@ -0,0 +1,72 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_queries_BoB
+#define INCLUDED_snikket_queries_BoB
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#include <snikket/queries/GenericQuery.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Hash)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,queries,BoB)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+
+namespace snikket{
+namespace queries{
+
+
+class HXCPP_CLASS_ATTRIBUTES BoB_obj : public  ::snikket::queries::GenericQuery_obj
+{
+	public:
+		typedef  ::snikket::queries::GenericQuery_obj super;
+		typedef BoB_obj OBJ_;
+		BoB_obj();
+
+	public:
+		enum { _hx_ClassId = 0x6fef110c };
+
+		void __construct(::String to,::String uri);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.queries.BoB")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.queries.BoB"); }
+		static ::hx::ObjectPtr< BoB_obj > __new(::String to,::String uri);
+		static ::hx::ObjectPtr< BoB_obj > __alloc(::hx::Ctx *_hx_ctx,::String to,::String uri);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~BoB_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("BoB",b5,75,32,00); }
+
+		static  ::snikket::queries::BoB forHash(::String to, ::snikket::Hash hash);
+		static ::Dynamic forHash_dyn();
+
+		::String xmlns;
+		::String queryId;
+		 ::snikket::Stanza responseStanza;
+		 ::Dynamic result;
+		void handleResponse( ::snikket::Stanza stanza);
+
+		 ::Dynamic getResult();
+		::Dynamic getResult_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace queries
+
+#endif /* INCLUDED_snikket_queries_BoB */ 
diff --git a/Sources/c_snikket/iinclude/snikket/queries/DiscoInfoGet.h b/Sources/c_snikket/iinclude/snikket/queries/DiscoInfoGet.h
new file mode 100644
index 0000000..cb69a82
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/queries/DiscoInfoGet.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_queries_DiscoInfoGet
+#define INCLUDED_snikket_queries_DiscoInfoGet
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#include <snikket/queries/GenericQuery.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Caps)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,queries,DiscoInfoGet)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+
+namespace snikket{
+namespace queries{
+
+
+class HXCPP_CLASS_ATTRIBUTES DiscoInfoGet_obj : public  ::snikket::queries::GenericQuery_obj
+{
+	public:
+		typedef  ::snikket::queries::GenericQuery_obj super;
+		typedef DiscoInfoGet_obj OBJ_;
+		DiscoInfoGet_obj();
+
+	public:
+		enum { _hx_ClassId = 0x17bd6e57 };
+
+		void __construct(::String to,::String node);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.queries.DiscoInfoGet")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.queries.DiscoInfoGet"); }
+		static ::hx::ObjectPtr< DiscoInfoGet_obj > __new(::String to,::String node);
+		static ::hx::ObjectPtr< DiscoInfoGet_obj > __alloc(::hx::Ctx *_hx_ctx,::String to,::String node);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~DiscoInfoGet_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DiscoInfoGet",8e,ac,16,ef); }
+
+		::String xmlns;
+		::String queryId;
+		 ::snikket::Stanza responseStanza;
+		 ::snikket::Caps result;
+		void handleResponse( ::snikket::Stanza stanza);
+
+		 ::snikket::Caps getResult();
+		::Dynamic getResult_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace queries
+
+#endif /* INCLUDED_snikket_queries_DiscoInfoGet */ 
diff --git a/Sources/c_snikket/iinclude/snikket/queries/DiscoItemsGet.h b/Sources/c_snikket/iinclude/snikket/queries/DiscoItemsGet.h
new file mode 100644
index 0000000..8096b9e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/queries/DiscoItemsGet.h
@@ -0,0 +1,67 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_queries_DiscoItemsGet
+#define INCLUDED_snikket_queries_DiscoItemsGet
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#include <snikket/queries/GenericQuery.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,queries,DiscoItemsGet)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+
+namespace snikket{
+namespace queries{
+
+
+class HXCPP_CLASS_ATTRIBUTES DiscoItemsGet_obj : public  ::snikket::queries::GenericQuery_obj
+{
+	public:
+		typedef  ::snikket::queries::GenericQuery_obj super;
+		typedef DiscoItemsGet_obj OBJ_;
+		DiscoItemsGet_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3759f407 };
+
+		void __construct(::String to,::String node);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.queries.DiscoItemsGet")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.queries.DiscoItemsGet"); }
+		static ::hx::ObjectPtr< DiscoItemsGet_obj > __new(::String to,::String node);
+		static ::hx::ObjectPtr< DiscoItemsGet_obj > __alloc(::hx::Ctx *_hx_ctx,::String to,::String node);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~DiscoItemsGet_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DiscoItemsGet",f0,25,17,ce); }
+
+		::String xmlns;
+		::String queryId;
+		 ::snikket::Stanza responseStanza;
+		::Array< ::Dynamic> result;
+		void handleResponse( ::snikket::Stanza stanza);
+
+		::Array< ::Dynamic> getResult();
+		::Dynamic getResult_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace queries
+
+#endif /* INCLUDED_snikket_queries_DiscoItemsGet */ 
diff --git a/Sources/c_snikket/iinclude/snikket/queries/ExtDiscoGet.h b/Sources/c_snikket/iinclude/snikket/queries/ExtDiscoGet.h
new file mode 100644
index 0000000..7f2afdc
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/queries/ExtDiscoGet.h
@@ -0,0 +1,67 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_queries_ExtDiscoGet
+#define INCLUDED_snikket_queries_ExtDiscoGet
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#include <snikket/queries/GenericQuery.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,queries,ExtDiscoGet)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+
+namespace snikket{
+namespace queries{
+
+
+class HXCPP_CLASS_ATTRIBUTES ExtDiscoGet_obj : public  ::snikket::queries::GenericQuery_obj
+{
+	public:
+		typedef  ::snikket::queries::GenericQuery_obj super;
+		typedef ExtDiscoGet_obj OBJ_;
+		ExtDiscoGet_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5f97d134 };
+
+		void __construct(::String to);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.queries.ExtDiscoGet")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.queries.ExtDiscoGet"); }
+		static ::hx::ObjectPtr< ExtDiscoGet_obj > __new(::String to);
+		static ::hx::ObjectPtr< ExtDiscoGet_obj > __alloc(::hx::Ctx *_hx_ctx,::String to);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ExtDiscoGet_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ExtDiscoGet",dd,86,3d,f9); }
+
+		::String xmlns;
+		::String queryId;
+		 ::snikket::Stanza responseStanza;
+		::Array< ::Dynamic> result;
+		void handleResponse( ::snikket::Stanza stanza);
+
+		::Array< ::Dynamic> getResult();
+		::Dynamic getResult_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace queries
+
+#endif /* INCLUDED_snikket_queries_ExtDiscoGet */ 
diff --git a/Sources/c_snikket/iinclude/snikket/queries/GenericQuery.h b/Sources/c_snikket/iinclude/snikket/queries/GenericQuery.h
new file mode 100644
index 0000000..b2b72e1
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/queries/GenericQuery.h
@@ -0,0 +1,65 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#define INCLUDED_snikket_queries_GenericQuery
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+
+namespace snikket{
+namespace queries{
+
+
+class HXCPP_CLASS_ATTRIBUTES GenericQuery_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef GenericQuery_obj OBJ_;
+		GenericQuery_obj();
+
+	public:
+		enum { _hx_ClassId = 0x22eda35a };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.queries.GenericQuery")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.queries.GenericQuery"); }
+
+		//~GenericQuery_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("GenericQuery",91,e1,46,fa); }
+
+		 ::snikket::Stanza queryStanza;
+		 ::Dynamic handleFinished;
+		Dynamic handleFinished_dyn() { return handleFinished;}
+		bool isFinished;
+		 ::snikket::Stanza getQueryStanza();
+		::Dynamic getQueryStanza_dyn();
+
+		void finish();
+		::Dynamic finish_dyn();
+
+		virtual void handleResponse( ::snikket::Stanza response) {}
+		::Dynamic handleResponse_dyn();
+		void onFinished( ::Dynamic handler);
+		::Dynamic onFinished_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace queries
+
+#endif /* INCLUDED_snikket_queries_GenericQuery */ 
diff --git a/Sources/c_snikket/iinclude/snikket/queries/HttpUploadSlot.h b/Sources/c_snikket/iinclude/snikket/queries/HttpUploadSlot.h
new file mode 100644
index 0000000..883512b
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/queries/HttpUploadSlot.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_queries_HttpUploadSlot
+#define INCLUDED_snikket_queries_HttpUploadSlot
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#include <snikket/queries/GenericQuery.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Hash)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+HX_DECLARE_CLASS2(snikket,queries,HttpUploadSlot)
+
+namespace snikket{
+namespace queries{
+
+
+class HXCPP_CLASS_ATTRIBUTES HttpUploadSlot_obj : public  ::snikket::queries::GenericQuery_obj
+{
+	public:
+		typedef  ::snikket::queries::GenericQuery_obj super;
+		typedef HttpUploadSlot_obj OBJ_;
+		HttpUploadSlot_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1883dc70 };
+
+		void __construct(::String to,::String filename,int size,::String mime,::Array< ::Dynamic> hashes);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.queries.HttpUploadSlot")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.queries.HttpUploadSlot"); }
+		static ::hx::ObjectPtr< HttpUploadSlot_obj > __new(::String to,::String filename,int size,::String mime,::Array< ::Dynamic> hashes);
+		static ::hx::ObjectPtr< HttpUploadSlot_obj > __alloc(::hx::Ctx *_hx_ctx,::String to,::String filename,int size,::String mime,::Array< ::Dynamic> hashes);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HttpUploadSlot_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HttpUploadSlot",67,56,52,67); }
+
+		::String xmlns;
+		::String queryId;
+		 ::snikket::Stanza responseStanza;
+		 ::Dynamic result;
+		void handleResponse( ::snikket::Stanza stanza);
+
+		 ::Dynamic getResult();
+		::Dynamic getResult_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace queries
+
+#endif /* INCLUDED_snikket_queries_HttpUploadSlot */ 
diff --git a/Sources/c_snikket/iinclude/snikket/queries/JabberIqGatewayGet.h b/Sources/c_snikket/iinclude/snikket/queries/JabberIqGatewayGet.h
new file mode 100644
index 0000000..9c76c99
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/queries/JabberIqGatewayGet.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_queries_JabberIqGatewayGet
+#define INCLUDED_snikket_queries_JabberIqGatewayGet
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#include <snikket/queries/GenericQuery.h>
+#endif
+HX_DECLARE_CLASS2(haxe,ds,Either)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+HX_DECLARE_CLASS2(snikket,queries,JabberIqGatewayGet)
+
+namespace snikket{
+namespace queries{
+
+
+class HXCPP_CLASS_ATTRIBUTES JabberIqGatewayGet_obj : public  ::snikket::queries::GenericQuery_obj
+{
+	public:
+		typedef  ::snikket::queries::GenericQuery_obj super;
+		typedef JabberIqGatewayGet_obj OBJ_;
+		JabberIqGatewayGet_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3942ef8b };
+
+		void __construct(::String to,::String prompt);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.queries.JabberIqGatewayGet")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.queries.JabberIqGatewayGet"); }
+		static ::hx::ObjectPtr< JabberIqGatewayGet_obj > __new(::String to,::String prompt);
+		static ::hx::ObjectPtr< JabberIqGatewayGet_obj > __alloc(::hx::Ctx *_hx_ctx,::String to,::String prompt);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~JabberIqGatewayGet_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("JabberIqGatewayGet",9e,bd,60,0b); }
+
+		::String xmlns;
+		::String queryId;
+		 ::snikket::Stanza responseStanza;
+		 ::haxe::ds::Either result;
+		void handleResponse( ::snikket::Stanza stanza);
+
+		 ::haxe::ds::Either getResult();
+		::Dynamic getResult_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace queries
+
+#endif /* INCLUDED_snikket_queries_JabberIqGatewayGet */ 
diff --git a/Sources/c_snikket/iinclude/snikket/queries/MAMQuery.h b/Sources/c_snikket/iinclude/snikket/queries/MAMQuery.h
new file mode 100644
index 0000000..c3abe95
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/queries/MAMQuery.h
@@ -0,0 +1,73 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_queries_MAMQuery
+#define INCLUDED_snikket_queries_MAMQuery
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#include <snikket/queries/GenericQuery.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+HX_DECLARE_CLASS2(snikket,queries,MAMQuery)
+
+namespace snikket{
+namespace queries{
+
+
+class HXCPP_CLASS_ATTRIBUTES MAMQuery_obj : public  ::snikket::queries::GenericQuery_obj
+{
+	public:
+		typedef  ::snikket::queries::GenericQuery_obj super;
+		typedef MAMQuery_obj OBJ_;
+		MAMQuery_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3d2643e0 };
+
+		void __construct( ::Dynamic params,::String jid);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.queries.MAMQuery")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.queries.MAMQuery"); }
+		static ::hx::ObjectPtr< MAMQuery_obj > __new( ::Dynamic params,::String jid);
+		static ::hx::ObjectPtr< MAMQuery_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic params,::String jid);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~MAMQuery_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("MAMQuery",cf,3d,b2,7d); }
+
+		::String xmlns;
+		::String queryId;
+		 ::snikket::Stanza responseStanza;
+		 ::Dynamic result;
+		void addStringField(::String name,::String value);
+		::Dynamic addStringField_dyn();
+
+		void addArrayField(::String name,::Array< ::String > values);
+		::Dynamic addArrayField_dyn();
+
+		void handleResponse( ::snikket::Stanza stanza);
+
+		 ::Dynamic getResult();
+		::Dynamic getResult_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace queries
+
+#endif /* INCLUDED_snikket_queries_MAMQuery */ 
diff --git a/Sources/c_snikket/iinclude/snikket/queries/PubsubGet.h b/Sources/c_snikket/iinclude/snikket/queries/PubsubGet.h
new file mode 100644
index 0000000..0765cc8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/queries/PubsubGet.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_queries_PubsubGet
+#define INCLUDED_snikket_queries_PubsubGet
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#include <snikket/queries/GenericQuery.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+HX_DECLARE_CLASS2(snikket,queries,PubsubGet)
+
+namespace snikket{
+namespace queries{
+
+
+class HXCPP_CLASS_ATTRIBUTES PubsubGet_obj : public  ::snikket::queries::GenericQuery_obj
+{
+	public:
+		typedef  ::snikket::queries::GenericQuery_obj super;
+		typedef PubsubGet_obj OBJ_;
+		PubsubGet_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1a0e23ea };
+
+		void __construct(::String to,::String node,::String itemId);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.queries.PubsubGet")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.queries.PubsubGet"); }
+		static ::hx::ObjectPtr< PubsubGet_obj > __new(::String to,::String node,::String itemId);
+		static ::hx::ObjectPtr< PubsubGet_obj > __alloc(::hx::Ctx *_hx_ctx,::String to,::String node,::String itemId);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~PubsubGet_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("PubsubGet",53,ed,9f,94); }
+
+		::String xmlns;
+		::String queryId;
+		::String ver;
+		 ::snikket::Stanza responseStanza;
+		::Array< ::Dynamic> result;
+		void handleResponse( ::snikket::Stanza stanza);
+
+		::Array< ::Dynamic> getResult();
+		::Dynamic getResult_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace queries
+
+#endif /* INCLUDED_snikket_queries_PubsubGet */ 
diff --git a/Sources/c_snikket/iinclude/snikket/queries/Push2Disable.h b/Sources/c_snikket/iinclude/snikket/queries/Push2Disable.h
new file mode 100644
index 0000000..19efee6
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/queries/Push2Disable.h
@@ -0,0 +1,63 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_queries_Push2Disable
+#define INCLUDED_snikket_queries_Push2Disable
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#include <snikket/queries/GenericQuery.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+HX_DECLARE_CLASS2(snikket,queries,Push2Disable)
+
+namespace snikket{
+namespace queries{
+
+
+class HXCPP_CLASS_ATTRIBUTES Push2Disable_obj : public  ::snikket::queries::GenericQuery_obj
+{
+	public:
+		typedef  ::snikket::queries::GenericQuery_obj super;
+		typedef Push2Disable_obj OBJ_;
+		Push2Disable_obj();
+
+	public:
+		enum { _hx_ClassId = 0x582a6599 };
+
+		void __construct(::String to);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.queries.Push2Disable")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.queries.Push2Disable"); }
+		static ::hx::ObjectPtr< Push2Disable_obj > __new(::String to);
+		static ::hx::ObjectPtr< Push2Disable_obj > __alloc(::hx::Ctx *_hx_ctx,::String to);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Push2Disable_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Push2Disable",d0,a3,83,2f); }
+
+		::String xmlns;
+		::String queryId;
+		 ::snikket::Stanza responseStanza;
+		void handleResponse( ::snikket::Stanza stanza);
+
+};
+
+} // end namespace snikket
+} // end namespace queries
+
+#endif /* INCLUDED_snikket_queries_Push2Disable */ 
diff --git a/Sources/c_snikket/iinclude/snikket/queries/RosterGet.h b/Sources/c_snikket/iinclude/snikket/queries/RosterGet.h
new file mode 100644
index 0000000..befa38a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/queries/RosterGet.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_queries_RosterGet
+#define INCLUDED_snikket_queries_RosterGet
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#include <snikket/queries/GenericQuery.h>
+#endif
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+HX_DECLARE_CLASS2(snikket,queries,RosterGet)
+
+namespace snikket{
+namespace queries{
+
+
+class HXCPP_CLASS_ATTRIBUTES RosterGet_obj : public  ::snikket::queries::GenericQuery_obj
+{
+	public:
+		typedef  ::snikket::queries::GenericQuery_obj super;
+		typedef RosterGet_obj OBJ_;
+		RosterGet_obj();
+
+	public:
+		enum { _hx_ClassId = 0x6634aa42 };
+
+		void __construct(::String ver);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.queries.RosterGet")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.queries.RosterGet"); }
+		static ::hx::ObjectPtr< RosterGet_obj > __new(::String ver);
+		static ::hx::ObjectPtr< RosterGet_obj > __alloc(::hx::Ctx *_hx_ctx,::String ver);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~RosterGet_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("RosterGet",ab,73,c6,e0); }
+
+		::String xmlns;
+		::String queryId;
+		::String ver;
+		 ::snikket::Stanza responseStanza;
+		::Array< ::Dynamic> result;
+		void handleResponse( ::snikket::Stanza stanza);
+
+		::Array< ::Dynamic> getResult();
+		::Dynamic getResult_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace queries
+
+#endif /* INCLUDED_snikket_queries_RosterGet */ 
diff --git a/Sources/c_snikket/iinclude/snikket/queries/VcardTempGet.h b/Sources/c_snikket/iinclude/snikket/queries/VcardTempGet.h
new file mode 100644
index 0000000..fea8f62
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/queries/VcardTempGet.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_queries_VcardTempGet
+#define INCLUDED_snikket_queries_VcardTempGet
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#include <snikket/queries/GenericQuery.h>
+#endif
+HX_DECLARE_CLASS1(snikket,JID)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,queries,GenericQuery)
+HX_DECLARE_CLASS2(snikket,queries,VcardTempGet)
+
+namespace snikket{
+namespace queries{
+
+
+class HXCPP_CLASS_ATTRIBUTES VcardTempGet_obj : public  ::snikket::queries::GenericQuery_obj
+{
+	public:
+		typedef  ::snikket::queries::GenericQuery_obj super;
+		typedef VcardTempGet_obj OBJ_;
+		VcardTempGet_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4c679325 };
+
+		void __construct( ::snikket::JID to);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.queries.VcardTempGet")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.queries.VcardTempGet"); }
+		static ::hx::ObjectPtr< VcardTempGet_obj > __new( ::snikket::JID to);
+		static ::hx::ObjectPtr< VcardTempGet_obj > __alloc(::hx::Ctx *_hx_ctx, ::snikket::JID to);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~VcardTempGet_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("VcardTempGet",5c,d1,c0,23); }
+
+		::String xmlns;
+		::String queryId;
+		 ::snikket::Stanza responseStanza;
+		 ::Dynamic result;
+		void handleResponse( ::snikket::Stanza stanza);
+
+		 ::Dynamic getResult();
+		::Dynamic getResult_dyn();
+
+};
+
+} // end namespace snikket
+} // end namespace queries
+
+#endif /* INCLUDED_snikket_queries_VcardTempGet */ 
diff --git a/Sources/c_snikket/iinclude/snikket/streams/XmppStropheStream.h b/Sources/c_snikket/iinclude/snikket/streams/XmppStropheStream.h
new file mode 100644
index 0000000..59b34d0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/snikket/streams/XmppStropheStream.h
@@ -0,0 +1,103 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_snikket_streams_XmppStropheStream
+#define INCLUDED_snikket_streams_XmppStropheStream
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_snikket_GenericStream
+#include <snikket/GenericStream.h>
+#endif
+#ifndef INCLUDED_18a1146676e1af0b
+#define INCLUDED_18a1146676e1af0b
+#include "strophe.h"
+#endif
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,BalancedTree)
+HX_DECLARE_CLASS2(haxe,ds,EnumValueMap)
+HX_DECLARE_CLASS1(snikket,EventEmitter)
+HX_DECLARE_CLASS1(snikket,GenericStream)
+HX_DECLARE_CLASS1(snikket,IqRequestType)
+HX_DECLARE_CLASS1(snikket,IqResult)
+HX_DECLARE_CLASS1(snikket,Stanza)
+HX_DECLARE_CLASS2(snikket,_Stanza,NodeInterface)
+HX_DECLARE_CLASS2(snikket,streams,XmppStropheStream)
+
+#include "strophe.h"
+namespace snikket{
+namespace streams{
+
+
+class HXCPP_CLASS_ATTRIBUTES XmppStropheStream_obj : public  ::snikket::GenericStream_obj
+{
+	public:
+		typedef  ::snikket::GenericStream_obj super;
+		typedef XmppStropheStream_obj OBJ_;
+		XmppStropheStream_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7e6ea620 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="snikket.streams.XmppStropheStream")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"snikket.streams.XmppStropheStream"); }
+		static ::hx::ObjectPtr< XmppStropheStream_obj > __new();
+		static ::hx::ObjectPtr< XmppStropheStream_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~XmppStropheStream_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("XmppStropheStream",da,d9,8d,8c); }
+
+		static int strophe_certfail_handler( const xmpp_tlscert_t* cert,const char* err);
+
+		static int strophe_stanza( xmpp_conn_t* conn, xmpp_stanza_t* sstanza,void* userdata);
+
+		static void strophe_connect( xmpp_conn_t* conn, xmpp_conn_event_t event,int error, xmpp_stream_error_t* stream_error,void* userdata);
+
+		static  ::snikket::Stanza convertToStanza( xmpp_stanza_t* el,void* dummy);
+
+		 ::haxe::ds::EnumValueMap iqHandlers;
+		::Array< ::Dynamic> pending;
+		bool ready;
+		::String newId();
+
+		void onIq( ::snikket::IqRequestType type,::String tag,::String xmlns, ::Dynamic handler);
+
+		void connect(::String jid,::Array< unsigned char > sm);
+
+		void disconnect();
+
+		void poll();
+		::Dynamic poll_dyn();
+
+		 xmpp_stanza_t* convertFromStanza( ::snikket::Stanza el);
+		::Dynamic convertFromStanza_dyn();
+
+		void sendStanza( ::snikket::Stanza stanza);
+
+		void finalize();
+		::Dynamic finalize_dyn();
+
+
+	private: xmpp_ctx_t *ctx;
+	private: xmpp_conn_t *conn;
+
+};
+
+} // end namespace snikket
+} // end namespace streams
+
+#endif /* INCLUDED_snikket_streams_XmppStropheStream */ 
diff --git a/Sources/c_snikket/iinclude/sys/FileSystem.h b/Sources/c_snikket/iinclude/sys/FileSystem.h
new file mode 100644
index 0000000..882325d
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/FileSystem.h
@@ -0,0 +1,75 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_FileSystem
+#define INCLUDED_sys_FileSystem
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(sys,FileSystem)
+
+namespace sys{
+
+
+class HXCPP_CLASS_ATTRIBUTES FileSystem_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef FileSystem_obj OBJ_;
+		FileSystem_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2378c654 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="sys.FileSystem")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"sys.FileSystem"); }
+
+		inline static ::hx::ObjectPtr< FileSystem_obj > __new() {
+			::hx::ObjectPtr< FileSystem_obj > __this = new FileSystem_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< FileSystem_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			FileSystem_obj *__this = (FileSystem_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(FileSystem_obj), false, "sys.FileSystem"));
+			*(void **)__this = FileSystem_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~FileSystem_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("FileSystem",ab,e2,17,ca); }
+
+		static bool exists(::String path);
+		static ::Dynamic exists_dyn();
+
+		static  ::Dynamic stat(::String path);
+		static ::Dynamic stat_dyn();
+
+		static ::String fullPath(::String relPath);
+		static ::Dynamic fullPath_dyn();
+
+		static ::String absolutePath(::String relPath);
+		static ::Dynamic absolutePath_dyn();
+
+		static bool isDirectory(::String path);
+		static ::Dynamic isDirectory_dyn();
+
+		static void deleteFile(::String path);
+		static ::Dynamic deleteFile_dyn();
+
+};
+
+} // end namespace sys
+
+#endif /* INCLUDED_sys_FileSystem */ 
diff --git a/Sources/c_snikket/iinclude/sys/Http.h b/Sources/c_snikket/iinclude/sys/Http.h
new file mode 100644
index 0000000..42e3202
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/Http.h
@@ -0,0 +1,88 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_Http
+#define INCLUDED_sys_Http
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_http_HttpBase
+#include <haxe/http/HttpBase.h>
+#endif
+HX_DECLARE_CLASS0(EReg)
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS2(haxe,http,HttpBase)
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,BytesOutput)
+HX_DECLARE_CLASS2(haxe,io,Input)
+HX_DECLARE_CLASS2(haxe,io,Output)
+HX_DECLARE_CLASS1(sys,Http)
+HX_DECLARE_CLASS2(sys,net,Socket)
+
+namespace sys{
+
+
+class HXCPP_CLASS_ATTRIBUTES Http_obj : public  ::haxe::http::HttpBase_obj
+{
+	public:
+		typedef  ::haxe::http::HttpBase_obj super;
+		typedef Http_obj OBJ_;
+		Http_obj();
+
+	public:
+		enum { _hx_ClassId = 0x02924475 };
+
+		void __construct(::String url);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.Http")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.Http"); }
+		static ::hx::ObjectPtr< Http_obj > __new(::String url);
+		static ::hx::ObjectPtr< Http_obj > __alloc(::hx::Ctx *_hx_ctx,::String url);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Http_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Http",a8,c7,ef,2f); }
+
+		static void __boot();
+		static  ::Dynamic PROXY;
+		bool noShutdown;
+		Float cnxTimeout;
+		 ::haxe::ds::StringMap responseHeaders;
+		 ::haxe::ds::StringMap responseHeadersSameKey;
+		 ::Dynamic chunk_size;
+		 ::haxe::io::Bytes chunk_buf;
+		 ::Dynamic file;
+		void request( ::Dynamic post);
+		::Dynamic request_dyn();
+
+		void customRequest(bool post, ::haxe::io::Output api, ::sys::net::Socket sock,::String method);
+		::Dynamic customRequest_dyn();
+
+		void writeBody( ::haxe::io::BytesOutput body, ::haxe::io::Input fileInput,int fileSize,::String boundary, ::sys::net::Socket sock);
+		::Dynamic writeBody_dyn();
+
+		void readHttpResponse( ::haxe::io::Output api, ::sys::net::Socket sock);
+		::Dynamic readHttpResponse_dyn();
+
+		bool readChunk( ::EReg chunk_re, ::haxe::io::Output api, ::haxe::io::Bytes buf,int len);
+		::Dynamic readChunk_dyn();
+
+};
+
+} // end namespace sys
+
+#endif /* INCLUDED_sys_Http */ 
diff --git a/Sources/c_snikket/iinclude/sys/db/Connection.h b/Sources/c_snikket/iinclude/sys/db/Connection.h
new file mode 100644
index 0000000..cf46b5f
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/db/Connection.h
@@ -0,0 +1,34 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_db_Connection
+#define INCLUDED_sys_db_Connection
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(sys,db,Connection)
+HX_DECLARE_CLASS2(sys,db,ResultSet)
+
+namespace sys{
+namespace db{
+
+
+class HXCPP_CLASS_ATTRIBUTES Connection_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		::Dynamic (::hx::Object :: *_hx_request)(::String s); 
+		static inline ::Dynamic request( ::Dynamic _hx_,::String s) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::sys::db::Connection_obj *>(_hx_.mPtr->_hx_getInterface(0x6e7a3d49)))->_hx_request)(s);
+		}
+		::String (::hx::Object :: *_hx_quote)(::String s); 
+		static inline ::String quote( ::Dynamic _hx_,::String s) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::sys::db::Connection_obj *>(_hx_.mPtr->_hx_getInterface(0x6e7a3d49)))->_hx_quote)(s);
+		}
+};
+
+} // end namespace sys
+} // end namespace db
+
+#endif /* INCLUDED_sys_db_Connection */ 
diff --git a/Sources/c_snikket/iinclude/sys/db/ResultSet.h b/Sources/c_snikket/iinclude/sys/db/ResultSet.h
new file mode 100644
index 0000000..6a8d3ca
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/db/ResultSet.h
@@ -0,0 +1,33 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_db_ResultSet
+#define INCLUDED_sys_db_ResultSet
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(sys,db,ResultSet)
+
+namespace sys{
+namespace db{
+
+
+class HXCPP_CLASS_ATTRIBUTES ResultSet_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		bool (::hx::Object :: *_hx_hasNext)(); 
+		static inline bool hasNext( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::sys::db::ResultSet_obj *>(_hx_.mPtr->_hx_getInterface(0xc11b83fa)))->_hx_hasNext)();
+		}
+		 ::Dynamic (::hx::Object :: *_hx_next)(); 
+		static inline  ::Dynamic next( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::sys::db::ResultSet_obj *>(_hx_.mPtr->_hx_getInterface(0xc11b83fa)))->_hx_next)();
+		}
+};
+
+} // end namespace sys
+} // end namespace db
+
+#endif /* INCLUDED_sys_db_ResultSet */ 
diff --git a/Sources/c_snikket/iinclude/sys/db/Sqlite.h b/Sources/c_snikket/iinclude/sys/db/Sqlite.h
new file mode 100644
index 0000000..ae8bcba
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/db/Sqlite.h
@@ -0,0 +1,63 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_db_Sqlite
+#define INCLUDED_sys_db_Sqlite
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(sys,db,Connection)
+HX_DECLARE_CLASS2(sys,db,Sqlite)
+
+namespace sys{
+namespace db{
+
+
+class HXCPP_CLASS_ATTRIBUTES Sqlite_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Sqlite_obj OBJ_;
+		Sqlite_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1fc648d3 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="sys.db.Sqlite")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"sys.db.Sqlite"); }
+
+		inline static ::hx::ObjectPtr< Sqlite_obj > __new() {
+			::hx::ObjectPtr< Sqlite_obj > __this = new Sqlite_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Sqlite_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Sqlite_obj *__this = (Sqlite_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Sqlite_obj), false, "sys.db.Sqlite"));
+			*(void **)__this = Sqlite_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Sqlite_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Sqlite",ec,9c,99,87); }
+
+		static ::Dynamic open(::String file);
+		static ::Dynamic open_dyn();
+
+};
+
+} // end namespace sys
+} // end namespace db
+
+#endif /* INCLUDED_sys_db_Sqlite */ 
diff --git a/Sources/c_snikket/iinclude/sys/db/_Sqlite/SqliteConnection.h b/Sources/c_snikket/iinclude/sys/db/_Sqlite/SqliteConnection.h
new file mode 100644
index 0000000..7c154f8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/db/_Sqlite/SqliteConnection.h
@@ -0,0 +1,67 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_db__Sqlite_SqliteConnection
+#define INCLUDED_sys_db__Sqlite_SqliteConnection
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_sys_db_Connection
+#include <sys/db/Connection.h>
+#endif
+HX_DECLARE_CLASS2(sys,db,Connection)
+HX_DECLARE_CLASS2(sys,db,ResultSet)
+HX_DECLARE_CLASS3(sys,db,_Sqlite,SqliteConnection)
+
+namespace sys{
+namespace db{
+namespace _Sqlite{
+
+
+class HXCPP_CLASS_ATTRIBUTES SqliteConnection_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef SqliteConnection_obj OBJ_;
+		SqliteConnection_obj();
+
+	public:
+		enum { _hx_ClassId = 0x26edc0ae };
+
+		void __construct(::String file);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.db._Sqlite.SqliteConnection")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.db._Sqlite.SqliteConnection"); }
+		static ::hx::ObjectPtr< SqliteConnection_obj > __new(::String file);
+		static ::hx::ObjectPtr< SqliteConnection_obj > __alloc(::hx::Ctx *_hx_ctx,::String file);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SqliteConnection_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("SqliteConnection",2a,20,03,a3); }
+
+		 ::Dynamic c;
+		::Dynamic request(::String s);
+		::Dynamic request_dyn();
+
+		::String quote(::String s);
+		::Dynamic quote_dyn();
+
+};
+
+} // end namespace sys
+} // end namespace db
+} // end namespace _Sqlite
+
+#endif /* INCLUDED_sys_db__Sqlite_SqliteConnection */ 
diff --git a/Sources/c_snikket/iinclude/sys/db/_Sqlite/SqliteResultSet.h b/Sources/c_snikket/iinclude/sys/db/_Sqlite/SqliteResultSet.h
new file mode 100644
index 0000000..3437f67
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/db/_Sqlite/SqliteResultSet.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_db__Sqlite_SqliteResultSet
+#define INCLUDED_sys_db__Sqlite_SqliteResultSet
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_sys_db_ResultSet
+#include <sys/db/ResultSet.h>
+#endif
+HX_DECLARE_CLASS2(haxe,ds,List)
+HX_DECLARE_CLASS2(sys,db,ResultSet)
+HX_DECLARE_CLASS3(sys,db,_Sqlite,SqliteResultSet)
+
+namespace sys{
+namespace db{
+namespace _Sqlite{
+
+
+class HXCPP_CLASS_ATTRIBUTES SqliteResultSet_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef SqliteResultSet_obj OBJ_;
+		SqliteResultSet_obj();
+
+	public:
+		enum { _hx_ClassId = 0x068aee19 };
+
+		void __construct( ::Dynamic r);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.db._Sqlite.SqliteResultSet")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.db._Sqlite.SqliteResultSet"); }
+		static ::hx::ObjectPtr< SqliteResultSet_obj > __new( ::Dynamic r);
+		static ::hx::ObjectPtr< SqliteResultSet_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic r);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SqliteResultSet_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("SqliteResultSet",39,58,4c,f7); }
+
+		 ::Dynamic r;
+		 ::haxe::ds::List cache;
+		bool hasNext();
+		::Dynamic hasNext_dyn();
+
+		 ::Dynamic next();
+		::Dynamic next_dyn();
+
+};
+
+} // end namespace sys
+} // end namespace db
+} // end namespace _Sqlite
+
+#endif /* INCLUDED_sys_db__Sqlite_SqliteResultSet */ 
diff --git a/Sources/c_snikket/iinclude/sys/io/File.h b/Sources/c_snikket/iinclude/sys/io/File.h
new file mode 100644
index 0000000..11172d1
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/io/File.h
@@ -0,0 +1,73 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_io_File
+#define INCLUDED_sys_io_File
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Input)
+HX_DECLARE_CLASS2(haxe,io,Output)
+HX_DECLARE_CLASS2(sys,io,File)
+HX_DECLARE_CLASS2(sys,io,FileInput)
+HX_DECLARE_CLASS2(sys,io,FileOutput)
+
+namespace sys{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES File_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef File_obj OBJ_;
+		File_obj();
+
+	public:
+		enum { _hx_ClassId = 0x645a6147 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="sys.io.File")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"sys.io.File"); }
+
+		inline static ::hx::ObjectPtr< File_obj > __new() {
+			::hx::ObjectPtr< File_obj > __this = new File_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< File_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			File_obj *__this = (File_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(File_obj), false, "sys.io.File"));
+			*(void **)__this = File_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~File_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("File",9c,fa,94,2e); }
+
+		static void saveBytes(::String path, ::haxe::io::Bytes bytes);
+		static ::Dynamic saveBytes_dyn();
+
+		static  ::sys::io::FileInput read(::String path,::hx::Null< bool >  binary);
+		static ::Dynamic read_dyn();
+
+		static  ::sys::io::FileOutput write(::String path,::hx::Null< bool >  binary);
+		static ::Dynamic write_dyn();
+
+};
+
+} // end namespace sys
+} // end namespace io
+
+#endif /* INCLUDED_sys_io_File */ 
diff --git a/Sources/c_snikket/iinclude/sys/io/FileInput.h b/Sources/c_snikket/iinclude/sys/io/FileInput.h
new file mode 100644
index 0000000..8cd622d
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/io/FileInput.h
@@ -0,0 +1,64 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_io_FileInput
+#define INCLUDED_sys_io_FileInput
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_io_Input
+#include <haxe/io/Input.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Input)
+HX_DECLARE_CLASS2(sys,io,FileInput)
+
+namespace sys{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES FileInput_obj : public  ::haxe::io::Input_obj
+{
+	public:
+		typedef  ::haxe::io::Input_obj super;
+		typedef FileInput_obj OBJ_;
+		FileInput_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1a1fbc7b };
+
+		void __construct( ::Dynamic f);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.io.FileInput")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.io.FileInput"); }
+		static ::hx::ObjectPtr< FileInput_obj > __new( ::Dynamic f);
+		static ::hx::ObjectPtr< FileInput_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic f);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~FileInput_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("FileInput",ce,43,18,62); }
+
+		 ::Dynamic _hx___f;
+		int readByte();
+
+		int readBytes( ::haxe::io::Bytes s,int p,int l);
+
+		void close();
+
+};
+
+} // end namespace sys
+} // end namespace io
+
+#endif /* INCLUDED_sys_io_FileInput */ 
diff --git a/Sources/c_snikket/iinclude/sys/io/FileOutput.h b/Sources/c_snikket/iinclude/sys/io/FileOutput.h
new file mode 100644
index 0000000..9bcf940
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/io/FileOutput.h
@@ -0,0 +1,64 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_io_FileOutput
+#define INCLUDED_sys_io_FileOutput
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_io_Output
+#include <haxe/io/Output.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Output)
+HX_DECLARE_CLASS2(sys,io,FileOutput)
+
+namespace sys{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES FileOutput_obj : public  ::haxe::io::Output_obj
+{
+	public:
+		typedef  ::haxe::io::Output_obj super;
+		typedef FileOutput_obj OBJ_;
+		FileOutput_obj();
+
+	public:
+		enum { _hx_ClassId = 0x32387970 };
+
+		void __construct( ::Dynamic f);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.io.FileOutput")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.io.FileOutput"); }
+		static ::hx::ObjectPtr< FileOutput_obj > __new( ::Dynamic f);
+		static ::hx::ObjectPtr< FileOutput_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic f);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~FileOutput_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("FileOutput",bd,5a,b6,e3); }
+
+		 ::Dynamic _hx___f;
+		void writeByte(int c);
+
+		int writeBytes( ::haxe::io::Bytes s,int p,int l);
+
+		void close();
+
+};
+
+} // end namespace sys
+} // end namespace io
+
+#endif /* INCLUDED_sys_io_FileOutput */ 
diff --git a/Sources/c_snikket/iinclude/sys/io/Process.h b/Sources/c_snikket/iinclude/sys/io/Process.h
new file mode 100644
index 0000000..d4386c5
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/io/Process.h
@@ -0,0 +1,61 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_io_Process
+#define INCLUDED_sys_io_Process
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Input)
+HX_DECLARE_CLASS2(haxe,io,Output)
+HX_DECLARE_CLASS2(sys,io,Process)
+
+namespace sys{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES Process_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Process_obj OBJ_;
+		Process_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7a155cb0 };
+
+		void __construct(::String cmd,::Array< ::String > args, ::Dynamic detached);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.io.Process")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.io.Process"); }
+		static ::hx::ObjectPtr< Process_obj > __new(::String cmd,::Array< ::String > args, ::Dynamic detached);
+		static ::hx::ObjectPtr< Process_obj > __alloc(::hx::Ctx *_hx_ctx,::String cmd,::Array< ::String > args, ::Dynamic detached);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Process_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Process",4f,ca,9b,be); }
+
+		 ::Dynamic p;
+		 ::haxe::io::Input _hx_stdout;
+		 ::haxe::io::Input _hx_stderr;
+		 ::haxe::io::Output _hx_stdin;
+		 ::Dynamic exitCode(::hx::Null< bool >  block);
+		::Dynamic exitCode_dyn();
+
+};
+
+} // end namespace sys
+} // end namespace io
+
+#endif /* INCLUDED_sys_io_Process */ 
diff --git a/Sources/c_snikket/iinclude/sys/io/_Process/Stdin.h b/Sources/c_snikket/iinclude/sys/io/_Process/Stdin.h
new file mode 100644
index 0000000..473d06a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/io/_Process/Stdin.h
@@ -0,0 +1,67 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_io__Process_Stdin
+#define INCLUDED_sys_io__Process_Stdin
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_io_Output
+#include <haxe/io/Output.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Output)
+HX_DECLARE_CLASS3(sys,io,_Process,Stdin)
+
+namespace sys{
+namespace io{
+namespace _Process{
+
+
+class HXCPP_CLASS_ATTRIBUTES Stdin_obj : public  ::haxe::io::Output_obj
+{
+	public:
+		typedef  ::haxe::io::Output_obj super;
+		typedef Stdin_obj OBJ_;
+		Stdin_obj();
+
+	public:
+		enum { _hx_ClassId = 0x037481cd };
+
+		void __construct( ::Dynamic p);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.io._Process.Stdin")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.io._Process.Stdin"); }
+		static ::hx::ObjectPtr< Stdin_obj > __new( ::Dynamic p);
+		static ::hx::ObjectPtr< Stdin_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic p);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Stdin_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Stdin",28,23,3b,17); }
+
+		 ::Dynamic p;
+		 ::haxe::io::Bytes buf;
+		void close();
+
+		void writeByte(int c);
+
+		int writeBytes( ::haxe::io::Bytes buf,int pos,int len);
+
+};
+
+} // end namespace sys
+} // end namespace io
+} // end namespace _Process
+
+#endif /* INCLUDED_sys_io__Process_Stdin */ 
diff --git a/Sources/c_snikket/iinclude/sys/io/_Process/Stdout.h b/Sources/c_snikket/iinclude/sys/io/_Process/Stdout.h
new file mode 100644
index 0000000..0533216
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/io/_Process/Stdout.h
@@ -0,0 +1,66 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_io__Process_Stdout
+#define INCLUDED_sys_io__Process_Stdout
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_io_Input
+#include <haxe/io/Input.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Input)
+HX_DECLARE_CLASS3(sys,io,_Process,Stdout)
+
+namespace sys{
+namespace io{
+namespace _Process{
+
+
+class HXCPP_CLASS_ATTRIBUTES Stdout_obj : public  ::haxe::io::Input_obj
+{
+	public:
+		typedef  ::haxe::io::Input_obj super;
+		typedef Stdout_obj OBJ_;
+		Stdout_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2316116e };
+
+		void __construct( ::Dynamic p,bool out);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.io._Process.Stdout")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.io._Process.Stdout"); }
+		static ::hx::ObjectPtr< Stdout_obj > __new( ::Dynamic p,bool out);
+		static ::hx::ObjectPtr< Stdout_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic p,bool out);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Stdout_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Stdout",eb,33,88,3c); }
+
+		 ::Dynamic p;
+		bool out;
+		 ::haxe::io::Bytes buf;
+		int readByte();
+
+		int readBytes( ::haxe::io::Bytes str,int pos,int len);
+
+};
+
+} // end namespace sys
+} // end namespace io
+} // end namespace _Process
+
+#endif /* INCLUDED_sys_io__Process_Stdout */ 
diff --git a/Sources/c_snikket/iinclude/sys/net/Host.h b/Sources/c_snikket/iinclude/sys/net/Host.h
new file mode 100644
index 0000000..0fe42fa
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/net/Host.h
@@ -0,0 +1,94 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_net_Host
+#define INCLUDED_sys_net_Host
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_87d3457c074e81a3_35_new)
+HX_DECLARE_CLASS2(sys,net,Host)
+
+namespace sys{
+namespace net{
+
+
+class HXCPP_CLASS_ATTRIBUTES Host_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Host_obj OBJ_;
+		Host_obj();
+
+	public:
+		enum { _hx_ClassId = 0x6c3d7e78 };
+
+		void __construct(::String name);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.net.Host")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.net.Host"); }
+
+		inline static ::hx::ObjectPtr< Host_obj > __new(::String name) {
+			::hx::ObjectPtr< Host_obj > __this = new Host_obj();
+			__this->__construct(name);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Host_obj > __alloc(::hx::Ctx *_hx_ctx,::String name) {
+			Host_obj *__this = (Host_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Host_obj), true, "sys.net.Host"));
+			*(void **)__this = Host_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_87d3457c074e81a3_35_new)
+HXLINE(  36)		( ( ::sys::net::Host)(__this) )->host = name;
+HXLINE(  37)		try {
+            			HX_STACK_CATCHABLE( ::Dynamic, 0);
+HXLINE(  38)			( ( ::sys::net::Host)(__this) )->ip = _hx_std_host_resolve(name);
+            		} catch( ::Dynamic _hx_e) {
+            			if (_hx_e.IsClass<  ::Dynamic >() ){
+            				HX_STACK_BEGIN_CATCH
+            				 ::Dynamic _g = _hx_e;
+HXLINE(  39)				{
+HXLINE(  39)					null();
+            				}
+HXLINE(  40)				( ( ::sys::net::Host)(__this) )->ipv6 = _hx_std_host_resolve_ipv6(name);
+            			}
+            			else {
+            				HX_STACK_DO_THROW(_hx_e);
+            			}
+            		}
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Host_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		static void __init__();
+
+		::String __ToString() const { return HX_("Host",88,fb,eb,2f); }
+
+		static void __boot();
+		::String host;
+		int ip;
+		::Array< unsigned char > ipv6;
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+} // end namespace sys
+} // end namespace net
+
+#endif /* INCLUDED_sys_net_Host */ 
diff --git a/Sources/c_snikket/iinclude/sys/net/Socket.h b/Sources/c_snikket/iinclude/sys/net/Socket.h
new file mode 100644
index 0000000..c1426ac
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/net/Socket.h
@@ -0,0 +1,82 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_net_Socket
+#define INCLUDED_sys_net_Socket
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Input)
+HX_DECLARE_CLASS2(haxe,io,Output)
+HX_DECLARE_CLASS2(sys,net,Host)
+HX_DECLARE_CLASS2(sys,net,Socket)
+
+namespace sys{
+namespace net{
+
+
+class HXCPP_CLASS_ATTRIBUTES Socket_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Socket_obj OBJ_;
+		Socket_obj();
+
+	public:
+		enum { _hx_ClassId = 0x70c71ec3 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.net.Socket")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.net.Socket"); }
+		static ::hx::ObjectPtr< Socket_obj > __new();
+		static ::hx::ObjectPtr< Socket_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Socket_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Socket",d3,ff,da,5a); }
+
+		 ::Dynamic __s;
+		Float _hx___timeout;
+		bool _hx___blocking;
+		bool _hx___fastSend;
+		 ::haxe::io::Input input;
+		 ::haxe::io::Output output;
+		virtual void init();
+		::Dynamic init_dyn();
+
+		virtual void close();
+		::Dynamic close_dyn();
+
+		virtual void connect( ::sys::net::Host host,int port);
+		::Dynamic connect_dyn();
+
+		void shutdown(bool read,bool write);
+		::Dynamic shutdown_dyn();
+
+		void setTimeout(Float timeout);
+		::Dynamic setTimeout_dyn();
+
+		void setBlocking(bool b);
+		::Dynamic setBlocking_dyn();
+
+		void setFastSend(bool b);
+		::Dynamic setFastSend_dyn();
+
+};
+
+} // end namespace sys
+} // end namespace net
+
+#endif /* INCLUDED_sys_net_Socket */ 
diff --git a/Sources/c_snikket/iinclude/sys/net/_Socket/SocketInput.h b/Sources/c_snikket/iinclude/sys/net/_Socket/SocketInput.h
new file mode 100644
index 0000000..7c6907c
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/net/_Socket/SocketInput.h
@@ -0,0 +1,66 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_net__Socket_SocketInput
+#define INCLUDED_sys_net__Socket_SocketInput
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_io_Input
+#include <haxe/io/Input.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Input)
+HX_DECLARE_CLASS3(sys,net,_Socket,SocketInput)
+
+namespace sys{
+namespace net{
+namespace _Socket{
+
+
+class HXCPP_CLASS_ATTRIBUTES SocketInput_obj : public  ::haxe::io::Input_obj
+{
+	public:
+		typedef  ::haxe::io::Input_obj super;
+		typedef SocketInput_obj OBJ_;
+		SocketInput_obj();
+
+	public:
+		enum { _hx_ClassId = 0x342d0eb5 };
+
+		void __construct( ::Dynamic s);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.net._Socket.SocketInput")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.net._Socket.SocketInput"); }
+		static ::hx::ObjectPtr< SocketInput_obj > __new( ::Dynamic s);
+		static ::hx::ObjectPtr< SocketInput_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic s);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SocketInput_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SocketInput",37,f7,80,be); }
+
+		 ::Dynamic __s;
+		int readByte();
+
+		int readBytes( ::haxe::io::Bytes buf,int pos,int len);
+
+		void close();
+
+};
+
+} // end namespace sys
+} // end namespace net
+} // end namespace _Socket
+
+#endif /* INCLUDED_sys_net__Socket_SocketInput */ 
diff --git a/Sources/c_snikket/iinclude/sys/net/_Socket/SocketOutput.h b/Sources/c_snikket/iinclude/sys/net/_Socket/SocketOutput.h
new file mode 100644
index 0000000..2c685e5
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/net/_Socket/SocketOutput.h
@@ -0,0 +1,66 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_net__Socket_SocketOutput
+#define INCLUDED_sys_net__Socket_SocketOutput
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_io_Output
+#include <haxe/io/Output.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Output)
+HX_DECLARE_CLASS3(sys,net,_Socket,SocketOutput)
+
+namespace sys{
+namespace net{
+namespace _Socket{
+
+
+class HXCPP_CLASS_ATTRIBUTES SocketOutput_obj : public  ::haxe::io::Output_obj
+{
+	public:
+		typedef  ::haxe::io::Output_obj super;
+		typedef SocketOutput_obj OBJ_;
+		SocketOutput_obj();
+
+	public:
+		enum { _hx_ClassId = 0x05556112 };
+
+		void __construct( ::Dynamic s);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.net._Socket.SocketOutput")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.net._Socket.SocketOutput"); }
+		static ::hx::ObjectPtr< SocketOutput_obj > __new( ::Dynamic s);
+		static ::hx::ObjectPtr< SocketOutput_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic s);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SocketOutput_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SocketOutput",34,a3,ea,62); }
+
+		 ::Dynamic __s;
+		void writeByte(int c);
+
+		int writeBytes( ::haxe::io::Bytes buf,int pos,int len);
+
+		void close();
+
+};
+
+} // end namespace sys
+} // end namespace net
+} // end namespace _Socket
+
+#endif /* INCLUDED_sys_net__Socket_SocketOutput */ 
diff --git a/Sources/c_snikket/iinclude/sys/ssl/Certificate.h b/Sources/c_snikket/iinclude/sys/ssl/Certificate.h
new file mode 100644
index 0000000..c0b6746
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/ssl/Certificate.h
@@ -0,0 +1,85 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_ssl_Certificate
+#define INCLUDED_sys_ssl_Certificate
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_15e02723fb84005c_33_new)
+HX_DECLARE_CLASS2(sys,ssl,Certificate)
+
+namespace sys{
+namespace ssl{
+
+
+class HXCPP_CLASS_ATTRIBUTES Certificate_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Certificate_obj OBJ_;
+		Certificate_obj();
+
+	public:
+		enum { _hx_ClassId = 0x205b2370 };
+
+		void __construct( ::Dynamic x, ::sys::ssl::Certificate h);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.ssl.Certificate")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.ssl.Certificate"); }
+
+		inline static ::hx::ObjectPtr< Certificate_obj > __new( ::Dynamic x, ::sys::ssl::Certificate h) {
+			::hx::ObjectPtr< Certificate_obj > __this = new Certificate_obj();
+			__this->__construct(x,h);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Certificate_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic x, ::sys::ssl::Certificate h) {
+			Certificate_obj *__this = (Certificate_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Certificate_obj), true, "sys.ssl.Certificate"));
+			*(void **)__this = Certificate_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_15e02723fb84005c_33_new)
+HXLINE(  34)		( ( ::sys::ssl::Certificate)(__this) )->_hx___x = x;
+HXLINE(  35)		( ( ::sys::ssl::Certificate)(__this) )->_hx___h = h;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Certificate_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		static void __init__();
+
+		::String __ToString() const { return HX_("Certificate",f7,60,75,ff); }
+
+		static void __boot();
+		static  ::sys::ssl::Certificate loadFile(::String file);
+		static ::Dynamic loadFile_dyn();
+
+		static  ::sys::ssl::Certificate loadPath(::String path);
+		static ::Dynamic loadPath_dyn();
+
+		static  ::sys::ssl::Certificate loadDefaults();
+		static ::Dynamic loadDefaults_dyn();
+
+		 ::sys::ssl::Certificate _hx___h;
+		 ::Dynamic _hx___x;
+};
+
+} // end namespace sys
+} // end namespace ssl
+
+#endif /* INCLUDED_sys_ssl_Certificate */ 
diff --git a/Sources/c_snikket/iinclude/sys/ssl/Key.h b/Sources/c_snikket/iinclude/sys/ssl/Key.h
new file mode 100644
index 0000000..68e01fd
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/ssl/Key.h
@@ -0,0 +1,73 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_ssl_Key
+#define INCLUDED_sys_ssl_Key
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_360df8ce648879c1_34_new)
+HX_DECLARE_CLASS2(sys,ssl,Key)
+
+namespace sys{
+namespace ssl{
+
+
+class HXCPP_CLASS_ATTRIBUTES Key_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Key_obj OBJ_;
+		Key_obj();
+
+	public:
+		enum { _hx_ClassId = 0x6dab52dc };
+
+		void __construct( ::Dynamic k);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.ssl.Key")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.ssl.Key"); }
+
+		inline static ::hx::ObjectPtr< Key_obj > __new( ::Dynamic k) {
+			::hx::ObjectPtr< Key_obj > __this = new Key_obj();
+			__this->__construct(k);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Key_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic k) {
+			Key_obj *__this = (Key_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Key_obj), true, "sys.ssl.Key"));
+			*(void **)__this = Key_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_360df8ce648879c1_34_new)
+HXDLIN(  34)		( ( ::sys::ssl::Key)(__this) )->_hx___k = k;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Key_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		static void __init__();
+
+		::String __ToString() const { return HX_("Key",7f,41,39,00); }
+
+		static void __boot();
+		 ::Dynamic _hx___k;
+};
+
+} // end namespace sys
+} // end namespace ssl
+
+#endif /* INCLUDED_sys_ssl_Key */ 
diff --git a/Sources/c_snikket/iinclude/sys/ssl/Socket.h b/Sources/c_snikket/iinclude/sys/ssl/Socket.h
new file mode 100644
index 0000000..97bacfe
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/ssl/Socket.h
@@ -0,0 +1,88 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_ssl_Socket
+#define INCLUDED_sys_ssl_Socket
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_sys_net_Socket
+#include <sys/net/Socket.h>
+#endif
+HX_DECLARE_CLASS2(sys,net,Host)
+HX_DECLARE_CLASS2(sys,net,Socket)
+HX_DECLARE_CLASS2(sys,ssl,Certificate)
+HX_DECLARE_CLASS2(sys,ssl,Key)
+HX_DECLARE_CLASS2(sys,ssl,Socket)
+
+namespace sys{
+namespace ssl{
+
+
+class HXCPP_CLASS_ATTRIBUTES Socket_obj : public  ::sys::net::Socket_obj
+{
+	public:
+		typedef  ::sys::net::Socket_obj super;
+		typedef Socket_obj OBJ_;
+		Socket_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7a492a0e };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.ssl.Socket")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.ssl.Socket"); }
+		static ::hx::ObjectPtr< Socket_obj > __new();
+		static ::hx::ObjectPtr< Socket_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Socket_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		static void __init__();
+
+		::String __ToString() const { return HX_("Socket",d3,ff,da,5a); }
+
+		static void __boot();
+		static  ::Dynamic DEFAULT_VERIFY_CERT;
+		static  ::sys::ssl::Certificate DEFAULT_CA;
+		 ::Dynamic conf;
+		 ::Dynamic ssl;
+		 ::Dynamic verifyCert;
+		 ::sys::ssl::Certificate caCert;
+		::String hostname;
+		 ::sys::ssl::Certificate ownCert;
+		 ::sys::ssl::Key ownKey;
+		::Array< ::Dynamic> altSNIContexts;
+		 ::Dynamic sniCallback;
+		bool handshakeDone;
+		void init();
+
+		void connect( ::sys::net::Host host,int port);
+
+		void handshake();
+		::Dynamic handshake_dyn();
+
+		void close();
+
+		 ::Dynamic buildSSLConfig(bool server);
+		::Dynamic buildSSLConfig_dyn();
+
+};
+
+} // end namespace sys
+} // end namespace ssl
+
+#endif /* INCLUDED_sys_ssl_Socket */ 
diff --git a/Sources/c_snikket/iinclude/sys/ssl/_Socket/SocketInput.h b/Sources/c_snikket/iinclude/sys/ssl/_Socket/SocketInput.h
new file mode 100644
index 0000000..7fa83ba
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/ssl/_Socket/SocketInput.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_ssl__Socket_SocketInput
+#define INCLUDED_sys_ssl__Socket_SocketInput
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_io_Input
+#include <haxe/io/Input.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Input)
+HX_DECLARE_CLASS2(sys,net,Socket)
+HX_DECLARE_CLASS2(sys,ssl,Socket)
+HX_DECLARE_CLASS3(sys,ssl,_Socket,SocketInput)
+
+namespace sys{
+namespace ssl{
+namespace _Socket{
+
+
+class HXCPP_CLASS_ATTRIBUTES SocketInput_obj : public  ::haxe::io::Input_obj
+{
+	public:
+		typedef  ::haxe::io::Input_obj super;
+		typedef SocketInput_obj OBJ_;
+		SocketInput_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5d27522c };
+
+		void __construct( ::sys::ssl::Socket s);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.ssl._Socket.SocketInput")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.ssl._Socket.SocketInput"); }
+		static ::hx::ObjectPtr< SocketInput_obj > __new( ::sys::ssl::Socket s);
+		static ::hx::ObjectPtr< SocketInput_obj > __alloc(::hx::Ctx *_hx_ctx, ::sys::ssl::Socket s);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SocketInput_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SocketInput",37,f7,80,be); }
+
+		 ::sys::ssl::Socket __s;
+		int readByte();
+
+		int readBytes( ::haxe::io::Bytes buf,int pos,int len);
+
+		void close();
+
+};
+
+} // end namespace sys
+} // end namespace ssl
+} // end namespace _Socket
+
+#endif /* INCLUDED_sys_ssl__Socket_SocketInput */ 
diff --git a/Sources/c_snikket/iinclude/sys/ssl/_Socket/SocketOutput.h b/Sources/c_snikket/iinclude/sys/ssl/_Socket/SocketOutput.h
new file mode 100644
index 0000000..6282196
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/ssl/_Socket/SocketOutput.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_ssl__Socket_SocketOutput
+#define INCLUDED_sys_ssl__Socket_SocketOutput
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_io_Output
+#include <haxe/io/Output.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Output)
+HX_DECLARE_CLASS2(sys,net,Socket)
+HX_DECLARE_CLASS2(sys,ssl,Socket)
+HX_DECLARE_CLASS3(sys,ssl,_Socket,SocketOutput)
+
+namespace sys{
+namespace ssl{
+namespace _Socket{
+
+
+class HXCPP_CLASS_ATTRIBUTES SocketOutput_obj : public  ::haxe::io::Output_obj
+{
+	public:
+		typedef  ::haxe::io::Output_obj super;
+		typedef SocketOutput_obj OBJ_;
+		SocketOutput_obj();
+
+	public:
+		enum { _hx_ClassId = 0x52cf5067 };
+
+		void __construct( ::sys::ssl::Socket s);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.ssl._Socket.SocketOutput")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.ssl._Socket.SocketOutput"); }
+		static ::hx::ObjectPtr< SocketOutput_obj > __new( ::sys::ssl::Socket s);
+		static ::hx::ObjectPtr< SocketOutput_obj > __alloc(::hx::Ctx *_hx_ctx, ::sys::ssl::Socket s);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SocketOutput_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SocketOutput",34,a3,ea,62); }
+
+		 ::sys::ssl::Socket __s;
+		void writeByte(int c);
+
+		int writeBytes( ::haxe::io::Bytes buf,int pos,int len);
+
+		void close();
+
+};
+
+} // end namespace sys
+} // end namespace ssl
+} // end namespace _Socket
+
+#endif /* INCLUDED_sys_ssl__Socket_SocketOutput */ 
diff --git a/Sources/c_snikket/iinclude/sys/thread/EventLoop.h b/Sources/c_snikket/iinclude/sys/thread/EventLoop.h
new file mode 100644
index 0000000..e5d0fee
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/thread/EventLoop.h
@@ -0,0 +1,80 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_thread_EventLoop
+#define INCLUDED_sys_thread_EventLoop
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(sys,thread,EventLoop)
+HX_DECLARE_CLASS2(sys,thread,Lock)
+HX_DECLARE_CLASS2(sys,thread,Mutex)
+HX_DECLARE_CLASS3(sys,thread,_EventLoop,RegularEvent)
+
+namespace sys{
+namespace thread{
+
+
+class HXCPP_CLASS_ATTRIBUTES EventLoop_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef EventLoop_obj OBJ_;
+		EventLoop_obj();
+
+	public:
+		enum { _hx_ClassId = 0x6a581147 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.thread.EventLoop")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.thread.EventLoop"); }
+		static ::hx::ObjectPtr< EventLoop_obj > __new();
+		static ::hx::ObjectPtr< EventLoop_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~EventLoop_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("EventLoop",7e,8f,97,98); }
+
+		static bool CREATED;
+		 ::sys::thread::Mutex mutex;
+		::Array< ::Dynamic> oneTimeEvents;
+		int oneTimeEventsIdx;
+		 ::sys::thread::Lock waitLock;
+		int promisedEventsCount;
+		 ::sys::thread::_EventLoop::RegularEvent regularEvents;
+		bool isMainThread;
+		 ::sys::thread::_EventLoop::RegularEvent repeat( ::Dynamic event,int intervalMs);
+		::Dynamic repeat_dyn();
+
+		void cancel( ::sys::thread::_EventLoop::RegularEvent eventHandler);
+		::Dynamic cancel_dyn();
+
+		void run( ::Dynamic event);
+		::Dynamic run_dyn();
+
+		bool wait( ::Dynamic timeout);
+		::Dynamic wait_dyn();
+
+		void loop();
+		::Dynamic loop_dyn();
+
+};
+
+} // end namespace sys
+} // end namespace thread
+
+#endif /* INCLUDED_sys_thread_EventLoop */ 
diff --git a/Sources/c_snikket/iinclude/sys/thread/Lock.h b/Sources/c_snikket/iinclude/sys/thread/Lock.h
new file mode 100644
index 0000000..b08cb6e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/thread/Lock.h
@@ -0,0 +1,76 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_thread_Lock
+#define INCLUDED_sys_thread_Lock
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_c256ff93ff467723_30_new)
+HX_DECLARE_CLASS2(sys,thread,Lock)
+
+namespace sys{
+namespace thread{
+
+
+class HXCPP_CLASS_ATTRIBUTES Lock_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Lock_obj OBJ_;
+		Lock_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7fa5e9e6 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.thread.Lock")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.thread.Lock"); }
+
+		inline static ::hx::ObjectPtr< Lock_obj > __new() {
+			::hx::ObjectPtr< Lock_obj > __this = new Lock_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Lock_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Lock_obj *__this = (Lock_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Lock_obj), true, "sys.thread.Lock"));
+			*(void **)__this = Lock_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_c256ff93ff467723_30_new)
+HXDLIN(  30)		( ( ::sys::thread::Lock)(__this) )->l =  ::__hxcpp_lock_create();
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Lock_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Lock",0b,c8,90,32); }
+
+		 ::Dynamic l;
+		bool wait( ::Dynamic timeout);
+		::Dynamic wait_dyn();
+
+		void release();
+		::Dynamic release_dyn();
+
+};
+
+} // end namespace sys
+} // end namespace thread
+
+#endif /* INCLUDED_sys_thread_Lock */ 
diff --git a/Sources/c_snikket/iinclude/sys/thread/Mutex.h b/Sources/c_snikket/iinclude/sys/thread/Mutex.h
new file mode 100644
index 0000000..7dcf304
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/thread/Mutex.h
@@ -0,0 +1,76 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_thread_Mutex
+#define INCLUDED_sys_thread_Mutex
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_2ef35e640612cac3_30_new)
+HX_DECLARE_CLASS2(sys,thread,Mutex)
+
+namespace sys{
+namespace thread{
+
+
+class HXCPP_CLASS_ATTRIBUTES Mutex_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Mutex_obj OBJ_;
+		Mutex_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5474b30c };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.thread.Mutex")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.thread.Mutex"); }
+
+		inline static ::hx::ObjectPtr< Mutex_obj > __new() {
+			::hx::ObjectPtr< Mutex_obj > __this = new Mutex_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Mutex_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Mutex_obj *__this = (Mutex_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Mutex_obj), true, "sys.thread.Mutex"));
+			*(void **)__this = Mutex_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_2ef35e640612cac3_30_new)
+HXDLIN(  30)		( ( ::sys::thread::Mutex)(__this) )->m =  ::__hxcpp_mutex_create();
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Mutex_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Mutex",5f,ff,88,a3); }
+
+		 ::Dynamic m;
+		void acquire();
+		::Dynamic acquire_dyn();
+
+		void release();
+		::Dynamic release_dyn();
+
+};
+
+} // end namespace sys
+} // end namespace thread
+
+#endif /* INCLUDED_sys_thread_Mutex */ 
diff --git a/Sources/c_snikket/iinclude/sys/thread/NoEventLoopException.h b/Sources/c_snikket/iinclude/sys/thread/NoEventLoopException.h
new file mode 100644
index 0000000..836f0ff
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/thread/NoEventLoopException.h
@@ -0,0 +1,70 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_thread_NoEventLoopException
+#define INCLUDED_sys_thread_NoEventLoopException
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_Exception
+#include <haxe/Exception.h>
+#endif
+HX_DECLARE_STACK_FRAME(_hx_pos_c0f6a7d563b0a42e_7_new)
+HX_DECLARE_CLASS1(haxe,Exception)
+HX_DECLARE_CLASS2(sys,thread,NoEventLoopException)
+
+namespace sys{
+namespace thread{
+
+
+class HXCPP_CLASS_ATTRIBUTES NoEventLoopException_obj : public  ::haxe::Exception_obj
+{
+	public:
+		typedef  ::haxe::Exception_obj super;
+		typedef NoEventLoopException_obj OBJ_;
+		NoEventLoopException_obj();
+
+	public:
+		enum { _hx_ClassId = 0x00a9e885 };
+
+		void __construct(::String __o_msg, ::haxe::Exception previous);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.thread.NoEventLoopException")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.thread.NoEventLoopException"); }
+
+		inline static ::hx::ObjectPtr< NoEventLoopException_obj > __new(::String __o_msg, ::haxe::Exception previous) {
+			::hx::ObjectPtr< NoEventLoopException_obj > __this = new NoEventLoopException_obj();
+			__this->__construct(__o_msg,previous);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< NoEventLoopException_obj > __alloc(::hx::Ctx *_hx_ctx,::String __o_msg, ::haxe::Exception previous) {
+			NoEventLoopException_obj *__this = (NoEventLoopException_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(NoEventLoopException_obj), true, "sys.thread.NoEventLoopException"));
+			*(void **)__this = NoEventLoopException_obj::_hx_vtable;
+{
+            		::String msg = __o_msg;
+            		if (::hx::IsNull(__o_msg)) msg = HX_("Event loop is not available. Refer to sys.thread.Thread.runWithEventLoop.",89,e6,4c,1c);
+            	HX_STACKFRAME(&_hx_pos_c0f6a7d563b0a42e_7_new)
+HXDLIN(   7)		__this->super::__construct(msg,previous,null());
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~NoEventLoopException_obj();
+
+		HX_DO_RTTI_ALL;
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("NoEventLoopException",92,71,e8,a8); }
+
+};
+
+} // end namespace sys
+} // end namespace thread
+
+#endif /* INCLUDED_sys_thread_NoEventLoopException */ 
diff --git a/Sources/c_snikket/iinclude/sys/thread/_EventLoop/RegularEvent.h b/Sources/c_snikket/iinclude/sys/thread/_EventLoop/RegularEvent.h
new file mode 100644
index 0000000..e91ddab
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/thread/_EventLoop/RegularEvent.h
@@ -0,0 +1,81 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_thread__EventLoop_RegularEvent
+#define INCLUDED_sys_thread__EventLoop_RegularEvent
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_692c76051dac6459_278_new)
+HX_DECLARE_CLASS3(sys,thread,_EventLoop,RegularEvent)
+
+namespace sys{
+namespace thread{
+namespace _EventLoop{
+
+
+class HXCPP_CLASS_ATTRIBUTES RegularEvent_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef RegularEvent_obj OBJ_;
+		RegularEvent_obj();
+
+	public:
+		enum { _hx_ClassId = 0x13f58728 };
+
+		void __construct( ::Dynamic run,Float nextRunTime,Float interval);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.thread._EventLoop.RegularEvent")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.thread._EventLoop.RegularEvent"); }
+
+		inline static ::hx::ObjectPtr< RegularEvent_obj > __new( ::Dynamic run,Float nextRunTime,Float interval) {
+			::hx::ObjectPtr< RegularEvent_obj > __this = new RegularEvent_obj();
+			__this->__construct(run,nextRunTime,interval);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< RegularEvent_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic run,Float nextRunTime,Float interval) {
+			RegularEvent_obj *__this = (RegularEvent_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(RegularEvent_obj), true, "sys.thread._EventLoop.RegularEvent"));
+			*(void **)__this = RegularEvent_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_692c76051dac6459_278_new)
+HXLINE( 284)		( ( ::sys::thread::_EventLoop::RegularEvent)(__this) )->cancelled = false;
+HXLINE( 287)		( ( ::sys::thread::_EventLoop::RegularEvent)(__this) )->run = run;
+HXLINE( 288)		( ( ::sys::thread::_EventLoop::RegularEvent)(__this) )->nextRunTime = nextRunTime;
+HXLINE( 289)		( ( ::sys::thread::_EventLoop::RegularEvent)(__this) )->interval = interval;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~RegularEvent_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("RegularEvent",3e,24,e8,2d); }
+
+		Float nextRunTime;
+		Float interval;
+		 ::Dynamic run;
+		Dynamic run_dyn() { return run;}
+		 ::sys::thread::_EventLoop::RegularEvent next;
+		 ::sys::thread::_EventLoop::RegularEvent previous;
+		bool cancelled;
+};
+
+} // end namespace sys
+} // end namespace thread
+} // end namespace _EventLoop
+
+#endif /* INCLUDED_sys_thread__EventLoop_RegularEvent */ 
diff --git a/Sources/c_snikket/iinclude/sys/thread/_Thread/HaxeThread.h b/Sources/c_snikket/iinclude/sys/thread/_Thread/HaxeThread.h
new file mode 100644
index 0000000..80f44f1
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/thread/_Thread/HaxeThread.h
@@ -0,0 +1,76 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_thread__Thread_HaxeThread
+#define INCLUDED_sys_thread__Thread_HaxeThread
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(sys,thread,EventLoop)
+HX_DECLARE_CLASS2(sys,thread,Mutex)
+HX_DECLARE_CLASS3(sys,thread,_Thread,HaxeThread)
+
+namespace sys{
+namespace thread{
+namespace _Thread{
+
+
+class HXCPP_CLASS_ATTRIBUTES HaxeThread_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef HaxeThread_obj OBJ_;
+		HaxeThread_obj();
+
+	public:
+		enum { _hx_ClassId = 0x72cf0b82 };
+
+		void __construct( ::Dynamic h);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="sys.thread._Thread.HaxeThread")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"sys.thread._Thread.HaxeThread"); }
+		static ::hx::ObjectPtr< HaxeThread_obj > __new( ::Dynamic h);
+		static ::hx::ObjectPtr< HaxeThread_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic h);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HaxeThread_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		static void __init__();
+
+		::String __ToString() const { return HX_("HaxeThread",b0,c7,55,fd); }
+
+		static void __boot();
+		static ::Array< ::Dynamic> threads;
+		static  ::sys::thread::Mutex threadsMutex;
+		static  ::Dynamic mainThreadHandle;
+		static  ::sys::thread::_Thread::HaxeThread mainThread;
+		static  ::sys::thread::_Thread::HaxeThread current();
+		static ::Dynamic current_dyn();
+
+		static  ::sys::thread::_Thread::HaxeThread create( ::Dynamic job,bool withEventLoop);
+		static ::Dynamic create_dyn();
+
+		static void dropThread( ::Dynamic item,int probableIndex);
+		static ::Dynamic dropThread_dyn();
+
+		 ::sys::thread::EventLoop events;
+		 ::Dynamic handle;
+};
+
+} // end namespace sys
+} // end namespace thread
+} // end namespace _Thread
+
+#endif /* INCLUDED_sys_thread__Thread_HaxeThread */ 
diff --git a/Sources/c_snikket/iinclude/sys/thread/_Thread/Thread_Impl_.h b/Sources/c_snikket/iinclude/sys/thread/_Thread/Thread_Impl_.h
new file mode 100644
index 0000000..1d125c1
--- /dev/null
+++ b/Sources/c_snikket/iinclude/sys/thread/_Thread/Thread_Impl_.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_sys_thread__Thread_Thread_Impl_
+#define INCLUDED_sys_thread__Thread_Thread_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(sys,thread,EventLoop)
+HX_DECLARE_CLASS3(sys,thread,_Thread,HaxeThread)
+HX_DECLARE_CLASS3(sys,thread,_Thread,Thread_Impl_)
+
+namespace sys{
+namespace thread{
+namespace _Thread{
+
+
+class HXCPP_CLASS_ATTRIBUTES Thread_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Thread_Impl__obj OBJ_;
+		Thread_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x3097b824 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="sys.thread._Thread.Thread_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"sys.thread._Thread.Thread_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Thread_Impl__obj > __new() {
+			::hx::ObjectPtr< Thread_Impl__obj > __this = new Thread_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Thread_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Thread_Impl__obj *__this = (Thread_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Thread_Impl__obj), false, "sys.thread._Thread.Thread_Impl_"));
+			*(void **)__this = Thread_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Thread_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Thread_Impl_",0a,37,9c,fe); }
+
+		static  ::sys::thread::EventLoop get_events( ::sys::thread::_Thread::HaxeThread this1);
+		static ::Dynamic get_events_dyn();
+
+		static void processEvents();
+		static ::Dynamic processEvents_dyn();
+
+};
+
+} // end namespace sys
+} // end namespace thread
+} // end namespace _Thread
+
+#endif /* INCLUDED_sys_thread__Thread_Thread_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/thenshim/PromiseFactory.h b/Sources/c_snikket/iinclude/thenshim/PromiseFactory.h
new file mode 100644
index 0000000..1fd53c5
--- /dev/null
+++ b/Sources/c_snikket/iinclude/thenshim/PromiseFactory.h
@@ -0,0 +1,36 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_thenshim_PromiseFactory
+#define INCLUDED_thenshim_PromiseFactory
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(thenshim,PromiseFactory)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+
+namespace thenshim{
+
+
+class HXCPP_CLASS_ATTRIBUTES PromiseFactory_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		::Dynamic (::hx::Object :: *_hx_make)( ::Dynamic executor); 
+		static inline ::Dynamic make( ::Dynamic _hx_, ::Dynamic executor) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::thenshim::PromiseFactory_obj *>(_hx_.mPtr->_hx_getInterface(0x93a35865)))->_hx_make)(executor);
+		}
+		::Dynamic (::hx::Object :: *_hx_asResolved)( ::Dynamic object); 
+		static inline ::Dynamic asResolved( ::Dynamic _hx_, ::Dynamic object) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::thenshim::PromiseFactory_obj *>(_hx_.mPtr->_hx_getInterface(0x93a35865)))->_hx_asResolved)(object);
+		}
+		::Dynamic (::hx::Object :: *_hx_asRejected)( ::Dynamic reason); 
+		static inline ::Dynamic asRejected( ::Dynamic _hx_, ::Dynamic reason) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::thenshim::PromiseFactory_obj *>(_hx_.mPtr->_hx_getInterface(0x93a35865)))->_hx_asRejected)(reason);
+		}
+};
+
+} // end namespace thenshim
+
+#endif /* INCLUDED_thenshim_PromiseFactory */ 
diff --git a/Sources/c_snikket/iinclude/thenshim/PromiseTools.h b/Sources/c_snikket/iinclude/thenshim/PromiseTools.h
new file mode 100644
index 0000000..f854535
--- /dev/null
+++ b/Sources/c_snikket/iinclude/thenshim/PromiseTools.h
@@ -0,0 +1,64 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_thenshim_PromiseTools
+#define INCLUDED_thenshim_PromiseTools
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(thenshim,PromiseTools)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+
+namespace thenshim{
+
+
+class HXCPP_CLASS_ATTRIBUTES PromiseTools_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef PromiseTools_obj OBJ_;
+		PromiseTools_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1873701a };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="thenshim.PromiseTools")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"thenshim.PromiseTools"); }
+
+		inline static ::hx::ObjectPtr< PromiseTools_obj > __new() {
+			::hx::ObjectPtr< PromiseTools_obj > __this = new PromiseTools_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< PromiseTools_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			PromiseTools_obj *__this = (PromiseTools_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(PromiseTools_obj), false, "thenshim.PromiseTools"));
+			*(void **)__this = PromiseTools_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~PromiseTools_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("PromiseTools",a0,4e,2e,4d); }
+
+		static ::Dynamic all( ::Dynamic promises);
+		static ::Dynamic all_dyn();
+
+		static ::Dynamic catch_(::Dynamic promise, ::Dynamic onRejected);
+		static ::Dynamic catch__dyn();
+
+};
+
+} // end namespace thenshim
+
+#endif /* INCLUDED_thenshim_PromiseTools */ 
diff --git a/Sources/c_snikket/iinclude/thenshim/Thenable.h b/Sources/c_snikket/iinclude/thenshim/Thenable.h
new file mode 100644
index 0000000..66c521e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/thenshim/Thenable.h
@@ -0,0 +1,27 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_thenshim_Thenable
+#define INCLUDED_thenshim_Thenable
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(thenshim,Thenable)
+
+namespace thenshim{
+
+
+class HXCPP_CLASS_ATTRIBUTES Thenable_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		::Dynamic (::hx::Object :: *_hx_then)( ::Dynamic onFulfilled, ::Dynamic onRejected); 
+		static inline ::Dynamic then( ::Dynamic _hx_, ::Dynamic onFulfilled, ::Dynamic onRejected) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::thenshim::Thenable_obj *>(_hx_.mPtr->_hx_getInterface(0xc019ce6d)))->_hx_then)(onFulfilled,onRejected);
+		}
+};
+
+} // end namespace thenshim
+
+#endif /* INCLUDED_thenshim_Thenable */ 
diff --git a/Sources/c_snikket/iinclude/thenshim/_Promise/Promise_Impl_.h b/Sources/c_snikket/iinclude/thenshim/_Promise/Promise_Impl_.h
new file mode 100644
index 0000000..266087a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/thenshim/_Promise/Promise_Impl_.h
@@ -0,0 +1,75 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_thenshim__Promise_Promise_Impl_
+#define INCLUDED_thenshim__Promise_Promise_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(thenshim,PromiseFactory)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+HX_DECLARE_CLASS2(thenshim,_Promise,Promise_Impl_)
+
+namespace thenshim{
+namespace _Promise{
+
+
+class HXCPP_CLASS_ATTRIBUTES Promise_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Promise_Impl__obj OBJ_;
+		Promise_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x048c0501 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="thenshim._Promise.Promise_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"thenshim._Promise.Promise_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Promise_Impl__obj > __new() {
+			::hx::ObjectPtr< Promise_Impl__obj > __this = new Promise_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Promise_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Promise_Impl__obj *__this = (Promise_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Promise_Impl__obj), false, "thenshim._Promise.Promise_Impl_"));
+			*(void **)__this = Promise_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Promise_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Promise_Impl_",5b,00,ba,be); }
+
+		static void __boot();
+		static ::Dynamic factory;
+		static ::Dynamic _new( ::Dynamic executor);
+		static ::Dynamic _new_dyn();
+
+		static ::Dynamic resolve( ::Dynamic object);
+		static ::Dynamic resolve_dyn();
+
+		static ::Dynamic reject( ::Dynamic reason);
+		static ::Dynamic reject_dyn();
+
+		static ::Dynamic then(::Dynamic this1, ::Dynamic onFulfilled, ::Dynamic onRejected);
+		static ::Dynamic then_dyn();
+
+};
+
+} // end namespace thenshim
+} // end namespace _Promise
+
+#endif /* INCLUDED_thenshim__Promise_Promise_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/thenshim/fallback/FallbackPromise.h b/Sources/c_snikket/iinclude/thenshim/fallback/FallbackPromise.h
new file mode 100644
index 0000000..21e2936
--- /dev/null
+++ b/Sources/c_snikket/iinclude/thenshim/fallback/FallbackPromise.h
@@ -0,0 +1,77 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_thenshim_fallback_FallbackPromise
+#define INCLUDED_thenshim_fallback_FallbackPromise
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_thenshim_Thenable
+#include <thenshim/Thenable.h>
+#endif
+HX_DECLARE_CLASS1(thenshim,Thenable)
+HX_DECLARE_CLASS2(thenshim,fallback,FallbackPromise)
+HX_DECLARE_CLASS2(thenshim,fallback,HandlerSession)
+HX_DECLARE_CLASS2(thenshim,fallback,PromiseState)
+HX_DECLARE_CLASS2(thenshim,fallback,TaskScheduler)
+
+namespace thenshim{
+namespace fallback{
+
+
+class HXCPP_CLASS_ATTRIBUTES FallbackPromise_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef FallbackPromise_obj OBJ_;
+		FallbackPromise_obj();
+
+	public:
+		enum { _hx_ClassId = 0x6da4d981 };
+
+		void __construct( ::thenshim::fallback::TaskScheduler scheduler);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="thenshim.fallback.FallbackPromise")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"thenshim.fallback.FallbackPromise"); }
+		static ::hx::ObjectPtr< FallbackPromise_obj > __new( ::thenshim::fallback::TaskScheduler scheduler);
+		static ::hx::ObjectPtr< FallbackPromise_obj > __alloc(::hx::Ctx *_hx_ctx, ::thenshim::fallback::TaskScheduler scheduler);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~FallbackPromise_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("FallbackPromise",79,35,7a,1c); }
+
+		 ::thenshim::fallback::TaskScheduler scheduler;
+		 ::thenshim::fallback::PromiseState state;
+		 ::Dynamic value;
+		 ::Dynamic reason;
+		::Array< ::Dynamic> sessions;
+		::Dynamic then( ::Dynamic onFulfilled, ::Dynamic onRejected);
+		::Dynamic then_dyn();
+
+		 ::thenshim::fallback::FallbackPromise thenImpl( ::Dynamic onFulfilled, ::Dynamic onRejected);
+		::Dynamic thenImpl_dyn();
+
+		void resolve( ::Dynamic value);
+		::Dynamic resolve_dyn();
+
+		void reject( ::Dynamic reason);
+		::Dynamic reject_dyn();
+
+};
+
+} // end namespace thenshim
+} // end namespace fallback
+
+#endif /* INCLUDED_thenshim_fallback_FallbackPromise */ 
diff --git a/Sources/c_snikket/iinclude/thenshim/fallback/FallbackPromiseFactory.h b/Sources/c_snikket/iinclude/thenshim/fallback/FallbackPromiseFactory.h
new file mode 100644
index 0000000..ecfa490
--- /dev/null
+++ b/Sources/c_snikket/iinclude/thenshim/fallback/FallbackPromiseFactory.h
@@ -0,0 +1,75 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_thenshim_fallback_FallbackPromiseFactory
+#define INCLUDED_thenshim_fallback_FallbackPromiseFactory
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_thenshim_PromiseFactory
+#include <thenshim/PromiseFactory.h>
+#endif
+HX_DECLARE_CLASS1(thenshim,PromiseFactory)
+HX_DECLARE_CLASS1(thenshim,Thenable)
+HX_DECLARE_CLASS2(thenshim,fallback,FallbackPromiseFactory)
+HX_DECLARE_CLASS2(thenshim,fallback,TaskScheduler)
+
+namespace thenshim{
+namespace fallback{
+
+
+class HXCPP_CLASS_ATTRIBUTES FallbackPromiseFactory_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef FallbackPromiseFactory_obj OBJ_;
+		FallbackPromiseFactory_obj();
+
+	public:
+		enum { _hx_ClassId = 0x592d0d49 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="thenshim.fallback.FallbackPromiseFactory")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"thenshim.fallback.FallbackPromiseFactory"); }
+		static ::hx::ObjectPtr< FallbackPromiseFactory_obj > __new();
+		static ::hx::ObjectPtr< FallbackPromiseFactory_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~FallbackPromiseFactory_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("FallbackPromiseFactory",51,a0,67,b6); }
+
+		 ::thenshim::fallback::TaskScheduler scheduler;
+		::Dynamic make( ::Dynamic executor);
+		::Dynamic make_dyn();
+
+		::Dynamic asResolved( ::Dynamic object);
+		::Dynamic asResolved_dyn();
+
+		::Dynamic asResolvedThenable(::Dynamic thenable);
+		::Dynamic asResolvedThenable_dyn();
+
+		::Dynamic asResolvedThenProperty( ::Dynamic object);
+		::Dynamic asResolvedThenProperty_dyn();
+
+		::Dynamic asRejected( ::Dynamic reason);
+		::Dynamic asRejected_dyn();
+
+};
+
+} // end namespace thenshim
+} // end namespace fallback
+
+#endif /* INCLUDED_thenshim_fallback_FallbackPromiseFactory */ 
diff --git a/Sources/c_snikket/iinclude/thenshim/fallback/HandlerSession.h b/Sources/c_snikket/iinclude/thenshim/fallback/HandlerSession.h
new file mode 100644
index 0000000..c9dc287
--- /dev/null
+++ b/Sources/c_snikket/iinclude/thenshim/fallback/HandlerSession.h
@@ -0,0 +1,84 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_thenshim_fallback_HandlerSession
+#define INCLUDED_thenshim_fallback_HandlerSession
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(thenshim,Thenable)
+HX_DECLARE_CLASS2(thenshim,fallback,FallbackPromise)
+HX_DECLARE_CLASS2(thenshim,fallback,HandlerSession)
+HX_DECLARE_CLASS2(thenshim,fallback,TaskScheduler)
+
+namespace thenshim{
+namespace fallback{
+
+
+class HXCPP_CLASS_ATTRIBUTES HandlerSession_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef HandlerSession_obj OBJ_;
+		HandlerSession_obj();
+
+	public:
+		enum { _hx_ClassId = 0x30baea8c };
+
+		void __construct( ::thenshim::fallback::TaskScheduler scheduler, ::Dynamic fulfilledCallback, ::Dynamic rejectedCallback);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="thenshim.fallback.HandlerSession")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"thenshim.fallback.HandlerSession"); }
+		static ::hx::ObjectPtr< HandlerSession_obj > __new( ::thenshim::fallback::TaskScheduler scheduler, ::Dynamic fulfilledCallback, ::Dynamic rejectedCallback);
+		static ::hx::ObjectPtr< HandlerSession_obj > __alloc(::hx::Ctx *_hx_ctx, ::thenshim::fallback::TaskScheduler scheduler, ::Dynamic fulfilledCallback, ::Dynamic rejectedCallback);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HandlerSession_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HandlerSession",cc,10,db,f7); }
+
+		static void resolvePromise( ::thenshim::fallback::FallbackPromise promise, ::Dynamic value);
+		static ::Dynamic resolvePromise_dyn();
+
+		static bool rejectIfSame( ::thenshim::fallback::FallbackPromise promise, ::Dynamic value);
+		static ::Dynamic rejectIfSame_dyn();
+
+		static void resolvePromiseThenable( ::thenshim::fallback::FallbackPromise promise,::Dynamic thenable);
+		static ::Dynamic resolvePromiseThenable_dyn();
+
+		static void resolvePromiseObject( ::thenshim::fallback::FallbackPromise promise, ::Dynamic object);
+		static ::Dynamic resolvePromiseObject_dyn();
+
+		 ::thenshim::fallback::FallbackPromise promise;
+		 ::thenshim::fallback::TaskScheduler scheduler;
+		 ::Dynamic fulfilledCallback;
+		 ::Dynamic rejectedCallback;
+		void resolve( ::Dynamic value);
+		::Dynamic resolve_dyn();
+
+		void resolveImpl( ::Dynamic value);
+		::Dynamic resolveImpl_dyn();
+
+		void reject( ::Dynamic reason);
+		::Dynamic reject_dyn();
+
+		void rejectImpl( ::Dynamic reason);
+		::Dynamic rejectImpl_dyn();
+
+};
+
+} // end namespace thenshim
+} // end namespace fallback
+
+#endif /* INCLUDED_thenshim_fallback_HandlerSession */ 
diff --git a/Sources/c_snikket/iinclude/thenshim/fallback/PromiseState.h b/Sources/c_snikket/iinclude/thenshim/fallback/PromiseState.h
new file mode 100644
index 0000000..7e84191
--- /dev/null
+++ b/Sources/c_snikket/iinclude/thenshim/fallback/PromiseState.h
@@ -0,0 +1,39 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_thenshim_fallback_PromiseState
+#define INCLUDED_thenshim_fallback_PromiseState
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(thenshim,fallback,PromiseState)
+namespace thenshim{
+namespace fallback{
+
+
+class PromiseState_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef PromiseState_obj OBJ_;
+
+	public:
+		PromiseState_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("thenshim.fallback.PromiseState",0a,45,f3,26); }
+		::String __ToString() const { return HX_("PromiseState.",d8,10,c1,ac) + _hx_tag; }
+
+		static ::thenshim::fallback::PromiseState Fulfilled;
+		static inline ::thenshim::fallback::PromiseState Fulfilled_dyn() { return Fulfilled; }
+		static ::thenshim::fallback::PromiseState Pending;
+		static inline ::thenshim::fallback::PromiseState Pending_dyn() { return Pending; }
+		static ::thenshim::fallback::PromiseState Rejected;
+		static inline ::thenshim::fallback::PromiseState Rejected_dyn() { return Rejected; }
+};
+
+} // end namespace thenshim
+} // end namespace fallback
+
+#endif /* INCLUDED_thenshim_fallback_PromiseState */ 
diff --git a/Sources/c_snikket/iinclude/thenshim/fallback/TaskScheduler.h b/Sources/c_snikket/iinclude/thenshim/fallback/TaskScheduler.h
new file mode 100644
index 0000000..ba47ed8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/thenshim/fallback/TaskScheduler.h
@@ -0,0 +1,72 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_thenshim_fallback_TaskScheduler
+#define INCLUDED_thenshim_fallback_TaskScheduler
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_8fc69505e32be3f2_11_new)
+HX_DECLARE_CLASS2(thenshim,fallback,TaskScheduler)
+
+namespace thenshim{
+namespace fallback{
+
+
+class HXCPP_CLASS_ATTRIBUTES TaskScheduler_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef TaskScheduler_obj OBJ_;
+		TaskScheduler_obj();
+
+	public:
+		enum { _hx_ClassId = 0x23747a3a };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="thenshim.fallback.TaskScheduler")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"thenshim.fallback.TaskScheduler"); }
+
+		inline static ::hx::ObjectPtr< TaskScheduler_obj > __new() {
+			::hx::ObjectPtr< TaskScheduler_obj > __this = new TaskScheduler_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< TaskScheduler_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			TaskScheduler_obj *__this = (TaskScheduler_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(TaskScheduler_obj), true, "thenshim.fallback.TaskScheduler"));
+			*(void **)__this = TaskScheduler_obj::_hx_vtable;
+			thenshim::fallback::TaskScheduler_obj::__alloc_dynamic_functions(_hx_ctx,__this);
+{
+            	HX_STACKFRAME(&_hx_pos_8fc69505e32be3f2_11_new)
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		static void __alloc_dynamic_functions(::hx::Ctx *_hx_alloc,TaskScheduler_obj *_hx_obj);
+		//~TaskScheduler_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("TaskScheduler",16,22,01,bb); }
+
+		::Dynamic addNext;
+		inline ::Dynamic &addNext_dyn() {return addNext; }
+
+};
+
+} // end namespace thenshim
+} // end namespace fallback
+
+#endif /* INCLUDED_thenshim_fallback_TaskScheduler */ 
diff --git a/Sources/c_snikket/iinclude/tink/_Chunk/Chunk_Impl_.h b/Sources/c_snikket/iinclude/tink/_Chunk/Chunk_Impl_.h
new file mode 100644
index 0000000..567282c
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/_Chunk/Chunk_Impl_.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink__Chunk_Chunk_Impl_
+#define INCLUDED_tink__Chunk_Chunk_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,_Chunk,Chunk_Impl_)
+HX_DECLARE_CLASS2(tink,chunk,ChunkObject)
+
+namespace tink{
+namespace _Chunk{
+
+
+class HXCPP_CLASS_ATTRIBUTES Chunk_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Chunk_Impl__obj OBJ_;
+		Chunk_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x3bb70ded };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink._Chunk.Chunk_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink._Chunk.Chunk_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Chunk_Impl__obj > __new() {
+			::hx::ObjectPtr< Chunk_Impl__obj > __this = new Chunk_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Chunk_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Chunk_Impl__obj *__this = (Chunk_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Chunk_Impl__obj), false, "tink._Chunk.Chunk_Impl_"));
+			*(void **)__this = Chunk_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Chunk_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Chunk_Impl_",ad,aa,7a,82); }
+
+		static void __boot();
+		static ::Dynamic concat(::Dynamic this1,::Dynamic that);
+		static ::Dynamic concat_dyn();
+
+		static ::Dynamic join(::Array< ::Dynamic> chunks);
+		static ::Dynamic join_dyn();
+
+		static ::Dynamic EMPTY;
+};
+
+} // end namespace tink
+} // end namespace _Chunk
+
+#endif /* INCLUDED_tink__Chunk_Chunk_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/tink/_Chunk/EmptyChunk.h b/Sources/c_snikket/iinclude/tink/_Chunk/EmptyChunk.h
new file mode 100644
index 0000000..b66b362
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/_Chunk/EmptyChunk.h
@@ -0,0 +1,77 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink__Chunk_EmptyChunk
+#define INCLUDED_tink__Chunk_EmptyChunk
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_chunk_ChunkBase
+#include <tink/chunk/ChunkBase.h>
+#endif
+#ifndef INCLUDED_tink_chunk_ChunkObject
+#include <tink/chunk/ChunkObject.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(tink,_Chunk,EmptyChunk)
+HX_DECLARE_CLASS2(tink,chunk,ChunkBase)
+HX_DECLARE_CLASS2(tink,chunk,ChunkObject)
+
+namespace tink{
+namespace _Chunk{
+
+
+class HXCPP_CLASS_ATTRIBUTES EmptyChunk_obj : public  ::tink::chunk::ChunkBase_obj
+{
+	public:
+		typedef  ::tink::chunk::ChunkBase_obj super;
+		typedef EmptyChunk_obj OBJ_;
+		EmptyChunk_obj();
+
+	public:
+		enum { _hx_ClassId = 0x01566580 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink._Chunk.EmptyChunk")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink._Chunk.EmptyChunk"); }
+		static ::hx::ObjectPtr< EmptyChunk_obj > __new();
+		static ::hx::ObjectPtr< EmptyChunk_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~EmptyChunk_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("EmptyChunk",c0,a0,c6,bc); }
+
+		static void __boot();
+		static  ::haxe::io::Bytes EMPTY;
+		int getLength();
+		::Dynamic getLength_dyn();
+
+		::Dynamic slice(int from,int to);
+		::Dynamic slice_dyn();
+
+		void blitTo( ::haxe::io::Bytes target,int offset);
+		::Dynamic blitTo_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+		 ::haxe::io::Bytes toBytes();
+		::Dynamic toBytes_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace _Chunk
+
+#endif /* INCLUDED_tink__Chunk_EmptyChunk */ 
diff --git a/Sources/c_snikket/iinclude/tink/_Url/Url_Impl_.h b/Sources/c_snikket/iinclude/tink/_Url/Url_Impl_.h
new file mode 100644
index 0000000..954edfb
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/_Url/Url_Impl_.h
@@ -0,0 +1,80 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink__Url_Url_Impl_
+#define INCLUDED_tink__Url_Url_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,_Url,Url_Impl_)
+
+namespace tink{
+namespace _Url{
+
+
+class HXCPP_CLASS_ATTRIBUTES Url_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Url_Impl__obj OBJ_;
+		Url_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x142a69a5 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink._Url.Url_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink._Url.Url_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Url_Impl__obj > __new() {
+			::hx::ObjectPtr< Url_Impl__obj > __this = new Url_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Url_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Url_Impl__obj *__this = (Url_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Url_Impl__obj), false, "tink._Url.Url_Impl_"));
+			*(void **)__this = Url_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Url_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Url_Impl_",2f,05,36,5a); }
+
+		static  ::Dynamic resolve( ::Dynamic this1, ::Dynamic that);
+		static ::Dynamic resolve_dyn();
+
+		static void makePayload( ::Dynamic parts);
+		static ::Dynamic makePayload_dyn();
+
+		static ::String toString( ::Dynamic this1);
+		static ::Dynamic toString_dyn();
+
+		static  ::Dynamic fromString(::String s);
+		static ::Dynamic fromString_dyn();
+
+		static void noop(::String _);
+		static ::Dynamic noop_dyn();
+
+		static  ::Dynamic parse(::String s, ::Dynamic onError);
+		static ::Dynamic parse_dyn();
+
+		static  ::Dynamic make( ::Dynamic parts);
+		static ::Dynamic make_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace _Url
+
+#endif /* INCLUDED_tink__Url_Url_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/tink/chunk/ByteChunk.h b/Sources/c_snikket/iinclude/tink/chunk/ByteChunk.h
new file mode 100644
index 0000000..6fa0b79
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/chunk/ByteChunk.h
@@ -0,0 +1,90 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_chunk_ByteChunk
+#define INCLUDED_tink_chunk_ByteChunk
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_chunk_ChunkBase
+#include <tink/chunk/ChunkBase.h>
+#endif
+#ifndef INCLUDED_tink_chunk_ChunkObject
+#include <tink/chunk/ChunkObject.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(tink,chunk,ByteChunk)
+HX_DECLARE_CLASS2(tink,chunk,ChunkBase)
+HX_DECLARE_CLASS2(tink,chunk,ChunkObject)
+
+namespace tink{
+namespace chunk{
+
+
+class HXCPP_CLASS_ATTRIBUTES ByteChunk_obj : public  ::tink::chunk::ChunkBase_obj
+{
+	public:
+		typedef  ::tink::chunk::ChunkBase_obj super;
+		typedef ByteChunk_obj OBJ_;
+		ByteChunk_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1854896e };
+
+		void __construct(::Array< unsigned char > data,int from,int to);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.chunk.ByteChunk")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.chunk.ByteChunk"); }
+		static ::hx::ObjectPtr< ByteChunk_obj > __new(::Array< unsigned char > data,int from,int to);
+		static ::hx::ObjectPtr< ByteChunk_obj > __alloc(::hx::Ctx *_hx_ctx,::Array< unsigned char > data,int from,int to);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ByteChunk_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("ByteChunk",25,7a,ca,7d); }
+
+		static ::Dynamic of( ::haxe::io::Bytes b);
+		static ::Dynamic of_dyn();
+
+		::Array< unsigned char > data;
+		int from;
+		int to;
+		 ::haxe::io::Bytes wrapped;
+		void flatten(::Array< ::Dynamic> into);
+
+		int getLength();
+		::Dynamic getLength_dyn();
+
+		 ::tink::chunk::ByteChunk getSlice(int from,int to);
+		::Dynamic getSlice_dyn();
+
+		::Dynamic slice(int from,int to);
+		::Dynamic slice_dyn();
+
+		void blitTo( ::haxe::io::Bytes target,int offset);
+		::Dynamic blitTo_dyn();
+
+		 ::haxe::io::Bytes toBytes();
+		::Dynamic toBytes_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace chunk
+
+#endif /* INCLUDED_tink_chunk_ByteChunk */ 
diff --git a/Sources/c_snikket/iinclude/tink/chunk/ChunkBase.h b/Sources/c_snikket/iinclude/tink/chunk/ChunkBase.h
new file mode 100644
index 0000000..f4af2f3
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/chunk/ChunkBase.h
@@ -0,0 +1,73 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_chunk_ChunkBase
+#define INCLUDED_tink_chunk_ChunkBase
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,chunk,ByteChunk)
+HX_DECLARE_CLASS2(tink,chunk,ChunkBase)
+HX_DECLARE_CLASS2(tink,chunk,ChunkCursor)
+HX_DECLARE_CLASS2(tink,chunk,ChunkObject)
+
+namespace tink{
+namespace chunk{
+
+
+class HXCPP_CLASS_ATTRIBUTES ChunkBase_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef ChunkBase_obj OBJ_;
+		ChunkBase_obj();
+
+	public:
+		enum { _hx_ClassId = 0x49bef7e3 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.chunk.ChunkBase")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.chunk.ChunkBase"); }
+
+		inline static ::hx::ObjectPtr< ChunkBase_obj > __new() {
+			::hx::ObjectPtr< ChunkBase_obj > __this = new ChunkBase_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< ChunkBase_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			ChunkBase_obj *__this = (ChunkBase_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(ChunkBase_obj), true, "tink.chunk.ChunkBase"));
+			*(void **)__this = ChunkBase_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ChunkBase_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ChunkBase",fe,f4,07,36); }
+
+		::Array< ::Dynamic> flattened;
+		 ::tink::chunk::ChunkCursor getCursor();
+		::Dynamic getCursor_dyn();
+
+		virtual void flatten(::Array< ::Dynamic> into);
+		::Dynamic flatten_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace chunk
+
+#endif /* INCLUDED_tink_chunk_ChunkBase */ 
diff --git a/Sources/c_snikket/iinclude/tink/chunk/ChunkCursor.h b/Sources/c_snikket/iinclude/tink/chunk/ChunkCursor.h
new file mode 100644
index 0000000..338a1b0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/chunk/ChunkCursor.h
@@ -0,0 +1,91 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_chunk_ChunkCursor
+#define INCLUDED_tink_chunk_ChunkCursor
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,chunk,ByteChunk)
+HX_DECLARE_CLASS2(tink,chunk,ChunkBase)
+HX_DECLARE_CLASS2(tink,chunk,ChunkCursor)
+HX_DECLARE_CLASS2(tink,chunk,ChunkObject)
+
+namespace tink{
+namespace chunk{
+
+
+class HXCPP_CLASS_ATTRIBUTES ChunkCursor_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef ChunkCursor_obj OBJ_;
+		ChunkCursor_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5b17b728 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.chunk.ChunkCursor")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.chunk.ChunkCursor"); }
+		static ::hx::ObjectPtr< ChunkCursor_obj > __new();
+		static ::hx::ObjectPtr< ChunkCursor_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ChunkCursor_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ChunkCursor",03,71,6e,a9); }
+
+		static  ::tink::chunk::ChunkCursor create(::Array< ::Dynamic> parts);
+		static ::Dynamic create_dyn();
+
+		::Array< ::Dynamic> parts;
+		 ::tink::chunk::ByteChunk curPart;
+		int curPartIndex;
+		int curOffset;
+		int curLength;
+		int length;
+		int currentPos;
+		int currentByte;
+		void reset();
+		::Dynamic reset_dyn();
+
+		::Dynamic flush();
+		::Dynamic flush_dyn();
+
+		void add(::Dynamic chunk);
+		::Dynamic add_dyn();
+
+		void shift(::Dynamic chunk);
+		::Dynamic shift_dyn();
+
+		::Dynamic left();
+		::Dynamic left_dyn();
+
+		::Dynamic right();
+		::Dynamic right_dyn();
+
+		void ffwd();
+		::Dynamic ffwd_dyn();
+
+		bool next();
+		::Dynamic next_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace chunk
+
+#endif /* INCLUDED_tink_chunk_ChunkCursor */ 
diff --git a/Sources/c_snikket/iinclude/tink/chunk/ChunkObject.h b/Sources/c_snikket/iinclude/tink/chunk/ChunkObject.h
new file mode 100644
index 0000000..7a4d920
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/chunk/ChunkObject.h
@@ -0,0 +1,57 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_chunk_ChunkObject
+#define INCLUDED_tink_chunk_ChunkObject
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(tink,chunk,ByteChunk)
+HX_DECLARE_CLASS2(tink,chunk,ChunkBase)
+HX_DECLARE_CLASS2(tink,chunk,ChunkCursor)
+HX_DECLARE_CLASS2(tink,chunk,ChunkObject)
+
+namespace tink{
+namespace chunk{
+
+
+class HXCPP_CLASS_ATTRIBUTES ChunkObject_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		 ::tink::chunk::ChunkCursor (::hx::Object :: *_hx_getCursor)(); 
+		static inline  ::tink::chunk::ChunkCursor getCursor( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::chunk::ChunkObject_obj *>(_hx_.mPtr->_hx_getInterface(0x027c3451)))->_hx_getCursor)();
+		}
+		void (::hx::Object :: *_hx_flatten)(::Array< ::Dynamic> into); 
+		static inline void flatten( ::Dynamic _hx_,::Array< ::Dynamic> into) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::tink::chunk::ChunkObject_obj *>(_hx_.mPtr->_hx_getInterface(0x027c3451)))->_hx_flatten)(into);
+		}
+		int (::hx::Object :: *_hx_getLength)(); 
+		static inline int getLength( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::chunk::ChunkObject_obj *>(_hx_.mPtr->_hx_getInterface(0x027c3451)))->_hx_getLength)();
+		}
+		::Dynamic (::hx::Object :: *_hx_slice)(int from,int to); 
+		static inline ::Dynamic slice( ::Dynamic _hx_,int from,int to) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::chunk::ChunkObject_obj *>(_hx_.mPtr->_hx_getInterface(0x027c3451)))->_hx_slice)(from,to);
+		}
+		::String (::hx::Object :: *_hx_toString)(); 
+		static inline ::String toString( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::chunk::ChunkObject_obj *>(_hx_.mPtr->_hx_getInterface(0x027c3451)))->_hx_toString)();
+		}
+		 ::haxe::io::Bytes (::hx::Object :: *_hx_toBytes)(); 
+		static inline  ::haxe::io::Bytes toBytes( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::chunk::ChunkObject_obj *>(_hx_.mPtr->_hx_getInterface(0x027c3451)))->_hx_toBytes)();
+		}
+		void (::hx::Object :: *_hx_blitTo)( ::haxe::io::Bytes target,int offset); 
+		static inline void blitTo( ::Dynamic _hx_, ::haxe::io::Bytes target,int offset) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::tink::chunk::ChunkObject_obj *>(_hx_.mPtr->_hx_getInterface(0x027c3451)))->_hx_blitTo)(target,offset);
+		}
+};
+
+} // end namespace tink
+} // end namespace chunk
+
+#endif /* INCLUDED_tink_chunk_ChunkObject */ 
diff --git a/Sources/c_snikket/iinclude/tink/chunk/CompoundChunk.h b/Sources/c_snikket/iinclude/tink/chunk/CompoundChunk.h
new file mode 100644
index 0000000..661f924
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/chunk/CompoundChunk.h
@@ -0,0 +1,97 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_chunk_CompoundChunk
+#define INCLUDED_tink_chunk_CompoundChunk
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_chunk_ChunkBase
+#include <tink/chunk/ChunkBase.h>
+#endif
+#ifndef INCLUDED_tink_chunk_ChunkObject
+#include <tink/chunk/ChunkObject.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(tink,chunk,ByteChunk)
+HX_DECLARE_CLASS2(tink,chunk,ChunkBase)
+HX_DECLARE_CLASS2(tink,chunk,ChunkObject)
+HX_DECLARE_CLASS2(tink,chunk,CompoundChunk)
+
+namespace tink{
+namespace chunk{
+
+
+class HXCPP_CLASS_ATTRIBUTES CompoundChunk_obj : public  ::tink::chunk::ChunkBase_obj
+{
+	public:
+		typedef  ::tink::chunk::ChunkBase_obj super;
+		typedef CompoundChunk_obj OBJ_;
+		CompoundChunk_obj();
+
+	public:
+		enum { _hx_ClassId = 0x73605847 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.chunk.CompoundChunk")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.chunk.CompoundChunk"); }
+		static ::hx::ObjectPtr< CompoundChunk_obj > __new();
+		static ::hx::ObjectPtr< CompoundChunk_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~CompoundChunk_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("CompoundChunk",e2,7e,3d,10); }
+
+		static  ::tink::chunk::CompoundChunk asCompound(::Dynamic c);
+		static ::Dynamic asCompound_dyn();
+
+		static ::Dynamic cons(::Dynamic a,::Dynamic b);
+		static ::Dynamic cons_dyn();
+
+		static  ::tink::chunk::CompoundChunk create(::Array< ::Dynamic> chunks,int depth);
+		static ::Dynamic create_dyn();
+
+		::Array< ::Dynamic> chunks;
+		::Array< int > offsets;
+		int length;
+		int depth;
+		int getLength();
+		::Dynamic getLength_dyn();
+
+		int findChunk(int target);
+		::Dynamic findChunk_dyn();
+
+		void flatten(::Array< ::Dynamic> into);
+
+		::Dynamic slice(int from,int to);
+		::Dynamic slice_dyn();
+
+		void blitTo( ::haxe::io::Bytes target,int offset);
+		::Dynamic blitTo_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+		 ::haxe::io::Bytes toBytes();
+		::Dynamic toBytes_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace chunk
+
+#endif /* INCLUDED_tink_chunk_CompoundChunk */ 
diff --git a/Sources/c_snikket/iinclude/tink/core/CallbackLinkRef.h b/Sources/c_snikket/iinclude/tink/core/CallbackLinkRef.h
new file mode 100644
index 0000000..fb645e0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/core/CallbackLinkRef.h
@@ -0,0 +1,61 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core_CallbackLinkRef
+#define INCLUDED_tink_core_CallbackLinkRef
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_core_LinkObject
+#include <tink/core/LinkObject.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,CallbackLinkRef)
+HX_DECLARE_CLASS2(tink,core,LinkObject)
+
+namespace tink{
+namespace core{
+
+
+class HXCPP_CLASS_ATTRIBUTES CallbackLinkRef_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef CallbackLinkRef_obj OBJ_;
+		CallbackLinkRef_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2af492e3 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.core.CallbackLinkRef")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.core.CallbackLinkRef"); }
+		static ::hx::ObjectPtr< CallbackLinkRef_obj > __new();
+		static ::hx::ObjectPtr< CallbackLinkRef_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~CallbackLinkRef_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("CallbackLinkRef",14,ba,30,89); }
+
+		::Dynamic link;
+		void cancel();
+		::Dynamic cancel_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace core
+
+#endif /* INCLUDED_tink_core_CallbackLinkRef */ 
diff --git a/Sources/c_snikket/iinclude/tink/core/CallbackList.h b/Sources/c_snikket/iinclude/tink/core/CallbackList.h
new file mode 100644
index 0000000..903c88f
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/core/CallbackList.h
@@ -0,0 +1,81 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core_CallbackList
+#define INCLUDED_tink_core_CallbackList
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_core_SimpleDisposable
+#include <tink/core/SimpleDisposable.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,CallbackList)
+HX_DECLARE_CLASS2(tink,core,Disposable)
+HX_DECLARE_CLASS2(tink,core,LinkObject)
+HX_DECLARE_CLASS2(tink,core,OwnedDisposable)
+HX_DECLARE_CLASS2(tink,core,SimpleDisposable)
+HX_DECLARE_CLASS3(tink,core,_Callback,ListCell)
+
+namespace tink{
+namespace core{
+
+
+class HXCPP_CLASS_ATTRIBUTES CallbackList_obj : public  ::tink::core::SimpleDisposable_obj
+{
+	public:
+		typedef  ::tink::core::SimpleDisposable_obj super;
+		typedef CallbackList_obj OBJ_;
+		CallbackList_obj();
+
+	public:
+		enum { _hx_ClassId = 0x12a8ef7c };
+
+		void __construct(::hx::Null< bool >  __o_destructive);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.core.CallbackList")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.core.CallbackList"); }
+		static ::hx::ObjectPtr< CallbackList_obj > __new(::hx::Null< bool >  __o_destructive);
+		static ::hx::ObjectPtr< CallbackList_obj > __alloc(::hx::Ctx *_hx_ctx,::hx::Null< bool >  __o_destructive);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~CallbackList_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("CallbackList",e3,f4,55,31); }
+
+		bool destructive;
+		::Array< ::Dynamic> cells;
+		int used;
+		::Array< ::Dynamic> queue;
+		bool busy;
+		 ::Dynamic ondrain;
+		Dynamic ondrain_dyn() { return ondrain;}
+		 ::Dynamic onfill;
+		Dynamic onfill_dyn() { return onfill;}
+		void destroy();
+		::Dynamic destroy_dyn();
+
+		void invoke( ::Dynamic data);
+		::Dynamic invoke_dyn();
+
+		void compact();
+		::Dynamic compact_dyn();
+
+		void resize(int length);
+		::Dynamic resize_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace core
+
+#endif /* INCLUDED_tink_core_CallbackList */ 
diff --git a/Sources/c_snikket/iinclude/tink/core/Disposable.h b/Sources/c_snikket/iinclude/tink/core/Disposable.h
new file mode 100644
index 0000000..bd2c459
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/core/Disposable.h
@@ -0,0 +1,25 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core_Disposable
+#define INCLUDED_tink_core_Disposable
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,Disposable)
+
+namespace tink{
+namespace core{
+
+
+class HXCPP_CLASS_ATTRIBUTES Disposable_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+};
+
+} // end namespace tink
+} // end namespace core
+
+#endif /* INCLUDED_tink_core_Disposable */ 
diff --git a/Sources/c_snikket/iinclude/tink/core/FutureStatus.h b/Sources/c_snikket/iinclude/tink/core/FutureStatus.h
new file mode 100644
index 0000000..f046dc9
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/core/FutureStatus.h
@@ -0,0 +1,45 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core_FutureStatus
+#define INCLUDED_tink_core_FutureStatus
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,FutureStatus)
+HX_DECLARE_CLASS3(tink,core,_Lazy,Computable)
+HX_DECLARE_CLASS3(tink,core,_Lazy,LazyObject)
+namespace tink{
+namespace core{
+
+
+class FutureStatus_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef FutureStatus_obj OBJ_;
+
+	public:
+		FutureStatus_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.core.FutureStatus",e8,d1,b4,f2); }
+		::String __ToString() const { return HX_("FutureStatus.",99,22,18,ea) + _hx_tag; }
+
+		static ::tink::core::FutureStatus Awaited;
+		static inline ::tink::core::FutureStatus Awaited_dyn() { return Awaited; }
+		static ::tink::core::FutureStatus EagerlyAwaited;
+		static inline ::tink::core::FutureStatus EagerlyAwaited_dyn() { return EagerlyAwaited; }
+		static ::tink::core::FutureStatus NeverEver;
+		static inline ::tink::core::FutureStatus NeverEver_dyn() { return NeverEver; }
+		static ::tink::core::FutureStatus Ready(::Dynamic result);
+		static ::Dynamic Ready_dyn();
+		static ::tink::core::FutureStatus Suspended;
+		static inline ::tink::core::FutureStatus Suspended_dyn() { return Suspended; }
+};
+
+} // end namespace tink
+} // end namespace core
+
+#endif /* INCLUDED_tink_core_FutureStatus */ 
diff --git a/Sources/c_snikket/iinclude/tink/core/LinkObject.h b/Sources/c_snikket/iinclude/tink/core/LinkObject.h
new file mode 100644
index 0000000..8ad85f0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/core/LinkObject.h
@@ -0,0 +1,29 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core_LinkObject
+#define INCLUDED_tink_core_LinkObject
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,LinkObject)
+
+namespace tink{
+namespace core{
+
+
+class HXCPP_CLASS_ATTRIBUTES LinkObject_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		void (::hx::Object :: *_hx_cancel)(); 
+		static inline void cancel( ::Dynamic _hx_) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::tink::core::LinkObject_obj *>(_hx_.mPtr->_hx_getInterface(0x0d15dd4a)))->_hx_cancel)();
+		}
+};
+
+} // end namespace tink
+} // end namespace core
+
+#endif /* INCLUDED_tink_core_LinkObject */ 
diff --git a/Sources/c_snikket/iinclude/tink/core/MPair.h b/Sources/c_snikket/iinclude/tink/core/MPair.h
new file mode 100644
index 0000000..5d16a2e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/core/MPair.h
@@ -0,0 +1,72 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core_MPair
+#define INCLUDED_tink_core_MPair
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_7fda083185addcb6_27_new)
+HX_DECLARE_CLASS2(tink,core,MPair)
+
+namespace tink{
+namespace core{
+
+
+class HXCPP_CLASS_ATTRIBUTES MPair_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef MPair_obj OBJ_;
+		MPair_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4cad4316 };
+
+		void __construct( ::Dynamic a, ::Dynamic b);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.core.MPair")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.core.MPair"); }
+
+		inline static ::hx::ObjectPtr< MPair_obj > __new( ::Dynamic a, ::Dynamic b) {
+			::hx::ObjectPtr< MPair_obj > __this = new MPair_obj();
+			__this->__construct(a,b);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< MPair_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic a, ::Dynamic b) {
+			MPair_obj *__this = (MPair_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(MPair_obj), true, "tink.core.MPair"));
+			*(void **)__this = MPair_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_7fda083185addcb6_27_new)
+HXLINE(  28)		( ( ::tink::core::MPair)(__this) )->a = a;
+HXLINE(  29)		( ( ::tink::core::MPair)(__this) )->b = b;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~MPair_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("MPair",07,b3,05,8b); }
+
+		 ::Dynamic a;
+		 ::Dynamic b;
+};
+
+} // end namespace tink
+} // end namespace core
+
+#endif /* INCLUDED_tink_core_MPair */ 
diff --git a/Sources/c_snikket/iinclude/tink/core/NamedWith.h b/Sources/c_snikket/iinclude/tink/core/NamedWith.h
new file mode 100644
index 0000000..125a8dd
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/core/NamedWith.h
@@ -0,0 +1,72 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core_NamedWith
+#define INCLUDED_tink_core_NamedWith
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_fe49a69a0def38bb_11_new)
+HX_DECLARE_CLASS2(tink,core,NamedWith)
+
+namespace tink{
+namespace core{
+
+
+class HXCPP_CLASS_ATTRIBUTES NamedWith_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef NamedWith_obj OBJ_;
+		NamedWith_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4df025ce };
+
+		void __construct( ::Dynamic name, ::Dynamic value);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.core.NamedWith")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.core.NamedWith"); }
+
+		inline static ::hx::ObjectPtr< NamedWith_obj > __new( ::Dynamic name, ::Dynamic value) {
+			::hx::ObjectPtr< NamedWith_obj > __this = new NamedWith_obj();
+			__this->__construct(name,value);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< NamedWith_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic name, ::Dynamic value) {
+			NamedWith_obj *__this = (NamedWith_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(NamedWith_obj), true, "tink.core.NamedWith"));
+			*(void **)__this = NamedWith_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_fe49a69a0def38bb_11_new)
+HXLINE(  12)		( ( ::tink::core::NamedWith)(__this) )->name = name;
+HXLINE(  13)		( ( ::tink::core::NamedWith)(__this) )->value = value;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~NamedWith_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("NamedWith",3f,e2,3d,d6); }
+
+		 ::Dynamic name;
+		 ::Dynamic value;
+};
+
+} // end namespace tink
+} // end namespace core
+
+#endif /* INCLUDED_tink_core_NamedWith */ 
diff --git a/Sources/c_snikket/iinclude/tink/core/Outcome.h b/Sources/c_snikket/iinclude/tink/core/Outcome.h
new file mode 100644
index 0000000..8434633
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/core/Outcome.h
@@ -0,0 +1,37 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core_Outcome
+#define INCLUDED_tink_core_Outcome
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,Outcome)
+namespace tink{
+namespace core{
+
+
+class Outcome_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef Outcome_obj OBJ_;
+
+	public:
+		Outcome_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.core.Outcome",5f,27,74,0c); }
+		::String __ToString() const { return HX_("Outcome.",7c,83,a3,53) + _hx_tag; }
+
+		static ::tink::core::Outcome Failure( ::Dynamic failure);
+		static ::Dynamic Failure_dyn();
+		static ::tink::core::Outcome Success( ::Dynamic data);
+		static ::Dynamic Success_dyn();
+};
+
+} // end namespace tink
+} // end namespace core
+
+#endif /* INCLUDED_tink_core_Outcome */ 
diff --git a/Sources/c_snikket/iinclude/tink/core/OwnedDisposable.h b/Sources/c_snikket/iinclude/tink/core/OwnedDisposable.h
new file mode 100644
index 0000000..fe901cf
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/core/OwnedDisposable.h
@@ -0,0 +1,29 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core_OwnedDisposable
+#define INCLUDED_tink_core_OwnedDisposable
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_core_Disposable
+#include <tink/core/Disposable.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,Disposable)
+HX_DECLARE_CLASS2(tink,core,OwnedDisposable)
+
+namespace tink{
+namespace core{
+
+
+class HXCPP_CLASS_ATTRIBUTES OwnedDisposable_obj {
+	public:
+		typedef  ::tink::core::Disposable_obj super;
+		HX_DO_INTERFACE_RTTI;
+
+};
+
+} // end namespace tink
+} // end namespace core
+
+#endif /* INCLUDED_tink_core_OwnedDisposable */ 
diff --git a/Sources/c_snikket/iinclude/tink/core/SimpleDisposable.h b/Sources/c_snikket/iinclude/tink/core/SimpleDisposable.h
new file mode 100644
index 0000000..0af4801
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/core/SimpleDisposable.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core_SimpleDisposable
+#define INCLUDED_tink_core_SimpleDisposable
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_core_OwnedDisposable
+#include <tink/core/OwnedDisposable.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,Disposable)
+HX_DECLARE_CLASS2(tink,core,OwnedDisposable)
+HX_DECLARE_CLASS2(tink,core,SimpleDisposable)
+
+namespace tink{
+namespace core{
+
+
+class HXCPP_CLASS_ATTRIBUTES SimpleDisposable_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef SimpleDisposable_obj OBJ_;
+		SimpleDisposable_obj();
+
+	public:
+		enum { _hx_ClassId = 0x11eb7047 };
+
+		void __construct( ::Dynamic dispose);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.core.SimpleDisposable")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.core.SimpleDisposable"); }
+		static ::hx::ObjectPtr< SimpleDisposable_obj > __new( ::Dynamic dispose);
+		static ::hx::ObjectPtr< SimpleDisposable_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic dispose);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SimpleDisposable_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("SimpleDisposable",92,24,4b,01); }
+
+		static void noop();
+		static ::Dynamic noop_dyn();
+
+		 ::Dynamic f;
+		Dynamic f_dyn() { return f;}
+		::Array< ::Dynamic> disposeHandlers;
+		void dispose();
+		::Dynamic dispose_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace core
+
+#endif /* INCLUDED_tink_core_SimpleDisposable */ 
diff --git a/Sources/c_snikket/iinclude/tink/core/TypedError.h b/Sources/c_snikket/iinclude/tink/core/TypedError.h
new file mode 100644
index 0000000..b359208
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/core/TypedError.h
@@ -0,0 +1,72 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core_TypedError
+#define INCLUDED_tink_core_TypedError
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,StackItem)
+HX_DECLARE_CLASS2(tink,core,TypedError)
+
+namespace tink{
+namespace core{
+
+
+class HXCPP_CLASS_ATTRIBUTES TypedError_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef TypedError_obj OBJ_;
+		TypedError_obj();
+
+	public:
+		enum { _hx_ClassId = 0x07b6f513 };
+
+		void __construct( ::Dynamic __o_code,::String message, ::Dynamic pos);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.core.TypedError")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.core.TypedError"); }
+		static ::hx::ObjectPtr< TypedError_obj > __new( ::Dynamic __o_code,::String message, ::Dynamic pos);
+		static ::hx::ObjectPtr< TypedError_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic __o_code,::String message, ::Dynamic pos);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~TypedError_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("TypedError",1e,0f,9b,3c); }
+
+		static  ::tink::core::TypedError withData( ::Dynamic code,::String message, ::Dynamic data, ::Dynamic pos);
+		static ::Dynamic withData_dyn();
+
+		static  ::tink::core::TypedError typed( ::Dynamic code,::String message, ::Dynamic data, ::Dynamic pos);
+		static ::Dynamic typed_dyn();
+
+		::String message;
+		int code;
+		 ::Dynamic data;
+		 ::Dynamic pos;
+		::Array< ::Dynamic> callStack;
+		::Array< ::Dynamic> exceptionStack;
+		::String printPos();
+		::Dynamic printPos_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace core
+
+#endif /* INCLUDED_tink_core_TypedError */ 
diff --git a/Sources/c_snikket/iinclude/tink/core/_Callback/Callback_Impl_.h b/Sources/c_snikket/iinclude/tink/core/_Callback/Callback_Impl_.h
new file mode 100644
index 0000000..a7f2a09
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/core/_Callback/Callback_Impl_.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core__Callback_Callback_Impl_
+#define INCLUDED_tink_core__Callback_Callback_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Callback,Callback_Impl_)
+
+namespace tink{
+namespace core{
+namespace _Callback{
+
+
+class HXCPP_CLASS_ATTRIBUTES Callback_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Callback_Impl__obj OBJ_;
+		Callback_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x10af39f4 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.core._Callback.Callback_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.core._Callback.Callback_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Callback_Impl__obj > __new() {
+			::hx::ObjectPtr< Callback_Impl__obj > __this = new Callback_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Callback_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Callback_Impl__obj *__this = (Callback_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Callback_Impl__obj), false, "tink.core._Callback.Callback_Impl_"));
+			*(void **)__this = Callback_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Callback_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Callback_Impl_",45,8c,62,d2); }
+
+		static void __boot();
+		static int depth;
+		static void invoke( ::Dynamic this1, ::Dynamic data);
+		static ::Dynamic invoke_dyn();
+
+		static void defer( ::Dynamic f);
+		static ::Dynamic defer_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace core
+} // end namespace _Callback
+
+#endif /* INCLUDED_tink_core__Callback_Callback_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/tink/core/_Callback/LinkPair.h b/Sources/c_snikket/iinclude/tink/core/_Callback/LinkPair.h
new file mode 100644
index 0000000..b86caa5
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/core/_Callback/LinkPair.h
@@ -0,0 +1,65 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core__Callback_LinkPair
+#define INCLUDED_tink_core__Callback_LinkPair
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_core_LinkObject
+#include <tink/core/LinkObject.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,LinkObject)
+HX_DECLARE_CLASS3(tink,core,_Callback,LinkPair)
+
+namespace tink{
+namespace core{
+namespace _Callback{
+
+
+class HXCPP_CLASS_ATTRIBUTES LinkPair_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef LinkPair_obj OBJ_;
+		LinkPair_obj();
+
+	public:
+		enum { _hx_ClassId = 0x01531ffb };
+
+		void __construct(::Dynamic a,::Dynamic b);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.core._Callback.LinkPair")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.core._Callback.LinkPair"); }
+		static ::hx::ObjectPtr< LinkPair_obj > __new(::Dynamic a,::Dynamic b);
+		static ::hx::ObjectPtr< LinkPair_obj > __alloc(::hx::Ctx *_hx_ctx,::Dynamic a,::Dynamic b);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~LinkPair_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("LinkPair",54,61,94,d5); }
+
+		::Dynamic a;
+		::Dynamic b;
+		bool dissolved;
+		void cancel();
+		::Dynamic cancel_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace core
+} // end namespace _Callback
+
+#endif /* INCLUDED_tink_core__Callback_LinkPair */ 
diff --git a/Sources/c_snikket/iinclude/tink/core/_Callback/ListCell.h b/Sources/c_snikket/iinclude/tink/core/_Callback/ListCell.h
new file mode 100644
index 0000000..1e66518
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/core/_Callback/ListCell.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core__Callback_ListCell
+#define INCLUDED_tink_core__Callback_ListCell
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_core_LinkObject
+#include <tink/core/LinkObject.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,CallbackList)
+HX_DECLARE_CLASS2(tink,core,Disposable)
+HX_DECLARE_CLASS2(tink,core,LinkObject)
+HX_DECLARE_CLASS2(tink,core,OwnedDisposable)
+HX_DECLARE_CLASS2(tink,core,SimpleDisposable)
+HX_DECLARE_CLASS3(tink,core,_Callback,ListCell)
+
+namespace tink{
+namespace core{
+namespace _Callback{
+
+
+class HXCPP_CLASS_ATTRIBUTES ListCell_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef ListCell_obj OBJ_;
+		ListCell_obj();
+
+	public:
+		enum { _hx_ClassId = 0x05a024cb };
+
+		void __construct( ::Dynamic cb, ::tink::core::CallbackList list);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.core._Callback.ListCell")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.core._Callback.ListCell"); }
+		static ::hx::ObjectPtr< ListCell_obj > __new( ::Dynamic cb, ::tink::core::CallbackList list);
+		static ::hx::ObjectPtr< ListCell_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic cb, ::tink::core::CallbackList list);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ListCell_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("ListCell",40,ad,63,fb); }
+
+		 ::Dynamic cb;
+		Dynamic cb_dyn() { return cb;}
+		 ::tink::core::CallbackList list;
+		void cancel();
+		::Dynamic cancel_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace core
+} // end namespace _Callback
+
+#endif /* INCLUDED_tink_core__Callback_ListCell */ 
diff --git a/Sources/c_snikket/iinclude/tink/core/_Future/FutureObject.h b/Sources/c_snikket/iinclude/tink/core/_Future/FutureObject.h
new file mode 100644
index 0000000..7e4ed1a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/core/_Future/FutureObject.h
@@ -0,0 +1,61 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core__Future_FutureObject
+#define INCLUDED_tink_core__Future_FutureObject
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,FutureStatus)
+HX_DECLARE_CLASS2(tink,core,LinkObject)
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+
+namespace tink{
+namespace core{
+namespace _Future{
+
+
+class HXCPP_CLASS_ATTRIBUTES FutureObject_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef FutureObject_obj OBJ_;
+		FutureObject_obj();
+
+	public:
+		enum { _hx_ClassId = 0x75d0f9d3 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.core._Future.FutureObject")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.core._Future.FutureObject"); }
+		static ::hx::ObjectPtr< FutureObject_obj > __new();
+		static ::hx::ObjectPtr< FutureObject_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~FutureObject_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("FutureObject",82,eb,54,94); }
+
+		virtual  ::tink::core::FutureStatus getStatus();
+		::Dynamic getStatus_dyn();
+
+		virtual ::Dynamic handle( ::Dynamic callback);
+		::Dynamic handle_dyn();
+
+		virtual void eager();
+		::Dynamic eager_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace core
+} // end namespace _Future
+
+#endif /* INCLUDED_tink_core__Future_FutureObject */ 
diff --git a/Sources/c_snikket/iinclude/tink/core/_Future/Future_Impl_.h b/Sources/c_snikket/iinclude/tink/core/_Future/Future_Impl_.h
new file mode 100644
index 0000000..94ba4b7
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/core/_Future/Future_Impl_.h
@@ -0,0 +1,79 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core__Future_Future_Impl_
+#define INCLUDED_tink_core__Future_Future_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS3(tink,core,_Future,Future_Impl_)
+
+namespace tink{
+namespace core{
+namespace _Future{
+
+
+class HXCPP_CLASS_ATTRIBUTES Future_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Future_Impl__obj OBJ_;
+		Future_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x78864394 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.core._Future.Future_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.core._Future.Future_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Future_Impl__obj > __new() {
+			::hx::ObjectPtr< Future_Impl__obj > __this = new Future_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Future_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Future_Impl__obj *__this = (Future_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Future_Impl__obj), false, "tink.core._Future.Future_Impl_"));
+			*(void **)__this = Future_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Future_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Future_Impl_",43,35,0a,97); }
+
+		static void __boot();
+		static  ::tink::core::_Future::FutureObject NEVER_INST;
+		static  ::tink::core::_Future::FutureObject never();
+		static ::Dynamic never_dyn();
+
+		static  ::tink::core::_Future::FutureObject map( ::tink::core::_Future::FutureObject this1, ::Dynamic f, ::Dynamic gather);
+		static ::Dynamic map_dyn();
+
+		static  ::tink::core::_Future::FutureObject flatMap( ::tink::core::_Future::FutureObject this1, ::Dynamic next, ::Dynamic gather);
+		static ::Dynamic flatMap_dyn();
+
+		static  ::tink::core::_Future::FutureObject async( ::Dynamic init, ::Dynamic lazy);
+		static ::Dynamic async_dyn();
+
+		static  ::tink::core::_Future::FutureObject irreversible( ::Dynamic init);
+		static ::Dynamic irreversible_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace core
+} // end namespace _Future
+
+#endif /* INCLUDED_tink_core__Future_Future_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/tink/core/_Future/SuspendableFuture.h b/Sources/c_snikket/iinclude/tink/core/_Future/SuspendableFuture.h
new file mode 100644
index 0000000..358a37e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/core/_Future/SuspendableFuture.h
@@ -0,0 +1,81 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core__Future_SuspendableFuture
+#define INCLUDED_tink_core__Future_SuspendableFuture
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_core__Future_FutureObject
+#include <tink/core/_Future/FutureObject.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,CallbackList)
+HX_DECLARE_CLASS2(tink,core,Disposable)
+HX_DECLARE_CLASS2(tink,core,FutureStatus)
+HX_DECLARE_CLASS2(tink,core,LinkObject)
+HX_DECLARE_CLASS2(tink,core,OwnedDisposable)
+HX_DECLARE_CLASS2(tink,core,SimpleDisposable)
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS3(tink,core,_Future,SuspendableFuture)
+
+namespace tink{
+namespace core{
+namespace _Future{
+
+
+class HXCPP_CLASS_ATTRIBUTES SuspendableFuture_obj : public  ::tink::core::_Future::FutureObject_obj
+{
+	public:
+		typedef  ::tink::core::_Future::FutureObject_obj super;
+		typedef SuspendableFuture_obj OBJ_;
+		SuspendableFuture_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1fbfb7e8 };
+
+		void __construct( ::Dynamic wakeup);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.core._Future.SuspendableFuture")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.core._Future.SuspendableFuture"); }
+		static ::hx::ObjectPtr< SuspendableFuture_obj > __new( ::Dynamic wakeup);
+		static ::hx::ObjectPtr< SuspendableFuture_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic wakeup);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SuspendableFuture_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SuspendableFuture",d9,4b,c6,80); }
+
+		 ::tink::core::CallbackList callbacks;
+		 ::tink::core::FutureStatus status;
+		::Dynamic link;
+		 ::Dynamic wakeup;
+		Dynamic wakeup_dyn() { return wakeup;}
+		 ::tink::core::FutureStatus getStatus();
+
+		void trigger( ::Dynamic value);
+		::Dynamic trigger_dyn();
+
+		::Dynamic handle( ::Dynamic callback);
+
+		void arm();
+		::Dynamic arm_dyn();
+
+		void eager();
+
+};
+
+} // end namespace tink
+} // end namespace core
+} // end namespace _Future
+
+#endif /* INCLUDED_tink_core__Future_SuspendableFuture */ 
diff --git a/Sources/c_snikket/iinclude/tink/core/_Future/SyncFuture.h b/Sources/c_snikket/iinclude/tink/core/_Future/SyncFuture.h
new file mode 100644
index 0000000..7c3b0d3
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/core/_Future/SyncFuture.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core__Future_SyncFuture
+#define INCLUDED_tink_core__Future_SyncFuture
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_core__Future_FutureObject
+#include <tink/core/_Future/FutureObject.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,FutureStatus)
+HX_DECLARE_CLASS2(tink,core,LinkObject)
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS3(tink,core,_Future,SyncFuture)
+HX_DECLARE_CLASS3(tink,core,_Lazy,Computable)
+HX_DECLARE_CLASS3(tink,core,_Lazy,LazyObject)
+
+namespace tink{
+namespace core{
+namespace _Future{
+
+
+class HXCPP_CLASS_ATTRIBUTES SyncFuture_obj : public  ::tink::core::_Future::FutureObject_obj
+{
+	public:
+		typedef  ::tink::core::_Future::FutureObject_obj super;
+		typedef SyncFuture_obj OBJ_;
+		SyncFuture_obj();
+
+	public:
+		enum { _hx_ClassId = 0x03763767 };
+
+		void __construct(::Dynamic value);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.core._Future.SyncFuture")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.core._Future.SyncFuture"); }
+		static ::hx::ObjectPtr< SyncFuture_obj > __new(::Dynamic value);
+		static ::hx::ObjectPtr< SyncFuture_obj > __alloc(::hx::Ctx *_hx_ctx,::Dynamic value);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SyncFuture_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SyncFuture",1e,81,9c,5c); }
+
+		::Dynamic value;
+		 ::tink::core::FutureStatus getStatus();
+
+		::Dynamic handle( ::Dynamic cb);
+
+		void eager();
+
+};
+
+} // end namespace tink
+} // end namespace core
+} // end namespace _Future
+
+#endif /* INCLUDED_tink_core__Future_SyncFuture */ 
diff --git a/Sources/c_snikket/iinclude/tink/core/_Lazy/Computable.h b/Sources/c_snikket/iinclude/tink/core/_Lazy/Computable.h
new file mode 100644
index 0000000..7d87bba
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/core/_Lazy/Computable.h
@@ -0,0 +1,39 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core__Lazy_Computable
+#define INCLUDED_tink_core__Lazy_Computable
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Lazy,Computable)
+
+namespace tink{
+namespace core{
+namespace _Lazy{
+
+
+class HXCPP_CLASS_ATTRIBUTES Computable_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		bool (::hx::Object :: *_hx_isComputed)(); 
+		static inline bool isComputed( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::core::_Lazy::Computable_obj *>(_hx_.mPtr->_hx_getInterface(0xd2b592ea)))->_hx_isComputed)();
+		}
+		void (::hx::Object :: *_hx_compute)(); 
+		static inline void compute( ::Dynamic _hx_) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::tink::core::_Lazy::Computable_obj *>(_hx_.mPtr->_hx_getInterface(0xd2b592ea)))->_hx_compute)();
+		}
+		::Dynamic (::hx::Object :: *_hx_underlying)(); 
+		static inline ::Dynamic underlying( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::core::_Lazy::Computable_obj *>(_hx_.mPtr->_hx_getInterface(0xd2b592ea)))->_hx_underlying)();
+		}
+};
+
+} // end namespace tink
+} // end namespace core
+} // end namespace _Lazy
+
+#endif /* INCLUDED_tink_core__Lazy_Computable */ 
diff --git a/Sources/c_snikket/iinclude/tink/core/_Lazy/LazyConst.h b/Sources/c_snikket/iinclude/tink/core/_Lazy/LazyConst.h
new file mode 100644
index 0000000..8313c7c
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/core/_Lazy/LazyConst.h
@@ -0,0 +1,73 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core__Lazy_LazyConst
+#define INCLUDED_tink_core__Lazy_LazyConst
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_core__Lazy_LazyObject
+#include <tink/core/_Lazy/LazyObject.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Lazy,Computable)
+HX_DECLARE_CLASS3(tink,core,_Lazy,LazyConst)
+HX_DECLARE_CLASS3(tink,core,_Lazy,LazyObject)
+
+namespace tink{
+namespace core{
+namespace _Lazy{
+
+
+class HXCPP_CLASS_ATTRIBUTES LazyConst_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef LazyConst_obj OBJ_;
+		LazyConst_obj();
+
+	public:
+		enum { _hx_ClassId = 0x43104c2d };
+
+		void __construct( ::Dynamic value);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.core._Lazy.LazyConst")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.core._Lazy.LazyConst"); }
+		static ::hx::ObjectPtr< LazyConst_obj > __new( ::Dynamic value);
+		static ::hx::ObjectPtr< LazyConst_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic value);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~LazyConst_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("LazyConst",2f,14,bd,5b); }
+
+		 ::Dynamic value;
+		bool isComputed();
+		::Dynamic isComputed_dyn();
+
+		 ::Dynamic get();
+		::Dynamic get_dyn();
+
+		void compute();
+		::Dynamic compute_dyn();
+
+		::Dynamic underlying();
+		::Dynamic underlying_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace core
+} // end namespace _Lazy
+
+#endif /* INCLUDED_tink_core__Lazy_LazyConst */ 
diff --git a/Sources/c_snikket/iinclude/tink/core/_Lazy/LazyFunc.h b/Sources/c_snikket/iinclude/tink/core/_Lazy/LazyFunc.h
new file mode 100644
index 0000000..d20b1d8
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/core/_Lazy/LazyFunc.h
@@ -0,0 +1,76 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core__Lazy_LazyFunc
+#define INCLUDED_tink_core__Lazy_LazyFunc
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_core__Lazy_LazyObject
+#include <tink/core/_Lazy/LazyObject.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Lazy,Computable)
+HX_DECLARE_CLASS3(tink,core,_Lazy,LazyFunc)
+HX_DECLARE_CLASS3(tink,core,_Lazy,LazyObject)
+
+namespace tink{
+namespace core{
+namespace _Lazy{
+
+
+class HXCPP_CLASS_ATTRIBUTES LazyFunc_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef LazyFunc_obj OBJ_;
+		LazyFunc_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1cb47fba };
+
+		void __construct( ::Dynamic f,::Dynamic from);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.core._Lazy.LazyFunc")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.core._Lazy.LazyFunc"); }
+		static ::hx::ObjectPtr< LazyFunc_obj > __new( ::Dynamic f,::Dynamic from);
+		static ::hx::ObjectPtr< LazyFunc_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic f,::Dynamic from);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~LazyFunc_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("LazyFunc",f8,2d,40,5e); }
+
+		 ::Dynamic f;
+		Dynamic f_dyn() { return f;}
+		::Dynamic from;
+		 ::Dynamic result;
+		::Dynamic underlying();
+		::Dynamic underlying_dyn();
+
+		bool isComputed();
+		::Dynamic isComputed_dyn();
+
+		 ::Dynamic get();
+		::Dynamic get_dyn();
+
+		void compute();
+		::Dynamic compute_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace core
+} // end namespace _Lazy
+
+#endif /* INCLUDED_tink_core__Lazy_LazyFunc */ 
diff --git a/Sources/c_snikket/iinclude/tink/core/_Lazy/LazyObject.h b/Sources/c_snikket/iinclude/tink/core/_Lazy/LazyObject.h
new file mode 100644
index 0000000..b6ab109
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/core/_Lazy/LazyObject.h
@@ -0,0 +1,47 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core__Lazy_LazyObject
+#define INCLUDED_tink_core__Lazy_LazyObject
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_core__Lazy_Computable
+#include <tink/core/_Lazy/Computable.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Lazy,Computable)
+HX_DECLARE_CLASS3(tink,core,_Lazy,LazyObject)
+
+namespace tink{
+namespace core{
+namespace _Lazy{
+
+
+class HXCPP_CLASS_ATTRIBUTES LazyObject_obj {
+	public:
+		typedef  ::tink::core::_Lazy::Computable_obj super;
+		HX_DO_INTERFACE_RTTI;
+
+		bool (::hx::Object :: *_hx_isComputed)(); 
+		static inline bool isComputed( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::core::_Lazy::LazyObject_obj *>(_hx_.mPtr->_hx_getInterface(0xe1200775)))->_hx_isComputed)();
+		}
+		void (::hx::Object :: *_hx_compute)(); 
+		static inline void compute( ::Dynamic _hx_) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::tink::core::_Lazy::LazyObject_obj *>(_hx_.mPtr->_hx_getInterface(0xe1200775)))->_hx_compute)();
+		}
+		::Dynamic (::hx::Object :: *_hx_underlying)(); 
+		static inline ::Dynamic underlying( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::core::_Lazy::LazyObject_obj *>(_hx_.mPtr->_hx_getInterface(0xe1200775)))->_hx_underlying)();
+		}
+		 ::Dynamic (::hx::Object :: *_hx_get)(); 
+		static inline  ::Dynamic get( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::core::_Lazy::LazyObject_obj *>(_hx_.mPtr->_hx_getInterface(0xe1200775)))->_hx_get)();
+		}
+};
+
+} // end namespace tink
+} // end namespace core
+} // end namespace _Lazy
+
+#endif /* INCLUDED_tink_core__Lazy_LazyObject */ 
diff --git a/Sources/c_snikket/iinclude/tink/core/_Lazy/Lazy_Impl_.h b/Sources/c_snikket/iinclude/tink/core/_Lazy/Lazy_Impl_.h
new file mode 100644
index 0000000..46a8e46
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/core/_Lazy/Lazy_Impl_.h
@@ -0,0 +1,66 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core__Lazy_Lazy_Impl_
+#define INCLUDED_tink_core__Lazy_Lazy_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Lazy,Computable)
+HX_DECLARE_CLASS3(tink,core,_Lazy,LazyObject)
+HX_DECLARE_CLASS3(tink,core,_Lazy,Lazy_Impl_)
+
+namespace tink{
+namespace core{
+namespace _Lazy{
+
+
+class HXCPP_CLASS_ATTRIBUTES Lazy_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Lazy_Impl__obj OBJ_;
+		Lazy_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x7f55432a };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.core._Lazy.Lazy_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.core._Lazy.Lazy_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Lazy_Impl__obj > __new() {
+			::hx::ObjectPtr< Lazy_Impl__obj > __this = new Lazy_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Lazy_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Lazy_Impl__obj *__this = (Lazy_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Lazy_Impl__obj), false, "tink.core._Lazy.Lazy_Impl_"));
+			*(void **)__this = Lazy_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Lazy_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Lazy_Impl_",34,20,cd,39); }
+
+		static  ::Dynamic get(::Dynamic this1);
+		static ::Dynamic get_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace core
+} // end namespace _Lazy
+
+#endif /* INCLUDED_tink_core__Lazy_Lazy_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/tink/core/_Promise/Promise_Impl_.h b/Sources/c_snikket/iinclude/tink/core/_Promise/Promise_Impl_.h
new file mode 100644
index 0000000..74f71a0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/core/_Promise/Promise_Impl_.h
@@ -0,0 +1,65 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_core__Promise_Promise_Impl_
+#define INCLUDED_tink_core__Promise_Promise_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS3(tink,core,_Promise,Promise_Impl_)
+
+namespace tink{
+namespace core{
+namespace _Promise{
+
+
+class HXCPP_CLASS_ATTRIBUTES Promise_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Promise_Impl__obj OBJ_;
+		Promise_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x03edc1ee };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.core._Promise.Promise_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.core._Promise.Promise_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Promise_Impl__obj > __new() {
+			::hx::ObjectPtr< Promise_Impl__obj > __this = new Promise_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Promise_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Promise_Impl__obj *__this = (Promise_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Promise_Impl__obj), false, "tink.core._Promise.Promise_Impl_"));
+			*(void **)__this = Promise_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Promise_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Promise_Impl_",5b,00,ba,be); }
+
+		static  ::tink::core::_Future::FutureObject next( ::tink::core::_Future::FutureObject this1, ::Dynamic f, ::Dynamic gather);
+		static ::Dynamic next_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace core
+} // end namespace _Promise
+
+#endif /* INCLUDED_tink_core__Promise_Promise_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/BodyPart.h b/Sources/c_snikket/iinclude/tink/http/BodyPart.h
new file mode 100644
index 0000000..29267c0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/BodyPart.h
@@ -0,0 +1,37 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_BodyPart
+#define INCLUDED_tink_http_BodyPart
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,http,BodyPart)
+namespace tink{
+namespace http{
+
+
+class BodyPart_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef BodyPart_obj OBJ_;
+
+	public:
+		BodyPart_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.http.BodyPart",ff,9c,21,13); }
+		::String __ToString() const { return HX_("BodyPart.",b9,9a,30,1f) + _hx_tag; }
+
+		static ::tink::http::BodyPart File( ::Dynamic handle);
+		static ::Dynamic File_dyn();
+		static ::tink::http::BodyPart Value(::String v);
+		static ::Dynamic Value_dyn();
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_BodyPart */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/ClientObject.h b/Sources/c_snikket/iinclude/tink/http/ClientObject.h
new file mode 100644
index 0000000..cfa81e2
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/ClientObject.h
@@ -0,0 +1,32 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_ClientObject
+#define INCLUDED_tink_http_ClientObject
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,http,ClientObject)
+HX_DECLARE_CLASS2(tink,http,Message)
+HX_DECLARE_CLASS2(tink,http,OutgoingRequest)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES ClientObject_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		 ::tink::core::_Future::FutureObject (::hx::Object :: *_hx_request)( ::tink::http::OutgoingRequest req); 
+		static inline  ::tink::core::_Future::FutureObject request( ::Dynamic _hx_, ::tink::http::OutgoingRequest req) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::http::ClientObject_obj *>(_hx_.mPtr->_hx_getInterface(0x9c46f484)))->_hx_request)(req);
+		}
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_ClientObject */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/ClientType.h b/Sources/c_snikket/iinclude/tink/http/ClientType.h
new file mode 100644
index 0000000..372ee0e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/ClientType.h
@@ -0,0 +1,46 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_ClientType
+#define INCLUDED_tink_http_ClientType
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,http,ClientObject)
+HX_DECLARE_CLASS2(tink,http,ClientType)
+HX_DECLARE_CLASS2(tink,http,Container)
+HX_DECLARE_CLASS3(tink,http,containers,LocalContainer)
+namespace tink{
+namespace http{
+
+
+class ClientType_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef ClientType_obj OBJ_;
+
+	public:
+		ClientType_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.http.ClientType",6f,ea,c8,55); }
+		::String __ToString() const { return HX_("ClientType.",c9,7d,23,dd) + _hx_tag; }
+
+		static ::tink::http::ClientType Curl;
+		static inline ::tink::http::ClientType Curl_dyn() { return Curl; }
+		static ::tink::http::ClientType Custom(::Dynamic v);
+		static ::Dynamic Custom_dyn();
+		static ::tink::http::ClientType Default;
+		static inline ::tink::http::ClientType Default_dyn() { return Default; }
+		static ::tink::http::ClientType Local( ::tink::http::containers::LocalContainer container);
+		static ::Dynamic Local_dyn();
+		static ::tink::http::ClientType StdLib;
+		static inline ::tink::http::ClientType StdLib_dyn() { return StdLib; }
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_ClientType */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/Container.h b/Sources/c_snikket/iinclude/tink/http/Container.h
new file mode 100644
index 0000000..e6373c2
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/Container.h
@@ -0,0 +1,25 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_Container
+#define INCLUDED_tink_http_Container
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,http,Container)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES Container_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_Container */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/Fetch.h b/Sources/c_snikket/iinclude/tink/http/Fetch.h
new file mode 100644
index 0000000..b965ff4
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/Fetch.h
@@ -0,0 +1,74 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_Fetch
+#define INCLUDED_tink_http_Fetch
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,BalancedTree)
+HX_DECLARE_CLASS2(haxe,ds,EnumValueMap)
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,http,ClientObject)
+HX_DECLARE_CLASS2(tink,http,ClientType)
+HX_DECLARE_CLASS2(tink,http,Fetch)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES Fetch_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Fetch_obj OBJ_;
+		Fetch_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7f806d70 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.http.Fetch")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.http.Fetch"); }
+
+		inline static ::hx::ObjectPtr< Fetch_obj > __new() {
+			::hx::ObjectPtr< Fetch_obj > __this = new Fetch_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Fetch_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Fetch_obj *__this = (Fetch_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Fetch_obj), false, "tink.http.Fetch"));
+			*(void **)__this = Fetch_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Fetch_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Fetch",1a,84,27,91); }
+
+		static void __boot();
+		static  ::haxe::ds::EnumValueMap cache;
+		static  ::tink::core::_Future::FutureObject fetch( ::Dynamic url, ::Dynamic options);
+		static ::Dynamic fetch_dyn();
+
+		static ::Dynamic getClient( ::tink::http::ClientType type);
+		static ::Dynamic getClient_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_Fetch */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/HandlerObject.h b/Sources/c_snikket/iinclude/tink/http/HandlerObject.h
new file mode 100644
index 0000000..37c2119
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/HandlerObject.h
@@ -0,0 +1,32 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_HandlerObject
+#define INCLUDED_tink_http_HandlerObject
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,http,HandlerObject)
+HX_DECLARE_CLASS2(tink,http,IncomingRequest)
+HX_DECLARE_CLASS2(tink,http,Message)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES HandlerObject_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		 ::tink::core::_Future::FutureObject (::hx::Object :: *_hx_process)( ::tink::http::IncomingRequest req); 
+		static inline  ::tink::core::_Future::FutureObject process( ::Dynamic _hx_, ::tink::http::IncomingRequest req) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::http::HandlerObject_obj *>(_hx_.mPtr->_hx_getInterface(0xee501fcf)))->_hx_process)(req);
+		}
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_HandlerObject */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/Header.h b/Sources/c_snikket/iinclude/tink/http/Header.h
new file mode 100644
index 0000000..8567553
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/Header.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_Header
+#define INCLUDED_tink_http_Header
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,NamedWith)
+HX_DECLARE_CLASS2(tink,core,Outcome)
+HX_DECLARE_CLASS2(tink,http,Header)
+HX_DECLARE_CLASS2(tink,http,HeaderField)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES Header_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Header_obj OBJ_;
+		Header_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4094a9e7 };
+
+		void __construct(::Array< ::Dynamic> fields);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.Header")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.Header"); }
+		static ::hx::ObjectPtr< Header_obj > __new(::Array< ::Dynamic> fields);
+		static ::hx::ObjectPtr< Header_obj > __alloc(::hx::Ctx *_hx_ctx,::Array< ::Dynamic> fields);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Header_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Header",ad,7d,94,31); }
+
+		::Array< ::Dynamic> fields;
+		::Array< ::String > get(::String name);
+		::Dynamic get_dyn();
+
+		 ::tink::core::Outcome byName(::String name);
+		::Dynamic byName_dyn();
+
+		 ::tink::core::Outcome getContentLength();
+		::Dynamic getContentLength_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_Header */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/HeaderField.h b/Sources/c_snikket/iinclude/tink/http/HeaderField.h
new file mode 100644
index 0000000..c12456f
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/HeaderField.h
@@ -0,0 +1,76 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_HeaderField
+#define INCLUDED_tink_http_HeaderField
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_core_NamedWith
+#include <tink/core/NamedWith.h>
+#endif
+HX_DECLARE_STACK_FRAME(_hx_pos_80f54cb31df217e8_249_new)
+HX_DECLARE_CLASS2(tink,core,NamedWith)
+HX_DECLARE_CLASS2(tink,http,HeaderField)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES HeaderField_obj : public  ::tink::core::NamedWith_obj
+{
+	public:
+		typedef  ::tink::core::NamedWith_obj super;
+		typedef HeaderField_obj OBJ_;
+		HeaderField_obj();
+
+	public:
+		enum { _hx_ClassId = 0x67181553 };
+
+		void __construct(::String name,::String value);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.HeaderField")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.HeaderField"); }
+
+		inline static ::hx::ObjectPtr< HeaderField_obj > __new(::String name,::String value) {
+			::hx::ObjectPtr< HeaderField_obj > __this = new HeaderField_obj();
+			__this->__construct(name,value);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< HeaderField_obj > __alloc(::hx::Ctx *_hx_ctx,::String name,::String value) {
+			HeaderField_obj *__this = (HeaderField_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(HeaderField_obj), true, "tink.http.HeaderField"));
+			*(void **)__this = HeaderField_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_80f54cb31df217e8_249_new)
+HXDLIN( 249)		__this->super::__construct(name,value);
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HeaderField_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HeaderField",cd,d3,84,f1); }
+
+		static  ::tink::http::HeaderField ofString(::String s);
+		static ::Dynamic ofString_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_HeaderField */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/HeaderParser.h b/Sources/c_snikket/iinclude/tink/http/HeaderParser.h
new file mode 100644
index 0000000..a493cba
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/HeaderParser.h
@@ -0,0 +1,73 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_HeaderParser
+#define INCLUDED_tink_http_HeaderParser
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_io_BytewiseParser
+#include <tink/io/BytewiseParser.h>
+#endif
+HX_DECLARE_CLASS0(StringBuf)
+HX_DECLARE_CLASS2(tink,core,NamedWith)
+HX_DECLARE_CLASS2(tink,core,Outcome)
+HX_DECLARE_CLASS2(tink,http,HeaderField)
+HX_DECLARE_CLASS2(tink,http,HeaderParser)
+HX_DECLARE_CLASS2(tink,io,BytewiseParser)
+HX_DECLARE_CLASS2(tink,io,ParseStep)
+HX_DECLARE_CLASS2(tink,io,StreamParserObject)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES HeaderParser_obj : public  ::tink::io::BytewiseParser_obj
+{
+	public:
+		typedef  ::tink::io::BytewiseParser_obj super;
+		typedef HeaderParser_obj OBJ_;
+		HeaderParser_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3af4a226 };
+
+		void __construct( ::Dynamic makeHeader);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.HeaderParser")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.HeaderParser"); }
+		static ::hx::ObjectPtr< HeaderParser_obj > __new( ::Dynamic makeHeader);
+		static ::hx::ObjectPtr< HeaderParser_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic makeHeader);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HeaderParser_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HeaderParser",6c,8e,ae,cf); }
+
+		 ::Dynamic header;
+		::Array< ::Dynamic> fields;
+		 ::StringBuf buf;
+		int last;
+		 ::Dynamic makeHeader;
+		Dynamic makeHeader_dyn() { return makeHeader;}
+		 ::tink::io::ParseStep read(int c);
+
+		 ::tink::io::ParseStep nextLine();
+		::Dynamic nextLine_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_HeaderParser */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/IncomingRequest.h b/Sources/c_snikket/iinclude/tink/http/IncomingRequest.h
new file mode 100644
index 0000000..3bdc78d
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/IncomingRequest.h
@@ -0,0 +1,61 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_IncomingRequest
+#define INCLUDED_tink_http_IncomingRequest
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_Message
+#include <tink/http/Message.h>
+#endif
+HX_DECLARE_CLASS2(tink,http,Header)
+HX_DECLARE_CLASS2(tink,http,IncomingRequest)
+HX_DECLARE_CLASS2(tink,http,IncomingRequestBody)
+HX_DECLARE_CLASS2(tink,http,IncomingRequestHeader)
+HX_DECLARE_CLASS2(tink,http,Message)
+HX_DECLARE_CLASS2(tink,http,RequestHeader)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES IncomingRequest_obj : public  ::tink::http::Message_obj
+{
+	public:
+		typedef  ::tink::http::Message_obj super;
+		typedef IncomingRequest_obj OBJ_;
+		IncomingRequest_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0386f7df };
+
+		void __construct(::String clientIp, ::tink::http::IncomingRequestHeader header, ::tink::http::IncomingRequestBody body);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.IncomingRequest")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.IncomingRequest"); }
+		static ::hx::ObjectPtr< IncomingRequest_obj > __new(::String clientIp, ::tink::http::IncomingRequestHeader header, ::tink::http::IncomingRequestBody body);
+		static ::hx::ObjectPtr< IncomingRequest_obj > __alloc(::hx::Ctx *_hx_ctx,::String clientIp, ::tink::http::IncomingRequestHeader header, ::tink::http::IncomingRequestBody body);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~IncomingRequest_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("IncomingRequest",e9,56,c7,13); }
+
+		::String clientIp;
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_IncomingRequest */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/IncomingRequestBody.h b/Sources/c_snikket/iinclude/tink/http/IncomingRequestBody.h
new file mode 100644
index 0000000..80b9e97
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/IncomingRequestBody.h
@@ -0,0 +1,39 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_IncomingRequestBody
+#define INCLUDED_tink_http_IncomingRequestBody
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,NamedWith)
+HX_DECLARE_CLASS2(tink,http,IncomingRequestBody)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+namespace tink{
+namespace http{
+
+
+class IncomingRequestBody_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef IncomingRequestBody_obj OBJ_;
+
+	public:
+		IncomingRequestBody_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.http.IncomingRequestBody",41,e5,fc,1f); }
+		::String __ToString() const { return HX_("IncomingRequestBody.",a3,3f,25,ff) + _hx_tag; }
+
+		static ::tink::http::IncomingRequestBody Parsed(::Array< ::Dynamic> parts);
+		static ::Dynamic Parsed_dyn();
+		static ::tink::http::IncomingRequestBody Plain(::Dynamic source);
+		static ::Dynamic Plain_dyn();
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_IncomingRequestBody */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/IncomingRequestHeader.h b/Sources/c_snikket/iinclude/tink/http/IncomingRequestHeader.h
new file mode 100644
index 0000000..8f6a9c0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/IncomingRequestHeader.h
@@ -0,0 +1,54 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_IncomingRequestHeader
+#define INCLUDED_tink_http_IncomingRequestHeader
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_RequestHeader
+#include <tink/http/RequestHeader.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,NamedWith)
+HX_DECLARE_CLASS2(tink,http,Header)
+HX_DECLARE_CLASS2(tink,http,HeaderField)
+HX_DECLARE_CLASS2(tink,http,IncomingRequestHeader)
+HX_DECLARE_CLASS2(tink,http,RequestHeader)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES IncomingRequestHeader_obj : public  ::tink::http::RequestHeader_obj
+{
+	public:
+		typedef  ::tink::http::RequestHeader_obj super;
+		typedef IncomingRequestHeader_obj OBJ_;
+		IncomingRequestHeader_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1c840e5c };
+
+		void __construct(::String method, ::Dynamic url,::String __o_protocol,::Array< ::Dynamic> fields);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.IncomingRequestHeader")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.IncomingRequestHeader"); }
+		static ::hx::ObjectPtr< IncomingRequestHeader_obj > __new(::String method, ::Dynamic url,::String __o_protocol,::Array< ::Dynamic> fields);
+		static ::hx::ObjectPtr< IncomingRequestHeader_obj > __alloc(::hx::Ctx *_hx_ctx,::String method, ::Dynamic url,::String __o_protocol,::Array< ::Dynamic> fields);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~IncomingRequestHeader_obj();
+
+		HX_DO_RTTI_ALL;
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("IncomingRequestHeader",56,69,89,e3); }
+
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_IncomingRequestHeader */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/IncomingResponse.h b/Sources/c_snikket/iinclude/tink/http/IncomingResponse.h
new file mode 100644
index 0000000..bf1e612
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/IncomingResponse.h
@@ -0,0 +1,54 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_IncomingResponse
+#define INCLUDED_tink_http_IncomingResponse
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_Message
+#include <tink/http/Message.h>
+#endif
+HX_DECLARE_CLASS2(tink,http,Header)
+HX_DECLARE_CLASS2(tink,http,IncomingResponse)
+HX_DECLARE_CLASS2(tink,http,Message)
+HX_DECLARE_CLASS2(tink,http,ResponseHeaderBase)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES IncomingResponse_obj : public  ::tink::http::Message_obj
+{
+	public:
+		typedef  ::tink::http::Message_obj super;
+		typedef IncomingResponse_obj OBJ_;
+		IncomingResponse_obj();
+
+	public:
+		enum { _hx_ClassId = 0x68c65661 };
+
+		void __construct( ::tink::http::ResponseHeaderBase header,::Dynamic body);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.IncomingResponse")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.IncomingResponse"); }
+		static ::hx::ObjectPtr< IncomingResponse_obj > __new( ::tink::http::ResponseHeaderBase header,::Dynamic body);
+		static ::hx::ObjectPtr< IncomingResponse_obj > __alloc(::hx::Ctx *_hx_ctx, ::tink::http::ResponseHeaderBase header,::Dynamic body);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~IncomingResponse_obj();
+
+		HX_DO_RTTI_ALL;
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("IncomingResponse",a7,dd,f2,2c); }
+
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_IncomingResponse */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/Message.h b/Sources/c_snikket/iinclude/tink/http/Message.h
new file mode 100644
index 0000000..df01137
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/Message.h
@@ -0,0 +1,72 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_Message
+#define INCLUDED_tink_http_Message
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_bcbf082f6c47a594_8_new)
+HX_DECLARE_CLASS2(tink,http,Message)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES Message_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Message_obj OBJ_;
+		Message_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7888e42d };
+
+		void __construct( ::Dynamic header, ::Dynamic body);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.Message")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.Message"); }
+
+		inline static ::hx::ObjectPtr< Message_obj > __new( ::Dynamic header, ::Dynamic body) {
+			::hx::ObjectPtr< Message_obj > __this = new Message_obj();
+			__this->__construct(header,body);
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Message_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic header, ::Dynamic body) {
+			Message_obj *__this = (Message_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Message_obj), true, "tink.http.Message"));
+			*(void **)__this = Message_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_bcbf082f6c47a594_8_new)
+HXLINE(   9)		( ( ::tink::http::Message)(__this) )->header = header;
+HXLINE(  10)		( ( ::tink::http::Message)(__this) )->body = body;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Message_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Message",a7,5d,62,67); }
+
+		 ::Dynamic header;
+		 ::Dynamic body;
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_Message */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/OutgoingRequest.h b/Sources/c_snikket/iinclude/tink/http/OutgoingRequest.h
new file mode 100644
index 0000000..cbe4430
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/OutgoingRequest.h
@@ -0,0 +1,55 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_OutgoingRequest
+#define INCLUDED_tink_http_OutgoingRequest
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_Message
+#include <tink/http/Message.h>
+#endif
+HX_DECLARE_CLASS2(tink,http,Header)
+HX_DECLARE_CLASS2(tink,http,Message)
+HX_DECLARE_CLASS2(tink,http,OutgoingRequest)
+HX_DECLARE_CLASS2(tink,http,OutgoingRequestHeader)
+HX_DECLARE_CLASS2(tink,http,RequestHeader)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES OutgoingRequest_obj : public  ::tink::http::Message_obj
+{
+	public:
+		typedef  ::tink::http::Message_obj super;
+		typedef OutgoingRequest_obj OBJ_;
+		OutgoingRequest_obj();
+
+	public:
+		enum { _hx_ClassId = 0x08bf21c5 };
+
+		void __construct( ::tink::http::OutgoingRequestHeader header,::Dynamic body);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.OutgoingRequest")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.OutgoingRequest"); }
+		static ::hx::ObjectPtr< OutgoingRequest_obj > __new( ::tink::http::OutgoingRequestHeader header,::Dynamic body);
+		static ::hx::ObjectPtr< OutgoingRequest_obj > __alloc(::hx::Ctx *_hx_ctx, ::tink::http::OutgoingRequestHeader header,::Dynamic body);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~OutgoingRequest_obj();
+
+		HX_DO_RTTI_ALL;
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("OutgoingRequest",23,1c,f4,79); }
+
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_OutgoingRequest */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/OutgoingRequestHeader.h b/Sources/c_snikket/iinclude/tink/http/OutgoingRequestHeader.h
new file mode 100644
index 0000000..89bb40c
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/OutgoingRequestHeader.h
@@ -0,0 +1,63 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_OutgoingRequestHeader
+#define INCLUDED_tink_http_OutgoingRequestHeader
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_RequestHeader
+#include <tink/http/RequestHeader.h>
+#endif
+HX_DECLARE_CLASS2(haxe,ds,Option)
+HX_DECLARE_CLASS2(tink,core,NamedWith)
+HX_DECLARE_CLASS2(tink,http,Header)
+HX_DECLARE_CLASS2(tink,http,HeaderField)
+HX_DECLARE_CLASS2(tink,http,OutgoingRequestHeader)
+HX_DECLARE_CLASS2(tink,http,RequestHeader)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES OutgoingRequestHeader_obj : public  ::tink::http::RequestHeader_obj
+{
+	public:
+		typedef  ::tink::http::RequestHeader_obj super;
+		typedef OutgoingRequestHeader_obj OBJ_;
+		OutgoingRequestHeader_obj();
+
+	public:
+		enum { _hx_ClassId = 0x17e6c132 };
+
+		void __construct(::String method, ::Dynamic url,::String __o_protocol,::Array< ::Dynamic> fields);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.OutgoingRequestHeader")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.OutgoingRequestHeader"); }
+		static ::hx::ObjectPtr< OutgoingRequestHeader_obj > __new(::String method, ::Dynamic url,::String __o_protocol,::Array< ::Dynamic> fields);
+		static ::hx::ObjectPtr< OutgoingRequestHeader_obj > __alloc(::hx::Ctx *_hx_ctx,::String method, ::Dynamic url,::String __o_protocol,::Array< ::Dynamic> fields);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~OutgoingRequestHeader_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("OutgoingRequestHeader",10,d6,f4,a2); }
+
+		static  ::haxe::ds::Option extractAuth( ::Dynamic url);
+		static ::Dynamic extractAuth_dyn();
+
+		 ::tink::http::OutgoingRequestHeader concat(::Array< ::Dynamic> fields);
+		::Dynamic concat_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_OutgoingRequestHeader */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/RequestHeader.h b/Sources/c_snikket/iinclude/tink/http/RequestHeader.h
new file mode 100644
index 0000000..465e640
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/RequestHeader.h
@@ -0,0 +1,63 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_RequestHeader
+#define INCLUDED_tink_http_RequestHeader
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_Header
+#include <tink/http/Header.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,NamedWith)
+HX_DECLARE_CLASS2(tink,http,Header)
+HX_DECLARE_CLASS2(tink,http,HeaderField)
+HX_DECLARE_CLASS2(tink,http,RequestHeader)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES RequestHeader_obj : public  ::tink::http::Header_obj
+{
+	public:
+		typedef  ::tink::http::Header_obj super;
+		typedef RequestHeader_obj OBJ_;
+		RequestHeader_obj();
+
+	public:
+		enum { _hx_ClassId = 0x72a5c122 };
+
+		void __construct(::String method, ::Dynamic url,::String __o_protocol,::Array< ::Dynamic> fields);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.RequestHeader")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.RequestHeader"); }
+		static ::hx::ObjectPtr< RequestHeader_obj > __new(::String method, ::Dynamic url,::String __o_protocol,::Array< ::Dynamic> fields);
+		static ::hx::ObjectPtr< RequestHeader_obj > __alloc(::hx::Ctx *_hx_ctx,::String method, ::Dynamic url,::String __o_protocol,::Array< ::Dynamic> fields);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~RequestHeader_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("RequestHeader",1c,92,9a,00); }
+
+		::String method;
+		 ::Dynamic url;
+		::String protocol;
+		virtual ::String toString();
+
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_RequestHeader */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/ResponseHeaderBase.h b/Sources/c_snikket/iinclude/tink/http/ResponseHeaderBase.h
new file mode 100644
index 0000000..e02ec11
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/ResponseHeaderBase.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_ResponseHeaderBase
+#define INCLUDED_tink_http_ResponseHeaderBase
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_Header
+#include <tink/http/Header.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,NamedWith)
+HX_DECLARE_CLASS2(tink,http,Header)
+HX_DECLARE_CLASS2(tink,http,HeaderField)
+HX_DECLARE_CLASS2(tink,http,ResponseHeaderBase)
+HX_DECLARE_CLASS2(tink,io,StreamParserObject)
+
+namespace tink{
+namespace http{
+
+
+class HXCPP_CLASS_ATTRIBUTES ResponseHeaderBase_obj : public  ::tink::http::Header_obj
+{
+	public:
+		typedef  ::tink::http::Header_obj super;
+		typedef ResponseHeaderBase_obj OBJ_;
+		ResponseHeaderBase_obj();
+
+	public:
+		enum { _hx_ClassId = 0x68228641 };
+
+		void __construct(int statusCode,::String reason,::Array< ::Dynamic> fields,::String __o_protocol);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.ResponseHeaderBase")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.ResponseHeaderBase"); }
+		static ::hx::ObjectPtr< ResponseHeaderBase_obj > __new(int statusCode,::String reason,::Array< ::Dynamic> fields,::String __o_protocol);
+		static ::hx::ObjectPtr< ResponseHeaderBase_obj > __alloc(::hx::Ctx *_hx_ctx,int statusCode,::String reason,::Array< ::Dynamic> fields,::String __o_protocol);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ResponseHeaderBase_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ResponseHeaderBase",3f,ca,db,63); }
+
+		static ::Dynamic parser();
+		static ::Dynamic parser_dyn();
+
+		int statusCode;
+		::String reason;
+		::String protocol;
+		virtual ::String toString();
+
+};
+
+} // end namespace tink
+} // end namespace http
+
+#endif /* INCLUDED_tink_http_ResponseHeaderBase */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/_Client/CustomClient.h b/Sources/c_snikket/iinclude/tink/http/_Client/CustomClient.h
new file mode 100644
index 0000000..75eff5b
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/_Client/CustomClient.h
@@ -0,0 +1,79 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http__Client_CustomClient
+#define INCLUDED_tink_http__Client_CustomClient
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_ClientObject
+#include <tink/http/ClientObject.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,http,ClientObject)
+HX_DECLARE_CLASS2(tink,http,IncomingResponse)
+HX_DECLARE_CLASS2(tink,http,Message)
+HX_DECLARE_CLASS2(tink,http,OutgoingRequest)
+HX_DECLARE_CLASS3(tink,http,_Client,CustomClient)
+
+namespace tink{
+namespace http{
+namespace _Client{
+
+
+class HXCPP_CLASS_ATTRIBUTES CustomClient_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef CustomClient_obj OBJ_;
+		CustomClient_obj();
+
+	public:
+		enum { _hx_ClassId = 0x16257e84 };
+
+		void __construct(::Array< ::Dynamic> preprocessors,::Array< ::Dynamic> postprocessors,::Dynamic real);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http._Client.CustomClient")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http._Client.CustomClient"); }
+		static ::hx::ObjectPtr< CustomClient_obj > __new(::Array< ::Dynamic> preprocessors,::Array< ::Dynamic> postprocessors,::Dynamic real);
+		static ::hx::ObjectPtr< CustomClient_obj > __alloc(::hx::Ctx *_hx_ctx,::Array< ::Dynamic> preprocessors,::Array< ::Dynamic> postprocessors,::Dynamic real);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~CustomClient_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("CustomClient",fc,6c,ff,d1); }
+
+		static ::cpp::VirtualArray concat(::cpp::VirtualArray a,::cpp::VirtualArray b);
+		static ::Dynamic concat_dyn();
+
+		static  ::tink::http::_Client::CustomClient create(::Dynamic c,::Array< ::Dynamic> preprocessors,::Array< ::Dynamic> postprocessors);
+		static ::Dynamic create_dyn();
+
+		::Array< ::Dynamic> preprocessors;
+		::Array< ::Dynamic> postprocessors;
+		::Dynamic real;
+		 ::tink::core::_Future::FutureObject pipe( ::Dynamic value,::Array< ::Dynamic> transforms, ::Dynamic index);
+		::Dynamic pipe_dyn();
+
+		 ::tink::core::_Future::FutureObject request( ::tink::http::OutgoingRequest req);
+		::Dynamic request_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace http
+} // end namespace _Client
+
+#endif /* INCLUDED_tink_http__Client_CustomClient */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/_Fetch/FetchResponse_Impl_.h b/Sources/c_snikket/iinclude/tink/http/_Fetch/FetchResponse_Impl_.h
new file mode 100644
index 0000000..0227082
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/_Fetch/FetchResponse_Impl_.h
@@ -0,0 +1,65 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http__Fetch_FetchResponse_Impl_
+#define INCLUDED_tink_http__Fetch_FetchResponse_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS3(tink,http,_Fetch,FetchResponse_Impl_)
+
+namespace tink{
+namespace http{
+namespace _Fetch{
+
+
+class HXCPP_CLASS_ATTRIBUTES FetchResponse_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef FetchResponse_Impl__obj OBJ_;
+		FetchResponse_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x706f0b26 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.http._Fetch.FetchResponse_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.http._Fetch.FetchResponse_Impl_"); }
+
+		inline static ::hx::ObjectPtr< FetchResponse_Impl__obj > __new() {
+			::hx::ObjectPtr< FetchResponse_Impl__obj > __this = new FetchResponse_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< FetchResponse_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			FetchResponse_Impl__obj *__this = (FetchResponse_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(FetchResponse_Impl__obj), false, "tink.http._Fetch.FetchResponse_Impl_"));
+			*(void **)__this = FetchResponse_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~FetchResponse_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("FetchResponse_Impl_",9b,93,47,bc); }
+
+		static  ::tink::core::_Future::FutureObject all( ::tink::core::_Future::FutureObject this1);
+		static ::Dynamic all_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace http
+} // end namespace _Fetch
+
+#endif /* INCLUDED_tink_http__Fetch_FetchResponse_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/_Header/HeaderValue_Impl_.h b/Sources/c_snikket/iinclude/tink/http/_Header/HeaderValue_Impl_.h
new file mode 100644
index 0000000..a0fbe32
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/_Header/HeaderValue_Impl_.h
@@ -0,0 +1,67 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http__Header_HeaderValue_Impl_
+#define INCLUDED_tink_http__Header_HeaderValue_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,http,_Header,HeaderValue_Impl_)
+
+namespace tink{
+namespace http{
+namespace _Header{
+
+
+class HXCPP_CLASS_ATTRIBUTES HeaderValue_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef HeaderValue_Impl__obj OBJ_;
+		HeaderValue_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x58df80d2 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.http._Header.HeaderValue_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.http._Header.HeaderValue_Impl_"); }
+
+		inline static ::hx::ObjectPtr< HeaderValue_Impl__obj > __new() {
+			::hx::ObjectPtr< HeaderValue_Impl__obj > __this = new HeaderValue_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< HeaderValue_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			HeaderValue_Impl__obj *__this = (HeaderValue_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(HeaderValue_Impl__obj), false, "tink.http._Header.HeaderValue_Impl_"));
+			*(void **)__this = HeaderValue_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~HeaderValue_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("HeaderValue_Impl_",24,b6,26,b3); }
+
+		static ::String basicAuth(::String username,::String password);
+		static ::Dynamic basicAuth_dyn();
+
+		static ::String ofInt(int i);
+		static ::Dynamic ofInt_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace http
+} // end namespace _Header
+
+#endif /* INCLUDED_tink_http__Header_HeaderValue_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/_Response/OutgoingResponseData.h b/Sources/c_snikket/iinclude/tink/http/_Response/OutgoingResponseData.h
new file mode 100644
index 0000000..7279c3c
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/_Response/OutgoingResponseData.h
@@ -0,0 +1,56 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http__Response_OutgoingResponseData
+#define INCLUDED_tink_http__Response_OutgoingResponseData
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_Message
+#include <tink/http/Message.h>
+#endif
+HX_DECLARE_CLASS2(tink,http,Header)
+HX_DECLARE_CLASS2(tink,http,Message)
+HX_DECLARE_CLASS2(tink,http,ResponseHeaderBase)
+HX_DECLARE_CLASS3(tink,http,_Response,OutgoingResponseData)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace http{
+namespace _Response{
+
+
+class HXCPP_CLASS_ATTRIBUTES OutgoingResponseData_obj : public  ::tink::http::Message_obj
+{
+	public:
+		typedef  ::tink::http::Message_obj super;
+		typedef OutgoingResponseData_obj OBJ_;
+		OutgoingResponseData_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0dfa253d };
+
+		void __construct( ::tink::http::ResponseHeaderBase header,::Dynamic body);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http._Response.OutgoingResponseData")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http._Response.OutgoingResponseData"); }
+		static ::hx::ObjectPtr< OutgoingResponseData_obj > __new( ::tink::http::ResponseHeaderBase header,::Dynamic body);
+		static ::hx::ObjectPtr< OutgoingResponseData_obj > __alloc(::hx::Ctx *_hx_ctx, ::tink::http::ResponseHeaderBase header,::Dynamic body);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~OutgoingResponseData_obj();
+
+		HX_DO_RTTI_ALL;
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("OutgoingResponseData",f7,c7,68,aa); }
+
+};
+
+} // end namespace tink
+} // end namespace http
+} // end namespace _Response
+
+#endif /* INCLUDED_tink_http__Response_OutgoingResponseData */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/clients/CurlClient.h b/Sources/c_snikket/iinclude/tink/http/clients/CurlClient.h
new file mode 100644
index 0000000..f926bf5
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/clients/CurlClient.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_clients_CurlClient
+#define INCLUDED_tink_http_clients_CurlClient
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_ClientObject
+#include <tink/http/ClientObject.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,http,ClientObject)
+HX_DECLARE_CLASS2(tink,http,Message)
+HX_DECLARE_CLASS2(tink,http,OutgoingRequest)
+HX_DECLARE_CLASS3(tink,http,clients,CurlClient)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace http{
+namespace clients{
+
+
+class HXCPP_CLASS_ATTRIBUTES CurlClient_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef CurlClient_obj OBJ_;
+		CurlClient_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1ef1a485 };
+
+		void __construct( ::Dynamic curl);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.clients.CurlClient")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.clients.CurlClient"); }
+		static ::hx::ObjectPtr< CurlClient_obj > __new( ::Dynamic curl);
+		static ::hx::ObjectPtr< CurlClient_obj > __alloc(::hx::Ctx *_hx_ctx, ::Dynamic curl);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		static void __alloc_dynamic_functions(::hx::Ctx *_hx_alloc,CurlClient_obj *_hx_obj);
+		//~CurlClient_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("CurlClient",77,86,3b,fe); }
+
+		 ::tink::core::_Future::FutureObject request( ::tink::http::OutgoingRequest req);
+		::Dynamic request_dyn();
+
+		::Dynamic curl;
+		inline ::Dynamic &curl_dyn() {return curl; }
+
+};
+
+} // end namespace tink
+} // end namespace http
+} // end namespace clients
+
+#endif /* INCLUDED_tink_http_clients_CurlClient */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/clients/Helpers.h b/Sources/c_snikket/iinclude/tink/http/clients/Helpers.h
new file mode 100644
index 0000000..ce58cd0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/clients/Helpers.h
@@ -0,0 +1,65 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_clients_Helpers
+#define INCLUDED_tink_http_clients_Helpers
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,ds,Option)
+HX_DECLARE_CLASS3(tink,http,clients,Helpers)
+
+namespace tink{
+namespace http{
+namespace clients{
+
+
+class HXCPP_CLASS_ATTRIBUTES Helpers_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Helpers_obj OBJ_;
+		Helpers_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1dfdf71f };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.http.clients.Helpers")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.http.clients.Helpers"); }
+
+		inline static ::hx::ObjectPtr< Helpers_obj > __new() {
+			::hx::ObjectPtr< Helpers_obj > __this = new Helpers_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Helpers_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Helpers_obj *__this = (Helpers_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Helpers_obj), false, "tink.http.clients.Helpers"));
+			*(void **)__this = Helpers_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Helpers_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Helpers",25,6b,b0,8d); }
+
+		static  ::haxe::ds::Option checkScheme(::String s);
+		static ::Dynamic checkScheme_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace http
+} // end namespace clients
+
+#endif /* INCLUDED_tink_http_clients_Helpers */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/clients/LocalContainerClient.h b/Sources/c_snikket/iinclude/tink/http/clients/LocalContainerClient.h
new file mode 100644
index 0000000..6e1785e
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/clients/LocalContainerClient.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_clients_LocalContainerClient
+#define INCLUDED_tink_http_clients_LocalContainerClient
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_ClientObject
+#include <tink/http/ClientObject.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,http,ClientObject)
+HX_DECLARE_CLASS2(tink,http,Container)
+HX_DECLARE_CLASS2(tink,http,Message)
+HX_DECLARE_CLASS2(tink,http,OutgoingRequest)
+HX_DECLARE_CLASS3(tink,http,clients,LocalContainerClient)
+HX_DECLARE_CLASS3(tink,http,containers,LocalContainer)
+
+namespace tink{
+namespace http{
+namespace clients{
+
+
+class HXCPP_CLASS_ATTRIBUTES LocalContainerClient_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef LocalContainerClient_obj OBJ_;
+		LocalContainerClient_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4c48d30b };
+
+		void __construct( ::tink::http::containers::LocalContainer container);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.clients.LocalContainerClient")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.clients.LocalContainerClient"); }
+		static ::hx::ObjectPtr< LocalContainerClient_obj > __new( ::tink::http::containers::LocalContainer container);
+		static ::hx::ObjectPtr< LocalContainerClient_obj > __alloc(::hx::Ctx *_hx_ctx, ::tink::http::containers::LocalContainer container);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~LocalContainerClient_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("LocalContainerClient",61,95,42,2f); }
+
+		 ::tink::http::containers::LocalContainer container;
+		 ::tink::core::_Future::FutureObject request( ::tink::http::OutgoingRequest req);
+		::Dynamic request_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace http
+} // end namespace clients
+
+#endif /* INCLUDED_tink_http_clients_LocalContainerClient */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/clients/SocketClient.h b/Sources/c_snikket/iinclude/tink/http/clients/SocketClient.h
new file mode 100644
index 0000000..71e2c7f
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/clients/SocketClient.h
@@ -0,0 +1,67 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_clients_SocketClient
+#define INCLUDED_tink_http_clients_SocketClient
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_ClientObject
+#include <tink/http/ClientObject.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,http,ClientObject)
+HX_DECLARE_CLASS2(tink,http,Message)
+HX_DECLARE_CLASS2(tink,http,OutgoingRequest)
+HX_DECLARE_CLASS3(tink,http,clients,SocketClient)
+HX_DECLARE_CLASS2(tink,io,WorkerObject)
+
+namespace tink{
+namespace http{
+namespace clients{
+
+
+class HXCPP_CLASS_ATTRIBUTES SocketClient_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef SocketClient_obj OBJ_;
+		SocketClient_obj();
+
+	public:
+		enum { _hx_ClassId = 0x29ac2844 };
+
+		void __construct(::Dynamic worker);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.clients.SocketClient")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.clients.SocketClient"); }
+		static ::hx::ObjectPtr< SocketClient_obj > __new(::Dynamic worker);
+		static ::hx::ObjectPtr< SocketClient_obj > __alloc(::hx::Ctx *_hx_ctx,::Dynamic worker);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SocketClient_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("SocketClient",7e,5e,b9,60); }
+
+		::Dynamic worker;
+		 ::tink::core::_Future::FutureObject request( ::tink::http::OutgoingRequest req);
+		::Dynamic request_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace http
+} // end namespace clients
+
+#endif /* INCLUDED_tink_http_clients_SocketClient */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/clients/StdClient.h b/Sources/c_snikket/iinclude/tink/http/clients/StdClient.h
new file mode 100644
index 0000000..bc59cd0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/clients/StdClient.h
@@ -0,0 +1,67 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_clients_StdClient
+#define INCLUDED_tink_http_clients_StdClient
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_ClientObject
+#include <tink/http/ClientObject.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,http,ClientObject)
+HX_DECLARE_CLASS2(tink,http,Message)
+HX_DECLARE_CLASS2(tink,http,OutgoingRequest)
+HX_DECLARE_CLASS3(tink,http,clients,StdClient)
+HX_DECLARE_CLASS2(tink,io,WorkerObject)
+
+namespace tink{
+namespace http{
+namespace clients{
+
+
+class HXCPP_CLASS_ATTRIBUTES StdClient_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef StdClient_obj OBJ_;
+		StdClient_obj();
+
+	public:
+		enum { _hx_ClassId = 0x6b1f5144 };
+
+		void __construct(::Dynamic worker);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.clients.StdClient")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.clients.StdClient"); }
+		static ::hx::ObjectPtr< StdClient_obj > __new(::Dynamic worker);
+		static ::hx::ObjectPtr< StdClient_obj > __alloc(::hx::Ctx *_hx_ctx,::Dynamic worker);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~StdClient_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("StdClient",2e,63,67,cc); }
+
+		::Dynamic worker;
+		 ::tink::core::_Future::FutureObject request( ::tink::http::OutgoingRequest req);
+		::Dynamic request_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace http
+} // end namespace clients
+
+#endif /* INCLUDED_tink_http_clients_StdClient */ 
diff --git a/Sources/c_snikket/iinclude/tink/http/containers/LocalContainer.h b/Sources/c_snikket/iinclude/tink/http/containers/LocalContainer.h
new file mode 100644
index 0000000..09cbd34
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/http/containers/LocalContainer.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_http_containers_LocalContainer
+#define INCLUDED_tink_http_containers_LocalContainer
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_http_Container
+#include <tink/http/Container.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,http,Container)
+HX_DECLARE_CLASS2(tink,http,HandlerObject)
+HX_DECLARE_CLASS2(tink,http,IncomingRequest)
+HX_DECLARE_CLASS2(tink,http,Message)
+HX_DECLARE_CLASS3(tink,http,containers,LocalContainer)
+
+namespace tink{
+namespace http{
+namespace containers{
+
+
+class HXCPP_CLASS_ATTRIBUTES LocalContainer_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef LocalContainer_obj OBJ_;
+		LocalContainer_obj();
+
+	public:
+		enum { _hx_ClassId = 0x315b134a };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.http.containers.LocalContainer")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.http.containers.LocalContainer"); }
+		static ::hx::ObjectPtr< LocalContainer_obj > __new();
+		static ::hx::ObjectPtr< LocalContainer_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~LocalContainer_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("LocalContainer",76,1a,ea,cb); }
+
+		::Dynamic handler;
+		bool running;
+		 ::tink::core::_Future::FutureObject serve( ::tink::http::IncomingRequest req);
+		::Dynamic serve_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace http
+} // end namespace containers
+
+#endif /* INCLUDED_tink_http_containers_LocalContainer */ 
diff --git a/Sources/c_snikket/iinclude/tink/io/BytewiseParser.h b/Sources/c_snikket/iinclude/tink/io/BytewiseParser.h
new file mode 100644
index 0000000..487c7a1
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/io/BytewiseParser.h
@@ -0,0 +1,76 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io_BytewiseParser
+#define INCLUDED_tink_io_BytewiseParser
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_io_StreamParserObject
+#include <tink/io/StreamParserObject.h>
+#endif
+HX_DECLARE_CLASS2(tink,chunk,ChunkCursor)
+HX_DECLARE_CLASS2(tink,core,Outcome)
+HX_DECLARE_CLASS2(tink,io,BytewiseParser)
+HX_DECLARE_CLASS2(tink,io,ParseStep)
+HX_DECLARE_CLASS2(tink,io,StreamParserObject)
+
+namespace tink{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES BytewiseParser_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef BytewiseParser_obj OBJ_;
+		BytewiseParser_obj();
+
+	public:
+		enum { _hx_ClassId = 0x66915863 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.io.BytewiseParser")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.io.BytewiseParser"); }
+
+		inline static ::hx::ObjectPtr< BytewiseParser_obj > __new() {
+			::hx::ObjectPtr< BytewiseParser_obj > __this = new BytewiseParser_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< BytewiseParser_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			BytewiseParser_obj *__this = (BytewiseParser_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(BytewiseParser_obj), false, "tink.io.BytewiseParser"));
+			*(void **)__this = BytewiseParser_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~BytewiseParser_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("BytewiseParser",4b,c6,88,ee); }
+
+		virtual  ::tink::io::ParseStep read(int _hx_char);
+		::Dynamic read_dyn();
+
+		 ::tink::io::ParseStep progress( ::tink::chunk::ChunkCursor cursor);
+		::Dynamic progress_dyn();
+
+		 ::tink::core::Outcome eof( ::tink::chunk::ChunkCursor rest);
+		::Dynamic eof_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace io
+
+#endif /* INCLUDED_tink_io_BytewiseParser */ 
diff --git a/Sources/c_snikket/iinclude/tink/io/IdealSourceTools.h b/Sources/c_snikket/iinclude/tink/io/IdealSourceTools.h
new file mode 100644
index 0000000..c7d617b
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/io/IdealSourceTools.h
@@ -0,0 +1,64 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io_IdealSourceTools
+#define INCLUDED_tink_io_IdealSourceTools
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,io,IdealSourceTools)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES IdealSourceTools_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef IdealSourceTools_obj OBJ_;
+		IdealSourceTools_obj();
+
+	public:
+		enum { _hx_ClassId = 0x186409e3 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.io.IdealSourceTools")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.io.IdealSourceTools"); }
+
+		inline static ::hx::ObjectPtr< IdealSourceTools_obj > __new() {
+			::hx::ObjectPtr< IdealSourceTools_obj > __this = new IdealSourceTools_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< IdealSourceTools_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			IdealSourceTools_obj *__this = (IdealSourceTools_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(IdealSourceTools_obj), false, "tink.io.IdealSourceTools"));
+			*(void **)__this = IdealSourceTools_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~IdealSourceTools_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("IdealSourceTools",cb,c1,80,1f); }
+
+		static  ::tink::core::_Future::FutureObject all(::Dynamic s);
+		static ::Dynamic all_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace io
+
+#endif /* INCLUDED_tink_io_IdealSourceTools */ 
diff --git a/Sources/c_snikket/iinclude/tink/io/ParseResult.h b/Sources/c_snikket/iinclude/tink/io/ParseResult.h
new file mode 100644
index 0000000..49ac084
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/io/ParseResult.h
@@ -0,0 +1,41 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io_ParseResult
+#define INCLUDED_tink_io_ParseResult
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS2(tink,io,ParseResult)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+namespace tink{
+namespace io{
+
+
+class ParseResult_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef ParseResult_obj OBJ_;
+
+	public:
+		ParseResult_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.io.ParseResult",c4,44,ed,6f); }
+		::String __ToString() const { return HX_("ParseResult.",de,f8,43,8d) + _hx_tag; }
+
+		static ::tink::io::ParseResult Broke( ::tink::core::TypedError e);
+		static ::Dynamic Broke_dyn();
+		static ::tink::io::ParseResult Invalid( ::tink::core::TypedError e,::Dynamic rest);
+		static ::Dynamic Invalid_dyn();
+		static ::tink::io::ParseResult Parsed( ::Dynamic data,::Dynamic rest);
+		static ::Dynamic Parsed_dyn();
+};
+
+} // end namespace tink
+} // end namespace io
+
+#endif /* INCLUDED_tink_io_ParseResult */ 
diff --git a/Sources/c_snikket/iinclude/tink/io/ParseStep.h b/Sources/c_snikket/iinclude/tink/io/ParseStep.h
new file mode 100644
index 0000000..05a3784
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/io/ParseStep.h
@@ -0,0 +1,40 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io_ParseStep
+#define INCLUDED_tink_io_ParseStep
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS2(tink,io,ParseStep)
+namespace tink{
+namespace io{
+
+
+class ParseStep_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef ParseStep_obj OBJ_;
+
+	public:
+		ParseStep_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.io.ParseStep",73,2b,8e,cf); }
+		::String __ToString() const { return HX_("ParseStep.",4f,c6,a0,a4) + _hx_tag; }
+
+		static ::tink::io::ParseStep Done( ::Dynamic r);
+		static ::Dynamic Done_dyn();
+		static ::tink::io::ParseStep Failed( ::tink::core::TypedError e);
+		static ::Dynamic Failed_dyn();
+		static ::tink::io::ParseStep Progressed;
+		static inline ::tink::io::ParseStep Progressed_dyn() { return Progressed; }
+};
+
+} // end namespace tink
+} // end namespace io
+
+#endif /* INCLUDED_tink_io_ParseStep */ 
diff --git a/Sources/c_snikket/iinclude/tink/io/PipeResult.h b/Sources/c_snikket/iinclude/tink/io/PipeResult.h
new file mode 100644
index 0000000..167b3e7
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/io/PipeResult.h
@@ -0,0 +1,43 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io_PipeResult
+#define INCLUDED_tink_io_PipeResult
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS2(tink,io,PipeResult)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+namespace tink{
+namespace io{
+
+
+class PipeResult_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef PipeResult_obj OBJ_;
+
+	public:
+		PipeResult_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.io.PipeResult",d7,3e,a3,6f); }
+		::String __ToString() const { return HX_("PipeResult.",03,26,3a,37) + _hx_tag; }
+
+		static ::tink::io::PipeResult AllWritten;
+		static inline ::tink::io::PipeResult AllWritten_dyn() { return AllWritten; }
+		static ::tink::io::PipeResult SinkEnded( ::Dynamic result,::Dynamic rest);
+		static ::Dynamic SinkEnded_dyn();
+		static ::tink::io::PipeResult SinkFailed( ::tink::core::TypedError e,::Dynamic rest);
+		static ::Dynamic SinkFailed_dyn();
+		static ::tink::io::PipeResult SourceFailed( ::tink::core::TypedError e);
+		static ::Dynamic SourceFailed_dyn();
+};
+
+} // end namespace tink
+} // end namespace io
+
+#endif /* INCLUDED_tink_io_PipeResult */ 
diff --git a/Sources/c_snikket/iinclude/tink/io/PipeResultTools.h b/Sources/c_snikket/iinclude/tink/io/PipeResultTools.h
new file mode 100644
index 0000000..de6e225
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/io/PipeResultTools.h
@@ -0,0 +1,65 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io_PipeResultTools
+#define INCLUDED_tink_io_PipeResultTools
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,chunk,ChunkObject)
+HX_DECLARE_CLASS2(tink,io,PipeResult)
+HX_DECLARE_CLASS2(tink,io,PipeResultTools)
+HX_DECLARE_CLASS2(tink,streams,Conclusion)
+
+namespace tink{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES PipeResultTools_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef PipeResultTools_obj OBJ_;
+		PipeResultTools_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0add7938 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.io.PipeResultTools")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.io.PipeResultTools"); }
+
+		inline static ::hx::ObjectPtr< PipeResultTools_obj > __new() {
+			::hx::ObjectPtr< PipeResultTools_obj > __this = new PipeResultTools_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< PipeResultTools_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			PipeResultTools_obj *__this = (PipeResultTools_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(PipeResultTools_obj), false, "tink.io.PipeResultTools"));
+			*(void **)__this = PipeResultTools_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~PipeResultTools_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("PipeResultTools",50,36,66,7b); }
+
+		static  ::tink::io::PipeResult toResult( ::tink::streams::Conclusion c, ::Dynamic result,::Dynamic buffered);
+		static ::Dynamic toResult_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace io
+
+#endif /* INCLUDED_tink_io_PipeResultTools */ 
diff --git a/Sources/c_snikket/iinclude/tink/io/RealSourceTools.h b/Sources/c_snikket/iinclude/tink/io/RealSourceTools.h
new file mode 100644
index 0000000..40852fc
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/io/RealSourceTools.h
@@ -0,0 +1,72 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io_RealSourceTools
+#define INCLUDED_tink_io_RealSourceTools
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,io,RealSourceTools)
+HX_DECLARE_CLASS2(tink,io,StreamParserObject)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES RealSourceTools_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef RealSourceTools_obj OBJ_;
+		RealSourceTools_obj();
+
+	public:
+		enum { _hx_ClassId = 0x688b0f4a };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.io.RealSourceTools")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.io.RealSourceTools"); }
+
+		inline static ::hx::ObjectPtr< RealSourceTools_obj > __new() {
+			::hx::ObjectPtr< RealSourceTools_obj > __this = new RealSourceTools_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< RealSourceTools_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			RealSourceTools_obj *__this = (RealSourceTools_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(RealSourceTools_obj), false, "tink.io.RealSourceTools"));
+			*(void **)__this = RealSourceTools_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~RealSourceTools_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("RealSourceTools",62,cc,13,d9); }
+
+		static  ::tink::core::_Future::FutureObject all(::Dynamic s);
+		static ::Dynamic all_dyn();
+
+		static  ::tink::core::_Future::FutureObject parse(::Dynamic s,::Dynamic p);
+		static ::Dynamic parse_dyn();
+
+		static ::Dynamic idealize(::Dynamic s, ::Dynamic rescue);
+		static ::Dynamic idealize_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace io
+
+#endif /* INCLUDED_tink_io_RealSourceTools */ 
diff --git a/Sources/c_snikket/iinclude/tink/io/SinkBase.h b/Sources/c_snikket/iinclude/tink/io/SinkBase.h
new file mode 100644
index 0000000..30475bb
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/io/SinkBase.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io_SinkBase
+#define INCLUDED_tink_io_SinkBase
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_io_SinkObject
+#include <tink/io/SinkObject.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,io,SinkBase)
+HX_DECLARE_CLASS2(tink,io,SinkObject)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES SinkBase_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef SinkBase_obj OBJ_;
+		SinkBase_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1efa06a0 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.io.SinkBase")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.io.SinkBase"); }
+
+		inline static ::hx::ObjectPtr< SinkBase_obj > __new() {
+			::hx::ObjectPtr< SinkBase_obj > __this = new SinkBase_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< SinkBase_obj > __alloc(::hx::Ctx *_hx_ctx) {
+			SinkBase_obj *__this = (SinkBase_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(SinkBase_obj), false, "tink.io.SinkBase"));
+			*(void **)__this = SinkBase_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SinkBase_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("SinkBase",24,8c,b4,5c); }
+
+		virtual  ::tink::core::_Future::FutureObject consume(::Dynamic source, ::Dynamic options);
+		::Dynamic consume_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace io
+
+#endif /* INCLUDED_tink_io_SinkBase */ 
diff --git a/Sources/c_snikket/iinclude/tink/io/SinkObject.h b/Sources/c_snikket/iinclude/tink/io/SinkObject.h
new file mode 100644
index 0000000..bf9b6e3
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/io/SinkObject.h
@@ -0,0 +1,31 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io_SinkObject
+#define INCLUDED_tink_io_SinkObject
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,io,SinkObject)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES SinkObject_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		 ::tink::core::_Future::FutureObject (::hx::Object :: *_hx_consume)(::Dynamic source, ::Dynamic options); 
+		static inline  ::tink::core::_Future::FutureObject consume( ::Dynamic _hx_,::Dynamic source, ::Dynamic options) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::io::SinkObject_obj *>(_hx_.mPtr->_hx_getInterface(0x483020ea)))->_hx_consume)(source,options);
+		}
+};
+
+} // end namespace tink
+} // end namespace io
+
+#endif /* INCLUDED_tink_io_SinkObject */ 
diff --git a/Sources/c_snikket/iinclude/tink/io/StreamParserObject.h b/Sources/c_snikket/iinclude/tink/io/StreamParserObject.h
new file mode 100644
index 0000000..290d16b
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/io/StreamParserObject.h
@@ -0,0 +1,36 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io_StreamParserObject
+#define INCLUDED_tink_io_StreamParserObject
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,chunk,ChunkCursor)
+HX_DECLARE_CLASS2(tink,core,Outcome)
+HX_DECLARE_CLASS2(tink,io,ParseStep)
+HX_DECLARE_CLASS2(tink,io,StreamParserObject)
+
+namespace tink{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES StreamParserObject_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		 ::tink::io::ParseStep (::hx::Object :: *_hx_progress)( ::tink::chunk::ChunkCursor cursor); 
+		static inline  ::tink::io::ParseStep progress( ::Dynamic _hx_, ::tink::chunk::ChunkCursor cursor) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::io::StreamParserObject_obj *>(_hx_.mPtr->_hx_getInterface(0x048ef116)))->_hx_progress)(cursor);
+		}
+		 ::tink::core::Outcome (::hx::Object :: *_hx_eof)( ::tink::chunk::ChunkCursor rest); 
+		static inline  ::tink::core::Outcome eof( ::Dynamic _hx_, ::tink::chunk::ChunkCursor rest) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::io::StreamParserObject_obj *>(_hx_.mPtr->_hx_getInterface(0x048ef116)))->_hx_eof)(rest);
+		}
+};
+
+} // end namespace tink
+} // end namespace io
+
+#endif /* INCLUDED_tink_io_StreamParserObject */ 
diff --git a/Sources/c_snikket/iinclude/tink/io/WorkerObject.h b/Sources/c_snikket/iinclude/tink/io/WorkerObject.h
new file mode 100644
index 0000000..152ff58
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/io/WorkerObject.h
@@ -0,0 +1,32 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io_WorkerObject
+#define INCLUDED_tink_io_WorkerObject
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS3(tink,core,_Lazy,Computable)
+HX_DECLARE_CLASS3(tink,core,_Lazy,LazyObject)
+HX_DECLARE_CLASS2(tink,io,WorkerObject)
+
+namespace tink{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES WorkerObject_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		 ::tink::core::_Future::FutureObject (::hx::Object :: *_hx_work)(::Dynamic task); 
+		static inline  ::tink::core::_Future::FutureObject work( ::Dynamic _hx_,::Dynamic task) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::io::WorkerObject_obj *>(_hx_.mPtr->_hx_getInterface(0xdcf3fb55)))->_hx_work)(task);
+		}
+};
+
+} // end namespace tink
+} // end namespace io
+
+#endif /* INCLUDED_tink_io_WorkerObject */ 
diff --git a/Sources/c_snikket/iinclude/tink/io/_Sink/SinkYielding_Impl_.h b/Sources/c_snikket/iinclude/tink/io/_Sink/SinkYielding_Impl_.h
new file mode 100644
index 0000000..2e51a31
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/io/_Sink/SinkYielding_Impl_.h
@@ -0,0 +1,66 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io__Sink_SinkYielding_Impl_
+#define INCLUDED_tink_io__Sink_SinkYielding_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Output)
+HX_DECLARE_CLASS2(tink,io,SinkObject)
+HX_DECLARE_CLASS3(tink,io,_Sink,SinkYielding_Impl_)
+
+namespace tink{
+namespace io{
+namespace _Sink{
+
+
+class HXCPP_CLASS_ATTRIBUTES SinkYielding_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef SinkYielding_Impl__obj OBJ_;
+		SinkYielding_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x1dd8821a };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.io._Sink.SinkYielding_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.io._Sink.SinkYielding_Impl_"); }
+
+		inline static ::hx::ObjectPtr< SinkYielding_Impl__obj > __new() {
+			::hx::ObjectPtr< SinkYielding_Impl__obj > __this = new SinkYielding_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< SinkYielding_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			SinkYielding_Impl__obj *__this = (SinkYielding_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(SinkYielding_Impl__obj), false, "tink.io._Sink.SinkYielding_Impl_"));
+			*(void **)__this = SinkYielding_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~SinkYielding_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SinkYielding_Impl_",e8,ec,49,5e); }
+
+		static ::Dynamic ofOutput(::String name, ::haxe::io::Output target, ::Dynamic options);
+		static ::Dynamic ofOutput_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace io
+} // end namespace _Sink
+
+#endif /* INCLUDED_tink_io__Sink_SinkYielding_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/tink/io/_Source/Source_Impl_.h b/Sources/c_snikket/iinclude/tink/io/_Source/Source_Impl_.h
new file mode 100644
index 0000000..d119491
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/io/_Source/Source_Impl_.h
@@ -0,0 +1,82 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io__Source_Source_Impl_
+#define INCLUDED_tink_io__Source_Source_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,io,SinkObject)
+HX_DECLARE_CLASS3(tink,io,_Source,Source_Impl_)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace io{
+namespace _Source{
+
+
+class HXCPP_CLASS_ATTRIBUTES Source_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Source_Impl__obj OBJ_;
+		Source_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x52c5539d };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.io._Source.Source_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.io._Source.Source_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Source_Impl__obj > __new() {
+			::hx::ObjectPtr< Source_Impl__obj > __this = new Source_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Source_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Source_Impl__obj *__this = (Source_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Source_Impl__obj), false, "tink.io._Source.Source_Impl_"));
+			*(void **)__this = Source_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Source_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Source_Impl_",db,cf,0d,d6); }
+
+		static void __boot();
+		static ::Dynamic EMPTY;
+		static ::Dynamic chunked(::Dynamic this1);
+		static ::Dynamic chunked_dyn();
+
+		static  ::tink::core::_Future::FutureObject concatAll(::Dynamic s);
+		static ::Dynamic concatAll_dyn();
+
+		static  ::tink::core::_Future::FutureObject pipeTo(::Dynamic this1,::Dynamic target, ::Dynamic options);
+		static ::Dynamic pipeTo_dyn();
+
+		static ::Dynamic limit(::Dynamic this1,int len);
+		static ::Dynamic limit_dyn();
+
+		static ::Dynamic ofError( ::tink::core::TypedError e);
+		static ::Dynamic ofError_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace io
+} // end namespace _Source
+
+#endif /* INCLUDED_tink_io__Source_Source_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/tink/io/_StreamParser/StreamParser_Impl_.h b/Sources/c_snikket/iinclude/tink/io/_StreamParser/StreamParser_Impl_.h
new file mode 100644
index 0000000..357b028
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/io/_StreamParser/StreamParser_Impl_.h
@@ -0,0 +1,70 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io__StreamParser_StreamParser_Impl_
+#define INCLUDED_tink_io__StreamParser_StreamParser_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,io,StreamParserObject)
+HX_DECLARE_CLASS3(tink,io,_StreamParser,StreamParser_Impl_)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace io{
+namespace _StreamParser{
+
+
+class HXCPP_CLASS_ATTRIBUTES StreamParser_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef StreamParser_Impl__obj OBJ_;
+		StreamParser_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x18cfe7c1 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.io._StreamParser.StreamParser_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.io._StreamParser.StreamParser_Impl_"); }
+
+		inline static ::hx::ObjectPtr< StreamParser_Impl__obj > __new() {
+			::hx::ObjectPtr< StreamParser_Impl__obj > __this = new StreamParser_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< StreamParser_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			StreamParser_Impl__obj *__this = (StreamParser_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(StreamParser_Impl__obj), false, "tink.io._StreamParser.StreamParser_Impl_"));
+			*(void **)__this = StreamParser_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~StreamParser_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("StreamParser_Impl_",7f,8f,ef,63); }
+
+		static  ::tink::core::_Future::FutureObject doParse(::Dynamic source,::Dynamic p, ::Dynamic consume, ::Dynamic finish);
+		static ::Dynamic doParse_dyn();
+
+		static  ::tink::core::_Future::FutureObject parse(::Dynamic s,::Dynamic p);
+		static ::Dynamic parse_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace io
+} // end namespace _StreamParser
+
+#endif /* INCLUDED_tink_io__StreamParser_StreamParser_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/tink/io/_Worker/EagerWorker.h b/Sources/c_snikket/iinclude/tink/io/_Worker/EagerWorker.h
new file mode 100644
index 0000000..0529ae7
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/io/_Worker/EagerWorker.h
@@ -0,0 +1,61 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io__Worker_EagerWorker
+#define INCLUDED_tink_io__Worker_EagerWorker
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_io_WorkerObject
+#include <tink/io/WorkerObject.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS3(tink,core,_Lazy,Computable)
+HX_DECLARE_CLASS3(tink,core,_Lazy,LazyObject)
+HX_DECLARE_CLASS2(tink,io,WorkerObject)
+HX_DECLARE_CLASS3(tink,io,_Worker,EagerWorker)
+
+namespace tink{
+namespace io{
+namespace _Worker{
+
+
+class HXCPP_CLASS_ATTRIBUTES EagerWorker_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef EagerWorker_obj OBJ_;
+		EagerWorker_obj();
+
+	public:
+		enum { _hx_ClassId = 0x49fe0131 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.io._Worker.EagerWorker")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.io._Worker.EagerWorker"); }
+		static ::hx::ObjectPtr< EagerWorker_obj > __new();
+		static ::hx::ObjectPtr< EagerWorker_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~EagerWorker_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("EagerWorker",36,20,f4,8a); }
+
+		 ::tink::core::_Future::FutureObject work(::Dynamic task);
+		::Dynamic work_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace io
+} // end namespace _Worker
+
+#endif /* INCLUDED_tink_io__Worker_EagerWorker */ 
diff --git a/Sources/c_snikket/iinclude/tink/io/_Worker/Worker_Impl_.h b/Sources/c_snikket/iinclude/tink/io/_Worker/Worker_Impl_.h
new file mode 100644
index 0000000..76182c0
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/io/_Worker/Worker_Impl_.h
@@ -0,0 +1,77 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io__Worker_Worker_Impl_
+#define INCLUDED_tink_io__Worker_Worker_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS3(tink,core,_Lazy,Computable)
+HX_DECLARE_CLASS3(tink,core,_Lazy,LazyObject)
+HX_DECLARE_CLASS2(tink,io,WorkerObject)
+HX_DECLARE_CLASS3(tink,io,_Worker,Worker_Impl_)
+
+namespace tink{
+namespace io{
+namespace _Worker{
+
+
+class HXCPP_CLASS_ATTRIBUTES Worker_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Worker_Impl__obj OBJ_;
+		Worker_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x132db49b };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.io._Worker.Worker_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.io._Worker.Worker_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Worker_Impl__obj > __new() {
+			::hx::ObjectPtr< Worker_Impl__obj > __this = new Worker_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Worker_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Worker_Impl__obj *__this = (Worker_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Worker_Impl__obj), false, "tink.io._Worker.Worker_Impl_"));
+			*(void **)__this = Worker_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Worker_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Worker_Impl_",be,2b,8e,66); }
+
+		static void __boot();
+		static ::Dynamic EAGER;
+		static ::Array< ::Dynamic> pool;
+		static ::Dynamic ensure(::Dynamic this1);
+		static ::Dynamic ensure_dyn();
+
+		static ::Dynamic get();
+		static ::Dynamic get_dyn();
+
+		static  ::tink::core::_Future::FutureObject work(::Dynamic this1,::Dynamic task);
+		static ::Dynamic work_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace io
+} // end namespace _Worker
+
+#endif /* INCLUDED_tink_io__Worker_Worker_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/tink/io/std/InputSource.h b/Sources/c_snikket/iinclude/tink/io/std/InputSource.h
new file mode 100644
index 0000000..0a66a9d
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/io/std/InputSource.h
@@ -0,0 +1,58 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io_std_InputSource
+#define INCLUDED_tink_io_std_InputSource
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_streams_Generator
+#include <tink/streams/Generator.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Input)
+HX_DECLARE_CLASS2(tink,io,WorkerObject)
+HX_DECLARE_CLASS3(tink,io,std,InputSource)
+HX_DECLARE_CLASS2(tink,streams,Generator)
+HX_DECLARE_CLASS2(tink,streams,StreamBase)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace io{
+namespace std{
+
+
+class HXCPP_CLASS_ATTRIBUTES InputSource_obj : public  ::tink::streams::Generator_obj
+{
+	public:
+		typedef  ::tink::streams::Generator_obj super;
+		typedef InputSource_obj OBJ_;
+		InputSource_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0f2d2d9e };
+
+		void __construct(::String name, ::haxe::io::Input target,::Dynamic worker, ::haxe::io::Bytes buf,int offset);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.io.std.InputSource")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.io.std.InputSource"); }
+		static ::hx::ObjectPtr< InputSource_obj > __new(::String name, ::haxe::io::Input target,::Dynamic worker, ::haxe::io::Bytes buf,int offset);
+		static ::hx::ObjectPtr< InputSource_obj > __alloc(::hx::Ctx *_hx_ctx,::String name, ::haxe::io::Input target,::Dynamic worker, ::haxe::io::Bytes buf,int offset);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~InputSource_obj();
+
+		HX_DO_RTTI_ALL;
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("InputSource",65,24,98,0b); }
+
+};
+
+} // end namespace tink
+} // end namespace io
+} // end namespace std
+
+#endif /* INCLUDED_tink_io_std_InputSource */ 
diff --git a/Sources/c_snikket/iinclude/tink/io/std/OutputSink.h b/Sources/c_snikket/iinclude/tink/io/std/OutputSink.h
new file mode 100644
index 0000000..56470b3
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/io/std/OutputSink.h
@@ -0,0 +1,68 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_io_std_OutputSink
+#define INCLUDED_tink_io_std_OutputSink
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_io_SinkBase
+#include <tink/io/SinkBase.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Output)
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,io,SinkBase)
+HX_DECLARE_CLASS2(tink,io,SinkObject)
+HX_DECLARE_CLASS2(tink,io,WorkerObject)
+HX_DECLARE_CLASS3(tink,io,std,OutputSink)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace io{
+namespace std{
+
+
+class HXCPP_CLASS_ATTRIBUTES OutputSink_obj : public  ::tink::io::SinkBase_obj
+{
+	public:
+		typedef  ::tink::io::SinkBase_obj super;
+		typedef OutputSink_obj OBJ_;
+		OutputSink_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1eacaafb };
+
+		void __construct(::String name, ::haxe::io::Output target,::Dynamic worker);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.io.std.OutputSink")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.io.std.OutputSink"); }
+		static ::hx::ObjectPtr< OutputSink_obj > __new(::String name, ::haxe::io::Output target,::Dynamic worker);
+		static ::hx::ObjectPtr< OutputSink_obj > __alloc(::hx::Ctx *_hx_ctx,::String name, ::haxe::io::Output target,::Dynamic worker);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~OutputSink_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("OutputSink",14,ea,f8,a4); }
+
+		::String name;
+		 ::haxe::io::Output target;
+		::Dynamic worker;
+		 ::tink::core::_Future::FutureObject consume(::Dynamic source, ::Dynamic options);
+
+};
+
+} // end namespace tink
+} // end namespace io
+} // end namespace std
+
+#endif /* INCLUDED_tink_io_std_OutputSink */ 
diff --git a/Sources/c_snikket/iinclude/tink/streams/Conclusion.h b/Sources/c_snikket/iinclude/tink/streams/Conclusion.h
new file mode 100644
index 0000000..94b9893
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/streams/Conclusion.h
@@ -0,0 +1,43 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_Conclusion
+#define INCLUDED_tink_streams_Conclusion
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS2(tink,streams,Conclusion)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+namespace tink{
+namespace streams{
+
+
+class Conclusion_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef Conclusion_obj OBJ_;
+
+	public:
+		Conclusion_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.streams.Conclusion",96,99,43,ae); }
+		::String __ToString() const { return HX_("Conclusion.",4f,54,5d,ac) + _hx_tag; }
+
+		static ::tink::streams::Conclusion Clogged( ::tink::core::TypedError error,::Dynamic at);
+		static ::Dynamic Clogged_dyn();
+		static ::tink::streams::Conclusion Depleted;
+		static inline ::tink::streams::Conclusion Depleted_dyn() { return Depleted; }
+		static ::tink::streams::Conclusion Failed( ::tink::core::TypedError error);
+		static ::Dynamic Failed_dyn();
+		static ::tink::streams::Conclusion Halted(::Dynamic rest);
+		static ::Dynamic Halted_dyn();
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_Conclusion */ 
diff --git a/Sources/c_snikket/iinclude/tink/streams/Empty.h b/Sources/c_snikket/iinclude/tink/streams/Empty.h
new file mode 100644
index 0000000..c56d215
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/streams/Empty.h
@@ -0,0 +1,65 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_Empty
+#define INCLUDED_tink_streams_Empty
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_streams_StreamBase
+#include <tink/streams/StreamBase.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,streams,Empty)
+HX_DECLARE_CLASS2(tink,streams,StreamBase)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace streams{
+
+
+class HXCPP_CLASS_ATTRIBUTES Empty_obj : public  ::tink::streams::StreamBase_obj
+{
+	public:
+		typedef  ::tink::streams::StreamBase_obj super;
+		typedef Empty_obj OBJ_;
+		Empty_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0b521554 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.streams.Empty")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.streams.Empty"); }
+		static ::hx::ObjectPtr< Empty_obj > __new();
+		static ::hx::ObjectPtr< Empty_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Empty_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Empty",6d,aa,07,03); }
+
+		static void __boot();
+		static  ::tink::streams::Empty inst;
+		static ::Dynamic make();
+		static ::Dynamic make_dyn();
+
+		bool get_depleted();
+
+		 ::tink::core::_Future::FutureObject forEach( ::Dynamic handler);
+
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_Empty */ 
diff --git a/Sources/c_snikket/iinclude/tink/streams/FutureStream.h b/Sources/c_snikket/iinclude/tink/streams/FutureStream.h
new file mode 100644
index 0000000..6e2ba9d
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/streams/FutureStream.h
@@ -0,0 +1,61 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_FutureStream
+#define INCLUDED_tink_streams_FutureStream
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_streams_StreamBase
+#include <tink/streams/StreamBase.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,streams,FutureStream)
+HX_DECLARE_CLASS2(tink,streams,StreamBase)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace streams{
+
+
+class HXCPP_CLASS_ATTRIBUTES FutureStream_obj : public  ::tink::streams::StreamBase_obj
+{
+	public:
+		typedef  ::tink::streams::StreamBase_obj super;
+		typedef FutureStream_obj OBJ_;
+		FutureStream_obj();
+
+	public:
+		enum { _hx_ClassId = 0x04fe513c };
+
+		void __construct( ::tink::core::_Future::FutureObject f);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.streams.FutureStream")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.streams.FutureStream"); }
+		static ::hx::ObjectPtr< FutureStream_obj > __new( ::tink::core::_Future::FutureObject f);
+		static ::hx::ObjectPtr< FutureStream_obj > __alloc(::hx::Ctx *_hx_ctx, ::tink::core::_Future::FutureObject f);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~FutureStream_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("FutureStream",43,81,42,90); }
+
+		 ::tink::core::_Future::FutureObject f;
+		 ::tink::core::_Future::FutureObject forEach( ::Dynamic handler);
+
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_FutureStream */ 
diff --git a/Sources/c_snikket/iinclude/tink/streams/Generator.h b/Sources/c_snikket/iinclude/tink/streams/Generator.h
new file mode 100644
index 0000000..62a0082
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/streams/Generator.h
@@ -0,0 +1,61 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_Generator
+#define INCLUDED_tink_streams_Generator
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_streams_StreamBase
+#include <tink/streams/StreamBase.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,streams,Generator)
+HX_DECLARE_CLASS2(tink,streams,StreamBase)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace streams{
+
+
+class HXCPP_CLASS_ATTRIBUTES Generator_obj : public  ::tink::streams::StreamBase_obj
+{
+	public:
+		typedef  ::tink::streams::StreamBase_obj super;
+		typedef Generator_obj OBJ_;
+		Generator_obj();
+
+	public:
+		enum { _hx_ClassId = 0x50a767d2 };
+
+		void __construct( ::tink::core::_Future::FutureObject upcoming);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.streams.Generator")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.streams.Generator"); }
+		static ::hx::ObjectPtr< Generator_obj > __new( ::tink::core::_Future::FutureObject upcoming);
+		static ::hx::ObjectPtr< Generator_obj > __alloc(::hx::Ctx *_hx_ctx, ::tink::core::_Future::FutureObject upcoming);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Generator_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Generator",33,d8,43,36); }
+
+		 ::tink::core::_Future::FutureObject upcoming;
+		 ::tink::core::_Future::FutureObject forEach( ::Dynamic handler);
+
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_Generator */ 
diff --git a/Sources/c_snikket/iinclude/tink/streams/Handled.h b/Sources/c_snikket/iinclude/tink/streams/Handled.h
new file mode 100644
index 0000000..f35f350
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/streams/Handled.h
@@ -0,0 +1,42 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_Handled
+#define INCLUDED_tink_streams_Handled
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS2(tink,streams,Handled)
+namespace tink{
+namespace streams{
+
+
+class Handled_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef Handled_obj OBJ_;
+
+	public:
+		Handled_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.streams.Handled",a5,94,ee,d9); }
+		::String __ToString() const { return HX_("Handled.",12,d1,d5,ae) + _hx_tag; }
+
+		static ::tink::streams::Handled BackOff;
+		static inline ::tink::streams::Handled BackOff_dyn() { return BackOff; }
+		static ::tink::streams::Handled Clog( ::tink::core::TypedError e);
+		static ::Dynamic Clog_dyn();
+		static ::tink::streams::Handled Finish;
+		static inline ::tink::streams::Handled Finish_dyn() { return Finish; }
+		static ::tink::streams::Handled Resume;
+		static inline ::tink::streams::Handled Resume_dyn() { return Resume; }
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_Handled */ 
diff --git a/Sources/c_snikket/iinclude/tink/streams/IdealStreamBase.h b/Sources/c_snikket/iinclude/tink/streams/IdealStreamBase.h
new file mode 100644
index 0000000..6d2b2da
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/streams/IdealStreamBase.h
@@ -0,0 +1,56 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_IdealStreamBase
+#define INCLUDED_tink_streams_IdealStreamBase
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_streams_StreamBase
+#include <tink/streams/StreamBase.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS2(tink,streams,IdealStreamBase)
+HX_DECLARE_CLASS2(tink,streams,StreamBase)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace streams{
+
+
+class HXCPP_CLASS_ATTRIBUTES IdealStreamBase_obj : public  ::tink::streams::StreamBase_obj
+{
+	public:
+		typedef  ::tink::streams::StreamBase_obj super;
+		typedef IdealStreamBase_obj OBJ_;
+		IdealStreamBase_obj();
+
+	public:
+		enum { _hx_ClassId = 0x79ca79c9 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.streams.IdealStreamBase")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.streams.IdealStreamBase"); }
+		static ::hx::ObjectPtr< IdealStreamBase_obj > __new();
+		static ::hx::ObjectPtr< IdealStreamBase_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~IdealStreamBase_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("IdealStreamBase",86,d8,f0,d8); }
+
+		::Dynamic idealize( ::Dynamic _tmp_rescue);
+
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_IdealStreamBase */ 
diff --git a/Sources/c_snikket/iinclude/tink/streams/IdealizeStream.h b/Sources/c_snikket/iinclude/tink/streams/IdealizeStream.h
new file mode 100644
index 0000000..ef12b38
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/streams/IdealizeStream.h
@@ -0,0 +1,67 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_IdealizeStream
+#define INCLUDED_tink_streams_IdealizeStream
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_streams_IdealStreamBase
+#include <tink/streams/IdealStreamBase.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,streams,IdealStreamBase)
+HX_DECLARE_CLASS2(tink,streams,IdealizeStream)
+HX_DECLARE_CLASS2(tink,streams,StreamBase)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace streams{
+
+
+class HXCPP_CLASS_ATTRIBUTES IdealizeStream_obj : public  ::tink::streams::IdealStreamBase_obj
+{
+	public:
+		typedef  ::tink::streams::IdealStreamBase_obj super;
+		typedef IdealizeStream_obj OBJ_;
+		IdealizeStream_obj();
+
+	public:
+		enum { _hx_ClassId = 0x15b188e0 };
+
+		void __construct(::Dynamic target, ::Dynamic rescue);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.streams.IdealizeStream")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.streams.IdealizeStream"); }
+		static ::hx::ObjectPtr< IdealizeStream_obj > __new(::Dynamic target, ::Dynamic rescue);
+		static ::hx::ObjectPtr< IdealizeStream_obj > __alloc(::hx::Ctx *_hx_ctx,::Dynamic target, ::Dynamic rescue);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~IdealizeStream_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("IdealizeStream",df,18,9d,1b); }
+
+		::Dynamic target;
+		 ::Dynamic rescue;
+		Dynamic rescue_dyn() { return rescue;}
+		bool get_depleted();
+
+		 ::tink::core::_Future::FutureObject forEach( ::Dynamic handler);
+
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_IdealizeStream */ 
diff --git a/Sources/c_snikket/iinclude/tink/streams/Reduction.h b/Sources/c_snikket/iinclude/tink/streams/Reduction.h
new file mode 100644
index 0000000..5d8fe33
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/streams/Reduction.h
@@ -0,0 +1,41 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_Reduction
+#define INCLUDED_tink_streams_Reduction
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS2(tink,streams,Reduction)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+namespace tink{
+namespace streams{
+
+
+class Reduction_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef Reduction_obj OBJ_;
+
+	public:
+		Reduction_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.streams.Reduction",5c,50,fe,4b); }
+		::String __ToString() const { return HX_("Reduction.",bb,b1,a8,cf) + _hx_tag; }
+
+		static ::tink::streams::Reduction Crashed( ::tink::core::TypedError error,::Dynamic at);
+		static ::Dynamic Crashed_dyn();
+		static ::tink::streams::Reduction Failed( ::tink::core::TypedError error);
+		static ::Dynamic Failed_dyn();
+		static ::tink::streams::Reduction Reduced( ::Dynamic result);
+		static ::Dynamic Reduced_dyn();
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_Reduction */ 
diff --git a/Sources/c_snikket/iinclude/tink/streams/ReductionStep.h b/Sources/c_snikket/iinclude/tink/streams/ReductionStep.h
new file mode 100644
index 0000000..a20fdfd
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/streams/ReductionStep.h
@@ -0,0 +1,38 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_ReductionStep
+#define INCLUDED_tink_streams_ReductionStep
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS2(tink,streams,ReductionStep)
+namespace tink{
+namespace streams{
+
+
+class ReductionStep_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef ReductionStep_obj OBJ_;
+
+	public:
+		ReductionStep_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.streams.ReductionStep",c8,c1,78,61); }
+		::String __ToString() const { return HX_("ReductionStep.",4f,e7,10,f7) + _hx_tag; }
+
+		static ::tink::streams::ReductionStep Crash( ::tink::core::TypedError e);
+		static ::Dynamic Crash_dyn();
+		static ::tink::streams::ReductionStep Progress( ::Dynamic result);
+		static ::Dynamic Progress_dyn();
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_ReductionStep */ 
diff --git a/Sources/c_snikket/iinclude/tink/streams/RegroupResult.h b/Sources/c_snikket/iinclude/tink/streams/RegroupResult.h
new file mode 100644
index 0000000..d8b27a2
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/streams/RegroupResult.h
@@ -0,0 +1,44 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_RegroupResult
+#define INCLUDED_tink_streams_RegroupResult
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,ds,Option)
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS2(tink,streams,RegroupResult)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+namespace tink{
+namespace streams{
+
+
+class RegroupResult_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef RegroupResult_obj OBJ_;
+
+	public:
+		RegroupResult_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.streams.RegroupResult",52,26,01,31); }
+		::String __ToString() const { return HX_("RegroupResult.",85,7b,e0,be) + _hx_tag; }
+
+		static ::tink::streams::RegroupResult Converted(::Dynamic data,::cpp::VirtualArray untouched);
+		static ::Dynamic Converted_dyn();
+		static ::tink::streams::RegroupResult Errored( ::tink::core::TypedError e);
+		static ::Dynamic Errored_dyn();
+		static ::tink::streams::RegroupResult Terminated( ::haxe::ds::Option data);
+		static ::Dynamic Terminated_dyn();
+		static ::tink::streams::RegroupResult Untouched;
+		static inline ::tink::streams::RegroupResult Untouched_dyn() { return Untouched; }
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_RegroupResult */ 
diff --git a/Sources/c_snikket/iinclude/tink/streams/RegroupStatus.h b/Sources/c_snikket/iinclude/tink/streams/RegroupStatus.h
new file mode 100644
index 0000000..7177b22
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/streams/RegroupStatus.h
@@ -0,0 +1,40 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_RegroupStatus
+#define INCLUDED_tink_streams_RegroupStatus
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS2(tink,streams,RegroupStatus)
+namespace tink{
+namespace streams{
+
+
+class RegroupStatus_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef RegroupStatus_obj OBJ_;
+
+	public:
+		RegroupStatus_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.streams.RegroupStatus",a7,a4,78,2e); }
+		::String __ToString() const { return HX_("RegroupStatus.",90,87,f7,89) + _hx_tag; }
+
+		static ::tink::streams::RegroupStatus Ended;
+		static inline ::tink::streams::RegroupStatus Ended_dyn() { return Ended; }
+		static ::tink::streams::RegroupStatus Errored( ::tink::core::TypedError e);
+		static ::Dynamic Errored_dyn();
+		static ::tink::streams::RegroupStatus Flowing;
+		static inline ::tink::streams::RegroupStatus Flowing_dyn() { return Flowing; }
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_RegroupStatus */ 
diff --git a/Sources/c_snikket/iinclude/tink/streams/Single.h b/Sources/c_snikket/iinclude/tink/streams/Single.h
new file mode 100644
index 0000000..fc74928
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/streams/Single.h
@@ -0,0 +1,63 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_Single
+#define INCLUDED_tink_streams_Single
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_streams_StreamBase
+#include <tink/streams/StreamBase.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS3(tink,core,_Lazy,Computable)
+HX_DECLARE_CLASS3(tink,core,_Lazy,LazyObject)
+HX_DECLARE_CLASS2(tink,streams,Single)
+HX_DECLARE_CLASS2(tink,streams,StreamBase)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace streams{
+
+
+class HXCPP_CLASS_ATTRIBUTES Single_obj : public  ::tink::streams::StreamBase_obj
+{
+	public:
+		typedef  ::tink::streams::StreamBase_obj super;
+		typedef Single_obj OBJ_;
+		Single_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2688f9e1 };
+
+		void __construct(::Dynamic value);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.streams.Single")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.streams.Single"); }
+		static ::hx::ObjectPtr< Single_obj > __new(::Dynamic value);
+		static ::hx::ObjectPtr< Single_obj > __alloc(::hx::Ctx *_hx_ctx,::Dynamic value);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Single_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Single",a8,da,b5,ed); }
+
+		::Dynamic value;
+		 ::tink::core::_Future::FutureObject forEach( ::Dynamic handle);
+
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_Single */ 
diff --git a/Sources/c_snikket/iinclude/tink/streams/Step.h b/Sources/c_snikket/iinclude/tink/streams/Step.h
new file mode 100644
index 0000000..e200806
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/streams/Step.h
@@ -0,0 +1,41 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_Step
+#define INCLUDED_tink_streams_Step
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS2(tink,streams,Step)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+namespace tink{
+namespace streams{
+
+
+class Step_obj : public ::hx::EnumBase_obj
+{
+	typedef ::hx::EnumBase_obj super;
+		typedef Step_obj OBJ_;
+
+	public:
+		Step_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("tink.streams.Step",c3,c6,00,cc); }
+		::String __ToString() const { return HX_("Step.",42,eb,3b,17) + _hx_tag; }
+
+		static ::tink::streams::Step End;
+		static inline ::tink::streams::Step End_dyn() { return End; }
+		static ::tink::streams::Step Fail( ::tink::core::TypedError e);
+		static ::Dynamic Fail_dyn();
+		static ::tink::streams::Step Link( ::Dynamic value,::Dynamic next);
+		static ::Dynamic Link_dyn();
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_Step */ 
diff --git a/Sources/c_snikket/iinclude/tink/streams/StreamBase.h b/Sources/c_snikket/iinclude/tink/streams/StreamBase.h
new file mode 100644
index 0000000..92259cf
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/streams/StreamBase.h
@@ -0,0 +1,77 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_StreamBase
+#define INCLUDED_tink_streams_StreamBase
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_streams_StreamObject
+#include <tink/streams/StreamObject.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,streams,StreamBase)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace streams{
+
+
+class HXCPP_CLASS_ATTRIBUTES StreamBase_obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef StreamBase_obj OBJ_;
+		StreamBase_obj();
+
+	public:
+		enum { _hx_ClassId = 0x61521c8a };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.streams.StreamBase")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.streams.StreamBase"); }
+		static ::hx::ObjectPtr< StreamBase_obj > __new();
+		static ::hx::ObjectPtr< StreamBase_obj > __alloc(::hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~StreamBase_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("StreamBase",d1,6c,2c,85); }
+
+		virtual bool get_depleted();
+		::Dynamic get_depleted_dyn();
+
+		::Dynamic regroup( ::Dynamic f);
+		::Dynamic regroup_dyn();
+
+		::Dynamic prepend(::Dynamic other);
+		::Dynamic prepend_dyn();
+
+		virtual void decompose(::Array< ::Dynamic> into);
+		::Dynamic decompose_dyn();
+
+		virtual ::Dynamic idealize( ::Dynamic rescue);
+		::Dynamic idealize_dyn();
+
+		 ::tink::core::_Future::FutureObject reduce( ::Dynamic initial, ::Dynamic reducer);
+		::Dynamic reduce_dyn();
+
+		virtual  ::tink::core::_Future::FutureObject forEach( ::Dynamic handler);
+		::Dynamic forEach_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_StreamBase */ 
diff --git a/Sources/c_snikket/iinclude/tink/streams/StreamObject.h b/Sources/c_snikket/iinclude/tink/streams/StreamObject.h
new file mode 100644
index 0000000..5a2bbc9
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/streams/StreamObject.h
@@ -0,0 +1,55 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams_StreamObject
+#define INCLUDED_tink_streams_StreamObject
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+
+namespace tink{
+namespace streams{
+
+
+class HXCPP_CLASS_ATTRIBUTES StreamObject_obj {
+	public:
+		typedef ::hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		bool (::hx::Object :: *_hx_get_depleted)(); 
+		static inline bool get_depleted( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::streams::StreamObject_obj *>(_hx_.mPtr->_hx_getInterface(0x6164ac00)))->_hx_get_depleted)();
+		}
+		::Dynamic (::hx::Object :: *_hx_regroup)( ::Dynamic f); 
+		static inline ::Dynamic regroup( ::Dynamic _hx_, ::Dynamic f) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::streams::StreamObject_obj *>(_hx_.mPtr->_hx_getInterface(0x6164ac00)))->_hx_regroup)(f);
+		}
+		::Dynamic (::hx::Object :: *_hx_idealize)( ::Dynamic rescue); 
+		static inline ::Dynamic idealize( ::Dynamic _hx_, ::Dynamic rescue) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::streams::StreamObject_obj *>(_hx_.mPtr->_hx_getInterface(0x6164ac00)))->_hx_idealize)(rescue);
+		}
+		::Dynamic (::hx::Object :: *_hx_prepend)(::Dynamic other); 
+		static inline ::Dynamic prepend( ::Dynamic _hx_,::Dynamic other) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::streams::StreamObject_obj *>(_hx_.mPtr->_hx_getInterface(0x6164ac00)))->_hx_prepend)(other);
+		}
+		void (::hx::Object :: *_hx_decompose)(::Array< ::Dynamic> into); 
+		static inline void decompose( ::Dynamic _hx_,::Array< ::Dynamic> into) {
+			(_hx_.mPtr->*( ::hx::interface_cast< ::tink::streams::StreamObject_obj *>(_hx_.mPtr->_hx_getInterface(0x6164ac00)))->_hx_decompose)(into);
+		}
+		 ::tink::core::_Future::FutureObject (::hx::Object :: *_hx_forEach)( ::Dynamic handle); 
+		static inline  ::tink::core::_Future::FutureObject forEach( ::Dynamic _hx_, ::Dynamic handle) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::streams::StreamObject_obj *>(_hx_.mPtr->_hx_getInterface(0x6164ac00)))->_hx_forEach)(handle);
+		}
+		 ::tink::core::_Future::FutureObject (::hx::Object :: *_hx_reduce)( ::Dynamic initial, ::Dynamic reducer); 
+		static inline  ::tink::core::_Future::FutureObject reduce( ::Dynamic _hx_, ::Dynamic initial, ::Dynamic reducer) {
+			return (_hx_.mPtr->*( ::hx::interface_cast< ::tink::streams::StreamObject_obj *>(_hx_.mPtr->_hx_getInterface(0x6164ac00)))->_hx_reduce)(initial,reducer);
+		}
+};
+
+} // end namespace tink
+} // end namespace streams
+
+#endif /* INCLUDED_tink_streams_StreamObject */ 
diff --git a/Sources/c_snikket/iinclude/tink/streams/_Stream/CompoundStream.h b/Sources/c_snikket/iinclude/tink/streams/_Stream/CompoundStream.h
new file mode 100644
index 0000000..529a9c5
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/streams/_Stream/CompoundStream.h
@@ -0,0 +1,75 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams__Stream_CompoundStream
+#define INCLUDED_tink_streams__Stream_CompoundStream
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_streams_StreamBase
+#include <tink/streams/StreamBase.h>
+#endif
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,streams,Conclusion)
+HX_DECLARE_CLASS2(tink,streams,StreamBase)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+HX_DECLARE_CLASS3(tink,streams,_Stream,CompoundStream)
+
+namespace tink{
+namespace streams{
+namespace _Stream{
+
+
+class HXCPP_CLASS_ATTRIBUTES CompoundStream_obj : public  ::tink::streams::StreamBase_obj
+{
+	public:
+		typedef  ::tink::streams::StreamBase_obj super;
+		typedef CompoundStream_obj OBJ_;
+		CompoundStream_obj();
+
+	public:
+		enum { _hx_ClassId = 0x56b49549 };
+
+		void __construct(::Array< ::Dynamic> parts);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.streams._Stream.CompoundStream")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.streams._Stream.CompoundStream"); }
+		static ::hx::ObjectPtr< CompoundStream_obj > __new(::Array< ::Dynamic> parts);
+		static ::hx::ObjectPtr< CompoundStream_obj > __alloc(::hx::Ctx *_hx_ctx,::Array< ::Dynamic> parts);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~CompoundStream_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("CompoundStream",6b,c2,13,72); }
+
+		static void consumeParts(::Array< ::Dynamic> parts, ::Dynamic handler, ::Dynamic cb);
+		static ::Dynamic consumeParts_dyn();
+
+		static ::Dynamic of(::Array< ::Dynamic> streams);
+		static ::Dynamic of_dyn();
+
+		::Array< ::Dynamic> parts;
+		bool get_depleted();
+
+		void decompose(::Array< ::Dynamic> into);
+
+		 ::tink::core::_Future::FutureObject forEach( ::Dynamic handler);
+
+};
+
+} // end namespace tink
+} // end namespace streams
+} // end namespace _Stream
+
+#endif /* INCLUDED_tink_streams__Stream_CompoundStream */ 
diff --git a/Sources/c_snikket/iinclude/tink/streams/_Stream/ErrorStream.h b/Sources/c_snikket/iinclude/tink/streams/_Stream/ErrorStream.h
new file mode 100644
index 0000000..609ab95
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/streams/_Stream/ErrorStream.h
@@ -0,0 +1,64 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams__Stream_ErrorStream
+#define INCLUDED_tink_streams__Stream_ErrorStream
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_streams_StreamBase
+#include <tink/streams/StreamBase.h>
+#endif
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,streams,StreamBase)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+HX_DECLARE_CLASS3(tink,streams,_Stream,ErrorStream)
+
+namespace tink{
+namespace streams{
+namespace _Stream{
+
+
+class HXCPP_CLASS_ATTRIBUTES ErrorStream_obj : public  ::tink::streams::StreamBase_obj
+{
+	public:
+		typedef  ::tink::streams::StreamBase_obj super;
+		typedef ErrorStream_obj OBJ_;
+		ErrorStream_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1afcc8aa };
+
+		void __construct( ::tink::core::TypedError error);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.streams._Stream.ErrorStream")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.streams._Stream.ErrorStream"); }
+		static ::hx::ObjectPtr< ErrorStream_obj > __new( ::tink::core::TypedError error);
+		static ::hx::ObjectPtr< ErrorStream_obj > __alloc(::hx::Ctx *_hx_ctx, ::tink::core::TypedError error);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~ErrorStream_obj();
+
+		HX_DO_RTTI_ALL;
+		::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp);
+		::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ErrorStream",48,f2,cc,e3); }
+
+		 ::tink::core::TypedError error;
+		 ::tink::core::_Future::FutureObject forEach( ::Dynamic handler);
+
+};
+
+} // end namespace tink
+} // end namespace streams
+} // end namespace _Stream
+
+#endif /* INCLUDED_tink_streams__Stream_ErrorStream */ 
diff --git a/Sources/c_snikket/iinclude/tink/streams/_Stream/Handler_Impl_.h b/Sources/c_snikket/iinclude/tink/streams/_Stream/Handler_Impl_.h
new file mode 100644
index 0000000..2e0cf9a
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/streams/_Stream/Handler_Impl_.h
@@ -0,0 +1,69 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams__Stream_Handler_Impl_
+#define INCLUDED_tink_streams__Stream_Handler_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,streams,Handled)
+HX_DECLARE_CLASS3(tink,streams,_Stream,Handler_Impl_)
+
+namespace tink{
+namespace streams{
+namespace _Stream{
+
+
+class HXCPP_CLASS_ATTRIBUTES Handler_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Handler_Impl__obj OBJ_;
+		Handler_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x065ceae4 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.streams._Stream.Handler_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.streams._Stream.Handler_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Handler_Impl__obj > __new() {
+			::hx::ObjectPtr< Handler_Impl__obj > __this = new Handler_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Handler_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Handler_Impl__obj *__this = (Handler_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Handler_Impl__obj), false, "tink.streams._Stream.Handler_Impl_"));
+			*(void **)__this = Handler_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Handler_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Handler_Impl_",ca,2f,2c,64); }
+
+		static  ::Dynamic ofSafeSync( ::Dynamic f);
+		static ::Dynamic ofSafeSync_dyn();
+
+		static  ::Dynamic ofUnknown( ::Dynamic f);
+		static ::Dynamic ofUnknown_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace streams
+} // end namespace _Stream
+
+#endif /* INCLUDED_tink_streams__Stream_Handler_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/tink/streams/_Stream/Reducer_Impl_.h b/Sources/c_snikket/iinclude/tink/streams/_Stream/Reducer_Impl_.h
new file mode 100644
index 0000000..3308ef5
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/streams/_Stream/Reducer_Impl_.h
@@ -0,0 +1,66 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams__Stream_Reducer_Impl_
+#define INCLUDED_tink_streams__Stream_Reducer_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,streams,ReductionStep)
+HX_DECLARE_CLASS3(tink,streams,_Stream,Reducer_Impl_)
+
+namespace tink{
+namespace streams{
+namespace _Stream{
+
+
+class HXCPP_CLASS_ATTRIBUTES Reducer_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Reducer_Impl__obj OBJ_;
+		Reducer_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x18a49ca6 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.streams._Stream.Reducer_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.streams._Stream.Reducer_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Reducer_Impl__obj > __new() {
+			::hx::ObjectPtr< Reducer_Impl__obj > __this = new Reducer_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Reducer_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Reducer_Impl__obj *__this = (Reducer_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Reducer_Impl__obj), false, "tink.streams._Stream.Reducer_Impl_"));
+			*(void **)__this = Reducer_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Reducer_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Reducer_Impl_",8c,e1,73,76); }
+
+		static  ::Dynamic ofSafeSync( ::Dynamic f);
+		static ::Dynamic ofSafeSync_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace streams
+} // end namespace _Stream
+
+#endif /* INCLUDED_tink_streams__Stream_Reducer_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/tink/streams/_Stream/RegroupStream.h b/Sources/c_snikket/iinclude/tink/streams/_Stream/RegroupStream.h
new file mode 100644
index 0000000..b268759
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/streams/_Stream/RegroupStream.h
@@ -0,0 +1,55 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams__Stream_RegroupStream
+#define INCLUDED_tink_streams__Stream_RegroupStream
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_tink_streams__Stream_CompoundStream
+#include <tink/streams/_Stream/CompoundStream.h>
+#endif
+HX_DECLARE_CLASS2(tink,streams,StreamBase)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+HX_DECLARE_CLASS3(tink,streams,_Stream,CompoundStream)
+HX_DECLARE_CLASS3(tink,streams,_Stream,RegroupStream)
+
+namespace tink{
+namespace streams{
+namespace _Stream{
+
+
+class HXCPP_CLASS_ATTRIBUTES RegroupStream_obj : public  ::tink::streams::_Stream::CompoundStream_obj
+{
+	public:
+		typedef  ::tink::streams::_Stream::CompoundStream_obj super;
+		typedef RegroupStream_obj OBJ_;
+		RegroupStream_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1850db0e };
+
+		void __construct(::Dynamic source, ::Dynamic f,::Dynamic prev,::cpp::VirtualArray buf);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="tink.streams._Stream.RegroupStream")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,true,"tink.streams._Stream.RegroupStream"); }
+		static ::hx::ObjectPtr< RegroupStream_obj > __new(::Dynamic source, ::Dynamic f,::Dynamic prev,::cpp::VirtualArray buf);
+		static ::hx::ObjectPtr< RegroupStream_obj > __alloc(::hx::Ctx *_hx_ctx,::Dynamic source, ::Dynamic f,::Dynamic prev,::cpp::VirtualArray buf);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~RegroupStream_obj();
+
+		HX_DO_RTTI_ALL;
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("RegroupStream",2c,28,b5,d4); }
+
+};
+
+} // end namespace tink
+} // end namespace streams
+} // end namespace _Stream
+
+#endif /* INCLUDED_tink_streams__Stream_RegroupStream */ 
diff --git a/Sources/c_snikket/iinclude/tink/streams/_Stream/Regrouper_Impl_.h b/Sources/c_snikket/iinclude/tink/streams/_Stream/Regrouper_Impl_.h
new file mode 100644
index 0000000..72afba4
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/streams/_Stream/Regrouper_Impl_.h
@@ -0,0 +1,65 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams__Stream_Regrouper_Impl_
+#define INCLUDED_tink_streams__Stream_Regrouper_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,streams,RegroupResult)
+HX_DECLARE_CLASS3(tink,streams,_Stream,Regrouper_Impl_)
+
+namespace tink{
+namespace streams{
+namespace _Stream{
+
+
+class HXCPP_CLASS_ATTRIBUTES Regrouper_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Regrouper_Impl__obj OBJ_;
+		Regrouper_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x74da6ebb };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.streams._Stream.Regrouper_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.streams._Stream.Regrouper_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Regrouper_Impl__obj > __new() {
+			::hx::ObjectPtr< Regrouper_Impl__obj > __this = new Regrouper_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Regrouper_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Regrouper_Impl__obj *__this = (Regrouper_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Regrouper_Impl__obj), false, "tink.streams._Stream.Regrouper_Impl_"));
+			*(void **)__this = Regrouper_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Regrouper_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Regrouper_Impl_",59,bf,c2,4c); }
+
+		static  ::Dynamic ofIgnoranceSync( ::Dynamic f);
+		static ::Dynamic ofIgnoranceSync_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace streams
+} // end namespace _Stream
+
+#endif /* INCLUDED_tink_streams__Stream_Regrouper_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/tink/streams/_Stream/Stream_Impl_.h b/Sources/c_snikket/iinclude/tink/streams/_Stream/Stream_Impl_.h
new file mode 100644
index 0000000..776c5cc
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/streams/_Stream/Stream_Impl_.h
@@ -0,0 +1,73 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_streams__Stream_Stream_Impl_
+#define INCLUDED_tink_streams__Stream_Stream_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(tink,core,TypedError)
+HX_DECLARE_CLASS3(tink,core,_Future,FutureObject)
+HX_DECLARE_CLASS2(tink,streams,StreamObject)
+HX_DECLARE_CLASS3(tink,streams,_Stream,Stream_Impl_)
+
+namespace tink{
+namespace streams{
+namespace _Stream{
+
+
+class HXCPP_CLASS_ATTRIBUTES Stream_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Stream_Impl__obj OBJ_;
+		Stream_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x5036bc9e };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.streams._Stream.Stream_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.streams._Stream.Stream_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Stream_Impl__obj > __new() {
+			::hx::ObjectPtr< Stream_Impl__obj > __this = new Stream_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Stream_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Stream_Impl__obj *__this = (Stream_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Stream_Impl__obj), false, "tink.streams._Stream.Stream_Impl_"));
+			*(void **)__this = Stream_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Stream_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Stream_Impl_",40,fd,8a,3d); }
+
+		static ::Dynamic single( ::Dynamic i);
+		static ::Dynamic single_dyn();
+
+		static ::Dynamic future( ::tink::core::_Future::FutureObject f);
+		static ::Dynamic future_dyn();
+
+		static ::Dynamic ofError( ::tink::core::TypedError e);
+		static ::Dynamic ofError_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace streams
+} // end namespace _Stream
+
+#endif /* INCLUDED_tink_streams__Stream_Stream_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/tink/url/_Host/Host_Impl_.h b/Sources/c_snikket/iinclude/tink/url/_Host/Host_Impl_.h
new file mode 100644
index 0000000..3db7153
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/url/_Host/Host_Impl_.h
@@ -0,0 +1,70 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_url__Host_Host_Impl_
+#define INCLUDED_tink_url__Host_Host_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,url,_Host,Host_Impl_)
+
+namespace tink{
+namespace url{
+namespace _Host{
+
+
+class HXCPP_CLASS_ATTRIBUTES Host_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Host_Impl__obj OBJ_;
+		Host_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x20d53a72 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.url._Host.Host_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.url._Host.Host_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Host_Impl__obj > __new() {
+			::hx::ObjectPtr< Host_Impl__obj > __this = new Host_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Host_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Host_Impl__obj *__this = (Host_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Host_Impl__obj), false, "tink.url._Host.Host_Impl_"));
+			*(void **)__this = Host_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Host_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Host_Impl_",28,8e,8a,61); }
+
+		static ::String _new(::String name, ::Dynamic port);
+		static ::Dynamic _new_dyn();
+
+		static ::String get_name(::String this1);
+		static ::Dynamic get_name_dyn();
+
+		static  ::Dynamic get_port(::String this1);
+		static ::Dynamic get_port_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace url
+} // end namespace _Host
+
+#endif /* INCLUDED_tink_url__Host_Host_Impl_ */ 
diff --git a/Sources/c_snikket/iinclude/tink/url/_Path/Path_Impl_.h b/Sources/c_snikket/iinclude/tink/url/_Path/Path_Impl_.h
new file mode 100644
index 0000000..25b6b43
--- /dev/null
+++ b/Sources/c_snikket/iinclude/tink/url/_Path/Path_Impl_.h
@@ -0,0 +1,70 @@
+// Generated by Haxe 4.3.3
+#ifndef INCLUDED_tink_url__Path_Path_Impl_
+#define INCLUDED_tink_url__Path_Path_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(tink,url,_Path,Path_Impl_)
+
+namespace tink{
+namespace url{
+namespace _Path{
+
+
+class HXCPP_CLASS_ATTRIBUTES Path_Impl__obj : public ::hx::Object
+{
+	public:
+		typedef ::hx::Object super;
+		typedef Path_Impl__obj OBJ_;
+		Path_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x718c1a2c };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="tink.url._Path.Path_Impl_")
+			{ return ::hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return ::hx::Object::operator new(inSize+extra,false,"tink.url._Path.Path_Impl_"); }
+
+		inline static ::hx::ObjectPtr< Path_Impl__obj > __new() {
+			::hx::ObjectPtr< Path_Impl__obj > __this = new Path_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static ::hx::ObjectPtr< Path_Impl__obj > __alloc(::hx::Ctx *_hx_ctx) {
+			Path_Impl__obj *__this = (Path_Impl__obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Path_Impl__obj), false, "tink.url._Path.Path_Impl_"));
+			*(void **)__this = Path_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(::hx::DynamicArray inArgs);
+		//~Path_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Path_Impl_",25,70,db,20); }
+
+		static ::String join(::String this1,::String that);
+		static ::Dynamic join_dyn();
+
+		static ::String ofString(::String s);
+		static ::Dynamic ofString_dyn();
+
+		static ::String normalize(::String s);
+		static ::Dynamic normalize_dyn();
+
+};
+
+} // end namespace tink
+} // end namespace url
+} // end namespace _Path
+
+#endif /* INCLUDED_tink_url__Path_Path_Impl_ */ 
diff --git a/Sources/c_snikket/include/snikket.h b/Sources/c_snikket/include/snikket.h
new file mode 100644
index 0000000..a294c1b
--- /dev/null
+++ b/Sources/c_snikket/include/snikket.h
@@ -0,0 +1,1002 @@
+/**
+ * \file snikket.h the Snikket SDK for C
+ *
+ * Everything returned from an SDK procedure or passed to a function
+ * pointer, both strings and opaque types, must be passed to
+ * snikket_release when you are done with it.
+ */
+
+#ifndef __SNIKKET_H
+#define __SNIKKET_H
+
+#ifndef MKDOCS
+#include <stdbool.h>
+#include <stddef.h>
+
+#ifndef API_PREFIX
+	#ifdef _WIN32
+		#define API_PREFIX __declspec(dllimport)
+	#else
+		#define API_PREFIX
+	#endif
+#endif
+
+#endif
+
+typedef void (*snikket_panic_callback) (const char *info);
+
+enum
+#ifdef __clang__
+__attribute__((enum_extensibility(closed)))
+#endif
+snikket_message_type {
+	MessageChat = 0,
+	MessageCall = 1,
+	MessageChannel = 2,
+	MessageChannelPrivate = 3
+};
+
+enum
+#ifdef __clang__
+__attribute__((enum_extensibility(closed)))
+#endif
+snikket_message_direction {
+	MessageReceived = 0,
+	MessageSent = 1
+};
+
+enum
+#ifdef __clang__
+__attribute__((enum_extensibility(closed)))
+#endif
+snikket_message_status {
+	MessagePending = 0,
+	MessageDeliveredToServer = 1,
+	MessageDeliveredToDevice = 2,
+	MessageFailedToSend = 3
+};
+
+enum
+#ifdef __clang__
+__attribute__((enum_extensibility(closed)))
+#endif
+snikket_ui_state {
+	Pinned = 0,
+	Open = 1,
+	Closed = 2
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Initializes the SDK
+ *
+ * This must be first before calling SDK functions (otherwise those calls will hang waiting for a response).
+ *
+ * @param panicCallback a callback to execute if the SDK panics. The SDK will continue processing events after a panic and you may want to stop it after receiving this callback. Use `NULL` for no callback
+ * @returns `NULL` if the thread initializes successfully or a null-terminated C string if an error occurs during initialization
+ */
+API_PREFIX const char *snikket_setup(snikket_panic_callback panic_callback);
+
+/**
+ * Stops the SDK, blocking until the main thread has completed. Once ended, it cannot be restarted (this is because static variable state will be retained from the last run).
+ *
+ * It can be safely called any number of times – if the SDK is not running this function will just return.
+ *
+ * After executing no more calls to SDK functions can be made (as these will hang waiting for a response).
+ *
+ * Thread-safety: Can be called safely called on any thread.
+ *
+ * @param wait If `true`, this function will wait for all events scheduled to execute in the future on the SDK thread to complete. If `false`, immediate pending events will be finished and the SDK stopped without executing events scheduled in the future
+ */
+API_PREFIX void snikket_stop(bool wait);
+
+/**
+ * Informs the garbage collector that object is no longer needed by the C code.
+ * 
+ * If the object has no remaining reference the garbage collector can free the associated memory (which can happen at any time in the future). It does not free the memory immediately.
+ * 
+ * Thread-safety: can be called on any thread.
+ * 
+ * @param ptr a handle to an arbitrary SDK object returned from an SDK function
+ */
+API_PREFIX void snikket_release(const void *ptr);
+
+API_PREFIX void *snikket_persistence_media_store_f_s_new(const char *path);
+
+API_PREFIX void snikket_persistence_media_store_f_s_get_media_path(void *media_store_fs, const char *uri, void (*callback) (const char*, void*), void *callback__context);
+
+/**
+ * Create a basic persistence layer based on sqlite
+ * 
+ * @param dbfile path to sqlite database
+ * @params media a MediaStore to use for media
+ * @returns new persistence layer
+ */
+API_PREFIX void *snikket_persistence_sqlite_new(const char *dbfile, void *media);
+
+API_PREFIX void snikket_persistence_sqlite_get_message(void *sqlite, const char *accountId, const char *chatId, const char *serverId, const char *localId, void (*callback) (void*, void*), void *callback__context);
+
+API_PREFIX void snikket_persistence_sqlite_remove_account(void *sqlite, const char *accountId, bool completely);
+
+API_PREFIX void snikket_persistence_sqlite_list_accounts(void *sqlite, void (*callback) (const char**, size_t, void*), void *callback__context);
+
+/**
+ * The ID as set by the creator of this message
+ */
+API_PREFIX const char *snikket_chat_message_local_id(void *chat_message);
+
+/**
+ * The ID as set by the authoritative server
+ */
+API_PREFIX const char *snikket_chat_message_server_id(void *chat_message);
+
+/**
+ * The ID of the server which set the serverId
+ */
+API_PREFIX const char *snikket_chat_message_server_id_by(void *chat_message);
+
+/**
+ * The type of this message (Chat, Call, etc)
+ */
+API_PREFIX enum snikket_message_type snikket_chat_message_type(void *chat_message);
+
+/**
+ * The timestamp of this message, in format YYYY-MM-DDThh:mm:ss[.sss]Z
+ */
+API_PREFIX const char *snikket_chat_message_timestamp(void *chat_message);
+
+/**
+ * The ID of the sender of this message
+ */
+API_PREFIX const char *snikket_chat_message_sender_id(void *chat_message);
+
+/**
+ * Message this one is in reply to, or NULL
+ */
+API_PREFIX void *snikket_chat_message_reply_to_message(void *chat_message);
+
+/**
+ * ID of the thread this message is in, or NULL
+ */
+API_PREFIX const char *snikket_chat_message_thread_id(void *chat_message);
+
+/**
+ * Array of attachments to this message
+ */
+API_PREFIX size_t snikket_chat_message_attachments(void *chat_message, void ***outPtr);
+
+/**
+ * Body text of this message or NULL
+ */
+API_PREFIX const char *snikket_chat_message_text(void *chat_message);
+
+/**
+ * Language code for the body text
+ */
+API_PREFIX const char *snikket_chat_message_lang(void *chat_message);
+
+/**
+ * Direction of this message
+ */
+API_PREFIX enum snikket_message_direction snikket_chat_message_direction(void *chat_message);
+
+/**
+ * Status of this message
+ */
+API_PREFIX enum snikket_message_status snikket_chat_message_status(void *chat_message);
+
+/**
+ * Status of this message
+ */
+API_PREFIX void snikket_chat_message_set_status(void *chat_message, enum snikket_message_status value);
+
+/**
+ * Array of past versions of this message, if it has been edited
+ */
+API_PREFIX size_t snikket_chat_message_versions(void *chat_message, void ***outPtr);
+
+/**
+ * Create a new ChatMessage in reply to this one
+ */
+API_PREFIX void *snikket_chat_message_reply(void *chat_message);
+
+API_PREFIX const char *snikket_chat_message_get_reply_id(void *chat_message);
+
+/**
+ * Get HTML version of the message body
+ * 
+ * WARNING: this is possibly untrusted HTML. You must parse or sanitize appropriately!
+ */
+API_PREFIX const char *snikket_chat_message_html(void *chat_message);
+
+/**
+ * The ID of the Chat this message is associated with
+ */
+API_PREFIX const char *snikket_chat_message_chat_id(void *chat_message);
+
+/**
+ * The ID of the account associated with this message
+ */
+API_PREFIX const char *snikket_chat_message_account(void *chat_message);
+
+/**
+ * Is this an incoming message?
+ */
+API_PREFIX bool snikket_chat_message_is_incoming(void *chat_message);
+
+/**
+ * The URI of an icon for the thread associated with this message, or NULL
+ */
+API_PREFIX const char *snikket_chat_message_thread_icon(void *chat_message);
+
+/**
+ * The last status of the call if this message is related to a call
+ */
+API_PREFIX const char *snikket_chat_message_call_status(void *chat_message);
+
+/**
+ * The session id of the call if this message is related to a call
+ */
+API_PREFIX const char *snikket_chat_message_call_sid(void *chat_message);
+
+/**
+ * The duration of the call if this message is related to a call
+ */
+API_PREFIX const char *snikket_chat_message_call_duration(void *chat_message);
+
+API_PREFIX void *snikket_chat_attachment_create(const char *name, const char *mime, int size, const char *uri);
+
+API_PREFIX const char *snikket_chat_attachment_name(void *chat_attachment);
+
+API_PREFIX const char *snikket_chat_attachment_mime(void *chat_attachment);
+
+API_PREFIX int snikket_chat_attachment_size(void *chat_attachment);
+
+API_PREFIX size_t snikket_chat_attachment_uris(void *chat_attachment, const char ***outPtr);
+
+API_PREFIX size_t snikket_chat_attachment_hashes(void *chat_attachment, void ***outPtr);
+
+API_PREFIX void *snikket_hash_from_hex(const char *algorithm, const char *hash);
+
+API_PREFIX void *snikket_hash_from_uri(const char *uri);
+
+API_PREFIX const char *snikket_hash_algorithm(void *hash);
+
+API_PREFIX const char *snikket_hash_to_uri(void *hash);
+
+API_PREFIX const char *snikket_hash_to_hex(void *hash);
+
+API_PREFIX const char *snikket_hash_to_base_64(void *hash);
+
+API_PREFIX const char *snikket_hash_to_base_64_url(void *hash);
+
+/**
+ * @returns a new blank ChatMessageBuilder
+ */
+API_PREFIX void *snikket_chat_message_builder_new();
+
+/**
+ * The ID as set by the creator of this message
+ */
+API_PREFIX const char *snikket_chat_message_builder_local_id(void *chat_message_builder);
+
+/**
+ * The ID as set by the creator of this message
+ */
+API_PREFIX void snikket_chat_message_builder_set_local_id(void *chat_message_builder, const char *value);
+
+/**
+ * The ID as set by the authoritative server
+ */
+API_PREFIX const char *snikket_chat_message_builder_server_id(void *chat_message_builder);
+
+/**
+ * The ID as set by the authoritative server
+ */
+API_PREFIX void snikket_chat_message_builder_set_server_id(void *chat_message_builder, const char *value);
+
+/**
+ * The ID of the server which set the serverId
+ */
+API_PREFIX const char *snikket_chat_message_builder_server_id_by(void *chat_message_builder);
+
+/**
+ * The ID of the server which set the serverId
+ */
+API_PREFIX void snikket_chat_message_builder_set_server_id_by(void *chat_message_builder, const char *value);
+
+/**
+ * The type of this message (Chat, Call, etc)
+ */
+API_PREFIX enum snikket_message_type snikket_chat_message_builder_type(void *chat_message_builder);
+
+/**
+ * The type of this message (Chat, Call, etc)
+ */
+API_PREFIX void snikket_chat_message_builder_set_type(void *chat_message_builder, enum snikket_message_type value);
+
+/**
+ * The timestamp of this message, in format YYYY-MM-DDThh:mm:ss[.sss]+00:00
+ */
+API_PREFIX const char *snikket_chat_message_builder_timestamp(void *chat_message_builder);
+
+/**
+ * The timestamp of this message, in format YYYY-MM-DDThh:mm:ss[.sss]+00:00
+ */
+API_PREFIX void snikket_chat_message_builder_set_timestamp(void *chat_message_builder, const char *value);
+
+API_PREFIX const char *snikket_chat_message_builder_sender_id(void *chat_message_builder);
+
+API_PREFIX void snikket_chat_message_builder_set_sender_id(void *chat_message_builder, const char *value);
+
+/**
+ * Message this one is in reply to, or NULL
+ */
+API_PREFIX void *snikket_chat_message_builder_reply_to_message(void *chat_message_builder);
+
+/**
+ * Message this one is in reply to, or NULL
+ */
+API_PREFIX void snikket_chat_message_builder_set_reply_to_message(void *chat_message_builder, void *value);
+
+/**
+ * ID of the thread this message is in, or NULL
+ */
+API_PREFIX const char *snikket_chat_message_builder_thread_id(void *chat_message_builder);
+
+/**
+ * ID of the thread this message is in, or NULL
+ */
+API_PREFIX void snikket_chat_message_builder_set_thread_id(void *chat_message_builder, const char *value);
+
+/**
+ * Array of attachments to this message
+ */
+API_PREFIX size_t snikket_chat_message_builder_attachments(void *chat_message_builder, void ***outPtr);
+
+/**
+ * Body text of this message or NULL
+ */
+API_PREFIX const char *snikket_chat_message_builder_text(void *chat_message_builder);
+
+/**
+ * Body text of this message or NULL
+ */
+API_PREFIX void snikket_chat_message_builder_set_text(void *chat_message_builder, const char *value);
+
+/**
+ * Language code for the body text
+ */
+API_PREFIX const char *snikket_chat_message_builder_lang(void *chat_message_builder);
+
+/**
+ * Language code for the body text
+ */
+API_PREFIX void snikket_chat_message_builder_set_lang(void *chat_message_builder, const char *value);
+
+/**
+ * Direction of this message
+ */
+API_PREFIX enum snikket_message_direction snikket_chat_message_builder_direction(void *chat_message_builder);
+
+/**
+ * Direction of this message
+ */
+API_PREFIX void snikket_chat_message_builder_set_direction(void *chat_message_builder, enum snikket_message_direction value);
+
+/**
+ * Status of this message
+ */
+API_PREFIX enum snikket_message_status snikket_chat_message_builder_status(void *chat_message_builder);
+
+/**
+ * Status of this message
+ */
+API_PREFIX void snikket_chat_message_builder_set_status(void *chat_message_builder, enum snikket_message_status value);
+
+/**
+ * Array of past versions of this message, if it has been edited
+ */
+API_PREFIX size_t snikket_chat_message_builder_versions(void *chat_message_builder, void ***outPtr);
+
+API_PREFIX void snikket_chat_message_builder_add_attachment(void *chat_message_builder, void *attachment);
+
+/**
+ * Set rich text using an HTML string
+ * Also sets the plain text body appropriately
+ */
+API_PREFIX void snikket_chat_message_builder_set_html(void *chat_message_builder, const char *html);
+
+/**
+ * The ID of the Chat this message is associated with
+ */
+API_PREFIX const char *snikket_chat_message_builder_chat_id(void *chat_message_builder);
+
+/**
+ * The ID of the sender of this message
+ */
+API_PREFIX const char *snikket_chat_message_builder_get_sender_id(void *chat_message_builder);
+
+API_PREFIX bool snikket_chat_message_builder_is_incoming(void *chat_message_builder);
+
+API_PREFIX void *snikket_chat_message_builder_build(void *chat_message_builder);
+
+/**
+ * Create a basic persistence layer that persists nothing
+ * 
+ * @returns new persistence layer
+ */
+API_PREFIX void *snikket_persistence_dummy_new();
+
+/**
+ * Create a new Client to connect to a particular account
+ * 
+ * @param address the account to connect to
+ * @param persistence the persistence layer to use for storage
+ */
+API_PREFIX void *snikket_client_new(const char *address, void *persistence);
+
+/**
+ * Set to false to suppress sending available presence
+ */
+API_PREFIX void snikket_client_set_send_available(void *client, bool value);
+
+/**
+ * Start this client running and trying to connect to the server
+ */
+API_PREFIX void snikket_client_start(void *client);
+
+/**
+ * Destroy local data for this account
+ * 
+ * @param completely if true chats, messages, etc will be deleted as well
+ */
+API_PREFIX void snikket_client_logout(void *client, bool completely);
+
+/**
+ * Sets the password to be used in response to the password needed event
+ * 
+ * @param password
+ */
+API_PREFIX void snikket_client_use_password(void *client, const char *password);
+
+/**
+ * Get the account ID for this Client
+ * 
+ * @returns account id
+ */
+API_PREFIX const char *snikket_client_account_id(void *client);
+
+/**
+ * Get the current display name for this account
+ * 
+ * @returns display name
+ */
+API_PREFIX const char *snikket_client_display_name(void *client);
+
+/**
+ * Set the current display name for this account on the server
+ * 
+ * @param display name to set (ignored if empty or NULL)
+ */
+API_PREFIX void snikket_client_set_display_name(void *client, const char *displayName);
+
+/**
+ * Turn a file into a ChatAttachment for attaching to a ChatMessage
+ */
+API_PREFIX void snikket_client_prepare_attachment(void *client, void *source, void (*callback) (void*, void*), void *callback__context);
+
+/**
+ * @returns array of open chats, sorted by last activity
+ */
+API_PREFIX size_t snikket_client_get_chats(void *client, void ***outPtr);
+
+/**
+ * Search for chats the user can start or join
+ * 
+ * @param q the search query to use
+ * @param callback takes two arguments, the query that was used and the array of results
+ */
+API_PREFIX void snikket_client_find_available_chats(void *client, const char *q, void (*callback) (const char*, void**, size_t, void*), void *callback__context);
+
+/**
+ * Start or join a chat from the search results
+ * 
+ * @returns the chat that was started
+ */
+API_PREFIX void *snikket_client_start_chat(void *client, void *availableChat);
+
+/**
+ * Find a chat by id
+ * 
+ * @returns the chat if known, or NULL
+ */
+API_PREFIX void *snikket_client_get_chat(void *client, const char *chatId);
+
+/**
+ * Event fired when client needs a password for authentication
+ * 
+ * @param handler takes one argument, the Client that needs a password
+ */
+API_PREFIX void snikket_client_add_password_needed_listener(void *client, void (*handler) (void*, void*), void *handler__context);
+
+/**
+ * Event fired when client is connected and fully synchronized
+ * 
+ * @param handler takes no arguments
+ */
+API_PREFIX void snikket_client_add_status_online_listener(void *client, void (*handler) (void*), void *handler__context);
+
+/**
+ * Event fired when client is disconnected
+ * 
+ * @param handler takes no arguments
+ */
+API_PREFIX void snikket_client_add_status_offline_listener(void *client, void (*handler) (void*), void *handler__context);
+
+/**
+ * Event fired when connection fails with a fatal error and will not be retried
+ * 
+ * @param handler takes no arguments
+ */
+API_PREFIX void snikket_client_add_connection_failed_listener(void *client, void (*handler) (void*), void *handler__context);
+
+/**
+ * Event fired when a new ChatMessage comes in on any Chat
+ * Also fires when status of a ChatMessage changes,
+ * when a ChatMessage is edited, or when a reaction is added
+ * 
+ * @param handler takes two arguments, the ChatMessage and ChatMessageEvent enum describing what happened
+ */
+API_PREFIX void snikket_client_add_chat_message_listener(void *client, void (*handler) (void*, int, void*), void *handler__context);
+
+/**
+ * Event fired when syncing a new ChatMessage that was send when offline.
+ * Normally you don't want this, but it may be useful if you want to notify on app start.
+ * 
+ * @param handler takes one argument, the ChatMessage
+ */
+API_PREFIX void snikket_client_add_sync_message_listener(void *client, void (*handler) (void*, void*), void *handler__context);
+
+/**
+ * Event fired when a Chat's metadata is updated, or when a new Chat is added
+ * 
+ * @param handler takes one argument, an array of Chats that were updated
+ */
+API_PREFIX void snikket_client_add_chats_updated_listener(void *client, void (*handler) (void**, size_t, void*), void *handler__context);
+
+/**
+ * Event fired when a new call comes in
+ * 
+ * @param handler takes two arguments, the call Session and the associated Chat ID
+ */
+API_PREFIX void snikket_client_add_call_ring_listener(void *client, void (*handler) (void*, const char*, void*), void *handler__context);
+
+/**
+ * Event fired when a call is retracted or hung up
+ * 
+ * @param handler takes one argument, the associated Chat ID
+ */
+API_PREFIX void snikket_client_add_call_retract_listener(void *client, void (*handler) (const char*, void*), void *handler__context);
+
+/**
+ * Event fired when an outgoing call starts ringing
+ * 
+ * @param handler takes one argument, the associated Chat ID
+ */
+API_PREFIX void snikket_client_add_call_ringing_listener(void *client, void (*handler) (const char*, void*), void *handler__context);
+
+/**
+ * Event fired when a call is asking for media to send
+ * 
+ * @param handler takes three arguments, the call Session,
+ *        a boolean indicating if audio is desired,
+ *        and a boolean indicating if video is desired
+ */
+API_PREFIX void snikket_client_add_call_media_listener(void *client, void (*handler) (void*, bool, bool, void*), void *handler__context);
+
+/**
+ * Event fired when call has a new MediaStreamTrack to play
+ * 
+ * @param handler takes three arguments, the associated Chat ID,
+ *        the new MediaStreamTrack, and an array of any associated MediaStreams
+ */
+API_PREFIX void snikket_client_add_call_track_listener(void *client, void (*handler) (const char*, void*, void**, size_t, void*), void *handler__context);
+
+/**
+ * Let the SDK know the UI is in the foreground
+ */
+API_PREFIX void snikket_client_set_in_foreground(void *client);
+
+/**
+ * Let the SDK know the UI is in the foreground
+ */
+API_PREFIX void snikket_client_set_not_in_foreground(void *client);
+
+/**
+ * ID of this Chat
+ */
+API_PREFIX const char *snikket_chat_chat_id(void *chat);
+
+/**
+ * Current state of this chat
+ */
+API_PREFIX enum snikket_ui_state snikket_chat_ui_state(void *chat);
+
+API_PREFIX bool snikket_chat_is_blocked(void *chat);
+
+/**
+ * Fetch a page of messages before some point
+ * 
+ * @param beforeId id of the message to look before
+ * @param beforeTime timestamp of the message to look before,
+ *        String in format YYYY-MM-DDThh:mm:ss[.sss]+00:00
+ * @param handler takes one argument, an array of ChatMessage that are found
+ */
+API_PREFIX void snikket_chat_get_messages_before(void *chat, const char *beforeId, const char *beforeTime, void (*handler) (void**, size_t, void*), void *handler__context);
+
+/**
+ * Fetch a page of messages after some point
+ * 
+ * @param afterId id of the message to look after
+ * @param afterTime timestamp of the message to look after,
+ *        String in format YYYY-MM-DDThh:mm:ss[.sss]+00:00
+ * @param handler takes one argument, an array of ChatMessage that are found
+ */
+API_PREFIX void snikket_chat_get_messages_after(void *chat, const char *afterId, const char *afterTime, void (*handler) (void**, size_t, void*), void *handler__context);
+
+/**
+ * Fetch a page of messages around (before, including, and after) some point
+ * 
+ * @param aroundId id of the message to look around
+ * @param aroundTime timestamp of the message to look around,
+ *        String in format YYYY-MM-DDThh:mm:ss[.sss]+00:00
+ * @param handler takes one argument, an array of ChatMessage that are found
+ */
+API_PREFIX void snikket_chat_get_messages_around(void *chat, const char *aroundId, const char *aroundTime, void (*handler) (void**, size_t, void*), void *handler__context);
+
+/**
+ * Send a ChatMessage to this Chat
+ * 
+ * @param message the ChatMessage to send
+ */
+API_PREFIX void snikket_chat_send_message(void *chat, void *message);
+
+/**
+ * Signals that all messages up to and including this one have probably
+ * been displayed to the user
+ * 
+ * @param message the ChatMessage most recently displayed
+ */
+API_PREFIX void snikket_chat_mark_read_up_to(void *chat, void *message);
+
+/**
+ * Save this Chat on the server
+ */
+API_PREFIX void snikket_chat_bookmark(void *chat);
+
+/**
+ * Get the list of IDs of participants in this Chat
+ * 
+ * @returns array of IDs
+ */
+API_PREFIX size_t snikket_chat_get_participants(void *chat, const char ***outPtr);
+
+/**
+ * Get the details for one participant in this Chat
+ * 
+ * @param participantId the ID of the participant to look up
+ */
+API_PREFIX void *snikket_chat_get_participant_details(void *chat, const char *participantId);
+
+/**
+ * Correct an already-send message by replacing it with a new one
+ * 
+ * @param localId the localId of the message to correct
+ *        must be the localId of the first version ever sent, not a subsequent correction
+ * @param message the new ChatMessage to replace it with
+ */
+API_PREFIX void snikket_chat_correct_message(void *chat, const char *localId, void *message);
+
+/**
+ * Add new reaction to a message in this Chat
+ * 
+ * @param m ChatMessage to react to
+ * @param reaction emoji of the reaction
+ */
+API_PREFIX void snikket_chat_add_reaction(void *chat, void *m, void *reaction);
+
+/**
+ * Remove an already-sent reaction from a message
+ * 
+ * @param m ChatMessage to remove the reaction from
+ * @param reaction the emoji to remove
+ */
+API_PREFIX void snikket_chat_remove_reaction(void *chat, void *m, void *reaction);
+
+/**
+ * Call this whenever the user is typing, can call on every keystroke
+ * 
+ * @param threadId optional, what thread the user has selected if any
+ * @param content optional, what the user has typed so far
+ */
+API_PREFIX void snikket_chat_typing(void *chat, const char *threadId, const char *content);
+
+/**
+ * Call this whenever the user makes a chat or thread "active" in your UX
+ * If you call this with true you MUST later call it will false
+ * 
+ * @param active true if the chat is "active", false otherwise
+ * @param threadId optional, what thread the user has selected if any
+ */
+API_PREFIX void snikket_chat_set_active(void *chat, bool active, const char *threadId);
+
+/**
+ * Archive this chat
+ */
+API_PREFIX void snikket_chat_close(void *chat);
+
+/**
+ * Pin or unpin this chat
+ */
+API_PREFIX void snikket_chat_toggle_pinned(void *chat);
+
+/**
+ * Block this chat so it will not re-open
+ */
+API_PREFIX void snikket_chat_block(void *chat, void *reportSpam, bool onServer);
+
+/**
+ * Unblock this chat so it will open again
+ */
+API_PREFIX void snikket_chat_unblock(void *chat, bool onServer);
+
+/**
+ * Update notification preferences
+ */
+API_PREFIX void snikket_chat_set_notifications(void *chat, bool filtered, bool mention, bool reply);
+
+/**
+ * Should notifications be filtered?
+ */
+API_PREFIX bool snikket_chat_notifications_filtered(void *chat);
+
+/**
+ * Should a mention produce a notification?
+ */
+API_PREFIX bool snikket_chat_notify_mention(void *chat);
+
+/**
+ * Should a reply produce a notification?
+ */
+API_PREFIX bool snikket_chat_notify_reply(void *chat);
+
+/**
+ * An ID of the most recent message in this chat
+ */
+API_PREFIX const char *snikket_chat_last_message_id(void *chat);
+
+/**
+ * The timestamp of the most recent message in this chat
+ */
+API_PREFIX const char *snikket_chat_last_message_timestamp(void *chat);
+
+/**
+ * Get the URI image to represent this Chat, or null
+ */
+API_PREFIX const char *snikket_chat_get_photo(void *chat);
+
+/**
+ * Get the URI to a placeholder image to represent this Chat
+ */
+API_PREFIX const char *snikket_chat_get_placeholder(void *chat);
+
+/**
+ * An ID of the last message displayed to the user
+ */
+API_PREFIX const char *snikket_chat_read_up_to(void *chat);
+
+/**
+ * The number of message that have not yet been displayed to the user
+ */
+API_PREFIX int snikket_chat_unread_count(void *chat);
+
+/**
+ * A preview of the chat, such as the most recent message body
+ */
+API_PREFIX const char *snikket_chat_preview(void *chat);
+
+API_PREFIX void snikket_chat_set_display_name(void *chat, const char *fn);
+
+/**
+ * The display name of this Chat
+ */
+API_PREFIX const char *snikket_chat_get_display_name(void *chat);
+
+API_PREFIX void snikket_chat_set_trusted(void *chat, bool trusted);
+
+/**
+ * Is this a chat with an entity we trust to see our online status?
+ */
+API_PREFIX bool snikket_chat_is_trusted(void *chat);
+
+API_PREFIX bool snikket_chat_syncing(void *chat);
+
+/**
+ * Can audio calls be started in this Chat?
+ */
+API_PREFIX bool snikket_chat_can_audio_call(void *chat);
+
+/**
+ * Can video calls be started in this Chat?
+ */
+API_PREFIX bool snikket_chat_can_video_call(void *chat);
+
+/**
+ * Start a new call in this Chat
+ * 
+ * @param audio do we want audio in this call
+ * @param video do we want video in this call
+ */
+API_PREFIX void snikket_chat_start_call(void *chat, bool audio, bool video);
+
+/**
+ * Accept any incoming calls in this Chat
+ */
+API_PREFIX void snikket_chat_accept_call(void *chat);
+
+/**
+ * Hangup or reject any calls in this chat
+ */
+API_PREFIX void snikket_chat_hangup(void *chat);
+
+/**
+ * The current status of a call in this chat
+ */
+API_PREFIX const char *snikket_chat_call_status(void *chat);
+
+/**
+ * A DTMFSender for a call in this chat, or NULL
+ */
+API_PREFIX void *snikket_chat_dtmf(void *chat);
+
+/**
+ * All video tracks in all active calls in this chat
+ */
+API_PREFIX size_t snikket_chat_video_tracks(void *chat, void ***outPtr);
+
+API_PREFIX const char *snikket_jingle_media_stream_track_id(void *media_stream_track);
+
+API_PREFIX bool snikket_jingle_media_stream_track_muted(void *media_stream_track);
+
+API_PREFIX const char *snikket_jingle_media_stream_track_kind(void *media_stream_track);
+
+API_PREFIX size_t snikket_jingle_media_stream_track_supported_audio_formats(void *media_stream_track, void ***outPtr);
+
+/**
+ * Event fired for new inbound audio frame
+ * 
+ * @param callback takes three arguments, the Signed 16-bit PCM data, the clock rate, and the number of channels
+ */
+API_PREFIX void snikket_jingle_media_stream_track_add_pcm_listener(void *media_stream_track, void (*callback) (short*, size_t, int, int, void*), void *callback__context);
+
+/**
+ * Event fired when ready for next outbound audio frame
+ * 
+ * @param callback
+ */
+API_PREFIX void snikket_jingle_media_stream_track_add_ready_for_pcm_listener(void *media_stream_track, void (*callback) (void*), void *callback__context);
+
+/**
+ * Send new audio to this track
+ * 
+ * @param pcm 16-bit signed linear PCM data (interleaved)
+ * @param clockRate the sampling rate of the data
+ * @param channels the number of audio channels
+ */
+API_PREFIX void snikket_jingle_media_stream_track_write_pcm(void *media_stream_track, const short *pcm, size_t pcm__len, int clockRate, int channels);
+
+API_PREFIX void snikket_jingle_media_stream_track_stop(void *media_stream_track);
+
+API_PREFIX void *snikket_jingle_audio_format_new(const char *format, unsigned char payloadType, int clockRate, int channels);
+
+API_PREFIX int snikket_jingle_audio_format_clock_rate(void *audio_format);
+
+API_PREFIX int snikket_jingle_audio_format_channels(void *audio_format);
+
+/**
+ * The ID of the Chat this search result represents
+ */
+API_PREFIX const char *snikket_available_chat_chat_id(void *available_chat);
+
+/**
+ * The display name of this search result
+ */
+API_PREFIX const char *snikket_available_chat_display_name(void *available_chat);
+
+/**
+ * A human-readable note associated with this search result
+ */
+API_PREFIX const char *snikket_available_chat_note(void *available_chat);
+
+/**
+ * Is this search result a channel?
+ */
+API_PREFIX bool snikket_available_chat_is_channel(void *available_chat);
+
+API_PREFIX const char *snikket_jingle_initiated_session_sid(void *initiated_session);
+
+API_PREFIX void snikket_jingle_initiated_session_accept(void *initiated_session);
+
+API_PREFIX void snikket_jingle_initiated_session_hangup(void *initiated_session);
+
+API_PREFIX void snikket_jingle_initiated_session_add_media(void *initiated_session, void *const *streams, size_t streams__len);
+
+API_PREFIX const char *snikket_jingle_initiated_session_call_status(void *initiated_session);
+
+API_PREFIX size_t snikket_jingle_initiated_session_video_tracks(void *initiated_session, void ***outPtr);
+
+API_PREFIX void *snikket_jingle_initiated_session_dtmf(void *initiated_session);
+
+API_PREFIX void snikket_jingle_initiated_session_supply_media(void *initiated_session, void *const *streams, size_t streams__len);
+
+API_PREFIX void *snikket_jingle_media_stream_new();
+
+/**
+ * Create default bidirectional audio track
+ */
+API_PREFIX void *snikket_jingle_media_stream_make_audio();
+
+API_PREFIX void snikket_jingle_media_stream_add_track(void *media_stream, void *track);
+
+API_PREFIX size_t snikket_jingle_media_stream_get_tracks(void *media_stream, void ***outPtr);
+
+API_PREFIX void *snikket_attachment_source_new(const char *path, const char *mime);
+
+API_PREFIX const char *snikket_attachment_source_path(void *attachment_source);
+
+API_PREFIX const char *snikket_attachment_source_type(void *attachment_source);
+
+API_PREFIX const char *snikket_attachment_source_name(void *attachment_source);
+
+API_PREFIX int snikket_attachment_source_size(void *attachment_source);
+
+API_PREFIX const char *snikket_participant_display_name(void *participant);
+
+API_PREFIX const char *snikket_participant_photo_uri(void *participant);
+
+API_PREFIX const char *snikket_participant_placeholder_uri(void *participant);
+
+API_PREFIX bool snikket_participant_is_self(void *participant);
+
+API_PREFIX bool snikket_channel_is_private(void *channel);
+
+API_PREFIX const char *snikket_reaction_sender_id(void *reaction);
+
+API_PREFIX const char *snikket_reaction_timestamp(void *reaction);
+
+API_PREFIX const char *snikket_reaction_text(void *reaction);
+
+API_PREFIX const char *snikket_reaction_key(void *reaction);
+
+API_PREFIX const char *snikket_reaction_envelope_id(void *reaction);
+
+API_PREFIX const char *snikket_custom_emoji_reaction_uri(void *custom_emoji_reaction);
+
+/**
+ * Schedule DTMF events to be sent
+ * 
+ * @param tones can be any number of 0123456789#*ABCD,
+ */
+API_PREFIX void snikket_jingle_dtmf_sender_insert_dtmf(void *dtmf_sender, const char *tones);
+
+#ifdef __cplusplus
+}
+#endif
+
+#undef API_PREFIX
+
+#endif
diff --git a/Sources/c_snikket/src/Array.cpp b/Sources/c_snikket/src/Array.cpp
new file mode 100644
index 0000000..19366ea
--- /dev/null
+++ b/Sources/c_snikket/src/Array.cpp
@@ -0,0 +1,1169 @@
+#include <hxcpp.h>
+#include <vector>
+#include <cpp/Pointer.h>
+
+#ifdef HXCPP_TELEMETRY
+extern void __hxt_new_array(void* obj, int size);
+#endif
+
+using namespace hx;
+
+
+// -------- ArrayBase -------------------------------------
+
+namespace hx
+{
+
+Array<Dynamic> ArrayBase::__new(int inSize,int inReserve)
+ { return  Array<Dynamic>(new Array_obj<Dynamic>(inSize,inReserve)); }
+
+ArrayBase::ArrayBase(int inSize,int inReserve,int inElementSize,bool inAtomic)
+{
+   length = inSize;
+   int alloc = inSize < inReserve ? inReserve : inSize;
+   if (alloc)
+   {
+      mBase = (char *)hx::InternalNew(alloc * inElementSize,false);
+      HX_OBJ_WB_GET(this,mBase);
+#ifdef HXCPP_TELEMETRY
+      __hxt_new_array(mBase, alloc * inElementSize);
+#endif
+   }
+   else
+      mBase = 0;
+   mAlloc = alloc;
+   mArrayConvertId = inAtomic ? inElementSize :
+               inElementSize==sizeof(String) ? aciStringArray : aciObjectArray;
+}
+
+
+
+void ArrayBase::reserve(int inSize) const
+{
+   if (mAlloc<inSize)
+   {
+      int elemSize = GetElementSize();
+      int bytes = inSize * elemSize;
+
+      if (mBase)
+      {
+         bool wasUnamanaged = mAlloc<0;
+         if (wasUnamanaged)
+         {
+            char *base=(char *)hx::InternalNew(bytes,false);
+            memcpy(base,mBase,length*elemSize);
+            mBase = base;
+         }
+         else
+            mBase = (char *)hx::InternalRealloc(length*elemSize,mBase, bytes );
+      }
+      else
+      {
+         mBase = (char *)hx::InternalNew(bytes,false);
+         #ifdef HXCPP_TELEMETRY
+         __hxt_new_array(mBase, bytes);
+         #endif
+      }
+
+      mAlloc = inSize;
+      HX_OBJ_WB_GET(const_cast<ArrayBase *>(this),mBase);
+   }
+}
+
+
+void ArrayBase::Realloc(int inSize) const
+{
+   // Try to detect "push" case vs resizing to big array size explicitly by looking at gap
+   bool pushCase = (inSize<=mAlloc + 16);
+   if (!pushCase)
+   {
+      reserve(inSize);
+   }
+   else if (pushCase)
+   {
+      int newAlloc = inSize;
+      unsigned int elemSize = GetElementSize();
+      unsigned int minBytes = inSize*elemSize + 8;
+      unsigned int roundup = 64;
+      while(roundup<minBytes)
+         roundup<<=1;
+
+      if (roundup>64)
+      {
+         int half = 3*(roundup>>2);
+         if (minBytes<half)
+            roundup = half;
+      }
+      unsigned int bytes = roundup-8;
+
+      if (mBase)
+      {
+         bool wasUnamanaged = mAlloc<0;
+         if (wasUnamanaged)
+         {
+            char *base=(char *)hx::InternalNew(bytes,false);
+            memcpy(base,mBase,length*elemSize);
+            mBase = base;
+         }
+         else
+         {
+            mBase = (char *)hx::InternalRealloc(length*elemSize,mBase, bytes, true);
+            int o = bytes;
+            bytes = hx::ObjectSizeSafe(mBase);
+         }
+      }
+      else
+      {
+         mBase = (char *)hx::InternalNew(bytes,false);
+         #ifdef HXCPP_TELEMETRY
+         __hxt_new_array(mBase, bytes);
+         #endif
+      }
+
+      mAlloc = bytes/elemSize;
+      HX_OBJ_WB_GET(const_cast<ArrayBase *>(this),mBase);
+   }
+}
+
+// Set numeric values to 0, pointers to null, bools to false
+void ArrayBase::zero(Dynamic inFirst, Dynamic inCount)
+{
+   int first = inFirst==null() ? 0 : inFirst->__ToInt();
+   if (first<0)
+      first+=length;
+   if (first<0 || first>=length)
+      return;
+
+   int count = length;
+   if (inCount!=null())
+      count = inCount->__ToInt();
+   if (count<0)
+      count += length;
+   if (count<0)
+      return;
+
+   if (first+count > length)
+      count = length - first;
+
+   int size = GetElementSize();
+   memset(mBase + first*size, 0, count*size);
+}
+
+int ArrayBase::Memcmp(ArrayBase *inOther)
+{
+   int bytesA = length * GetElementSize();
+   int bytesB = inOther->length * inOther->GetElementSize();
+   int common = bytesA<bytesB ? bytesA : bytesB;
+   int result = memcmp(mBase, inOther->mBase, common);
+   if (result)
+      return result;
+   return bytesA - bytesB;
+}
+
+void ArrayBase::Blit(int inDestElement, ArrayBase *inSourceArray, int inSourceElement, int inElementCount)
+{
+   int srcSize = inSourceArray->GetElementSize();
+   int srcElems = inSourceArray->length;
+   if (inDestElement<0 || inSourceElement<0 || inSourceElement+inElementCount>srcElems)
+      hx::Throw( HX_CSTRING("blit out of bounds") );
+   if (srcSize!=GetElementSize())
+      hx::Throw( HX_CSTRING("blit array mismatch") );
+
+   int newSize = inDestElement + inElementCount;
+   if (newSize>length)
+      resize(newSize);
+
+   const char *src = inSourceArray->mBase + inSourceElement*srcSize;
+   char *dest = mBase + inDestElement*srcSize;
+   int len = inElementCount*srcSize;
+   if (src+len < dest || dest+len<src)
+      memcpy(dest,src,len);
+   else
+      memmove(dest,src,len);
+
+   HX_OBJ_WB_PESSIMISTIC_GET(this);
+}
+
+int ArrayBase::__Compare(const hx::Object *inRHS) const
+{
+   if (inRHS==this)
+      return 0;
+   if (inRHS->__GetType()!=vtArray)
+      return -1;
+   ArrayCommon *common = (ArrayCommon *)inRHS;
+   hx::Object *implementation = common->__GetRealObject();
+   return implementation<this ? -1 : implementation!=this;
+}
+
+String ArrayBase::__ToString() const { return HX_CSTRING("Array"); }
+String ArrayBase::toString()
+{
+   // Byte-array (not bool!)
+   if (IsByteArray())
+   {
+      return String( (const char *) mBase, length);
+   }
+
+   return HX_CSTRING("[") + __join(HX_CSTRING(",")) + HX_CSTRING("]");
+}
+
+
+void ArrayBase::__SetSizeExact(int inSize)
+{
+   if (inSize==0)
+   {
+      InternalReleaseMem(mBase);
+      mBase = 0;
+      mAlloc = length = 0;
+   }
+   else if (inSize!=length || inSize!=mAlloc)
+   {
+      int elemSize = GetElementSize();
+      int bytes = inSize * elemSize;
+      if (mBase)
+      {
+         bool wasUnamanaged = mAlloc<0;
+
+         if (wasUnamanaged)
+         {
+            char *base=(char *)(AllocAtomic() ? hx::NewGCPrivate(0,bytes) : hx::NewGCBytes(0,bytes));
+            memcpy(base,mBase,std::min(length,inSize)*elemSize);
+            mBase = base;
+         }
+         else
+            mBase = (char *)hx::InternalRealloc(length*elemSize,mBase, bytes );
+      }
+      else if (AllocAtomic())
+      {
+         mBase = (char *)hx::NewGCPrivate(0,bytes);
+#ifdef HXCPP_TELEMETRY
+         __hxt_new_array(mBase, bytes);
+#endif
+      }
+      else
+      {
+         mBase = (char *)hx::NewGCBytes(0,bytes);
+#ifdef HXCPP_TELEMETRY
+         __hxt_new_array(mBase, bytes);
+#endif
+      }
+      mAlloc = length = inSize;
+      HX_OBJ_WB_GET(this,mBase);
+   }
+}
+
+
+Dynamic ArrayBase::__unsafe_get(const Dynamic &i)
+{
+   return __GetItem(i);
+}
+
+
+Dynamic ArrayBase::__unsafe_set(const Dynamic &i, const Dynamic &val)
+{
+   return __SetItem(i,val);
+}
+
+
+
+void ArrayBase::Insert(int inPos)
+{
+   if (inPos>=length)
+      resize(length+1);
+   else
+   {
+      resize(length+1);
+      int s = GetElementSize();
+      memmove(mBase + inPos*s + s, mBase+inPos*s, (length-inPos-1)*s );
+   }
+}
+
+void ArrayBase::Splice(ArrayBase *outResult,int inPos,int inLen)
+{
+   if (inPos>=length)
+   {
+      return;
+   }
+   else if (inPos<0)
+   {
+      inPos += length;
+      if (inPos<0)
+         inPos =0;
+   }
+   if (inLen<0)
+      return;
+   if (inPos+inLen>length)
+      inLen = length - inPos;
+
+   int s = GetElementSize();
+   if (outResult)
+   {
+      outResult->resize(inLen);
+      memcpy(outResult->mBase, mBase+inPos*s, s*inLen);
+      // todo - only needed if we have dirty pointer elements
+      HX_OBJ_WB_PESSIMISTIC_GET(outResult);
+   }
+   memmove(mBase+inPos*s, mBase + (inPos+inLen)*s, (length-(inPos+inLen))*s);
+   resize(length-inLen);
+}
+
+void ArrayBase::Slice(ArrayBase *outResult,int inPos,int inEnd)
+{
+   if (inPos<0)
+   {
+      inPos += length;
+      if (inPos<0)
+         inPos =0;
+   }
+   if (inEnd<0)
+      inEnd += length;
+   if (inEnd>length)
+      inEnd = length;
+   int n = inEnd - inPos;
+   if (n<=0)
+      outResult->resize(0);
+   else
+   {
+      outResult->resize(n);
+      int s = GetElementSize();
+      memcpy(outResult->mBase, mBase+inPos*s, n*s);
+      // todo - only needed if we have dirty pointer elements
+      HX_OBJ_WB_PESSIMISTIC_GET(outResult);
+   }
+}
+
+void ArrayBase::RemoveElement(int inPos)
+{
+   if (inPos<length)
+   {
+      int s = GetElementSize();
+      memmove(mBase + inPos*s, mBase+inPos*s + s, (length-inPos-1)*s );
+      resize(length-1);
+   }
+
+}
+
+void ArrayBase::Concat(ArrayBase *outResult,const char *inSecond,int inLen)
+{
+   char *ptr =  outResult->GetBase();
+   int n = length * GetElementSize();
+   memcpy(ptr,mBase,n);
+   ptr += n;
+   memcpy(ptr,inSecond,inLen*GetElementSize());
+   HX_OBJ_WB_PESSIMISTIC_GET(this);
+}
+
+
+String ArrayBase::joinArray(Array_obj<String> *inArray, String inSeparator)
+{
+   int length = inArray->length;
+   if (length==0)
+      return HX_CSTRING("");
+
+   int len = 0;
+   bool isWChar = false;
+   for(int i=0;i<length;i++)
+   {
+      String strI = inArray->__unsafe_get(i);
+      if (strI.raw_ptr())
+      {
+         len += strI.length;
+         #ifdef HX_SMART_STRINGS
+         if (strI.isUTF16Encoded())
+            isWChar = true;
+         #endif
+      }
+      else
+         len += 4;
+   }
+
+   len += (length-1) * inSeparator.length;
+   #ifdef HX_SMART_STRINGS
+   bool sepIsWide = inSeparator.isUTF16Encoded();
+   if (isWChar || sepIsWide)
+   {
+      char16_t *buf = String::allocChar16Ptr(len);
+      int pos = 0;
+      bool separated = inSeparator.length>0;
+
+      for(int i=0;i<length;i++)
+      {
+         String strI = inArray->__unsafe_get(i);
+         if (!strI.raw_ptr())
+         {
+            memcpy(buf+pos,u"null",8);
+            pos+=4;
+         }
+         else if(strI.length==0)
+         {
+            // ignore
+         }
+         else if (strI.isUTF16Encoded())
+         {
+            memcpy(buf+pos,strI.raw_wptr(),strI.length*sizeof(char16_t));
+            pos += strI.length;
+         }
+         else
+         {
+            const char *ptr = strI.raw_ptr();
+            for(int c=0;c<strI.length;c++)
+               buf[pos++] = ptr[c];
+         }
+
+         if (separated && (i+1<length) )
+         {
+            if (sepIsWide)
+            {
+               memcpy(buf+pos,inSeparator.raw_ptr(),inSeparator.length*sizeof(char16_t));
+               pos += inSeparator.length;
+            }
+            else
+            {
+               const char *ptr = inSeparator.raw_ptr();
+               for(int c=0;c<inSeparator.length;c++)
+                  buf[pos++] = ptr[c];
+            }
+         }
+      }
+      buf[len] = '\0';
+
+      String result(buf,len);
+      return result;
+   }
+   #endif
+   {
+      char *buf = hx::NewString(len);
+
+      int pos = 0;
+      bool separated = inSeparator.length>0;
+      for(int i=0;i<length;i++)
+      {
+         String strI = inArray->__unsafe_get(i);
+         if (!strI.raw_ptr())
+         {
+            memcpy(buf+pos,"null",4);
+            pos+=4;
+         }
+         else
+         {
+            memcpy(buf+pos,strI.raw_ptr(),strI.length*sizeof(char));
+            pos += strI.length;
+         }
+         if (separated && (i+1<length) )
+         {
+            memcpy(buf+pos,inSeparator.raw_ptr(),inSeparator.length*sizeof(char));
+            pos += inSeparator.length;
+         }
+      }
+      buf[len] = '\0';
+
+      return String(buf,len);
+   }
+}
+
+
+int _hx_toString_depth = 0;
+String ArrayBase::joinArray(ArrayBase *inBase, String inSeparator)
+{
+   if (_hx_toString_depth >= 5)
+      return HX_CSTRING("...");
+   int length = inBase->length;
+   if (length==0)
+      return HX_CSTRING("");
+
+   Array<String> stringArray = Array_obj<String>::__new(length, length);
+   _hx_toString_depth++;
+   try
+   {
+      for(int i=0;i<length;i++)
+         stringArray->__unsafe_set(i, inBase->ItemString(i));
+      _hx_toString_depth--;
+   }
+   catch (...)
+   {
+      _hx_toString_depth--;
+      throw;
+   }
+
+   return stringArray->join(inSeparator);
+}
+
+template<typename T>
+struct ArrayBaseSorter
+{
+   ArrayBaseSorter(T *inArray, Dynamic inFunc)
+   {
+      mFunc = inFunc;
+      mArray = inArray;
+   }
+
+   bool operator()(int inA, int inB)
+      { return mFunc(mArray[inA], mArray[inB])->__ToInt() < 0; }
+
+   Dynamic mFunc;
+   T*      mArray;
+};
+
+template<typename T,typename STORE>
+void TArraySortLen(T *inArray, int inLength, Dynamic inSorter)
+{
+   std::vector<STORE> index(inLength);
+   for(int i=0;i<inLength;i++)
+      index[i] = (STORE)i;
+
+   std::stable_sort(index.begin(), index.end(), ArrayBaseSorter<T>(inArray,inSorter) );
+
+   // Put the results back ...
+   for(int i=0;i<inLength;i++)
+   {
+      int from = index[i];
+      while(from < i)
+         from = index[from];
+      if (from!=i)
+      {
+         std::swap(inArray[i],inArray[from]);
+         index[i] = from;
+      }
+   }
+}
+
+template<typename T>
+void TArraySort(T *inArray, int inLength, Dynamic inSorter)
+{
+   if (inLength<2)
+      return;
+   if (inLength<=256)
+      TArraySortLen<T,unsigned char >(inArray, inLength, inSorter);
+   else if (inLength<=65536)
+      TArraySortLen<T,unsigned short >(inArray, inLength, inSorter);
+   else
+      TArraySortLen<T,unsigned int >(inArray, inLength, inSorter);
+}
+
+void ArrayBase::safeSort(Dynamic inSorter, bool inIsString)
+{
+   if (inIsString)
+      TArraySort((String *)mBase, length,inSorter);
+   else
+      TArraySort((Dynamic *)mBase, length,inSorter);
+}
+
+
+
+#ifdef HXCPP_VISIT_ALLOCS
+#define ARRAY_VISIT_FUNC \
+    void __Visit(hx::VisitContext *__inCtx) { HX_VISIT_MEMBER(mThis); }
+#else
+#define ARRAY_VISIT_FUNC
+#endif
+
+#define DEFINE_ARRAY_FUNC(ret,func,array_list,dynamic_arg_list,arg_list,ARG_C) \
+struct ArrayBase_##func : public hx::Object \
+{ \
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdClosure }; \
+   bool __IsFunction() const { return true; } \
+   ArrayBase *mThis; \
+   ArrayBase_##func(ArrayBase *inThis) : mThis(inThis) { } \
+   String toString() const{ return HX_CSTRING(#func) ; } \
+   String __ToString() const{ return HX_CSTRING(#func) ; } \
+   int __GetType() const { return vtFunction; } \
+   void *__GetHandle() const { return mThis; } \
+   int __ArgCount() const { return ARG_C; } \
+   void __Mark(hx::MarkContext *__inCtx) { HX_MARK_MEMBER(mThis); } \
+   ARRAY_VISIT_FUNC \
+   Dynamic __Run(const Array<Dynamic> &inArgs) \
+   { \
+      ret mThis->__##func(array_list); return Dynamic(); \
+   } \
+   Dynamic __run(dynamic_arg_list) \
+   { \
+      ret mThis->__##func(arg_list); return Dynamic(); \
+   } \
+   int __Compare(const hx::Object *inRHS) const \
+   { \
+      if (!dynamic_cast<const ArrayBase_##func *>(inRHS)) return -1; \
+      return (mThis==inRHS->__GetHandle() ? 0 : -1); \
+   } \
+}; \
+Dynamic ArrayBase::func##_dyn()  { return new ArrayBase_##func(this);  }
+
+
+#define DEFINE_ARRAY_FUNC0(ret,func) DEFINE_ARRAY_FUNC(ret,func,HX_ARR_LIST0,HX_DYNAMIC_ARG_LIST0,HX_ARG_LIST0,0)
+#define DEFINE_ARRAY_FUNC1(ret,func) DEFINE_ARRAY_FUNC(ret,func,HX_ARR_LIST1,HX_DYNAMIC_ARG_LIST1,HX_ARG_LIST1,1)
+#define DEFINE_ARRAY_FUNC2(ret,func) DEFINE_ARRAY_FUNC(ret,func,HX_ARR_LIST2,HX_DYNAMIC_ARG_LIST2,HX_ARG_LIST2,2)
+#define DEFINE_ARRAY_FUNC3(ret,func) DEFINE_ARRAY_FUNC(ret,func,HX_ARR_LIST3,HX_DYNAMIC_ARG_LIST3,HX_ARG_LIST3,3)
+#define DEFINE_ARRAY_FUNC4(ret,func) DEFINE_ARRAY_FUNC(ret,func,HX_ARR_LIST4,HX_DYNAMIC_ARG_LIST4,HX_ARG_LIST4,4)
+
+
+DEFINE_ARRAY_FUNC1(,__SetSize);
+DEFINE_ARRAY_FUNC1(,__SetSizeExact);
+DEFINE_ARRAY_FUNC2(,insert);
+DEFINE_ARRAY_FUNC0(,reverse);
+DEFINE_ARRAY_FUNC1(,sort);
+DEFINE_ARRAY_FUNC1(,unshift);
+DEFINE_ARRAY_FUNC4(,blit);
+DEFINE_ARRAY_FUNC2(,zero);
+DEFINE_ARRAY_FUNC1(,resize);
+DEFINE_ARRAY_FUNC1(return,concat);
+DEFINE_ARRAY_FUNC0(return,iterator);
+DEFINE_ARRAY_FUNC0(return,keyValueIterator);
+DEFINE_ARRAY_FUNC1(return,join);
+DEFINE_ARRAY_FUNC0(return,pop);
+DEFINE_ARRAY_FUNC0(return,copy);
+DEFINE_ARRAY_FUNC1(return,push);
+DEFINE_ARRAY_FUNC1(return,contains);
+DEFINE_ARRAY_FUNC1(return,remove);
+DEFINE_ARRAY_FUNC1(return,removeAt);
+DEFINE_ARRAY_FUNC2(return,indexOf);
+DEFINE_ARRAY_FUNC2(return,lastIndexOf);
+DEFINE_ARRAY_FUNC0(return,shift);
+DEFINE_ARRAY_FUNC2(return,slice);
+DEFINE_ARRAY_FUNC2(return,splice);
+DEFINE_ARRAY_FUNC0(return,toString);
+DEFINE_ARRAY_FUNC1(return,map);
+DEFINE_ARRAY_FUNC1(return,filter);
+DEFINE_ARRAY_FUNC1(return,__unsafe_get);
+DEFINE_ARRAY_FUNC2(return,__unsafe_set);
+DEFINE_ARRAY_FUNC1(return,memcmp);
+
+
+
+
+hx::Val ArrayBase::__Field(const String &inString, hx::PropertyAccess inCallProp)
+{
+   if (inString==HX_CSTRING("length")) return (int)size();
+   if (inString==HX_CSTRING("concat")) return concat_dyn();
+   if (inString==HX_CSTRING("insert")) return insert_dyn();
+   if (inString==HX_CSTRING("copy")) return copy_dyn();
+   if (inString==HX_CSTRING("iterator")) return iterator_dyn();
+   if (inString==HX_CSTRING("keyValueIterator")) return keyValueIterator_dyn();
+   if (inString==HX_CSTRING("join")) return join_dyn();
+   if (inString==HX_CSTRING("pop")) return pop_dyn();
+   if (inString==HX_CSTRING("push")) return push_dyn();
+   if (inString==HX_CSTRING("contains")) return contains_dyn();
+   if (inString==HX_CSTRING("remove")) return remove_dyn();
+   if (inString==HX_CSTRING("removeAt")) return removeAt_dyn();
+   if (inString==HX_CSTRING("indexOf")) return indexOf_dyn();
+   if (inString==HX_CSTRING("lastIndexOf")) return lastIndexOf_dyn();
+   if (inString==HX_CSTRING("reverse")) return reverse_dyn();
+   if (inString==HX_CSTRING("shift")) return shift_dyn();
+   if (inString==HX_CSTRING("splice")) return splice_dyn();
+   if (inString==HX_CSTRING("slice")) return slice_dyn();
+   if (inString==HX_CSTRING("sort")) return sort_dyn();
+   if (inString==HX_CSTRING("toString")) return toString_dyn();
+   if (inString==HX_CSTRING("unshift")) return unshift_dyn();
+   if (inString==HX_CSTRING("filter")) return filter_dyn();
+   if (inString==HX_CSTRING("map")) return map_dyn();
+   if (inString==HX_CSTRING("__SetSize")) return __SetSize_dyn();
+   if (inString==HX_CSTRING("__SetSizeExact")) return __SetSizeExact_dyn();
+   if (inString==HX_CSTRING("__unsafe_get")) return __unsafe_get_dyn();
+   if (inString==HX_CSTRING("__unsafe_set")) return __unsafe_set_dyn();
+   if (inString==HX_CSTRING("blit")) return blit_dyn();
+   if (inString==HX_CSTRING("zero")) return zero_dyn();
+   if (inString==HX_CSTRING("memcmp")) return memcmp_dyn();
+   if (inString==HX_CSTRING("_hx_storeType")) return (int)getStoreType();
+   if (inString==HX_CSTRING("_hx_elementSize")) return (int)GetElementSize();
+   if (inString==HX_CSTRING("_hx_pointer")) return cpp::CreateDynamicPointer((void *)mBase);
+   if (inString==HX_CSTRING("resize")) return resize_dyn();
+   return null();
+}
+
+
+static String sArrayFields[] = {
+   HX_CSTRING("length"),
+   HX_CSTRING("concat"),
+   HX_CSTRING("insert"),
+   HX_CSTRING("iterator"),
+   HX_CSTRING("keyValueIterator"),
+   HX_CSTRING("join"),
+   HX_CSTRING("copy"),
+   HX_CSTRING("pop"),
+   HX_CSTRING("push"),
+   HX_CSTRING("contains"),
+   HX_CSTRING("remove"),
+   HX_CSTRING("removeAt"),
+   HX_CSTRING("indexOf"),
+   HX_CSTRING("lastIndexOf"),
+   HX_CSTRING("reverse"),
+   HX_CSTRING("shift"),
+   HX_CSTRING("slice"),
+   HX_CSTRING("splice"),
+   HX_CSTRING("sort"),
+   HX_CSTRING("toString"),
+   HX_CSTRING("unshift"),
+   HX_CSTRING("filter"),
+   HX_CSTRING("map"),
+   HX_CSTRING("resize"),
+   String(null())
+};
+
+
+
+// TODO;
+hx::Class ArrayBase::__mClass;
+
+Dynamic ArrayCreateEmpty() { return new Array<Dynamic>(0,0); }
+Dynamic ArrayCreateArgs(DynamicArray inArgs)
+{
+   return inArgs->__copy();
+}
+
+static bool ArrayCanCast(hx::Object *inInstance)
+{
+   return inInstance->__GetClass().mPtr == ArrayBase::__mClass.mPtr;
+}
+
+void ArrayBase::__boot()
+{
+   Static(__mClass) = hx::_hx_RegisterClass(HX_CSTRING("Array"),ArrayCanCast,sNone,sArrayFields,
+                                    ArrayCreateEmpty,ArrayCreateArgs,0,0);
+}
+
+
+
+bool DynamicEq(const Dynamic &a, const Dynamic &b)
+{
+   // ? return hx::IsInstanceEq(a,b);
+   return hx::IsEq(a,b);
+}
+
+
+
+// -------- ArrayIterator -------------------------------------
+
+} // End namespace hx
+
+
+namespace cpp
+{
+HX_DEFINE_DYNAMIC_FUNC0(IteratorBase,hasNext,return)
+HX_DEFINE_DYNAMIC_FUNC0(IteratorBase,_dynamicNext,return)
+
+Dynamic IteratorBase::next_dyn()
+{
+   return hx::CreateMemberFunction0("next",this,__IteratorBase_dynamicNext);
+}
+
+hx::Val IteratorBase::__Field(const String &inString, hx::PropertyAccess inCallProp)
+{
+   if (inString==HX_CSTRING("hasNext")) return hasNext_dyn();
+   if (inString==HX_CSTRING("next")) return _dynamicNext_dyn();
+   return null();
+}
+}
+
+
+#ifdef HX_VARRAY_DEFINED
+// -------- VirtualArray -------------------------------------
+
+namespace cpp
+{
+
+
+
+#define DEFINE_VARRAY_FUNC(ret, func,array_list,dynamic_arg_list,arg_list,ARG_C) \
+struct VirtualArray_##func : public hx::Object \
+{ \
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdClosure }; \
+   bool __IsFunction() const { return true; } \
+   VirtualArray mThis; \
+   VirtualArray_##func(VirtualArray inThis) : mThis(inThis) { \
+      HX_OBJ_WB_NEW_MARKED_OBJECT(this); \
+   } \
+   String toString() const{ return HX_CSTRING(#func) ; } \
+   String __ToString() const{ return HX_CSTRING(#func) ; } \
+   int __GetType() const { return vtFunction; } \
+   void *__GetHandle() const { return mThis.mPtr; } \
+   int __ArgCount() const { return ARG_C; } \
+   void __Mark(hx::MarkContext *__inCtx) { HX_MARK_MEMBER(mThis); } \
+   ARRAY_VISIT_FUNC \
+   Dynamic __Run(const Array<Dynamic> &inArgs) \
+   { \
+      ret mThis->func(array_list); return Dynamic(); \
+   } \
+   Dynamic __run(dynamic_arg_list) \
+   { \
+      ret mThis->func(arg_list); return Dynamic(); \
+   } \
+}; \
+Dynamic VirtualArray_obj::func##_dyn()  { return new VirtualArray_##func(this);  }
+
+
+#define DEFINE_VARRAY_FUNC0(ret,func) DEFINE_VARRAY_FUNC(ret,func,HX_ARR_LIST0,HX_DYNAMIC_ARG_LIST0,HX_ARG_LIST0,0)
+#define DEFINE_VARRAY_FUNC1(ret,func) DEFINE_VARRAY_FUNC(ret,func,HX_ARR_LIST1,HX_DYNAMIC_ARG_LIST1,HX_ARG_LIST1,1)
+#define DEFINE_VARRAY_FUNC2(ret,func) DEFINE_VARRAY_FUNC(ret,func,HX_ARR_LIST2,HX_DYNAMIC_ARG_LIST2,HX_ARG_LIST2,2)
+#define DEFINE_VARRAY_FUNC3(ret,func) DEFINE_VARRAY_FUNC(ret,func,HX_ARR_LIST3,HX_DYNAMIC_ARG_LIST3,HX_ARG_LIST3,3)
+#define DEFINE_VARRAY_FUNC4(ret,func) DEFINE_VARRAY_FUNC(ret,func,HX_ARR_LIST4,HX_DYNAMIC_ARG_LIST4,HX_ARG_LIST4,4)
+
+
+DEFINE_VARRAY_FUNC1(return,concat);
+DEFINE_VARRAY_FUNC2(,insert);
+DEFINE_VARRAY_FUNC0(return,iterator);
+DEFINE_VARRAY_FUNC0(return,keyValueIterator);
+DEFINE_VARRAY_FUNC1(return,join);
+DEFINE_VARRAY_FUNC0(return,pop);
+DEFINE_VARRAY_FUNC0(return,copy);
+DEFINE_VARRAY_FUNC1(return,push);
+DEFINE_VARRAY_FUNC1(return,contains);
+DEFINE_VARRAY_FUNC1(return,remove);
+DEFINE_VARRAY_FUNC1(return,removeAt);
+DEFINE_VARRAY_FUNC2(return,indexOf);
+DEFINE_VARRAY_FUNC2(return,lastIndexOf);
+DEFINE_VARRAY_FUNC0(,reverse);
+DEFINE_VARRAY_FUNC0(return,shift);
+DEFINE_VARRAY_FUNC2(return,slice);
+DEFINE_VARRAY_FUNC2(return,splice);
+DEFINE_VARRAY_FUNC1(,sort);
+DEFINE_VARRAY_FUNC0(return,toString);
+DEFINE_VARRAY_FUNC1(,unshift);
+DEFINE_VARRAY_FUNC1(return,map);
+DEFINE_VARRAY_FUNC1(return,filter);
+DEFINE_VARRAY_FUNC1(,__SetSize);
+DEFINE_VARRAY_FUNC1(,__SetSizeExact);
+DEFINE_VARRAY_FUNC2(,zero);
+DEFINE_VARRAY_FUNC1(,memcmp);
+DEFINE_VARRAY_FUNC1(return,__unsafe_get);
+DEFINE_VARRAY_FUNC2(return,__unsafe_set);
+DEFINE_VARRAY_FUNC4(,blit);
+DEFINE_VARRAY_FUNC1(,resize);
+
+
+
+
+int VirtualArray_obj::__Compare(const hx::Object *inRHS) const
+{
+   if (inRHS->__GetType()!=vtArray)
+      return -1;
+   ArrayCommon *common = (ArrayCommon *)inRHS;
+   hx::Object *a = const_cast<VirtualArray_obj *>(this)->__GetRealObject();
+   hx::Object *b = common->__GetRealObject();
+   return a<b ? -1 : a>b;
+}
+
+Dynamic VirtualArray_obj::__GetItem(int inIndex) const
+{
+   checkBase();
+   if (store==hx::arrayEmpty || inIndex<0 || inIndex>=get_length()) return
+      null();
+   return base->__GetItem(inIndex);
+}
+
+Dynamic VirtualArray_obj::__SetItem(int inIndex,Dynamic inValue)
+{
+   checkBase();
+
+   if (store!=hx::arrayFixed)
+   {
+      if (inIndex>(store==hx::arrayEmpty ? 0 : (int)base->length) )
+         EnsureObjectStorage();
+      else
+         EnsureStorage(inValue);
+   }
+
+   base->__SetItem(inIndex,inValue);
+   return inValue;
+}
+
+hx::Val VirtualArray_obj::__Field(const String &inString, hx::PropertyAccess inCallProp)
+{
+   if (inString==HX_CSTRING("length")) return (int)get_length();
+   if (inString==HX_CSTRING("concat")) return concat_dyn();
+   if (inString==HX_CSTRING("insert")) return insert_dyn();
+   if (inString==HX_CSTRING("copy")) return copy_dyn();
+   if (inString==HX_CSTRING("iterator")) return iterator_dyn();
+   if (inString==HX_CSTRING("keyValueIterator")) return keyValueIterator_dyn();
+   if (inString==HX_CSTRING("join")) return join_dyn();
+   if (inString==HX_CSTRING("pop")) return pop_dyn();
+   if (inString==HX_CSTRING("push")) return push_dyn();
+   if (inString==HX_CSTRING("contains")) return contains_dyn();
+   if (inString==HX_CSTRING("remove")) return remove_dyn();
+   if (inString==HX_CSTRING("removeAt")) return removeAt_dyn();
+   if (inString==HX_CSTRING("indexOf")) return indexOf_dyn();
+   if (inString==HX_CSTRING("lastIndexOf")) return lastIndexOf_dyn();
+   if (inString==HX_CSTRING("reverse")) return reverse_dyn();
+   if (inString==HX_CSTRING("shift")) return shift_dyn();
+   if (inString==HX_CSTRING("splice")) return splice_dyn();
+   if (inString==HX_CSTRING("slice")) return slice_dyn();
+   if (inString==HX_CSTRING("sort")) return sort_dyn();
+   if (inString==HX_CSTRING("toString")) return toString_dyn();
+   if (inString==HX_CSTRING("unshift")) return unshift_dyn();
+   if (inString==HX_CSTRING("filter")) return filter_dyn();
+   if (inString==HX_CSTRING("map")) return map_dyn();
+   if (inString==HX_CSTRING("__SetSize")) return __SetSize_dyn();
+   if (inString==HX_CSTRING("__SetSizeExact")) return __SetSizeExact_dyn();
+   if (inString==HX_CSTRING("__unsafe_get")) return __unsafe_get_dyn();
+   if (inString==HX_CSTRING("__unsafe_set")) return __unsafe_set_dyn();
+   if (inString==HX_CSTRING("blit")) return blit_dyn();
+   if (inString==HX_CSTRING("zero")) return zero_dyn();
+   if (inString==HX_CSTRING("memcmp")) return memcmp_dyn();
+   if (inString==HX_CSTRING("resize")) return resize_dyn();
+
+   if (inString==HX_CSTRING("_hx_storeType"))
+   {
+      if (!base)
+         return -1;
+      return (int)base->getStoreType();
+   }
+   if (inString==HX_CSTRING("_hx_elementSize"))
+   {
+      if (!base)
+         return 0;
+      return (int)base->GetElementSize();
+   }
+   if (inString==HX_CSTRING("_hx_pointer"))
+   {
+      if (!base)
+         return cpp::CreateDynamicPointer((void *)0);
+      else
+         return cpp::CreateDynamicPointer((void *)base->GetBase());
+   }
+
+
+   return null();
+
+}
+
+
+hx::Class VirtualArray_obj::__GetClass() const { return ArrayBase::__mClass; }
+String VirtualArray_obj::toString()
+{
+   if (!base)
+   {
+      if (store==arrayEmpty)
+         return HX_CSTRING("[]");
+      return HX_CSTRING("null");
+   }
+   return base->toString();
+
+}
+
+void VirtualArray_obj::EnsureArrayStorage(ArrayStore inStore)
+{
+   switch(inStore)
+   {
+      case arrayFixed:
+      case arrayNull:
+         // These should not happen
+         break;
+
+      case arrayEmpty:
+         EnsureBase();
+         break;
+
+      case arrayBool:  EnsureBoolStorage(); break;
+      case arrayInt:  EnsureIntStorage(); break;
+      case arrayFloat:  EnsureFloatStorage(); break;
+      case arrayString:  EnsureStringStorage(); break;
+      case arrayInt64:  EnsureInt64Storage(); break;
+      case arrayObject:  EnsureObjectStorage(); break;
+   }
+}
+
+void VirtualArray_obj::EnsureArrayStorage(VirtualArray inValue)
+{
+   if (store!=arrayFixed)
+   {
+      if (inValue->store==arrayFixed)
+      {
+         EnsureArrayStorage(inValue->base->getStoreType());
+         store = arrayFixed;
+      }
+      else
+      {
+         EnsureArrayStorage(inValue->store);
+      }
+   }
+}
+
+void VirtualArray_obj::MakeIntArray()
+{
+   if (store==arrayEmpty && base )
+   {
+      int len = base->length;
+      base = new Array_obj<int>(len,len);
+   }
+   else if (!base)
+      base = new Array_obj<int>(0,0);
+   else
+   {
+      Array<int> result = Dynamic(base);
+      base = result.mPtr;
+   }
+   store = arrayInt;
+   HX_OBJ_WB_GET(this,base);
+}
+
+void VirtualArray_obj::MakeInt64Array()
+{
+   if (store==arrayEmpty && base)
+   {
+      int len = base->length;
+      base = new Array_obj< ::cpp::Int64>(len, len);
+   }
+   else if (!base)
+      base = new Array_obj< ::cpp::Int64>(0, 0);
+   else
+   {
+      Array< ::cpp::Int64> result = Dynamic(base);
+      base = result.mPtr;
+   }
+   store = arrayInt64;
+   HX_OBJ_WB_GET(this, base);
+}
+
+void VirtualArray_obj::MakeObjectArray()
+{
+   if (store==arrayEmpty && base )
+   {
+      // Actually, ok already.
+   }
+   else if (!base)
+   {
+      base = new Array_obj<Dynamic>(0,0);
+      HX_OBJ_WB_GET(this,base);
+   }
+   else
+   {
+      Array<Dynamic> result = Dynamic(base);
+      base = result.mPtr;
+      HX_OBJ_WB_GET(this,base);
+   }
+   store = arrayObject;
+}
+
+
+void VirtualArray_obj::MakeStringArray()
+{
+   if (store==arrayEmpty && base )
+   {
+      int len = base->length;
+      base = new Array_obj<String>(len,len);
+   }
+   else if (!base)
+      base = new Array_obj<String>(0,0);
+   else
+   {
+      Array<String> result = Dynamic(base);
+      base = result.mPtr;
+   }
+   store = arrayString;
+   HX_OBJ_WB_GET(this,base);
+}
+
+
+void VirtualArray_obj::MakeBoolArray()
+{
+   if (store==arrayEmpty && base )
+   {
+      int len = base->length;
+      base = new Array_obj<bool>(len,len);
+   }
+   else if (!base)
+      base = new Array_obj<bool>(0,0);
+   else
+   {
+      Array<bool> result = Dynamic(base);
+      base = result.mPtr;
+   }
+   store = arrayBool;
+   HX_OBJ_WB_GET(this,base);
+}
+
+
+void VirtualArray_obj::MakeFloatArray()
+{
+   if (store==arrayEmpty && base )
+   {
+      int len = base->length;
+      base = new Array_obj<Float>(len,len);
+   }
+   else if (!base)
+      base = new Array_obj<Float>(0,0);
+   else
+   {
+      Array<Float> result = Dynamic(base);
+      base = result.mPtr;
+   }
+   store = arrayFloat;
+   HX_OBJ_WB_GET(this,base);
+}
+
+void VirtualArray_obj::CreateEmptyArray(int inLen)
+{
+   base = new Array_obj<Dynamic>(inLen,inLen);
+   HX_OBJ_WB_GET(this,base);
+}
+
+void VirtualArray_obj::EnsureBase()
+{
+   if (!base)
+   {
+      base = new Array_obj<unsigned char>(0,0);
+      store = arrayInt;
+      HX_OBJ_WB_GET(this,base);
+   }
+}
+
+VirtualArray VirtualArray_obj::splice(int inPos, int len)
+{
+   if ( !base )
+      return new VirtualArray_obj();
+
+   Dynamic cut = base->__splice(inPos, len);
+
+   VirtualArray result = new VirtualArray_obj( dynamic_cast<cpp::ArrayBase_obj *>(cut.mPtr), false);
+   result->store = store;
+   return result;
+}
+
+VirtualArray VirtualArray_obj::map(Dynamic inFunc)
+{
+   VirtualArray result = new VirtualArray_obj( );
+   int len = get_length();
+   for(int i=0;i<len;i++)
+      result->push( inFunc(  base->__GetItem(i)  ) );
+   return result;
+}
+
+VirtualArray VirtualArray_obj::filter(Dynamic inFunc)
+{
+   if ( !base )
+      return new VirtualArray_obj();
+
+   Dynamic filtered = base->__filter(inFunc);
+
+   VirtualArray result = new VirtualArray_obj( dynamic_cast<cpp::ArrayBase_obj *>(filtered.mPtr), false);
+   result->store = store;
+   return result;
+}
+
+class EmptyIterator : public IteratorBase
+{
+public:
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdArrayIterator }; \
+
+   bool hasNext() { return false; }
+   Dynamic _dynamicNext() { return null(); }
+};
+
+
+
+Dynamic VirtualArray_obj::getEmptyIterator()
+{
+   return new EmptyIterator();
+}
+
+
+
+} // End namespace cpp
+
+Dynamic _hx_reslove_virtual_array(cpp::VirtualArray inArray)
+{
+   if (!inArray.mPtr)
+      return Dynamic();
+   if (inArray->store==hx::arrayFixed  || inArray->store==hx::arrayObject)
+      return inArray->__GetRealObject();
+   return inArray;
+}
+
+#endif
diff --git a/Sources/c_snikket/src/Date.cpp b/Sources/c_snikket/src/Date.cpp
new file mode 100644
index 0000000..83667f5
--- /dev/null
+++ b/Sources/c_snikket/src/Date.cpp
@@ -0,0 +1,231 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Date
+#include <Date.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_8e4589df03e4f3cc_26_new,"Date","new",0x9aa26240,"Date.new","/usr/local/lib/haxe/std/cpp/_std/Date.hx",26,0xd1a513ee)
+HX_LOCAL_STACK_FRAME(_hx_pos_8e4589df03e4f3cc_30_getTime,"Date","getTime",0x0cac7da3,"Date.getTime","/usr/local/lib/haxe/std/cpp/_std/Date.hx",30,0xd1a513ee)
+HX_LOCAL_STACK_FRAME(_hx_pos_8e4589df03e4f3cc_62_getUTCHours,"Date","getUTCHours",0x5f8b1fa1,"Date.getUTCHours","/usr/local/lib/haxe/std/cpp/_std/Date.hx",62,0xd1a513ee)
+HX_LOCAL_STACK_FRAME(_hx_pos_8e4589df03e4f3cc_66_getUTCMinutes,"Date","getUTCMinutes",0x1440e071,"Date.getUTCMinutes","/usr/local/lib/haxe/std/cpp/_std/Date.hx",66,0xd1a513ee)
+HX_LOCAL_STACK_FRAME(_hx_pos_8e4589df03e4f3cc_70_getUTCSeconds,"Date","getUTCSeconds",0x1aefffd1,"Date.getUTCSeconds","/usr/local/lib/haxe/std/cpp/_std/Date.hx",70,0xd1a513ee)
+HX_LOCAL_STACK_FRAME(_hx_pos_8e4589df03e4f3cc_74_getUTCFullYear,"Date","getUTCFullYear",0xf9f9315a,"Date.getUTCFullYear","/usr/local/lib/haxe/std/cpp/_std/Date.hx",74,0xd1a513ee)
+HX_LOCAL_STACK_FRAME(_hx_pos_8e4589df03e4f3cc_78_getUTCMonth,"Date","getUTCMonth",0x4086b812,"Date.getUTCMonth","/usr/local/lib/haxe/std/cpp/_std/Date.hx",78,0xd1a513ee)
+HX_LOCAL_STACK_FRAME(_hx_pos_8e4589df03e4f3cc_82_getUTCDate,"Date","getUTCDate",0xb1f9e59c,"Date.getUTCDate","/usr/local/lib/haxe/std/cpp/_std/Date.hx",82,0xd1a513ee)
+HX_LOCAL_STACK_FRAME(_hx_pos_8e4589df03e4f3cc_94_toString,"Date","toString",0xd2a372cc,"Date.toString","/usr/local/lib/haxe/std/cpp/_std/Date.hx",94,0xd1a513ee)
+HX_LOCAL_STACK_FRAME(_hx_pos_8e4589df03e4f3cc_98_now,"Date","now",0x9aa26af6,"Date.now","/usr/local/lib/haxe/std/cpp/_std/Date.hx",98,0xd1a513ee)
+HX_LOCAL_STACK_FRAME(_hx_pos_8e4589df03e4f3cc_105_fromTime,"Date","fromTime",0x44fd3cb7,"Date.fromTime","/usr/local/lib/haxe/std/cpp/_std/Date.hx",105,0xd1a513ee)
+
+void Date_obj::__construct(int year,int month,int day,int hour,int min,int sec){
+            	HX_STACKFRAME(&_hx_pos_8e4589df03e4f3cc_26_new)
+HXDLIN(  26)		this->mSeconds =  ::__hxcpp_new_date(year,month,day,hour,min,sec);
+            	}
+
+Dynamic Date_obj::__CreateEmpty() { return new Date_obj; }
+
+void *Date_obj::_hx_vtable = 0;
+
+Dynamic Date_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Date_obj > _hx_result = new Date_obj();
+	_hx_result->__construct(inArgs[0],inArgs[1],inArgs[2],inArgs[3],inArgs[4],inArgs[5]);
+	return _hx_result;
+}
+
+bool Date_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x018f7872;
+}
+
+Float Date_obj::getTime(){
+            	HX_STACKFRAME(&_hx_pos_8e4589df03e4f3cc_30_getTime)
+HXDLIN(  30)		return (this->mSeconds * ((Float)1000.0));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Date_obj,getTime,return )
+
+int Date_obj::getUTCHours(){
+            	HX_STACKFRAME(&_hx_pos_8e4589df03e4f3cc_62_getUTCHours)
+HXDLIN(  62)		return  ::__hxcpp_get_utc_hours(this->mSeconds);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Date_obj,getUTCHours,return )
+
+int Date_obj::getUTCMinutes(){
+            	HX_STACKFRAME(&_hx_pos_8e4589df03e4f3cc_66_getUTCMinutes)
+HXDLIN(  66)		return  ::__hxcpp_get_utc_minutes(this->mSeconds);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Date_obj,getUTCMinutes,return )
+
+int Date_obj::getUTCSeconds(){
+            	HX_STACKFRAME(&_hx_pos_8e4589df03e4f3cc_70_getUTCSeconds)
+HXDLIN(  70)		return  ::__hxcpp_get_utc_seconds(this->mSeconds);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Date_obj,getUTCSeconds,return )
+
+int Date_obj::getUTCFullYear(){
+            	HX_STACKFRAME(&_hx_pos_8e4589df03e4f3cc_74_getUTCFullYear)
+HXDLIN(  74)		return  ::__hxcpp_get_utc_year(this->mSeconds);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Date_obj,getUTCFullYear,return )
+
+int Date_obj::getUTCMonth(){
+            	HX_STACKFRAME(&_hx_pos_8e4589df03e4f3cc_78_getUTCMonth)
+HXDLIN(  78)		return  ::__hxcpp_get_utc_month(this->mSeconds);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Date_obj,getUTCMonth,return )
+
+int Date_obj::getUTCDate(){
+            	HX_STACKFRAME(&_hx_pos_8e4589df03e4f3cc_82_getUTCDate)
+HXDLIN(  82)		return  ::__hxcpp_get_utc_date(this->mSeconds);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Date_obj,getUTCDate,return )
+
+::String Date_obj::toString(){
+            	HX_STACKFRAME(&_hx_pos_8e4589df03e4f3cc_94_toString)
+HXDLIN(  94)		return  ::__hxcpp_to_string(this->mSeconds);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Date_obj,toString,return )
+
+ ::Date Date_obj::now(){
+            	HX_STACKFRAME(&_hx_pos_8e4589df03e4f3cc_98_now)
+HXDLIN(  98)		return ::Date_obj::fromTime((( (Float)( ::__hxcpp_date_now()) ) * ((Float)1000.0)));
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC0(Date_obj,now,return )
+
+ ::Date Date_obj::fromTime(Float t){
+            	HX_GC_STACKFRAME(&_hx_pos_8e4589df03e4f3cc_105_fromTime)
+HXLINE( 106)		 ::Date result =  ::Date_obj::__alloc( HX_CTX ,0,0,0,0,0,0);
+HXLINE( 107)		result->mSeconds = (t * ((Float)0.001));
+HXLINE( 108)		return result;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Date_obj,fromTime,return )
+
+
+Date_obj::Date_obj()
+{
+}
+
+::hx::Val Date_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 7:
+		if (HX_FIELD_EQ(inName,"getTime") ) { return ::hx::Val( getTime_dyn() ); }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"mSeconds") ) { return ::hx::Val( mSeconds ); }
+		if (HX_FIELD_EQ(inName,"toString") ) { return ::hx::Val( toString_dyn() ); }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"getUTCDate") ) { return ::hx::Val( getUTCDate_dyn() ); }
+		break;
+	case 11:
+		if (HX_FIELD_EQ(inName,"getUTCHours") ) { return ::hx::Val( getUTCHours_dyn() ); }
+		if (HX_FIELD_EQ(inName,"getUTCMonth") ) { return ::hx::Val( getUTCMonth_dyn() ); }
+		break;
+	case 13:
+		if (HX_FIELD_EQ(inName,"getUTCMinutes") ) { return ::hx::Val( getUTCMinutes_dyn() ); }
+		if (HX_FIELD_EQ(inName,"getUTCSeconds") ) { return ::hx::Val( getUTCSeconds_dyn() ); }
+		break;
+	case 14:
+		if (HX_FIELD_EQ(inName,"getUTCFullYear") ) { return ::hx::Val( getUTCFullYear_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+bool Date_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"now") ) { outValue = now_dyn(); return true; }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"fromTime") ) { outValue = fromTime_dyn(); return true; }
+	}
+	return false;
+}
+
+::hx::Val Date_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 8:
+		if (HX_FIELD_EQ(inName,"mSeconds") ) { mSeconds=inValue.Cast< Float >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void Date_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("mSeconds",92,75,59,82));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo Date_obj_sMemberStorageInfo[] = {
+	{::hx::fsFloat,(int)offsetof(Date_obj,mSeconds),HX_("mSeconds",92,75,59,82)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *Date_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String Date_obj_sMemberFields[] = {
+	HX_("mSeconds",92,75,59,82),
+	HX_("getTime",c3,7b,7f,1f),
+	HX_("getUTCHours",c1,ad,87,77),
+	HX_("getUTCMinutes",91,36,15,8f),
+	HX_("getUTCSeconds",f1,55,c4,95),
+	HX_("getUTCFullYear",3a,37,f0,f8),
+	HX_("getUTCMonth",32,46,83,58),
+	HX_("getUTCDate",7c,7b,c0,a7),
+	HX_("toString",ac,d0,6e,38),
+	::String(null()) };
+
+::hx::Class Date_obj::__mClass;
+
+static ::String Date_obj_sStaticFields[] = {
+	HX_("now",16,d9,53,00),
+	HX_("fromTime",97,9a,c8,aa),
+	::String(null())
+};
+
+void Date_obj::__register()
+{
+	Date_obj _hx_dummy;
+	Date_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("Date",4e,82,3c,2d);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &Date_obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(Date_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(Date_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< Date_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Date_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Date_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
diff --git a/Sources/c_snikket/src/Dynamic.cpp b/Sources/c_snikket/src/Dynamic.cpp
new file mode 100644
index 0000000..9feaa5c
--- /dev/null
+++ b/Sources/c_snikket/src/Dynamic.cpp
@@ -0,0 +1,637 @@
+#include <hxcpp.h>
+#include <math.h>
+#include <hxMath.h>
+#include <stdio.h>
+
+using namespace hx;
+
+
+
+extern hx::Class __StringClass;
+namespace hx
+{
+
+extern hx::Class hxEnumBase_obj__mClass;
+extern hx::Class Object__mClass;
+
+
+hx::Class __BoolClass;
+hx::Class __IntClass;
+hx::Class __FloatClass;
+hx::Class __Int64Class;
+hx::Class __PointerClass;
+hx::Class __VoidClass;
+#ifdef HXCPP_OBJC
+hx::Class __ObjcClass;
+#endif
+
+
+hx::Class &GetBoolClass() { return __BoolClass; }
+hx::Class &GetIntClass() { return __IntClass; }
+hx::Class &GetFloatClass() { return __FloatClass; }
+hx::Class &GetInt64Class() { return __Int64Class; }
+hx::Class &GetPointerClass() { return __PointerClass; }
+hx::Class &GetVoidClass() { return __VoidClass; }
+
+
+
+// --- "Simple" Data Objects ---------------------------------------------------
+
+
+Dynamic DynTrue;
+Dynamic DynFalse;
+
+class IntData : public hx::Object
+{
+public:
+   enum { _hx_ClassId = hx::clsIdInt };
+
+   bool _hx_isInstanceOf(int inClassId)
+   {
+      return inClassId==1 || inClassId==(int)_hx_ClassId || inClassId==(int)hx::clsIdFloat;
+   }
+
+
+   inline void *operator new( size_t inSize, hx::NewObjectType inAlloc=NewObjAlloc, const char *inName="Int")
+      { return hx::Object::operator new(inSize,inAlloc,inName); }
+   IntData(int inValue=0) : mValue(inValue) {};
+
+   hx::Class __GetClass() const { return __IntClass; }
+
+   virtual int __GetType() const { return vtInt; }
+
+   String toString() { return String(mValue); }
+   String __ToString() const { return String(mValue); }
+   double __ToDouble() const { return mValue; }
+   int __ToInt() const { return mValue; }
+   cpp::Int64 __ToInt64() const { return mValue; }
+
+   int __Compare(const hx::Object *inRHS) const
+   {
+      double diff = mValue - inRHS->__ToDouble();
+      return diff < 0 ? -1 : diff==0 ? 0 : 1;
+   }
+
+
+   int mValue;
+};
+
+
+class BoolData : public hx::Object
+{
+public:
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = clsIdBool };
+
+   inline void *operator new( size_t inSize, hx::NewObjectType inAlloc=NewObjAlloc,const char *inName="Bool")
+      { return hx::Object::operator new(inSize,inAlloc,"Bool"); }
+   BoolData(bool inValue=false) : mValue(inValue) {};
+
+   hx::Class __GetClass() const { return __BoolClass; }
+
+   virtual int __GetType() const { return vtBool; }
+
+   String __ToString() const { return mValue ? HX_CSTRING("true") : HX_CSTRING("false"); }
+   String toString() { return mValue ? HX_CSTRING("true") : HX_CSTRING("false"); }
+   double __ToDouble() const { return mValue; }
+   int __ToInt() const { return mValue; }
+
+   int __Compare(const hx::Object *inRHS) const
+   {
+      double diff = (double)mValue - inRHS->__ToDouble();
+      return diff < 0 ? -1 : diff==0 ? 0 : 1;
+   }
+
+
+   bool mValue;
+};
+
+
+
+class DoubleData : public hx::Object
+{
+public:
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdFloat };
+
+   inline void *operator new( size_t inSize, hx::NewObjectType inAlloc=NewObjAlloc,const char *inName="Float")
+      { return hx::Object::operator new(inSize,inAlloc,inName); }
+   DoubleData(double inValue=0) : mValue(inValue) {};
+
+   hx::Class __GetClass() const { return __FloatClass; }
+
+   virtual int __GetType() const { return vtFloat; }
+   String toString() { return String(mValue); }
+   String __ToString() const { return String(mValue); }
+   double __ToDouble() const { return mValue; }
+   int __ToInt() const { return (int)mValue; }
+   cpp::Int64 __ToInt64() const { return mValue; }
+
+   int __Compare(const hx::Object *inRHS) const
+   {
+      double rval = inRHS->__ToDouble();
+      if (rval==mValue)
+         return 0;
+
+      return mValue < rval ? -1 :  1;
+   }
+
+
+   double mValue;
+};
+
+
+class Int64Data : public hx::Object
+{
+public:
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdInt64 };
+
+   inline void *operator new( size_t inSize, hx::NewObjectType inAlloc=NewObjAlloc,const char *inName="Int64")
+      { return hx::Object::operator new(inSize,inAlloc,inName); }
+   Int64Data(cpp::Int64 inValue=0) : mValue(inValue) {};
+
+   hx::Class __GetClass() const { return __Int64Class; }
+
+   virtual int __GetType() const { return vtInt64; }
+   String toString() { return String(mValue); }
+   String __ToString() const { return String(mValue); }
+   double __ToDouble() const { return mValue; }
+   int __ToInt() const { return (int)mValue; }
+   cpp::Int64 __ToInt64() const { return mValue; }
+   void __GetFields(Array<String> &outFields)
+   {
+      outFields->push( HX_HCSTRING("hi","\x01","\x5b","\x00","\x00") );
+      outFields->push( HX_HCSTRING("lo","\x83","\x5e","\x00","\x00") );
+   }
+   hx::Val __Field(const String &inName, hx::PropertyAccess inCallProp)
+   {
+      if (HX_FIELD_EQ(inName,"hi") ) { return hx::Val( (int)(mValue>>32)); }
+      if (HX_FIELD_EQ(inName,"lo") ) { return hx::Val( (int)(mValue&0xffffffff)); }
+      return hx::Object::__Field(inName,inCallProp);
+   }
+   hx::Val __SetField(const String &inName,const hx::Val &inValue, hx::PropertyAccess inCallProp)
+   {
+      if (HX_FIELD_EQ(inName,"hi") )
+      {
+         mValue = (int)(mValue & 0xffffffff) | (cpp::Int64(inValue.Cast< int >())<<32);
+         return inValue;
+      }
+      if (HX_FIELD_EQ(inName,"lo") )
+      {
+         mValue = (mValue & (cpp::Int64(0xffffffff)<<32) ) | cpp::Int64( (unsigned int)(inValue.Cast< int >()));
+         return inValue;
+      }
+      return hx::Object::__SetField(inName,inValue,inCallProp);
+   }
+
+   int __Compare(const hx::Object *inRHS) const
+   {
+      double rval = inRHS->__ToInt64();
+      if (rval==mValue)
+         return 0;
+
+      return mValue < rval ? -1 :  1;
+   }
+
+
+
+
+    cpp::Int64 mValue;
+};
+
+
+
+class PointerData : public hx::Object
+{
+public:
+   inline void *operator new( size_t inSize, hx::NewObjectType inAlloc=NewObjAlloc,const char *inName="cpp.Pointer")
+      { return hx::Object::operator new(inSize,inAlloc,inName); }
+
+   PointerData(void *inValue) : mValue(inValue) {};
+
+    HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdPointer };
+
+   hx::Class __GetClass() const { return __PointerClass; }
+
+   // k_cpp_pointer
+   int __GetType() const { return vtAbstractBase + 2; }
+   void * __GetHandle() const { return mValue; }
+   String toString()
+   {
+      char buf[100];
+      snprintf(buf,sizeof(buf),"Pointer(%p)", mValue);
+      return String(buf);
+   }
+   String __ToString() const { return String(mValue); }
+
+   int __Compare(const hx::Object *inRHS) const
+   {
+      void *r = inRHS==0 ? 0 : inRHS->__GetHandle();
+      return mValue < r ? -1 : mValue==r ? 0 : 1;
+   }
+
+
+   void *mValue;
+};
+
+
+class StructData : public hx::Object
+{
+public:
+   inline void *operator new( size_t inSize, hx::NewObjectType inAlloc=NewObjContainer,const char *inName="cpp.Struct")
+      { return hx::Object::operator new(inSize,inAlloc,inName); }
+
+   StructData(const void *inValue,int inLength, cpp::DynamicHandlerFunc inHandler)
+   {
+      mLength= inLength;
+      mValue = InternalNew(inLength,false);
+      HX_OBJ_WB_GET(this, mValue);
+      memcpy(mValue, inValue, inLength);
+      mHandler = inHandler;
+   }
+
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdStruct };
+
+   hx::Class __GetClass() const { return __PointerClass; }
+
+   // k_cpp_struct
+   int __GetType() const { return vtAbstractBase + 3; }
+   void * __GetHandle() const { return mValue; }
+   String toString()
+   {
+      return __ToString();
+   }
+   String __ToString() const
+   {
+      String result;
+      mHandler(cpp::dhoToString, mValue, 0, &result );
+      return result;
+   }
+   const char *__CStr() const
+   {
+      const char *result = "unknown";
+      mHandler(cpp::dhoGetClassName, mValue, 0, &result );
+      return result;
+   }
+
+   int __Compare(const hx::Object *inRHS) const
+   {
+      if (!inRHS)
+         return 1;
+
+      int diff = __length() - inRHS->__length();
+      if (diff==0)
+         diff = __GetType() - inRHS->__GetType();
+      if (diff==0)
+         diff = memcmp( mValue, inRHS->__GetHandle(), mLength );
+
+      if (diff<0) return -1;
+      if (diff>0) return 1;
+      return 0;
+   }
+
+   int __length() const { return mLength; }
+
+   void __Mark(hx::MarkContext *__inCtx)
+   {
+      HX_MARK_ARRAY(mValue);
+   }
+
+   #ifdef HXCPP_VISIT_ALLOCS
+   void __Visit(hx::VisitContext *__inCtx)
+   {
+      HX_VISIT_ARRAY(mValue);
+   }
+   #endif
+
+   int  mLength;
+   void *mValue;
+   cpp::DynamicHandlerFunc mHandler;
+};
+
+
+
+
+
+}
+
+
+namespace cpp
+{
+// --- Pointer -------------------------------------------------
+
+Dynamic CreateDynamicPointer(void *inValue) {
+   if (!inValue)
+      return Dynamic();
+   return new hx::PointerData(inValue);
+}
+
+// --- Struct -------------------------------------------------
+
+Dynamic CreateDynamicStruct(const void *inValue, int inSize, DynamicHandlerFunc inFunc)
+
+{
+   return new hx::StructData(inValue,inSize,inFunc); }
+}
+
+
+
+// --- Dynamic -------------------------------------------------
+
+Dynamic sConstDynamicInts[256+1];
+
+static hx::Object *fromInt(int inVal)
+{
+   hx::Object *result = 0;
+   if (inVal>=-1 && inVal<256)
+   {
+      int idx = inVal+1;
+      result = sConstDynamicInts[idx].mPtr;
+      if (!result)
+         result = sConstDynamicInts[idx].mPtr = new (hx::NewObjConst)IntData(inVal);
+   }
+   else
+      result = (hx::Object *)new IntData(inVal);
+   return result;
+}
+
+Dynamic::Dynamic(bool inVal) : super( inVal ? hx::DynTrue.mPtr : hx::DynFalse.mPtr ) { }
+
+
+Dynamic::Dynamic(int inVal)
+{
+   mPtr = fromInt(inVal);
+}
+
+Dynamic::Dynamic(short inVal)
+{
+   mPtr = fromInt(inVal);
+}
+
+#if !defined(__GNUC__) || defined(__MINGW32__) || (defined(__WORDSIZE) && (__WORDSIZE != 64))
+Dynamic::Dynamic(unsigned long inVal)
+{
+   mPtr = fromInt(inVal);
+}
+Dynamic::Dynamic(long inVal)
+{
+   mPtr = fromInt(inVal);
+}
+#endif
+
+Dynamic::Dynamic(unsigned int inVal)
+{
+   mPtr = fromInt(inVal);
+}
+
+Dynamic::Dynamic(unsigned short inVal)
+{
+   mPtr = fromInt(inVal);
+}
+
+Dynamic::Dynamic(unsigned char inVal)
+{
+   mPtr = fromInt(inVal);
+}
+
+Dynamic::Dynamic(signed char inVal)
+{
+   mPtr = fromInt(inVal);
+}
+
+
+
+Dynamic::Dynamic(double inVal)
+{
+   if ( (int)inVal==inVal && inVal>=-1 && inVal<256 )
+   {
+      int idx = inVal+1;
+      mPtr = sConstDynamicInts[idx].mPtr;
+      if (!mPtr)
+         mPtr = sConstDynamicInts[idx].mPtr = new (hx::NewObjConst)IntData(inVal);
+   }
+   else
+      mPtr = (hx::Object *)new DoubleData(inVal);
+}
+
+
+Dynamic::Dynamic(cpp::Int64 inVal)
+{
+   if ( (int)inVal==inVal && inVal>=-1 && inVal<256 )
+   {
+      int idx = inVal+1;
+      mPtr = sConstDynamicInts[idx].mPtr;
+      if (!mPtr)
+         mPtr = sConstDynamicInts[idx].mPtr = new (hx::NewObjConst)IntData(inVal);
+   }
+   else
+      mPtr = (hx::Object *)new Int64Data(inVal);
+}
+
+
+Dynamic::Dynamic(cpp::UInt64 inVal)
+{
+   if ( (int)inVal==inVal && inVal<256 )
+   {
+      int idx = inVal+1;
+      mPtr = sConstDynamicInts[idx].mPtr;
+      if (!mPtr)
+         mPtr = sConstDynamicInts[idx].mPtr = new (hx::NewObjConst)IntData(inVal);
+   }
+   else
+      mPtr = (hx::Object *)new Int64Data(inVal);
+}
+
+Dynamic::Dynamic(unsigned long inVal)
+{
+   if ( (int)inVal==inVal && inVal<256 )
+   {
+      int idx = inVal+1;
+      mPtr = sConstDynamicInts[idx].mPtr;
+      if (!mPtr)
+         mPtr = sConstDynamicInts[idx].mPtr = new (hx::NewObjConst)IntData(inVal);
+   }
+   else
+      mPtr = (hx::Object *)new Int64Data(inVal);
+}
+
+
+
+
+
+Dynamic::Dynamic(float inVal)
+{
+   mPtr = Dynamic( (double) inVal ).mPtr;
+}
+
+Dynamic::Dynamic(const cpp::CppInt32__ &inVal) :
+  super(  Dynamic(inVal.mValue).mPtr ) { }
+
+Dynamic::Dynamic(const String &inVal) :
+  super( inVal.raw_ptr() ? inVal.__ToObject() : 0 ) { }
+
+Dynamic::Dynamic(const HX_CHAR *inVal) :
+  super( inVal ? String(inVal).__ToObject() : 0 ) { }
+
+
+Dynamic Dynamic::operator+(const Dynamic &inRHS) const
+{
+   int t1 = mPtr ? mPtr->__GetType() : vtNull;
+   int t2 = inRHS.mPtr ? inRHS.mPtr->__GetType() : vtNull;
+
+   if ( (t1==vtInt || t1==vtFloat)  &&  (t2==vtInt || t2==vtFloat) )
+   {
+      return mPtr->__ToDouble() + inRHS.mPtr->__ToDouble();
+   }
+   if (!mPtr)
+      return String() + inRHS;
+   if (!inRHS.mPtr)
+      return *this + String();
+
+   return const_cast<hx::Object*>(mPtr)->toString() + const_cast<Dynamic&>(inRHS)->toString();
+}
+
+#define DYN_OP_ADD(TYPE) \
+Dynamic Dynamic::operator+(const TYPE &i) const \
+{ \
+   int t = mPtr ? mPtr->__GetType() : vtNull; \
+   if (t==vtString) \
+      return Cast<String>() + String(i); \
+   return Cast<double>() + i; \
+}
+
+DYN_OP_ADD(double)
+DYN_OP_ADD(float)
+DYN_OP_ADD(int)
+DYN_OP_ADD(unsigned int)
+DYN_OP_ADD(short)
+DYN_OP_ADD(unsigned short)
+DYN_OP_ADD(signed char)
+DYN_OP_ADD(unsigned char)
+DYN_OP_ADD(cpp::Int64)
+DYN_OP_ADD(cpp::UInt64)
+
+Dynamic Dynamic::operator+(const cpp::Variant &v) const
+{
+   int t = mPtr ? mPtr->__GetType() : vtNull;
+   if (t==vtString || v.type == cpp::Variant::typeString)
+      return Cast<String>() + v.asString();
+   return Cast<double>() + v.asDouble();
+}
+
+
+
+double Dynamic::operator%(const Dynamic &inRHS) const
+{
+   if (mPtr->__GetType()==vtInt && inRHS.mPtr->__GetType()==vtInt)
+      return mPtr->__ToInt() % inRHS->__ToInt();
+   double lhs = mPtr->__ToDouble();
+   double rhs = inRHS->__ToDouble();
+   int even = (int)(lhs/rhs);
+   double remain = lhs - even * rhs;
+   if (remain<0) remain += fabs(rhs);
+   return remain;
+}
+
+hx::IndexRef Dynamic::operator[](int inIndex)
+{
+   return hx::IndexRef(mPtr,inIndex);
+}
+
+
+void Dynamic::ThrowBadFunctionError()
+{
+   #ifdef HXCPP_DEBUGGER
+   NullReference("Function", true);
+   #endif
+   hx::Throw( HX_NULL_FUNCTION_POINTER );
+}
+
+#include <hx/DynamicImpl.h>
+
+namespace cpp
+{
+CppInt32__::CppInt32__(const Dynamic &inD) : mValue(inD->__ToInt()) { }
+}
+
+namespace hx {
+null BadCast()
+{
+   hx::Throw(HX_INVALID_CAST);
+   return null();
+}
+
+void InvalidInterface()
+{
+   hx::Throw(HX_INVALID_INTERFACE);
+}
+
+
+}
+
+
+static bool NoCast(hx::Object *) { return false; }
+static bool IsFloat(hx::Object *inPtr)
+{
+   return inPtr && (TCanCast<IntData>(inPtr) || TCanCast<DoubleData>(inPtr) || TCanCast<Int64Data>(inPtr) );
+}
+static bool IsInt64(hx::Object *inPtr)
+{
+   return inPtr && (TCanCast<Int64Data>(inPtr) || TCanCast<IntData>(inPtr));
+}
+
+static bool IsPointer(hx::Object *inPtr)
+{
+   return inPtr && inPtr->__GetType() >= vtAbstractBase;
+}
+
+static bool IsInt(hx::Object *inPtr)
+{
+   if (!inPtr)
+      return false;
+   if (TCanCast<IntData>(inPtr))
+      return true;
+   DoubleData *d = dynamic_cast<DoubleData *>(inPtr);
+   if (!d)
+   {
+      Int64Data *i64 = dynamic_cast<Int64Data *>(inPtr);
+      if (i64)
+      {
+         int val = i64->mValue;
+         return val==i64->mValue;
+      }
+      return false;
+   }
+   double val = d->__ToDouble();
+   return ((int)val == val);
+}
+
+static Dynamic createEmptyInt64()
+{
+   return new Int64Data();
+}
+
+static Dynamic createInt64(hx::DynamicArray inArgs)
+{
+   return new Int64Data();
+}
+
+void Dynamic::__boot()
+{
+   Static(__VoidClass) = hx::_hx_RegisterClass(HX_CSTRING("Void"),NoCast,sNone,sNone,0,0,0, 0, 0
+      #ifdef HXCPP_VISIT_ALLOCS
+      ,0
+      #endif
+   );
+   Static(__BoolClass) = hx::_hx_RegisterClass(HX_CSTRING("Bool"),TCanCast<BoolData>,sNone,sNone, 0,0, 0);
+   Static(__IntClass) = hx::_hx_RegisterClass(HX_CSTRING("Int"),IsInt,sNone,sNone,0,0, 0 );
+   Static(__FloatClass) = hx::_hx_RegisterClass(HX_CSTRING("Float"),IsFloat,sNone,sNone, 0,0,&__IntClass );
+   Static(__Int64Class) = hx::_hx_RegisterClass(HX_CSTRING("cpp::Int64"),IsInt64,sNone,sNone, 0,0,&__IntClass );
+   __Int64Class->mConstructEmpty = &createEmptyInt64;
+   __Int64Class->mConstructArgs = &createInt64;
+
+   Static(__PointerClass) = hx::_hx_RegisterClass(HX_CSTRING("cpp::Pointer"),IsPointer,sNone,sNone, 0,0,&__PointerClass );
+   DynTrue = Dynamic( new (hx::NewObjConst) hx::BoolData(true) );
+   DynFalse = Dynamic( new (hx::NewObjConst) hx::BoolData(false) );
+#ifdef HXCPP_OBJC
+   Static(__ObjcClass) = hx::_hx_RegisterClass(HX_CSTRING("objc::BoxedType"),IsPointer,sNone,sNone, 0,0,&__ObjcClass );
+#endif
+}
diff --git a/Sources/c_snikket/src/EReg.cpp b/Sources/c_snikket/src/EReg.cpp
new file mode 100644
index 0000000..f12470b
--- /dev/null
+++ b/Sources/c_snikket/src/EReg.cpp
@@ -0,0 +1,578 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_EReg
+#include <EReg.h>
+#endif
+#ifndef INCLUDED_Std
+#include <Std.h>
+#endif
+#ifndef INCLUDED_StringBuf
+#include <StringBuf.h>
+#endif
+#ifndef INCLUDED_haxe_Exception
+#include <haxe/Exception.h>
+#endif
+#ifndef INCLUDED_haxe_ValueException
+#include <haxe/ValueException.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_359fe5fd855fee60_28_new,"EReg","new",0x8b859e81,"EReg.new","/usr/local/lib/haxe/std/cpp/_std/EReg.hx",28,0x5a2fdacd)
+HX_LOCAL_STACK_FRAME(_hx_pos_359fe5fd855fee60_36_match,"EReg","match",0x18fda1a6,"EReg.match","/usr/local/lib/haxe/std/cpp/_std/EReg.hx",36,0x5a2fdacd)
+HX_LOCAL_STACK_FRAME(_hx_pos_359fe5fd855fee60_45_matched,"EReg","matched",0x8ce62f85,"EReg.matched","/usr/local/lib/haxe/std/cpp/_std/EReg.hx",45,0x5a2fdacd)
+HX_LOCAL_STACK_FRAME(_hx_pos_359fe5fd855fee60_62_matchedPos,"EReg","matchedPos",0x7007a70f,"EReg.matchedPos","/usr/local/lib/haxe/std/cpp/_std/EReg.hx",62,0x5a2fdacd)
+HX_LOCAL_STACK_FRAME(_hx_pos_359fe5fd855fee60_65_matchSub,"EReg","matchSub",0xbc75cb7a,"EReg.matchSub","/usr/local/lib/haxe/std/cpp/_std/EReg.hx",65,0x5a2fdacd)
+HX_LOCAL_STACK_FRAME(_hx_pos_359fe5fd855fee60_98_replace,"EReg","replace",0xae923ad5,"EReg.replace","/usr/local/lib/haxe/std/cpp/_std/EReg.hx",98,0x5a2fdacd)
+static const ::String _hx_array_data_2dda4a0f_8[] = {
+	HX_("$",24,00,00,00),
+};
+static const ::String _hx_array_data_2dda4a0f_9[] = {
+	HX_("$",24,00,00,00),
+};
+HX_LOCAL_STACK_FRAME(_hx_pos_359fe5fd855fee60_149_map,"EReg","map",0x8b84d8bd,"EReg.map","/usr/local/lib/haxe/std/cpp/_std/EReg.hx",149,0x5a2fdacd)
+
+void EReg_obj::__construct(::String r,::String opt){
+            	HX_STACKFRAME(&_hx_pos_359fe5fd855fee60_28_new)
+HXLINE(  29)		::Array< ::String > a = opt.split(HX_("g",67,00,00,00));
+HXLINE(  30)		this->global = (a->length > 1);
+HXLINE(  31)		if (this->global) {
+HXLINE(  32)			opt = a->join(HX_("",00,00,00,00));
+            		}
+HXLINE(  33)		this->r = _hx_regexp_new_options(r,opt);
+            	}
+
+Dynamic EReg_obj::__CreateEmpty() { return new EReg_obj; }
+
+void *EReg_obj::_hx_vtable = 0;
+
+Dynamic EReg_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< EReg_obj > _hx_result = new EReg_obj();
+	_hx_result->__construct(inArgs[0],inArgs[1]);
+	return _hx_result;
+}
+
+bool EReg_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x022d4033;
+}
+
+bool EReg_obj::match(::String s){
+            	HX_STACKFRAME(&_hx_pos_359fe5fd855fee60_36_match)
+HXLINE(  37)		bool p = _hx_regexp_match(this->r,s,0,s.length);
+HXLINE(  38)		if (p) {
+HXLINE(  39)			this->last = s;
+            		}
+            		else {
+HXLINE(  41)			this->last = null();
+            		}
+HXLINE(  42)		return p;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(EReg_obj,match,return )
+
+::String EReg_obj::matched(int n){
+            	HX_STACKFRAME(&_hx_pos_359fe5fd855fee60_45_matched)
+HXLINE(  46)		::String m = _hx_regexp_matched(this->r,n);
+HXLINE(  47)		return m;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(EReg_obj,matched,return )
+
+ ::Dynamic EReg_obj::matchedPos(){
+            	HX_STACKFRAME(&_hx_pos_359fe5fd855fee60_62_matchedPos)
+HXDLIN(  62)		return _hx_regexp_matched_pos(this->r,0);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(EReg_obj,matchedPos,return )
+
+bool EReg_obj::matchSub(::String s,int pos,::hx::Null< int >  __o_len){
+            		int len = __o_len.Default(-1);
+            	HX_STACKFRAME(&_hx_pos_359fe5fd855fee60_65_matchSub)
+HXLINE(  66)		int p;
+HXDLIN(  66)		if ((len < 0)) {
+HXLINE(  66)			p = (s.length - pos);
+            		}
+            		else {
+HXLINE(  66)			p = len;
+            		}
+HXDLIN(  66)		bool p1 = _hx_regexp_match(this->r,s,pos,p);
+HXLINE(  67)		if (p1) {
+HXLINE(  68)			this->last = s;
+            		}
+            		else {
+HXLINE(  70)			this->last = null();
+            		}
+HXLINE(  71)		return p1;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC3(EReg_obj,matchSub,return )
+
+::String EReg_obj::replace(::String s,::String by){
+            	HX_GC_STACKFRAME(&_hx_pos_359fe5fd855fee60_98_replace)
+HXLINE(  99)		 ::StringBuf b =  ::StringBuf_obj::__alloc( HX_CTX );
+HXLINE( 100)		int pos = 0;
+HXLINE( 101)		int len = s.length;
+HXLINE( 102)		::Array< ::String > a = by.split(HX_("$",24,00,00,00));
+HXLINE( 103)		bool first = true;
+HXLINE( 104)		while(_hx_regexp_match(this->r,s,pos,len)){
+HXLINE( 107)			 ::Dynamic p = _hx_regexp_matched_pos(this->r,0);
+HXLINE( 108)			bool _hx_tmp;
+HXDLIN( 108)			if (::hx::IsEq( p->__Field(HX_("len",d5,4b,52,00),::hx::paccDynamic),0 )) {
+HXLINE( 108)				_hx_tmp = !(first);
+            			}
+            			else {
+HXLINE( 108)				_hx_tmp = false;
+            			}
+HXDLIN( 108)			if (_hx_tmp) {
+HXLINE( 109)				if (::hx::IsEq( p->__Field(HX_("pos",94,5d,55,00),::hx::paccDynamic),s.length )) {
+HXLINE( 110)					goto _hx_goto_5;
+            				}
+HXLINE( 111)				 ::Dynamic p1 = p;
+HXDLIN( 111)				p1->__SetField(HX_("pos",94,5d,55,00),(p1->__Field(HX_("pos",94,5d,55,00),::hx::paccDynamic) + 1),::hx::paccDynamic);
+            			}
+HXLINE( 113)			{
+HXLINE( 113)				 ::Dynamic len1 = (( (int)(p->__Field(HX_("pos",94,5d,55,00),::hx::paccDynamic)) ) - pos);
+HXDLIN( 113)				if (::hx::IsNotNull( b->charBuf )) {
+HXLINE( 113)					b->flush();
+            				}
+HXDLIN( 113)				if (::hx::IsNull( b->b )) {
+HXLINE( 113)					b->b = ::Array_obj< ::String >::__new(1)->init(0,s.substr(pos,len1));
+            				}
+            				else {
+HXLINE( 113)					::Array< ::String > b1 = b->b;
+HXDLIN( 113)					b1->push(s.substr(pos,len1));
+            				}
+            			}
+HXLINE( 114)			if ((a->length > 0)) {
+HXLINE( 115)				::String x = a->__get(0);
+HXDLIN( 115)				if (::hx::IsNotNull( b->charBuf )) {
+HXLINE( 115)					b->flush();
+            				}
+HXDLIN( 115)				if (::hx::IsNull( b->b )) {
+HXLINE( 115)					b->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(x));
+            				}
+            				else {
+HXLINE( 115)					::Array< ::String > b2 = b->b;
+HXDLIN( 115)					b2->push(::Std_obj::string(x));
+            				}
+            			}
+HXLINE( 116)			int i = 1;
+HXLINE( 117)			while((i < a->length)){
+HXLINE( 118)				::String k = a->__get(i);
+HXLINE( 119)				 ::Dynamic c = k.charCodeAt(0);
+HXLINE( 121)				bool _hx_tmp1;
+HXDLIN( 121)				if (::hx::IsGreaterEq( c,49 )) {
+HXLINE( 121)					_hx_tmp1 = ::hx::IsLessEq( c,57 );
+            				}
+            				else {
+HXLINE( 121)					_hx_tmp1 = false;
+            				}
+HXDLIN( 121)				if (_hx_tmp1) {
+HXLINE( 122)					 ::Dynamic p2;
+HXDLIN( 122)					try {
+            						HX_STACK_CATCHABLE(::String, 0);
+            						HX_STACK_CATCHABLE( ::haxe::ValueException, 1);
+HXLINE( 122)						 ::Dynamic p3 = this->r;
+HXDLIN( 122)						p2 = _hx_regexp_matched_pos(p3,(::Std_obj::_hx_int(( (Float)(c) )) - 48));
+            					} catch( ::Dynamic _hx_e) {
+            						if (_hx_e.IsClass< ::String >() && _hx_e->toString()!=null() ){
+            							HX_STACK_BEGIN_CATCH
+            							::String e = _hx_e;
+HXLINE( 122)							p2 = null();
+            						}
+            						else if (_hx_e.IsClass<  ::haxe::ValueException >() ){
+            							HX_STACK_BEGIN_CATCH
+            							 ::haxe::ValueException _g = _hx_e;
+HXLINE( 122)							{
+HXLINE( 122)								null();
+            							}
+HXDLIN( 122)							if (::Std_obj::isOfType(_g->value,::hx::ClassOf< ::String >())) {
+HXLINE( 122)								p2 = null();
+            							}
+            							else {
+HXLINE( 122)								HX_STACK_DO_THROW(_g);
+            							}
+            						}
+            						else {
+            							HX_STACK_DO_THROW(_hx_e);
+            						}
+            					}
+HXLINE( 123)					if (::hx::IsNull( p2 )) {
+HXLINE( 124)						{
+HXLINE( 124)							if (::hx::IsNotNull( b->charBuf )) {
+HXLINE( 124)								b->flush();
+            							}
+HXDLIN( 124)							if (::hx::IsNull( b->b )) {
+HXLINE( 124)								b->b = ::Array_obj< ::String >::fromData( _hx_array_data_2dda4a0f_8,1);
+            							}
+            							else {
+HXLINE( 124)								b->b->push(HX_("$",24,00,00,00));
+            							}
+            						}
+HXLINE( 125)						{
+HXLINE( 125)							if (::hx::IsNotNull( b->charBuf )) {
+HXLINE( 125)								b->flush();
+            							}
+HXDLIN( 125)							if (::hx::IsNull( b->b )) {
+HXLINE( 125)								b->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(k));
+            							}
+            							else {
+HXLINE( 125)								::Array< ::String > b3 = b->b;
+HXDLIN( 125)								b3->push(::Std_obj::string(k));
+            							}
+            						}
+            					}
+            					else {
+HXLINE( 127)						{
+HXLINE( 127)							int pos1 = ( (int)(p2->__Field(HX_("pos",94,5d,55,00),::hx::paccDynamic)) );
+HXDLIN( 127)							 ::Dynamic len2 = p2->__Field(HX_("len",d5,4b,52,00),::hx::paccDynamic);
+HXDLIN( 127)							if (::hx::IsNotNull( b->charBuf )) {
+HXLINE( 127)								b->flush();
+            							}
+HXDLIN( 127)							if (::hx::IsNull( b->b )) {
+HXLINE( 127)								b->b = ::Array_obj< ::String >::__new(1)->init(0,s.substr(pos1,len2));
+            							}
+            							else {
+HXLINE( 127)								::Array< ::String > b4 = b->b;
+HXDLIN( 127)								b4->push(s.substr(pos1,len2));
+            							}
+            						}
+HXLINE( 128)						{
+HXLINE( 128)							 ::Dynamic len3 = (k.length - 1);
+HXDLIN( 128)							if (::hx::IsNotNull( b->charBuf )) {
+HXLINE( 128)								b->flush();
+            							}
+HXDLIN( 128)							if (::hx::IsNull( b->b )) {
+HXLINE( 128)								b->b = ::Array_obj< ::String >::__new(1)->init(0,k.substr(1,len3));
+            							}
+            							else {
+HXLINE( 128)								::Array< ::String > b5 = b->b;
+HXDLIN( 128)								b5->push(k.substr(1,len3));
+            							}
+            						}
+            					}
+            				}
+            				else {
+HXLINE( 130)					if (::hx::IsNull( c )) {
+HXLINE( 131)						{
+HXLINE( 131)							if (::hx::IsNotNull( b->charBuf )) {
+HXLINE( 131)								b->flush();
+            							}
+HXDLIN( 131)							if (::hx::IsNull( b->b )) {
+HXLINE( 131)								b->b = ::Array_obj< ::String >::fromData( _hx_array_data_2dda4a0f_9,1);
+            							}
+            							else {
+HXLINE( 131)								b->b->push(HX_("$",24,00,00,00));
+            							}
+            						}
+HXLINE( 132)						i = (i + 1);
+HXLINE( 133)						::String k2 = a->__get(i);
+HXLINE( 134)						bool _hx_tmp2;
+HXDLIN( 134)						if (::hx::IsNotNull( k2 )) {
+HXLINE( 134)							_hx_tmp2 = (k2.length > 0);
+            						}
+            						else {
+HXLINE( 134)							_hx_tmp2 = false;
+            						}
+HXDLIN( 134)						if (_hx_tmp2) {
+HXLINE( 135)							if (::hx::IsNotNull( b->charBuf )) {
+HXLINE( 135)								b->flush();
+            							}
+HXDLIN( 135)							if (::hx::IsNull( b->b )) {
+HXLINE( 135)								b->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(k2));
+            							}
+            							else {
+HXLINE( 135)								::Array< ::String > b6 = b->b;
+HXDLIN( 135)								b6->push(::Std_obj::string(k2));
+            							}
+            						}
+            					}
+            					else {
+HXLINE( 137)						::String x1 = (HX_("$",24,00,00,00) + k);
+HXDLIN( 137)						if (::hx::IsNotNull( b->charBuf )) {
+HXLINE( 137)							b->flush();
+            						}
+HXDLIN( 137)						if (::hx::IsNull( b->b )) {
+HXLINE( 137)							b->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(x1));
+            						}
+            						else {
+HXLINE( 137)							::Array< ::String > b7 = b->b;
+HXDLIN( 137)							b7->push(::Std_obj::string(x1));
+            						}
+            					}
+            				}
+HXLINE( 138)				i = (i + 1);
+            			}
+HXLINE( 140)			int tot = (( (int)((p->__Field(HX_("pos",94,5d,55,00),::hx::paccDynamic) + p->__Field(HX_("len",d5,4b,52,00),::hx::paccDynamic))) ) - pos);
+HXLINE( 141)			pos = (pos + tot);
+HXLINE( 142)			len = (len - tot);
+HXLINE( 143)			first = false;
+HXLINE( 104)			if (!(this->global)) {
+HXLINE( 104)				goto _hx_goto_5;
+            			}
+            		}
+            		_hx_goto_5:;
+HXLINE( 145)		{
+HXLINE( 145)			if (::hx::IsNotNull( b->charBuf )) {
+HXLINE( 145)				b->flush();
+            			}
+HXDLIN( 145)			if (::hx::IsNull( b->b )) {
+HXLINE( 145)				b->b = ::Array_obj< ::String >::__new(1)->init(0,s.substr(pos,len));
+            			}
+            			else {
+HXLINE( 145)				::Array< ::String > b8 = b->b;
+HXDLIN( 145)				b8->push(s.substr(pos,len));
+            			}
+            		}
+HXLINE( 146)		return b->toString();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(EReg_obj,replace,return )
+
+::String EReg_obj::map(::String s, ::Dynamic f){
+            	HX_GC_STACKFRAME(&_hx_pos_359fe5fd855fee60_149_map)
+HXLINE( 150)		int offset = 0;
+HXLINE( 151)		 ::StringBuf buf =  ::StringBuf_obj::__alloc( HX_CTX );
+HXLINE( 152)		do {
+HXLINE( 153)			if ((offset >= s.length)) {
+HXLINE( 154)				goto _hx_goto_10;
+            			}
+            			else {
+HXLINE( 155)				if (!(this->matchSub(s,offset,null()))) {
+HXLINE( 156)					{
+HXLINE( 156)						::String x = s.substr(offset,null());
+HXDLIN( 156)						if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 156)							buf->flush();
+            						}
+HXDLIN( 156)						if (::hx::IsNull( buf->b )) {
+HXLINE( 156)							buf->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(x));
+            						}
+            						else {
+HXLINE( 156)							::Array< ::String > buf1 = buf->b;
+HXDLIN( 156)							buf1->push(::Std_obj::string(x));
+            						}
+            					}
+HXLINE( 157)					goto _hx_goto_10;
+            				}
+            			}
+HXLINE( 159)			 ::Dynamic p = _hx_regexp_matched_pos(this->r,0);
+HXLINE( 160)			{
+HXLINE( 160)				::String x1 = s.substr(offset,(( (int)(p->__Field(HX_("pos",94,5d,55,00),::hx::paccDynamic)) ) - offset));
+HXDLIN( 160)				if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 160)					buf->flush();
+            				}
+HXDLIN( 160)				if (::hx::IsNull( buf->b )) {
+HXLINE( 160)					buf->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(x1));
+            				}
+            				else {
+HXLINE( 160)					::Array< ::String > buf2 = buf->b;
+HXDLIN( 160)					buf2->push(::Std_obj::string(x1));
+            				}
+            			}
+HXLINE( 161)			{
+HXLINE( 161)				::String x2 = ( (::String)(f(::hx::ObjectPtr<OBJ_>(this))) );
+HXDLIN( 161)				if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 161)					buf->flush();
+            				}
+HXDLIN( 161)				if (::hx::IsNull( buf->b )) {
+HXLINE( 161)					buf->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(x2));
+            				}
+            				else {
+HXLINE( 161)					::Array< ::String > buf3 = buf->b;
+HXDLIN( 161)					buf3->push(::Std_obj::string(x2));
+            				}
+            			}
+HXLINE( 162)			if (::hx::IsEq( p->__Field(HX_("len",d5,4b,52,00),::hx::paccDynamic),0 )) {
+HXLINE( 163)				{
+HXLINE( 163)					::String x3 = s.substr(( (int)(p->__Field(HX_("pos",94,5d,55,00),::hx::paccDynamic)) ),1);
+HXDLIN( 163)					if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 163)						buf->flush();
+            					}
+HXDLIN( 163)					if (::hx::IsNull( buf->b )) {
+HXLINE( 163)						buf->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(x3));
+            					}
+            					else {
+HXLINE( 163)						::Array< ::String > buf4 = buf->b;
+HXDLIN( 163)						buf4->push(::Std_obj::string(x3));
+            					}
+            				}
+HXLINE( 164)				offset = ( (int)((p->__Field(HX_("pos",94,5d,55,00),::hx::paccDynamic) + 1)) );
+            			}
+            			else {
+HXLINE( 166)				offset = ( (int)((p->__Field(HX_("pos",94,5d,55,00),::hx::paccDynamic) + p->__Field(HX_("len",d5,4b,52,00),::hx::paccDynamic))) );
+            			}
+            		} while(this->global);
+            		_hx_goto_10:;
+HXLINE( 168)		bool _hx_tmp;
+HXDLIN( 168)		bool _hx_tmp1;
+HXDLIN( 168)		if (!(this->global)) {
+HXLINE( 168)			_hx_tmp1 = (offset > 0);
+            		}
+            		else {
+HXLINE( 168)			_hx_tmp1 = false;
+            		}
+HXDLIN( 168)		if (_hx_tmp1) {
+HXLINE( 168)			_hx_tmp = (offset < s.length);
+            		}
+            		else {
+HXLINE( 168)			_hx_tmp = false;
+            		}
+HXDLIN( 168)		if (_hx_tmp) {
+HXLINE( 169)			::String x4 = s.substr(offset,null());
+HXDLIN( 169)			if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 169)				buf->flush();
+            			}
+HXDLIN( 169)			if (::hx::IsNull( buf->b )) {
+HXLINE( 169)				buf->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(x4));
+            			}
+            			else {
+HXLINE( 169)				::Array< ::String > buf5 = buf->b;
+HXDLIN( 169)				buf5->push(::Std_obj::string(x4));
+            			}
+            		}
+HXLINE( 170)		return buf->toString();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(EReg_obj,map,return )
+
+
+::hx::ObjectPtr< EReg_obj > EReg_obj::__new(::String r,::String opt) {
+	::hx::ObjectPtr< EReg_obj > __this = new EReg_obj();
+	__this->__construct(r,opt);
+	return __this;
+}
+
+::hx::ObjectPtr< EReg_obj > EReg_obj::__alloc(::hx::Ctx *_hx_ctx,::String r,::String opt) {
+	EReg_obj *__this = (EReg_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(EReg_obj), true, "EReg"));
+	*(void **)__this = EReg_obj::_hx_vtable;
+	__this->__construct(r,opt);
+	return __this;
+}
+
+EReg_obj::EReg_obj()
+{
+}
+
+void EReg_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(EReg);
+	HX_MARK_MEMBER_NAME(r,"r");
+	HX_MARK_MEMBER_NAME(last,"last");
+	HX_MARK_MEMBER_NAME(global,"global");
+	HX_MARK_END_CLASS();
+}
+
+void EReg_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(r,"r");
+	HX_VISIT_MEMBER_NAME(last,"last");
+	HX_VISIT_MEMBER_NAME(global,"global");
+}
+
+::hx::Val EReg_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 1:
+		if (HX_FIELD_EQ(inName,"r") ) { return ::hx::Val( r ); }
+		break;
+	case 3:
+		if (HX_FIELD_EQ(inName,"map") ) { return ::hx::Val( map_dyn() ); }
+		break;
+	case 4:
+		if (HX_FIELD_EQ(inName,"last") ) { return ::hx::Val( last ); }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"match") ) { return ::hx::Val( match_dyn() ); }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"global") ) { return ::hx::Val( global ); }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"matched") ) { return ::hx::Val( matched_dyn() ); }
+		if (HX_FIELD_EQ(inName,"replace") ) { return ::hx::Val( replace_dyn() ); }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"matchSub") ) { return ::hx::Val( matchSub_dyn() ); }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"matchedPos") ) { return ::hx::Val( matchedPos_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val EReg_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 1:
+		if (HX_FIELD_EQ(inName,"r") ) { r=inValue.Cast<  ::Dynamic >(); return inValue; }
+		break;
+	case 4:
+		if (HX_FIELD_EQ(inName,"last") ) { last=inValue.Cast< ::String >(); return inValue; }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"global") ) { global=inValue.Cast< bool >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void EReg_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("r",72,00,00,00));
+	outFields->push(HX_("last",56,0a,ad,47));
+	outFields->push(HX_("global",63,31,b2,a7));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo EReg_obj_sMemberStorageInfo[] = {
+	{::hx::fsObject /*  ::Dynamic */ ,(int)offsetof(EReg_obj,r),HX_("r",72,00,00,00)},
+	{::hx::fsString,(int)offsetof(EReg_obj,last),HX_("last",56,0a,ad,47)},
+	{::hx::fsBool,(int)offsetof(EReg_obj,global),HX_("global",63,31,b2,a7)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *EReg_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String EReg_obj_sMemberFields[] = {
+	HX_("r",72,00,00,00),
+	HX_("last",56,0a,ad,47),
+	HX_("global",63,31,b2,a7),
+	HX_("match",45,49,23,03),
+	HX_("matched",e4,3c,7c,89),
+	HX_("matchedPos",10,ff,c2,cb),
+	HX_("matchSub",3b,71,2b,c3),
+	HX_("replace",34,48,28,ab),
+	HX_("map",9c,0a,53,00),
+	::String(null()) };
+
+::hx::Class EReg_obj::__mClass;
+
+void EReg_obj::__register()
+{
+	EReg_obj _hx_dummy;
+	EReg_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("EReg",0f,4a,da,2d);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(EReg_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< EReg_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = EReg_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = EReg_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
diff --git a/Sources/c_snikket/src/Enum.cpp b/Sources/c_snikket/src/Enum.cpp
new file mode 100644
index 0000000..e8fee46
--- /dev/null
+++ b/Sources/c_snikket/src/Enum.cpp
@@ -0,0 +1,137 @@
+#include <hxcpp.h>
+
+
+// -------- Enums ---------------------------------
+
+namespace hx
+{
+
+Dynamic EnumBase_obj::__Create(DynamicArray inArgs) { return new hx::EnumBase_obj; }
+Dynamic EnumBase_obj::__CreateEmpty() { return new hx::EnumBase_obj; }
+
+
+int EnumBase_obj::__FindIndex(String inName)
+{
+   if (inName==HX_CSTRING("__")) return 1;
+   return -1;
+}
+int EnumBase_obj::__FindArgCount(String inName)
+{
+   if (inName==HX_CSTRING("__")) return 0;
+   return -1;
+}
+hx::Val EnumBase_obj::__Field(const String &inName, hx::PropertyAccess inCallProp)
+{
+   if (HX_FIELD_EQ(inName,"tag") ) { return ::hx::Val( _hx_tag ); }
+   if (HX_FIELD_EQ(inName,"index") ) { return ::hx::Val( index ); }
+   return null();
+}
+
+hx::Class hxEnumBase_obj__mClass;
+hx::Class &EnumBase_obj::__SGetClass() { return hxEnumBase_obj__mClass; }
+
+//void hxEnumBase_obj::__GetFields(Array<String> &outFields) { }
+
+void EnumBase_obj::__boot()
+{
+   Static(hxEnumBase_obj__mClass) = hx::_hx_RegisterClass(HX_CSTRING("__EnumBase") ,TCanCast<EnumBase_obj>,
+                       sNone,sNone,
+                       &__CreateEmpty, &__Create, 0 );
+}
+
+DynamicArray EnumBase_obj::_hx_getParameters()
+{
+   Array<Dynamic> result = Array_obj<Dynamic>::__new(mFixedFields);
+   cpp::Variant *fixed = _hx_getFixed();
+   for(int i=0;i<mFixedFields;i++)
+      result[i] = fixed[i];
+   return result;
+}
+
+int EnumBase_obj::__Compare(const hx::Object *inRHS) const
+{
+   if (inRHS->__GetType()!=vtEnum) return -1;
+   const EnumBase_obj *rhs = static_cast<const EnumBase_obj *>(inRHS);
+
+   if (_hx_tag!=rhs->_hx_tag || GetEnumName()!=rhs->GetEnumName()) return -1;
+   if (mFixedFields!=rhs->mFixedFields) return -1;
+   if (!mFixedFields) return 0;
+
+   const cpp::Variant *f0 = _hx_getFixed();
+   const cpp::Variant *f1 = rhs->_hx_getFixed();
+   for(int i=0;i<mFixedFields;i++)
+      if ( f0[i] != f1[i])
+         return -1;
+
+   return 0;
+}
+
+bool __hxcpp_enum_eq( ::hx::EnumBase a, ::hx::EnumBase b)
+{
+   if (!a.mPtr || !b.mPtr)
+      return !a.mPtr && !b.mPtr;
+   // Known to be same type
+   if (a->index != b->index)
+      return 0;
+   int n =  a->_hx_getParamCount();
+   if (n==0)
+      return true;
+   cpp::Variant *fa = a->_hx_getFixed();
+   cpp::Variant *fb = b->_hx_getFixed();
+   for(int i=0;i<n;i++)
+      if ( fa[i]!=fb[i] )
+         return false;
+   return true;
+}
+
+
+
+void EnumBase_obj::__Mark(hx::MarkContext *__inCtx)
+{
+   HX_MARK_MEMBER(_hx_tag);
+   if (mFixedFields>0)
+   {
+      cpp::Variant *v = _hx_getFixed();
+      for(int i=0;i<mFixedFields;i++)
+         HX_MARK_MEMBER(v[i]);
+   }
+}
+
+#ifdef HXCPP_VISIT_ALLOCS
+void EnumBase_obj::__Visit(hx::VisitContext *__inCtx)
+{
+
+   HX_VISIT_MEMBER(_hx_tag);
+   if (mFixedFields>0)
+   {
+      cpp::Variant *v = _hx_getFixed();
+      for(int i=0;i<mFixedFields;i++)
+         HX_VISIT_MEMBER(v[i]);
+   }
+}
+#endif
+
+
+Dynamic EnumBase_obj::__GetItem(int inIndex) const
+{
+   return ((EnumBase_obj *)this)->_hx_getParamI(inIndex);
+}
+
+
+
+String EnumBase_obj::toString() {
+   if (mFixedFields==0)
+      return _hx_tag;
+   if (mFixedFields==1)
+      return _hx_tag + HX_CSTRING("(") + _hx_getFixed()->asString() + HX_CSTRING(")");
+
+   Array<String> args = Array_obj<String>::__new(mFixedFields);
+   cpp::Variant *v = _hx_getFixed();
+   for(int i=0;i<mFixedFields;i++)
+      args[i] = v[i].asString();
+
+   return _hx_tag + HX_CSTRING("(") + args->join(HX_CSTRING(",")) + HX_CSTRING(")");
+}
+
+}
+
diff --git a/Sources/c_snikket/src/HaxeCBridge.cpp b/Sources/c_snikket/src/HaxeCBridge.cpp
new file mode 100644
index 0000000..94dcd30
--- /dev/null
+++ b/Sources/c_snikket/src/HaxeCBridge.cpp
@@ -0,0 +1,337 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_cbce7ceea2d0df24
+#define INCLUDED_cbce7ceea2d0df24
+#include "HaxeCBridge.h"
+#endif
+#ifndef INCLUDED_95f339a1d026d52c
+#define INCLUDED_95f339a1d026d52c
+#include "hxMath.h"
+#endif
+#ifndef INCLUDED_Std
+#include <Std.h>
+#endif
+#ifndef INCLUDED_Sys
+#include <Sys.h>
+#endif
+#ifndef INCLUDED__HaxeCBridge_Internal
+#include <_HaxeCBridge/Internal.h>
+#endif
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+#ifndef INCLUDED_haxe_ds_IntMap
+#include <haxe/ds/IntMap.h>
+#endif
+#ifndef INCLUDED_sys_thread_EventLoop
+#include <sys/thread/EventLoop.h>
+#endif
+#ifndef INCLUDED_sys_thread_Lock
+#include <sys/thread/Lock.h>
+#endif
+#ifndef INCLUDED_sys_thread_Mutex
+#include <sys/thread/Mutex.h>
+#endif
+#ifndef INCLUDED_sys_thread__EventLoop_RegularEvent
+#include <sys/thread/_EventLoop/RegularEvent.h>
+#endif
+#ifndef INCLUDED_sys_thread__Thread_HaxeThread
+#include <sys/thread/_Thread/HaxeThread.h>
+#endif
+#ifndef INCLUDED_sys_thread__Thread_Thread_Impl_
+#include <sys/thread/_Thread/Thread_Impl_.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_74d844958d4dcf5a_1907_mainThreadInit,"HaxeCBridge","mainThreadInit",0x6f09ae5b,"HaxeCBridge.mainThreadInit","HaxeCBridge.hx",1907,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_74d844958d4dcf5a_1922_mainThreadRun,"HaxeCBridge","mainThreadRun",0xa4afa660,"HaxeCBridge.mainThreadRun","HaxeCBridge.hx",1922,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_74d844958d4dcf5a_2001_retainHaxeArray,"HaxeCBridge","retainHaxeArray",0x7373bc46,"HaxeCBridge.retainHaxeArray","HaxeCBridge.hx",2001,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_74d844958d4dcf5a_2010_retainHaxeObject,"HaxeCBridge","retainHaxeObject",0xef200772,"HaxeCBridge.retainHaxeObject","HaxeCBridge.hx",2010,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_74d844958d4dcf5a_2020_retainHaxeString,"HaxeCBridge","retainHaxeString",0xeb10b184,"HaxeCBridge.retainHaxeString","HaxeCBridge.hx",2020,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_74d844958d4dcf5a_2027_releaseHaxePtr,"HaxeCBridge","releaseHaxePtr",0x5df2fc29,"HaxeCBridge.releaseHaxePtr","HaxeCBridge.hx",2027,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_74d844958d4dcf5a_2034_isMainThread,"HaxeCBridge","isMainThread",0x6f71c035,"HaxeCBridge.isMainThread","HaxeCBridge.hx",2034,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_74d844958d4dcf5a_2039_endMainThread,"HaxeCBridge","endMainThread",0x0d9deed6,"HaxeCBridge.endMainThread","HaxeCBridge.hx",2039,0xa18550d8)
+
+void HaxeCBridge::mainThreadInit(::cpp::Function< bool  () > isMainThreadCb){
+            	HX_STACKFRAME(&_hx_pos_74d844958d4dcf5a_1907_mainThreadInit)
+HXLINE(1913)		::_HaxeCBridge::Internal_obj::isMainThreadCb = isMainThreadCb;
+HXLINE(1914)		::_HaxeCBridge::Internal_obj::mainThreadWaitLock = ::sys::thread::_Thread::Thread_Impl__obj::get_events(::sys::thread::_Thread::HaxeThread_obj::current())->waitLock;
+            	}
+
+
+void HaxeCBridge::mainThreadRun(::cpp::Function< void  () > processNativeCalls,::cpp::Function< void  (const char*) > onUnhandledException){
+            	HX_STACKFRAME(&_hx_pos_74d844958d4dcf5a_1922_mainThreadRun)
+HXLINE(1923)		try {
+            			HX_STACK_CATCHABLE( ::Dynamic, 0);
+            		} catch( ::Dynamic _hx_e) {
+            			if (_hx_e.IsClass<  ::Dynamic >() ){
+            				HX_STACK_BEGIN_CATCH
+            				 ::Dynamic _g = _hx_e;
+HXLINE(1925)				{
+HXLINE(1925)					null();
+            				}
+HXDLIN(1925)				 ::Dynamic e = _g;
+HXLINE(1926)				{
+HXLINE(1926)					::String s;
+HXDLIN(1926)					if (::hx::IsNull( e )) {
+HXLINE(1926)						s = HX_("null",87,9e,0e,49);
+            					}
+            					else {
+HXLINE(1926)						s = ::Std_obj::string(e);
+            					}
+HXDLIN(1926)					onUnhandledException(s.utf8_str());
+            				}
+            			}
+            			else {
+            				HX_STACK_DO_THROW(_hx_e);
+            			}
+            		}
+HXLINE(1930)		 ::sys::thread::EventLoop eventLoop = ::sys::thread::_Thread::Thread_Impl__obj::get_events(::sys::thread::_Thread::HaxeThread_obj::current());
+HXLINE(1932)		::Array< ::Dynamic> events = ::Array_obj< ::Dynamic>::__new(0);
+HXLINE(1933)		while(::_HaxeCBridge::Internal_obj::mainThreadLoopActive){
+HXLINE(1934)			try {
+            				HX_STACK_CATCHABLE( ::Dynamic, 0);
+HXLINE(1936)				processNativeCalls();
+HXLINE(1939)				Float now = ::Sys_obj::time();
+HXDLIN(1939)				::Array< ::Dynamic> eventsToRun = events;
+HXDLIN(1939)				int eventsToRunIdx = 0;
+HXDLIN(1939)				Float nextEventAt = ( (Float)(-1) );
+HXDLIN(1939)				eventLoop->mutex->acquire();
+HXDLIN(1939)				 ::sys::thread::_EventLoop::RegularEvent current = eventLoop->regularEvents;
+HXDLIN(1939)				while(::hx::IsNotNull( current )){
+HXLINE(1939)					if ((current->nextRunTime <= now)) {
+HXLINE(1939)						eventsToRunIdx = (eventsToRunIdx + 1);
+HXDLIN(1939)						eventsToRun[(eventsToRunIdx - 1)] = current->run;
+HXDLIN(1939)						 ::sys::thread::_EventLoop::RegularEvent current1 = current;
+HXDLIN(1939)						current1->nextRunTime = (current1->nextRunTime + current->interval);
+HXLINE(2152)						nextEventAt = ( (Float)(-2) );
+            					}
+            					else {
+HXLINE(1939)						bool _hx_tmp;
+HXDLIN(1939)						if ((nextEventAt != -1)) {
+HXLINE(1939)							_hx_tmp = (current->nextRunTime < nextEventAt);
+            						}
+            						else {
+HXLINE(1939)							_hx_tmp = true;
+            						}
+HXDLIN(1939)						if (_hx_tmp) {
+HXLINE(2154)							nextEventAt = current->nextRunTime;
+            						}
+            					}
+HXLINE(2156)					current = current->next;
+            				}
+HXLINE(1939)				eventLoop->mutex->release();
+HXDLIN(1939)				int _g1 = 0;
+HXDLIN(1939)				int _g2 = eventsToRunIdx;
+HXDLIN(1939)				while((_g1 < _g2)){
+HXLINE(1939)					_g1 = (_g1 + 1);
+HXDLIN(1939)					int i = (_g1 - 1);
+HXDLIN(1939)					eventsToRun->__get(i)();
+HXDLIN(1939)					eventsToRun[i] = null();
+            				}
+HXLINE(2165)				eventsToRunIdx = 0;
+HXLINE(1939)				eventLoop->mutex->acquire();
+HXDLIN(1939)				int _g_current = 0;
+HXDLIN(1939)				::Array< ::Dynamic> _g_array = eventLoop->oneTimeEvents;
+HXDLIN(1939)				while((_g_current < _g_array->length)){
+HXLINE(1939)					 ::Dynamic _g_value = _g_array->__get(_g_current);
+HXDLIN(1939)					_g_current = (_g_current + 1);
+HXDLIN(1939)					int _g_key = (_g_current - 1);
+HXDLIN(1939)					int i1 = _g_key;
+HXDLIN(1939)					 ::Dynamic event = _g_value;
+HXDLIN(1939)					if (::hx::IsNull( event )) {
+HXLINE(1939)						goto _hx_goto_4;
+            					}
+            					else {
+HXLINE(1939)						eventsToRunIdx = (eventsToRunIdx + 1);
+HXDLIN(1939)						eventsToRun[(eventsToRunIdx - 1)] = event;
+HXDLIN(1939)						eventLoop->oneTimeEvents[i1] = null();
+            					}
+            				}
+            				_hx_goto_4:;
+HXDLIN(1939)				eventLoop->oneTimeEventsIdx = 0;
+HXDLIN(1939)				bool hasPromisedEvents = (eventLoop->promisedEventsCount > 0);
+HXDLIN(1939)				eventLoop->mutex->release();
+HXDLIN(1939)				int _g3 = 0;
+HXDLIN(1939)				int _g4 = eventsToRunIdx;
+HXDLIN(1939)				while((_g3 < _g4)){
+HXLINE(1939)					_g3 = (_g3 + 1);
+HXDLIN(1939)					int i2 = (_g3 - 1);
+HXDLIN(1939)					eventsToRun->__get(i2)();
+HXDLIN(1939)					eventsToRun[i2] = null();
+            				}
+HXDLIN(1939)				if ((eventsToRunIdx > 0)) {
+HXLINE(2190)					nextEventAt = ( (Float)(-2) );
+            				}
+HXLINE(1939)				Float eventTickInfo_nextEventAt = nextEventAt;
+HXDLIN(1939)				bool eventTickInfo_anyTime = hasPromisedEvents;
+HXLINE(1940)				{
+HXLINE(1940)					Float _g5 = eventTickInfo_nextEventAt;
+HXDLIN(1940)					Float _hx_switch_0 = _g5;
+            					if (  (_hx_switch_0==( (Float)(-2) )) ){
+HXLINE(1941)						goto _hx_goto_6;
+            					}
+            					if (  (_hx_switch_0==( (Float)(-1) )) ){
+HXLINE(1943)						bool _hx_tmp1;
+HXDLIN(1943)						if (::_HaxeCBridge::Internal_obj::mainThreadEndIfNoPending) {
+HXLINE(1943)							_hx_tmp1 = !(eventTickInfo_anyTime);
+            						}
+            						else {
+HXLINE(1943)							_hx_tmp1 = false;
+            						}
+HXDLIN(1943)						if (_hx_tmp1) {
+HXLINE(1945)							goto _hx_goto_1;
+            						}
+HXLINE(1947)						::_HaxeCBridge::Internal_obj::mainThreadWaitLock->wait(null());
+HXLINE(1942)						goto _hx_goto_6;
+            					}
+            					/* default */{
+HXLINE(1948)						Float time = _g5;
+HXDLIN(1948)						{
+HXLINE(1949)							Float timeout = (time - ::Sys_obj::time());
+HXLINE(1950)							::_HaxeCBridge::Internal_obj::mainThreadWaitLock->wait(::Math_obj::max(( (Float)(0) ),timeout));
+            						}
+            					}
+            					_hx_goto_6:;
+            				}
+            			} catch( ::Dynamic _hx_e) {
+            				if (_hx_e.IsClass<  ::Dynamic >() ){
+            					HX_STACK_BEGIN_CATCH
+            					 ::Dynamic _g6 = _hx_e;
+HXLINE(1952)					{
+HXLINE(1952)						null();
+            					}
+HXDLIN(1952)					 ::Dynamic e1 = _g6;
+HXLINE(1953)					{
+HXLINE(1953)						::String s1;
+HXDLIN(1953)						if (::hx::IsNull( e1 )) {
+HXLINE(1953)							s1 = HX_("null",87,9e,0e,49);
+            						}
+            						else {
+HXLINE(1953)							s1 = ::Std_obj::string(e1);
+            						}
+HXDLIN(1953)						onUnhandledException(s1.utf8_str());
+            					}
+            				}
+            				else {
+            					HX_STACK_DO_THROW(_hx_e);
+            				}
+            			}
+            		}
+            		_hx_goto_1:;
+HXLINE(1958)		__hxcpp_collect(true);
+            	}
+
+
+void** HaxeCBridge::retainHaxeArray(::cpp::VirtualArray haxeArray){
+            	HX_GC_STACKFRAME(&_hx_pos_74d844958d4dcf5a_2001_retainHaxeArray)
+HXLINE(2004)		void** ptr = (void**)haxeArray->getBase();
+HXLINE(2005)		::cpp::Int64 ptrInt64 = reinterpret_cast<int64_t>(ptr);
+HXLINE(2006)		{
+HXLINE(2006)			 ::haxe::ds::IntMap this1 = ::_HaxeCBridge::Internal_obj::gcRetainMap;
+HXDLIN(2006)			int low = ptrInt64 & 0xffffffff;
+HXDLIN(2006)			int high = ptrInt64 >> 32;
+HXDLIN(2006)			 ::haxe::ds::IntMap highMap = ( ( ::haxe::ds::IntMap)(this1->get(low)) );
+HXDLIN(2006)			if (::hx::IsNull( highMap )) {
+HXLINE(2006)				highMap =  ::haxe::ds::IntMap_obj::__alloc( HX_CTX );
+HXDLIN(2006)				this1->set(low,highMap);
+            			}
+HXDLIN(2006)			highMap->set(high,haxeArray);
+            		}
+HXLINE(2007)		return ptr;
+            	}
+
+
+void* HaxeCBridge::retainHaxeObject( ::Dynamic haxeObject){
+            	HX_GC_STACKFRAME(&_hx_pos_74d844958d4dcf5a_2010_retainHaxeObject)
+HXLINE(2012)		void* ptr = haxeObject.mPtr;
+HXLINE(2015)		::cpp::Int64 ptrInt64 = reinterpret_cast<int64_t>(ptr);
+HXLINE(2016)		{
+HXLINE(2016)			 ::haxe::ds::IntMap this1 = ::_HaxeCBridge::Internal_obj::gcRetainMap;
+HXDLIN(2016)			int low = ptrInt64 & 0xffffffff;
+HXDLIN(2016)			int high = ptrInt64 >> 32;
+HXDLIN(2016)			 ::haxe::ds::IntMap highMap = ( ( ::haxe::ds::IntMap)(this1->get(low)) );
+HXDLIN(2016)			if (::hx::IsNull( highMap )) {
+HXLINE(2016)				highMap =  ::haxe::ds::IntMap_obj::__alloc( HX_CTX );
+HXDLIN(2016)				this1->set(low,highMap);
+            			}
+HXDLIN(2016)			highMap->set(high,haxeObject);
+            		}
+HXLINE(2017)		return ptr;
+            	}
+
+
+const char* HaxeCBridge::retainHaxeString(::String haxeString){
+            	HX_GC_STACKFRAME(&_hx_pos_74d844958d4dcf5a_2020_retainHaxeString)
+HXLINE(2021)		const char* cStrPtr = haxeString.utf8_str();
+HXLINE(2022)		::cpp::Int64 ptrInt64 = reinterpret_cast<int64_t>(cStrPtr);
+HXLINE(2023)		{
+HXLINE(2023)			 ::haxe::ds::IntMap this1 = ::_HaxeCBridge::Internal_obj::gcRetainMap;
+HXDLIN(2023)			int low = ptrInt64 & 0xffffffff;
+HXDLIN(2023)			int high = ptrInt64 >> 32;
+HXDLIN(2023)			 ::haxe::ds::IntMap highMap = ( ( ::haxe::ds::IntMap)(this1->get(low)) );
+HXDLIN(2023)			if (::hx::IsNull( highMap )) {
+HXLINE(2023)				highMap =  ::haxe::ds::IntMap_obj::__alloc( HX_CTX );
+HXDLIN(2023)				this1->set(low,highMap);
+            			}
+HXDLIN(2023)			highMap->set(high,haxeString);
+            		}
+HXLINE(2024)		return cStrPtr;
+            	}
+
+
+void HaxeCBridge::releaseHaxePtr(void * haxePtr){
+            	HX_STACKFRAME(&_hx_pos_74d844958d4dcf5a_2027_releaseHaxePtr)
+HXLINE(2028)		::cpp::Int64 ptrInt64 = reinterpret_cast<int64_t>(haxePtr);
+HXLINE(2029)		{
+HXLINE(2029)			 ::haxe::ds::IntMap this1 = ::_HaxeCBridge::Internal_obj::gcRetainMap;
+HXDLIN(2029)			int low = ptrInt64 & 0xffffffff;
+HXDLIN(2029)			int high = ptrInt64 >> 32;
+HXDLIN(2029)			 ::haxe::ds::IntMap highMap = ( ( ::haxe::ds::IntMap)(this1->get(low)) );
+HXDLIN(2029)			if (::hx::IsNotNull( highMap )) {
+HXLINE(2029)				bool removed = highMap->remove(high);
+HXDLIN(2029)				bool isHighMapEmpty = true;
+HXDLIN(2029)				{
+HXLINE(2029)					 ::Dynamic k = highMap->keys();
+HXDLIN(2029)					while(( (bool)(k->__Field(HX_("hasNext",6d,a5,46,18),::hx::paccDynamic)()) )){
+HXLINE(2029)						int k1 = ( (int)(k->__Field(HX_("next",f3,84,02,49),::hx::paccDynamic)()) );
+HXDLIN(2029)						isHighMapEmpty = false;
+HXDLIN(2029)						goto _hx_goto_11;
+            					}
+            					_hx_goto_11:;
+            				}
+HXDLIN(2029)				if (isHighMapEmpty) {
+HXLINE(2029)					this1->remove(low);
+            				}
+            			}
+            		}
+            	}
+
+
+bool HaxeCBridge::isMainThread(){
+            	HX_STACKFRAME(&_hx_pos_74d844958d4dcf5a_2034_isMainThread)
+HXDLIN(2034)		return ::_HaxeCBridge::Internal_obj::isMainThreadCb();
+            	}
+
+
+void HaxeCBridge::endMainThread(bool waitOnScheduledEvents){
+            	HX_STACKFRAME(&_hx_pos_74d844958d4dcf5a_2039_endMainThread)
+HXLINE(2040)		::_HaxeCBridge::Internal_obj::mainThreadEndIfNoPending = true;
+HXLINE(2041)		bool _hx_tmp;
+HXDLIN(2041)		if (::_HaxeCBridge::Internal_obj::mainThreadLoopActive) {
+HXLINE(2041)			_hx_tmp = waitOnScheduledEvents;
+            		}
+            		else {
+HXLINE(2041)			_hx_tmp = false;
+            		}
+HXDLIN(2041)		::_HaxeCBridge::Internal_obj::mainThreadLoopActive = _hx_tmp;
+HXLINE(2042)		 ::__hxcpp_lock_release(::_HaxeCBridge::Internal_obj::mainThreadWaitLock->l);
+            	}
+
+
+void HaxeCBridge::wakeMainThread(){
+	 ::__hxcpp_lock_release(::_HaxeCBridge::Internal_obj::mainThreadWaitLock->l);
+}
+
+
+
diff --git a/Sources/c_snikket/src/Lambda.cpp b/Sources/c_snikket/src/Lambda.cpp
new file mode 100644
index 0000000..df36922
--- /dev/null
+++ b/Sources/c_snikket/src/Lambda.cpp
@@ -0,0 +1,209 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Lambda
+#include <Lambda.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_a2b9229e56451ffa_45_array,"Lambda","array",0x9c8b0512,"Lambda.array","/usr/local/lib/haxe/std/Lambda.hx",45,0xf61dfe9a)
+HX_LOCAL_STACK_FRAME(_hx_pos_a2b9229e56451ffa_125_exists,"Lambda","exists",0x65091043,"Lambda.exists","/usr/local/lib/haxe/std/Lambda.hx",125,0xf61dfe9a)
+HX_LOCAL_STACK_FRAME(_hx_pos_a2b9229e56451ffa_168_filter,"Lambda","filter",0x2a5e121f,"Lambda.filter","/usr/local/lib/haxe/std/Lambda.hx",168,0xf61dfe9a)
+HX_LOCAL_STACK_FRAME(_hx_pos_a2b9229e56451ffa_183_fold,"Lambda","fold",0x9b8816a8,"Lambda.fold","/usr/local/lib/haxe/std/Lambda.hx",183,0xf61dfe9a)
+HX_LOCAL_STACK_FRAME(_hx_pos_a2b9229e56451ffa_225_empty,"Lambda","empty",0xe6d5d206,"Lambda.empty","/usr/local/lib/haxe/std/Lambda.hx",225,0xf61dfe9a)
+HX_LOCAL_STACK_FRAME(_hx_pos_a2b9229e56451ffa_255_find,"Lambda","find",0x9b838ae0,"Lambda.find","/usr/local/lib/haxe/std/Lambda.hx",255,0xf61dfe9a)
+HX_LOCAL_STACK_FRAME(_hx_pos_a2b9229e56451ffa_273_findIndex,"Lambda","findIndex",0xea9b1412,"Lambda.findIndex","/usr/local/lib/haxe/std/Lambda.hx",273,0xf61dfe9a)
+
+void Lambda_obj::__construct() { }
+
+Dynamic Lambda_obj::__CreateEmpty() { return new Lambda_obj; }
+
+void *Lambda_obj::_hx_vtable = 0;
+
+Dynamic Lambda_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Lambda_obj > _hx_result = new Lambda_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool Lambda_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x4cec6e4b;
+}
+
+::cpp::VirtualArray Lambda_obj::array( ::Dynamic it){
+            	HX_STACKFRAME(&_hx_pos_a2b9229e56451ffa_45_array)
+HXLINE(  46)		::cpp::VirtualArray a = ::cpp::VirtualArray_obj::__new();
+HXLINE(  47)		{
+HXLINE(  47)			 ::Dynamic i = it->__Field(HX_("iterator",ee,49,9a,93),::hx::paccDynamic)();
+HXDLIN(  47)			while(( (bool)(i->__Field(HX_("hasNext",6d,a5,46,18),::hx::paccDynamic)()) )){
+HXLINE(  47)				 ::Dynamic i1 = i->__Field(HX_("next",f3,84,02,49),::hx::paccDynamic)();
+HXLINE(  48)				a->push(i1);
+            			}
+            		}
+HXLINE(  49)		return a;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Lambda_obj,array,return )
+
+bool Lambda_obj::exists( ::Dynamic it, ::Dynamic f){
+            	HX_STACKFRAME(&_hx_pos_a2b9229e56451ffa_125_exists)
+HXLINE( 126)		{
+HXLINE( 126)			 ::Dynamic x = it->__Field(HX_("iterator",ee,49,9a,93),::hx::paccDynamic)();
+HXDLIN( 126)			while(( (bool)(x->__Field(HX_("hasNext",6d,a5,46,18),::hx::paccDynamic)()) )){
+HXLINE( 126)				 ::Dynamic x1 = x->__Field(HX_("next",f3,84,02,49),::hx::paccDynamic)();
+HXLINE( 127)				if (( (bool)(f(x1)) )) {
+HXLINE( 128)					return true;
+            				}
+            			}
+            		}
+HXLINE( 129)		return false;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(Lambda_obj,exists,return )
+
+::cpp::VirtualArray Lambda_obj::filter( ::Dynamic it, ::Dynamic f){
+            	HX_STACKFRAME(&_hx_pos_a2b9229e56451ffa_168_filter)
+HXDLIN( 168)		::cpp::VirtualArray _g = ::cpp::VirtualArray_obj::__new(0);
+HXDLIN( 168)		{
+HXDLIN( 168)			 ::Dynamic x = it->__Field(HX_("iterator",ee,49,9a,93),::hx::paccDynamic)();
+HXDLIN( 168)			while(( (bool)(x->__Field(HX_("hasNext",6d,a5,46,18),::hx::paccDynamic)()) )){
+HXDLIN( 168)				 ::Dynamic x1 = x->__Field(HX_("next",f3,84,02,49),::hx::paccDynamic)();
+HXDLIN( 168)				if (( (bool)(f(x1)) )) {
+HXDLIN( 168)					_g->push(x1);
+            				}
+            			}
+            		}
+HXDLIN( 168)		return _g;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(Lambda_obj,filter,return )
+
+ ::Dynamic Lambda_obj::fold( ::Dynamic it, ::Dynamic f, ::Dynamic first){
+            	HX_STACKFRAME(&_hx_pos_a2b9229e56451ffa_183_fold)
+HXLINE( 184)		{
+HXLINE( 184)			 ::Dynamic x = it->__Field(HX_("iterator",ee,49,9a,93),::hx::paccDynamic)();
+HXDLIN( 184)			while(( (bool)(x->__Field(HX_("hasNext",6d,a5,46,18),::hx::paccDynamic)()) )){
+HXLINE( 184)				 ::Dynamic x1 = x->__Field(HX_("next",f3,84,02,49),::hx::paccDynamic)();
+HXLINE( 185)				first = f(x1,first);
+            			}
+            		}
+HXLINE( 186)		return first;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC3(Lambda_obj,fold,return )
+
+bool Lambda_obj::empty( ::Dynamic it){
+            	HX_STACKFRAME(&_hx_pos_a2b9229e56451ffa_225_empty)
+HXDLIN( 225)		return !(( (bool)(it->__Field(HX_("iterator",ee,49,9a,93),::hx::paccDynamic)()->__Field(HX_("hasNext",6d,a5,46,18),::hx::paccDynamic)()) ));
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Lambda_obj,empty,return )
+
+ ::Dynamic Lambda_obj::find( ::Dynamic it, ::Dynamic f){
+            	HX_STACKFRAME(&_hx_pos_a2b9229e56451ffa_255_find)
+HXLINE( 256)		{
+HXLINE( 256)			 ::Dynamic v = it->__Field(HX_("iterator",ee,49,9a,93),::hx::paccDynamic)();
+HXDLIN( 256)			while(( (bool)(v->__Field(HX_("hasNext",6d,a5,46,18),::hx::paccDynamic)()) )){
+HXLINE( 256)				 ::Dynamic v1 = v->__Field(HX_("next",f3,84,02,49),::hx::paccDynamic)();
+HXLINE( 257)				if (( (bool)(f(v1)) )) {
+HXLINE( 258)					return v1;
+            				}
+            			}
+            		}
+HXLINE( 260)		return null();
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(Lambda_obj,find,return )
+
+int Lambda_obj::findIndex( ::Dynamic it, ::Dynamic f){
+            	HX_STACKFRAME(&_hx_pos_a2b9229e56451ffa_273_findIndex)
+HXLINE( 274)		int i = 0;
+HXLINE( 275)		{
+HXLINE( 275)			 ::Dynamic v = it->__Field(HX_("iterator",ee,49,9a,93),::hx::paccDynamic)();
+HXDLIN( 275)			while(( (bool)(v->__Field(HX_("hasNext",6d,a5,46,18),::hx::paccDynamic)()) )){
+HXLINE( 275)				 ::Dynamic v1 = v->__Field(HX_("next",f3,84,02,49),::hx::paccDynamic)();
+HXLINE( 276)				if (( (bool)(f(v1)) )) {
+HXLINE( 277)					return i;
+            				}
+HXLINE( 278)				i = (i + 1);
+            			}
+            		}
+HXLINE( 280)		return -1;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(Lambda_obj,findIndex,return )
+
+
+Lambda_obj::Lambda_obj()
+{
+}
+
+bool Lambda_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"fold") ) { outValue = fold_dyn(); return true; }
+		if (HX_FIELD_EQ(inName,"find") ) { outValue = find_dyn(); return true; }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"array") ) { outValue = array_dyn(); return true; }
+		if (HX_FIELD_EQ(inName,"empty") ) { outValue = empty_dyn(); return true; }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"exists") ) { outValue = exists_dyn(); return true; }
+		if (HX_FIELD_EQ(inName,"filter") ) { outValue = filter_dyn(); return true; }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"findIndex") ) { outValue = findIndex_dyn(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *Lambda_obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo *Lambda_obj_sStaticStorageInfo = 0;
+#endif
+
+::hx::Class Lambda_obj::__mClass;
+
+static ::String Lambda_obj_sStaticFields[] = {
+	HX_("array",99,6d,8f,25),
+	HX_("exists",dc,1d,e0,bf),
+	HX_("filter",b8,1f,35,85),
+	HX_("fold",01,5c,c0,43),
+	HX_("empty",8d,3a,da,6f),
+	HX_("find",39,d0,bb,43),
+	HX_("findIndex",19,cc,0b,ad),
+	::String(null())
+};
+
+void Lambda_obj::__register()
+{
+	Lambda_obj _hx_dummy;
+	Lambda_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("Lambda",27,a7,54,85);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &Lambda_obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(Lambda_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< Lambda_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Lambda_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Lambda_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
diff --git a/Sources/c_snikket/src/Math.cpp b/Sources/c_snikket/src/Math.cpp
new file mode 100755
index 0000000..2b2b5fa
--- /dev/null
+++ b/Sources/c_snikket/src/Math.cpp
@@ -0,0 +1,194 @@
+#include <hxcpp.h>
+#include <limits>
+#include <hxMath.h>
+
+#include <stdlib.h>
+#include <time.h>
+#if defined(HX_WINRT) && !defined(__cplusplus_winrt)
+#include <windows.h>
+#elif defined(HX_WINDOWS)
+#include <process.h>
+#else
+#include <unistd.h>
+#include <sys/time.h>
+#endif
+
+// -------- Math ---------------------------------------
+
+using namespace hx;
+
+
+bool Math_obj::isNaN(double inX)
+  { return inX!=inX; }
+
+bool Math_obj::isFinite(double inX)
+  { return inX==inX && inX!=NEGATIVE_INFINITY && inX!=POSITIVE_INFINITY; }
+
+double Math_obj::NaN = std::numeric_limits<double>::quiet_NaN();
+double Math_obj::NEGATIVE_INFINITY = -std::numeric_limits<double>::infinity();
+double Math_obj::PI = 3.1415926535897932385;
+double Math_obj::POSITIVE_INFINITY = std::numeric_limits<double>::infinity();
+
+#ifdef min
+#undef min
+#endif
+
+#ifdef max
+#undef max
+#endif
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Math_obj,floor,return);
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Math_obj,ffloor,return);
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Math_obj,ceil,return);
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Math_obj,fceil,return);
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Math_obj,round,return);
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Math_obj,fround,return);
+STATIC_HX_DEFINE_DYNAMIC_FUNC0(Math_obj,random,return);
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Math_obj,sqrt,return);
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Math_obj,cos,return);
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Math_obj,sin,return);
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Math_obj,tan,return);
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(Math_obj,atan2,return);
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Math_obj,abs,return);
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(Math_obj,pow,return);
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Math_obj,log,return);
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(Math_obj,min,return);
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(Math_obj,max,return);
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Math_obj,atan,return);
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Math_obj,asin,return);
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Math_obj,acos,return);
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Math_obj,exp,return);
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Math_obj,isNaN,return);
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Math_obj,isFinite,return);
+
+hx::Val Math_obj::__Field(const String &inString, hx::PropertyAccess inCallProp)
+{
+   if (inString==HX_CSTRING("floor")) return floor_dyn();
+   if (inString==HX_CSTRING("ffloor")) return ffloor_dyn();
+   if (inString==HX_CSTRING("ceil")) return ceil_dyn();
+   if (inString==HX_CSTRING("fceil")) return fceil_dyn();
+   if (inString==HX_CSTRING("round")) return round_dyn();
+   if (inString==HX_CSTRING("fround")) return fround_dyn();
+   if (inString==HX_CSTRING("random")) return random_dyn();
+   if (inString==HX_CSTRING("sqrt")) return sqrt_dyn();
+   if (inString==HX_CSTRING("cos")) return cos_dyn();
+   if (inString==HX_CSTRING("sin")) return sin_dyn();
+   if (inString==HX_CSTRING("tan")) return tan_dyn();
+   if (inString==HX_CSTRING("atan2")) return atan2_dyn();
+   if (inString==HX_CSTRING("abs")) return abs_dyn();
+   if (inString==HX_CSTRING("pow")) return pow_dyn();
+   if (inString==HX_CSTRING("log")) return log_dyn();
+   if (inString==HX_CSTRING("min")) return min_dyn();
+   if (inString==HX_CSTRING("max")) return max_dyn();
+   if (inString==HX_CSTRING("atan")) return atan_dyn();
+   if (inString==HX_CSTRING("acos")) return acos_dyn();
+   if (inString==HX_CSTRING("asin")) return asin_dyn();
+   if (inString==HX_CSTRING("exp")) return exp_dyn();
+   if (inString==HX_CSTRING("isNaN")) return isNaN_dyn();
+   if (inString==HX_CSTRING("isFinite")) return isFinite_dyn();
+
+   if (inString==HX_CSTRING("NEGATIVE_INFINITY")) return NEGATIVE_INFINITY;
+   if (inString==HX_CSTRING("POSITIVE_INFINITY")) return POSITIVE_INFINITY;
+   if (inString==HX_CSTRING("PI")) return PI;
+   if (inString==HX_CSTRING("NaN")) return NaN;
+   return null();
+}
+
+void Math_obj::__GetFields(Array<String> &outFields) { }
+
+static String sMathFields[] = {
+   HX_CSTRING("floor"),
+   HX_CSTRING("ceil"),
+   HX_CSTRING("round"),
+   HX_CSTRING("random"),
+   HX_CSTRING("sqrt"),
+   HX_CSTRING("cos"),
+   HX_CSTRING("sin"),
+   HX_CSTRING("tan"),
+   HX_CSTRING("atan2"),
+   HX_CSTRING("abs"),
+   HX_CSTRING("pow"),
+   HX_CSTRING("atan"),
+   HX_CSTRING("acos"),
+   HX_CSTRING("asin"),
+   HX_CSTRING("exp"),
+   HX_CSTRING("isFinite"),
+   String(null()) };
+
+
+hx::Val Math_obj::__SetField(const String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp) { return null(); }
+
+Dynamic Math_obj::__CreateEmpty() { return new Math_obj; }
+
+hx::Class Math_obj::__mClass;
+
+/*
+Class &Math_obj::__SGetClass() { return __mClass; }
+Class Math_obj::__GetClass() const { return __mClass; }
+*/
+
+#if HXCPP_SCRIPTABLE
+static hx::StaticInfo Math_obj_sStaticStorageInfo[] = {
+	{hx::fsFloat,(void *) &Math_obj::PI,HX_HCSTRING("PI","\xf9","\x45","\x00","\x00")},
+	{hx::fsFloat,(void *) &Math_obj::NEGATIVE_INFINITY,HX_HCSTRING("NEGATIVE_INFINITY","\x32","\xf1","\x1e","\x93")},
+	{hx::fsFloat,(void *) &Math_obj::POSITIVE_INFINITY,HX_HCSTRING("POSITIVE_INFINITY","\x6e","\x48","\x1e","\x72")},
+	{hx::fsFloat,(void *) &Math_obj::NaN,HX_HCSTRING("NaN","\x9b","\x84","\x3b","\x00")},
+	{ hx::fsUnknown, 0, null()}
+};
+#endif
+
+void Math_obj::__boot()
+{
+   Static(Math_obj::__mClass) = hx::_hx_RegisterClass(HX_CSTRING("Math"),TCanCast<Math_obj>,sMathFields,sNone, &__CreateEmpty,0 , 0 );
+
+#ifdef HXCPP_SCRIPTABLE
+   Math_obj::__mClass->mStaticStorageInfo = Math_obj_sStaticStorageInfo;
+#endif
+
+#if defined(HX_WINDOWS) || defined(__SNC__)
+   unsigned int t = clock();
+#else
+   struct timeval tv;
+   gettimeofday(&tv,0);
+   unsigned int t = tv.tv_sec * 1000000 + tv.tv_usec;
+#endif
+
+#if defined(HX_WINDOWS) && !defined(__BORLANDC__)
+  #if defined(HX_WINRT)
+   #if defined(__cplusplus_winrt)
+   int pid = Windows::Security::Cryptography::CryptographicBuffer::GenerateRandomNumber();
+   #else
+   int pid = GetCurrentProcessId();
+   #endif
+  #else
+   int pid = _getpid();
+  #endif
+#else
+   int pid = getpid();
+#endif  
+
+  srand(t ^ (pid | (pid << 16)));
+  #ifdef HX_ANDROID
+  srand48(t ^ (pid | (pid << 16)));
+  #endif
+  rand();
+}
+
+namespace hx
+{
+
+double DoubleMod(double inLHS,double inRHS)
+{
+   return fmod(inLHS,inRHS);
+}
+
+double hxZero = 0.0;
+double DivByZero(double d)
+{
+   return d/hxZero;
+}
+
+
+}
+
+
diff --git a/Sources/c_snikket/src/Reflect.cpp b/Sources/c_snikket/src/Reflect.cpp
new file mode 100644
index 0000000..415f3f9
--- /dev/null
+++ b/Sources/c_snikket/src/Reflect.cpp
@@ -0,0 +1,264 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Reflect
+#include <Reflect.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_7b3988d9963d5a21_30_hasField,"Reflect","hasField",0xef8c2571,"Reflect.hasField","/usr/local/lib/haxe/std/cpp/_std/Reflect.hx",30,0x1c2422c3)
+HX_LOCAL_STACK_FRAME(_hx_pos_7b3988d9963d5a21_35_field,"Reflect","field",0x54b04da9,"Reflect.field","/usr/local/lib/haxe/std/cpp/_std/Reflect.hx",35,0x1c2422c3)
+HX_LOCAL_STACK_FRAME(_hx_pos_7b3988d9963d5a21_40_setField,"Reflect","setField",0x71684429,"Reflect.setField","/usr/local/lib/haxe/std/cpp/_std/Reflect.hx",40,0x1c2422c3)
+HX_LOCAL_STACK_FRAME(_hx_pos_7b3988d9963d5a21_45_getProperty,"Reflect","getProperty",0x632ca13a,"Reflect.getProperty","/usr/local/lib/haxe/std/cpp/_std/Reflect.hx",45,0x1c2422c3)
+HX_LOCAL_STACK_FRAME(_hx_pos_7b3988d9963d5a21_54_callMethod,"Reflect","callMethod",0xb49e52d0,"Reflect.callMethod","/usr/local/lib/haxe/std/cpp/_std/Reflect.hx",54,0x1c2422c3)
+HX_LOCAL_STACK_FRAME(_hx_pos_7b3988d9963d5a21_67_fields,"Reflect","fields",0xc593a6aa,"Reflect.fields","/usr/local/lib/haxe/std/cpp/_std/Reflect.hx",67,0x1c2422c3)
+HX_LOCAL_STACK_FRAME(_hx_pos_7b3988d9963d5a21_77_isFunction,"Reflect","isFunction",0x0f1541d3,"Reflect.isFunction","/usr/local/lib/haxe/std/cpp/_std/Reflect.hx",77,0x1c2422c3)
+HX_LOCAL_STACK_FRAME(_hx_pos_7b3988d9963d5a21_81_compare,"Reflect","compare",0xa2d92b54,"Reflect.compare","/usr/local/lib/haxe/std/cpp/_std/Reflect.hx",81,0x1c2422c3)
+HX_LOCAL_STACK_FRAME(_hx_pos_7b3988d9963d5a21_84_compareMethods,"Reflect","compareMethods",0x8b8ddd7e,"Reflect.compareMethods","/usr/local/lib/haxe/std/cpp/_std/Reflect.hx",84,0x1c2422c3)
+HX_LOCAL_STACK_FRAME(_hx_pos_7b3988d9963d5a21_93_isObject,"Reflect","isObject",0xd04960ba,"Reflect.isObject","/usr/local/lib/haxe/std/cpp/_std/Reflect.hx",93,0x1c2422c3)
+HX_LOCAL_STACK_FRAME(_hx_pos_7b3988d9963d5a21_102_isEnumValue,"Reflect","isEnumValue",0x97884d95,"Reflect.isEnumValue","/usr/local/lib/haxe/std/cpp/_std/Reflect.hx",102,0x1c2422c3)
+HX_LOCAL_STACK_FRAME(_hx_pos_7b3988d9963d5a21_112_copy,"Reflect","copy",0x47e2b5a6,"Reflect.copy","/usr/local/lib/haxe/std/cpp/_std/Reflect.hx",112,0x1c2422c3)
+
+void Reflect_obj::__construct() { }
+
+Dynamic Reflect_obj::__CreateEmpty() { return new Reflect_obj; }
+
+void *Reflect_obj::_hx_vtable = 0;
+
+Dynamic Reflect_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Reflect_obj > _hx_result = new Reflect_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool Reflect_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x769a515d;
+}
+
+bool Reflect_obj::hasField( ::Dynamic o,::String field){
+            	HX_STACKFRAME(&_hx_pos_7b3988d9963d5a21_30_hasField)
+HXDLIN(  30)		return (::hx::IsNotNull( o ) && ( (bool)(o->__HasField(field)) ));
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(Reflect_obj,hasField,return )
+
+ ::Dynamic Reflect_obj::field( ::Dynamic o,::String field){
+            	HX_STACKFRAME(&_hx_pos_7b3988d9963d5a21_35_field)
+HXDLIN(  35)		return ::hx::IsNull( o ) ? null() : o->__Field(field,::hx::paccNever);
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(Reflect_obj,field,return )
+
+void Reflect_obj::setField( ::Dynamic o,::String field, ::Dynamic value){
+            	HX_STACKFRAME(&_hx_pos_7b3988d9963d5a21_40_setField)
+HXDLIN(  40)		if (::hx::IsNotNull( o )) {
+HXLINE(  41)			o->__SetField(field,value,::hx::paccNever);
+            		}
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC3(Reflect_obj,setField,(void))
+
+ ::Dynamic Reflect_obj::getProperty( ::Dynamic o,::String field){
+            	HX_STACKFRAME(&_hx_pos_7b3988d9963d5a21_45_getProperty)
+HXDLIN(  45)		return ::hx::IsNull( o ) ? null() : o->__Field(field,::hx::paccAlways);
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(Reflect_obj,getProperty,return )
+
+ ::Dynamic Reflect_obj::callMethod( ::Dynamic o, ::Dynamic func,::cpp::VirtualArray args){
+            	HX_STACKFRAME(&_hx_pos_7b3988d9963d5a21_54_callMethod)
+HXLINE(  55)		if ((::hx::IsNotNull( func ) && ::hx::IsEq( func->__GetType(),3 ))) {
+HXLINE(  56)			if (::hx::IsNull( o )) {
+HXLINE(  57)				HX_STACK_DO_THROW(HX_STACK_DO_THROW(HX_INVALID_OBJECT));
+            			}
+HXLINE(  58)			func = o->__Field(func,::hx::paccDynamic);
+            		}
+HXLINE(  60)		if (::hx::IsNull( func )) {
+HXLINE(  61)			HX_STACK_DO_THROW(HX_STACK_DO_THROW(HX_NULL_FUNCTION_POINTER));
+            		}
+HXLINE(  62)		func->__SetThis(o);
+HXLINE(  63)		return func->__Run(args);
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC3(Reflect_obj,callMethod,return )
+
+::Array< ::String > Reflect_obj::fields( ::Dynamic o){
+            	HX_STACKFRAME(&_hx_pos_7b3988d9963d5a21_67_fields)
+HXLINE(  68)		if (::hx::IsNull( o )) {
+HXLINE(  69)			return ::Array_obj< ::String >::__new();
+            		}
+HXLINE(  70)		::Array< ::String > a = ::Array_obj< ::String >::__new(0);
+HXLINE(  71)		o->__GetFields(a);
+HXLINE(  72)		return a;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Reflect_obj,fields,return )
+
+bool Reflect_obj::isFunction( ::Dynamic f){
+            	HX_STACKFRAME(&_hx_pos_7b3988d9963d5a21_77_isFunction)
+HXDLIN(  77)		return (::hx::IsNotNull( f ) && ::hx::IsEq( f->__GetType(),6 ));
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Reflect_obj,isFunction,return )
+
+int Reflect_obj::compare( ::Dynamic a, ::Dynamic b){
+            	HX_STACKFRAME(&_hx_pos_7b3988d9963d5a21_81_compare)
+HXDLIN(  81)		return ::hx::IsEq( a,b ) ? 0 : ::hx::IsGreater( a,b ) ? 1 : -1;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(Reflect_obj,compare,return )
+
+bool Reflect_obj::compareMethods( ::Dynamic f1, ::Dynamic f2){
+            	HX_STACKFRAME(&_hx_pos_7b3988d9963d5a21_84_compareMethods)
+HXLINE(  85)		if (::hx::IsEq( f1,f2 )) {
+HXLINE(  86)			return true;
+            		}
+HXLINE(  87)		if ((!(::Reflect_obj::isFunction(f1)) || !(::Reflect_obj::isFunction(f2)))) {
+HXLINE(  88)			return false;
+            		}
+HXLINE(  89)		return  ::__hxcpp_same_closure(f1,f2);
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(Reflect_obj,compareMethods,return )
+
+bool Reflect_obj::isObject( ::Dynamic v){
+            	HX_STACKFRAME(&_hx_pos_7b3988d9963d5a21_93_isObject)
+HXLINE(  94)		if (::hx::IsNull( v )) {
+HXLINE(  95)			return false;
+            		}
+HXLINE(  96)		int t = ( (int)(v->__GetType()) );
+HXLINE(  97)		return ((((t == 4) || (t == 8)) || (t == 3)) || (t == 5));
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Reflect_obj,isObject,return )
+
+bool Reflect_obj::isEnumValue( ::Dynamic v){
+            	HX_STACKFRAME(&_hx_pos_7b3988d9963d5a21_102_isEnumValue)
+HXDLIN( 102)		return (::hx::IsNotNull( v ) && ::hx::IsEq( v->__GetType(),7 ));
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Reflect_obj,isEnumValue,return )
+
+ ::Dynamic Reflect_obj::copy( ::Dynamic o){
+            	HX_STACKFRAME(&_hx_pos_7b3988d9963d5a21_112_copy)
+HXLINE( 113)		if (::hx::IsNull( o )) {
+HXLINE( 114)			return null();
+            		}
+HXLINE( 115)		if (::hx::IsEq( o->__GetType(),3 )) {
+HXLINE( 116)			return o;
+            		}
+HXLINE( 117)		if (::hx::IsEq( o->__GetType(),5 )) {
+HXLINE( 118)			return o->__Field(HX_("copy",b5,bb,c4,41),::hx::paccDynamic)();
+            		}
+HXLINE( 119)		 ::Dynamic o2 =  ::Dynamic(::hx::Anon_obj::Create(0));
+HXLINE( 120)		{
+HXLINE( 120)			int _g = 0;
+HXDLIN( 120)			::Array< ::String > _g1 = ::Reflect_obj::fields(o);
+HXDLIN( 120)			while((_g < _g1->length)){
+HXLINE( 120)				::String f = _g1->__get(_g);
+HXDLIN( 120)				++_g;
+HXLINE( 121)				::Reflect_obj::setField(o2,f,::Reflect_obj::field(o,f));
+            			}
+            		}
+HXLINE( 122)		return o2;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Reflect_obj,copy,return )
+
+
+Reflect_obj::Reflect_obj()
+{
+}
+
+bool Reflect_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"copy") ) { outValue = copy_dyn(); return true; }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"field") ) { outValue = field_dyn(); return true; }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"fields") ) { outValue = fields_dyn(); return true; }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"compare") ) { outValue = compare_dyn(); return true; }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"hasField") ) { outValue = hasField_dyn(); return true; }
+		if (HX_FIELD_EQ(inName,"setField") ) { outValue = setField_dyn(); return true; }
+		if (HX_FIELD_EQ(inName,"isObject") ) { outValue = isObject_dyn(); return true; }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"callMethod") ) { outValue = callMethod_dyn(); return true; }
+		if (HX_FIELD_EQ(inName,"isFunction") ) { outValue = isFunction_dyn(); return true; }
+		break;
+	case 11:
+		if (HX_FIELD_EQ(inName,"getProperty") ) { outValue = getProperty_dyn(); return true; }
+		if (HX_FIELD_EQ(inName,"isEnumValue") ) { outValue = isEnumValue_dyn(); return true; }
+		break;
+	case 14:
+		if (HX_FIELD_EQ(inName,"compareMethods") ) { outValue = compareMethods_dyn(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *Reflect_obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo *Reflect_obj_sStaticStorageInfo = 0;
+#endif
+
+::hx::Class Reflect_obj::__mClass;
+
+static ::String Reflect_obj_sStaticFields[] = {
+	HX_("hasField",00,df,eb,8c),
+	HX_("field",ba,94,93,00),
+	HX_("setField",b8,fd,c7,0e),
+	HX_("getProperty",0b,0b,2c,d2),
+	HX_("callMethod",1f,ce,8a,34),
+	HX_("fields",79,8e,8e,80),
+	HX_("isFunction",22,bd,01,8f),
+	HX_("compare",a5,18,69,83),
+	HX_("compareMethods",4d,ac,7b,37),
+	HX_("isObject",49,1a,a9,6d),
+	HX_("isEnumValue",66,b7,87,06),
+	HX_("copy",b5,bb,c4,41),
+	::String(null())
+};
+
+void Reflect_obj::__register()
+{
+	Reflect_obj _hx_dummy;
+	Reflect_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("Reflect",1d,ac,7a,b6);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &Reflect_obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(Reflect_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< Reflect_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Reflect_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Reflect_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
diff --git a/Sources/c_snikket/src/Std.cpp b/Sources/c_snikket/src/Std.cpp
new file mode 100644
index 0000000..dc5c1ab
--- /dev/null
+++ b/Sources/c_snikket/src/Std.cpp
@@ -0,0 +1,201 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Std
+#include <Std.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_e2e0452d28e59cd7_26_is,"Std","is",0x3c56d6f5,"Std.is","/usr/local/lib/haxe/std/cpp/_std/Std.hx",26,0xe751091d)
+HX_LOCAL_STACK_FRAME(_hx_pos_e2e0452d28e59cd7_30_isOfType,"Std","isOfType",0x6718c846,"Std.isOfType","/usr/local/lib/haxe/std/cpp/_std/Std.hx",30,0xe751091d)
+HX_LOCAL_STACK_FRAME(_hx_pos_e2e0452d28e59cd7_34_downcast,"Std","downcast",0x4619c56c,"Std.downcast","/usr/local/lib/haxe/std/cpp/_std/Std.hx",34,0xe751091d)
+HX_LOCAL_STACK_FRAME(_hx_pos_e2e0452d28e59cd7_39_instance,"Std","instance",0x1431f4e0,"Std.instance","/usr/local/lib/haxe/std/cpp/_std/Std.hx",39,0xe751091d)
+HX_LOCAL_STACK_FRAME(_hx_pos_e2e0452d28e59cd7_43_string,"Std","string",0xcf48855c,"Std.string","/usr/local/lib/haxe/std/cpp/_std/Std.hx",43,0xe751091d)
+HX_LOCAL_STACK_FRAME(_hx_pos_e2e0452d28e59cd7_47_int,"Std","int",0x8fa53b84,"Std.int","/usr/local/lib/haxe/std/cpp/_std/Std.hx",47,0xe751091d)
+HX_LOCAL_STACK_FRAME(_hx_pos_e2e0452d28e59cd7_51_parseInt,"Std","parseInt",0x90c2ebc7,"Std.parseInt","/usr/local/lib/haxe/std/cpp/_std/Std.hx",51,0xe751091d)
+HX_LOCAL_STACK_FRAME(_hx_pos_e2e0452d28e59cd7_55_parseFloat,"Std","parseFloat",0xbca10a74,"Std.parseFloat","/usr/local/lib/haxe/std/cpp/_std/Std.hx",55,0xe751091d)
+HX_LOCAL_STACK_FRAME(_hx_pos_e2e0452d28e59cd7_58_random,"Std","random",0x75a77e8e,"Std.random","/usr/local/lib/haxe/std/cpp/_std/Std.hx",58,0xe751091d)
+
+void Std_obj::__construct() { }
+
+Dynamic Std_obj::__CreateEmpty() { return new Std_obj; }
+
+void *Std_obj::_hx_vtable = 0;
+
+Dynamic Std_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Std_obj > _hx_result = new Std_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool Std_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x7ee3a517;
+}
+
+bool Std_obj::is( ::Dynamic v, ::Dynamic t){
+            	HX_STACKFRAME(&_hx_pos_e2e0452d28e59cd7_26_is)
+HXDLIN(  26)		return ::Std_obj::isOfType(v,t);
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(Std_obj,is,return )
+
+bool Std_obj::isOfType( ::Dynamic v, ::Dynamic t){
+            	HX_STACKFRAME(&_hx_pos_e2e0452d28e59cd7_30_isOfType)
+HXDLIN(  30)		return  ::__instanceof(v,t);
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(Std_obj,isOfType,return )
+
+ ::Dynamic Std_obj::downcast( ::Dynamic value,::hx::Class c){
+            	HX_STACKFRAME(&_hx_pos_e2e0452d28e59cd7_34_downcast)
+HXDLIN(  34)		if (::Std_obj::isOfType(value,c)) {
+HXDLIN(  34)			return value;
+            		}
+            		else {
+HXDLIN(  34)			return null();
+            		}
+HXDLIN(  34)		return null();
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(Std_obj,downcast,return )
+
+ ::Dynamic Std_obj::instance( ::Dynamic value,::hx::Class c){
+            	HX_STACKFRAME(&_hx_pos_e2e0452d28e59cd7_39_instance)
+HXDLIN(  39)		 ::Dynamic _hx_tmp;
+HXDLIN(  39)		if (::Std_obj::isOfType(value,c)) {
+HXDLIN(  39)			_hx_tmp = value;
+            		}
+            		else {
+HXDLIN(  39)			_hx_tmp = null();
+            		}
+HXDLIN(  39)		return _hx_tmp;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(Std_obj,instance,return )
+
+::String Std_obj::string( ::Dynamic s){
+            	HX_STACKFRAME(&_hx_pos_e2e0452d28e59cd7_43_string)
+HXDLIN(  43)		if (::hx::IsNull( s )) {
+HXDLIN(  43)			return HX_("null",87,9e,0e,49);
+            		}
+            		else {
+HXDLIN(  43)			return ( (::String)(s->toString()) );
+            		}
+HXDLIN(  43)		return null();
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Std_obj,string,return )
+
+int Std_obj::_hx_int(Float x){
+            	HX_STACKFRAME(&_hx_pos_e2e0452d28e59cd7_47_int)
+HXDLIN(  47)		return  ::__int__(x);
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Std_obj,_hx_int,return )
+
+ ::Dynamic Std_obj::parseInt(::String x){
+            	HX_STACKFRAME(&_hx_pos_e2e0452d28e59cd7_51_parseInt)
+HXDLIN(  51)		return  ::__hxcpp_parse_int(x);
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Std_obj,parseInt,return )
+
+Float Std_obj::parseFloat(::String x){
+            	HX_STACKFRAME(&_hx_pos_e2e0452d28e59cd7_55_parseFloat)
+HXDLIN(  55)		return  ::__hxcpp_parse_float(x);
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Std_obj,parseFloat,return )
+
+int Std_obj::random(int x){
+            	HX_STACKFRAME(&_hx_pos_e2e0452d28e59cd7_58_random)
+HXLINE(  59)		if ((x <= 0)) {
+HXLINE(  60)			return 0;
+            		}
+HXLINE(  61)		return  ::__hxcpp_irand(x);
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Std_obj,random,return )
+
+
+Std_obj::Std_obj()
+{
+}
+
+bool Std_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 2:
+		if (HX_FIELD_EQ(inName,"is") ) { outValue = is_dyn(); return true; }
+		break;
+	case 3:
+		if (HX_FIELD_EQ(inName,"int") ) { outValue = _hx_int_dyn(); return true; }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"string") ) { outValue = string_dyn(); return true; }
+		if (HX_FIELD_EQ(inName,"random") ) { outValue = random_dyn(); return true; }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"isOfType") ) { outValue = isOfType_dyn(); return true; }
+		if (HX_FIELD_EQ(inName,"downcast") ) { outValue = downcast_dyn(); return true; }
+		if (HX_FIELD_EQ(inName,"instance") ) { outValue = instance_dyn(); return true; }
+		if (HX_FIELD_EQ(inName,"parseInt") ) { outValue = parseInt_dyn(); return true; }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"parseFloat") ) { outValue = parseFloat_dyn(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *Std_obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo *Std_obj_sStaticStorageInfo = 0;
+#endif
+
+::hx::Class Std_obj::__mClass;
+
+static ::String Std_obj_sStaticFields[] = {
+	HX_("is",ea,5b,00,00),
+	HX_("isOfType",fb,f2,c7,ac),
+	HX_("downcast",21,f0,c8,8b),
+	HX_("instance",95,1f,e1,59),
+	HX_("string",d1,28,30,11),
+	HX_("int",ef,0c,50,00),
+	HX_("parseInt",7c,16,72,d6),
+	HX_("parseFloat",69,0c,78,2c),
+	HX_("random",03,22,8f,b7),
+	::String(null())
+};
+
+void Std_obj::__register()
+{
+	Std_obj _hx_dummy;
+	Std_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("Std",83,60,3f,00);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &Std_obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(Std_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< Std_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Std_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Std_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
diff --git a/Sources/c_snikket/src/String.cpp b/Sources/c_snikket/src/String.cpp
new file mode 100644
index 0000000..815d976
--- /dev/null
+++ b/Sources/c_snikket/src/String.cpp
@@ -0,0 +1,2417 @@
+#include <hxcpp.h>
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <set>
+#include <string>
+#include <hx/Unordered.h>
+#include "hx/Hash.h"
+#include <hx/Thread.h>
+#include <locale>
+
+using namespace hx;
+
+#if defined(BLACKBERRY)
+using namespace std;
+#endif
+
+// -------- String ----------------------------------------
+
+
+#ifdef HX_WINDOWS
+
+#ifndef _MSC_VER
+#define _MSC_VER 1
+#endif
+
+// vc 7...
+#if _MSC_VER < 1400
+
+#define SPRINTF _snprintf
+
+#else // vc8+
+
+#define SPRINTF _snprintf_s
+
+#endif
+
+#else // not windows ..
+
+#define SPRINTF snprintf
+
+#endif
+
+#ifdef HX_SMART_STRINGS
+#include "hx/Unicase.h"
+#endif
+
+namespace hx
+{
+char HX_DOUBLE_PATTERN[20] = "%.15g";
+#define HX_INT_PATTERN "%d"
+#define HX_UINT_PATTERN "%ud"
+}
+
+void __hxcpp_set_float_format(String inFormat)
+{
+  int last = inFormat.length < 19 ? inFormat.length : 19;
+  memcpy(HX_DOUBLE_PATTERN, inFormat.utf8_str(), last*sizeof(char) );
+  HX_DOUBLE_PATTERN[last] = '\0';
+}
+
+// --- GC helper
+
+hx::Class __StringClass;
+
+String  String::emptyString = HX_("",00,00,00,00);
+static Dynamic sConstEmptyString;
+static String  sConstStrings[256];
+static Dynamic sConstDynamicStrings[256];
+static String *sCharToString[1088] = { 0 };
+
+
+typedef Hash<TNonGcStringSet> StringSet;
+static StringSet *sPermanentStringSet = 0;
+static volatile int sPermanentStringSetMutex = 0;
+
+#ifdef HXCPP_COMBINE_STRINGS
+static bool sIsIdent[256];
+static bool InitIdent()
+{
+   for(int i=0;i<256;i++)
+      sIsIdent[i]= (i>='a' && i<='z') || (i>='A' && i<='Z') || (i>='0' && i<='9') || (i=='_');
+   return true;
+}
+#endif
+
+inline static bool IsUtf16Surrogate(int ch)
+{
+   return ch>=0xd800 && ch<0xe000;
+}
+inline static bool IsUtf16LowSurrogate(int ch)
+{
+   return ch>=0xdc00 && ch<0xe000;
+}
+inline static bool IsUtf16HighSurrogate(int ch)
+{
+   return ch>=0xd800 && ch<0xdc00;
+}
+
+static int UTF8Bytes(int c)
+{
+      if( c <= 0x7F )
+         return 1;
+      else if( c <= 0x7FF )
+         return 2;
+      else if( c <= 0xFFFF )
+         return 3;
+      else
+         return 4;
+}
+
+inline static int UTF16BytesCheck(int ch)
+{
+   if (ch>=0x10000)
+   {
+      if (ch<0x110000)
+          return 2;
+   }
+   return 1;
+}
+
+static void UTF8EncodeAdvance(char * &ioPtr,int c)
+{
+      if( c <= 0x7F )
+         *ioPtr++ = (c);
+      else if( c <= 0x7FF )
+      {
+         *ioPtr++ = ( 0xC0 | (c >> 6) );
+         *ioPtr++ = ( 0x80 | (c & 63) );
+      }
+      else if( c <= 0xFFFF )
+      {
+         *ioPtr++  = ( 0xE0 | (c >> 12) );
+         *ioPtr++  = ( 0x80 | ((c >> 6) & 63) );
+         *ioPtr++  = ( 0x80 | (c & 63) );
+      }
+      else
+      {
+         *ioPtr++  = ( 0xF0 | (c >> 18) );
+         *ioPtr++  = ( 0x80 | ((c >> 12) & 63) );
+         *ioPtr++  = ( 0x80 | ((c >> 6) & 63) );
+         *ioPtr++  = ( 0x80 | (c & 63) );
+      }
+}
+
+static unsigned char *sUtf8LenArray = 0;
+
+static const unsigned char *getUtf8LenArray()
+{
+   if (!sUtf8LenArray)
+   {
+      sUtf8LenArray = (unsigned char *)malloc(256);
+      for(int i=0;i<256;i++)
+         sUtf8LenArray[i] =  i< 0x80 ? 1 : i<0xe0 ? 2 : i<0xf0 ? 3 : 4;
+   }
+   return sUtf8LenArray;
+}
+
+static inline int DecodeAdvanceUTF8(const unsigned char * &ioPtr)
+{
+   int c = *ioPtr++;
+   if( c < 0x80 )
+   {
+      return c;
+   }
+   else if( c < 0xE0 )
+   {
+      return ((c & 0x3F) << 6) | ((*ioPtr++) & 0x7F);
+   }
+   else if( c < 0xF0 )
+   {
+      int c2 = *ioPtr++;
+      return  ((c & 0x1F) << 12) | ((c2 & 0x7F) << 6) | ( (*ioPtr++) & 0x7F);
+   }
+
+   int c2 = *ioPtr++;
+   int c3 = *ioPtr++;
+   return ((c & 0x0F) << 18) | ((c2 & 0x7F) << 12) | ((c3 & 0x7F) << 6) | ((*ioPtr++) & 0x7F);
+}
+
+static inline int DecodeAdvanceUTF8(const unsigned char * &ioPtr,const unsigned char *end)
+{
+   int c = *ioPtr++;
+   if( c < 0x80 )
+   {
+      return c;
+   }
+   else if( c < 0xE0 )
+   {
+      return ((c & 0x3F) << 6) | (ioPtr < end ? (*ioPtr++) & 0x7F : 0);
+   }
+   else if( c < 0xF0 )
+   {
+      int c2 = ioPtr<end ? *ioPtr++ : 0;
+      return  ((c & 0x1F) << 12) | ((c2 & 0x7F) << 6) | ( ioPtr<end ? (*ioPtr++) & 0x7F : 0 );
+   }
+
+   int c2 = ioPtr<end ? *ioPtr++ : 0;
+   int c3 = ioPtr<end ? *ioPtr++ : 0;
+   return ((c & 0x0F) << 18) | ((c2 & 0x7F) << 12) | ((c3 & 0x7F) << 6) | ( ioPtr<end ? (*ioPtr++) & 0x7F : 0);
+}
+
+
+int _hx_utf8_decode_advance(char *&ioPtr)
+{
+   return DecodeAdvanceUTF8( (const unsigned char * &) ioPtr );
+}
+
+
+inline int Char16Advance(const char16_t *&ioStr,bool throwOnErr=true)
+{
+   int ch = *ioStr++;
+   if (IsUtf16Surrogate(ch))
+   {
+      if (IsUtf16LowSurrogate(ch))
+      {
+         if (throwOnErr)
+            hx::Throw(HX_CSTRING("Invalid UTF16"));
+         return 0xFFFD;
+      }
+
+      int peek = *ioStr++;
+      if (IsUtf16HighSurrogate(peek))
+      {
+         if (throwOnErr)
+            hx::Throw(HX_CSTRING("Invalid UTF16"));
+         return 0xFFFD;
+      }
+
+      ch = 0x10000 + ((ch-0xd800)  << 10) | (peek-0xdc00);
+   }
+   return ch;
+}
+
+
+void Char16AdvanceSet(char16_t *&ioStr,int inChar)
+{
+   if (inChar>=0x10000)
+   {
+      int over = (inChar-0x10000);
+      if (over>=0x100000)
+      {
+         *ioStr++ = 0xfffd;
+      }
+      else
+      {
+         *ioStr++ = (over>>10) + 0xd800;
+         *ioStr++ = (over&0x3ff) + 0xdc00;
+      }
+   }
+   else if (IsUtf16Surrogate(inChar))
+   {
+      *ioStr++ = 0xfffd;
+   }
+   else
+      *ioStr++ = inChar;
+}
+
+
+template<typename T>
+char *TConvertToUTF8(const T *inStr, int *ioLen, hx::IStringAlloc *inBuffer,bool)
+{
+   int len = 0;
+   int chars = 0;
+   if (ioLen==0 || *ioLen==0)
+   {
+      while(inStr[len])
+         chars += UTF8Bytes(inStr[len++]);
+   }
+   else
+   {
+      len = *ioLen;
+      for(int i=0;i<len;i++)
+         chars += UTF8Bytes(inStr[i]);
+   }
+
+   char *buf = inBuffer ? (char *)inBuffer->allocBytes(chars+1) :
+                          (char *)NewGCPrivate(0,chars+1);
+   char *ptr = buf;
+   for(int i=0;i<len;i++)
+       UTF8EncodeAdvance(ptr,inStr[i]);
+   *ptr = 0;
+   if (ioLen)
+      *ioLen = chars;
+
+   return buf;
+}
+
+
+template<>
+char *TConvertToUTF8(const char16_t *inStr, int *ioLen, hx::IStringAlloc *inBuffer,bool throwInvalid)
+{
+   int len = 0;
+   if (ioLen==0 || *ioLen==0)
+   {
+      const char16_t *s = inStr;
+      while( Char16Advance(s,throwInvalid) ) { }
+      len = s - inStr - 1;
+   }
+   else
+   {
+      len = *ioLen;
+   }
+   const char16_t *s = inStr;
+   const char16_t *end = s + len;
+   int chars = 0;
+   while(s<end)
+      chars += UTF8Bytes( Char16Advance( s,throwInvalid ) );
+
+   char *buf = inBuffer ? (char *)inBuffer->allocBytes(chars+1) :
+                          (char *)NewGCPrivate(0,chars+1);
+   char *ptr = buf;
+   s = inStr;
+   while(s<end)
+      UTF8EncodeAdvance(ptr,Char16Advance(s,throwInvalid));
+
+   *ptr = 0;
+   if (ioLen)
+      *ioLen = chars;
+
+   return buf;
+}
+
+char16_t *String::allocChar16Ptr(int len)
+{
+   char16_t *result = (char16_t *)hx::InternalNew( (len+1)*2, false );
+   ((unsigned int *)result)[-1] |= HX_GC_STRING_CHAR16_T;
+   result[len] = 0;
+   return result;
+}
+
+
+template<typename T>
+static const char *GCStringDup(const T *inStr,int inLen, int *outLen=0)
+{
+   if (inStr==0 && inLen<=0)
+   {
+      if (outLen)
+         outLen = 0;
+      return String::emptyString.raw_ptr();
+   }
+
+   int len = inLen;
+   bool allAscii = true;
+   if (len==-1)
+   {
+      len=0;
+      while(inStr[len])
+      {
+         if (sizeof(T)>1 && allAscii)
+            allAscii = inStr[len] <= 127;
+         len++;
+      }
+   }
+   else if (sizeof(T)>1)
+   {
+      for(int i=0;i<inLen;i++)
+         if (inStr[i]>127)
+         {
+            allAscii = false;
+            break;
+         }
+   }
+
+   if (outLen)
+      *outLen = len;
+
+   if (len==1)
+      return String::fromCharCode(inStr[0]).raw_ptr();
+
+   #ifdef HXCPP_COMBINE_STRINGS
+   bool ident = len<20 && sIsIdent[inStr[0]] && (inStr[0]<'0' || inStr[0]>'9');
+   if (ident && len>3)
+      for(int p=1; p<len;p++)
+         if (!sIsIdent[ inStr[p] ])
+         {
+            ident = false;
+            break;
+         }
+
+   if (ident)
+   {
+      hx::StackContext *ctx = hx::StackContext::getCurrent();
+      if (!ctx->stringSet)
+         ctx->stringSet = new WeakStringSet();
+
+      unsigned int hash = 0;
+      for(int i=0;i<len;i++)
+         hash = hash*223 + ((unsigned char *)inStr)[i];
+
+      struct Finder
+      {
+         int len;
+         const char *ptr;
+         Finder(int len, const char *inPtr) : len(len), ptr(inPtr) { }
+         bool operator==(const String &inStr) const
+         {
+            return len == inStr.length && !memcmp(ptr, inStr.__s, len*sizeof(char));
+         }
+      };
+      String found;
+      if (ctx->stringSet->findEquivalentKey(found, hash, Finder(len, inStr)))
+         return found.__s;
+
+      char *result = hx::NewString(len + 4);
+      memcpy(result,inStr,sizeof(char)*(len));
+      result[len] = '\0';
+      *((unsigned int *)(result + len + 1)) = hash;
+      ((unsigned int *)(result))[-1] |= HX_GC_STRING_HASH;
+
+      String asString(result, len);
+      ctx->stringSet->TSet( asString, true );
+
+      return result;
+   }
+   #endif
+
+   if (sizeof(T)==1 || allAscii)
+   {
+      char *result = hx::NewString( len );
+      if (sizeof(T)==1)
+         memcpy(result,inStr,sizeof(char)*(len));
+      else
+         for(int i=0;i<len;i++)
+            result[i] = inStr[i];
+      return result;
+   }
+
+
+   char16_t *result = String::allocChar16Ptr(len);
+   memcpy(result,inStr,2*len);
+   if (IsUtf16LowSurrogate(result[0]))
+      result[0] = 0xFFFD;
+   if (len>1 && IsUtf16HighSurrogate(result[len-1]))
+      result[len-1] = 0xFFFD;
+   return (const char *)result;
+}
+
+
+
+
+template<typename T>
+inline String TCopyString(const T *inString,int inLength)
+{
+   if (!inString)
+      return String();
+
+   #ifndef HX_SMART_STRINGS
+      if (inLength<0)
+         for(inLength=0; !inString[inLength]; inString++) { }
+
+      if (sizeof(T)==1)
+      {
+         int len = 0;
+         const char *res = GCStringDup((const char *)inString,inLength,&len);
+         return String(res,len);
+      }
+      else
+      {
+         int length = inLength;
+         const char *ptr = TConvertToUTF8(inString, &length, 0, true );
+         return String(ptr,length);
+      }
+   #else
+      int c16len=0;
+      bool hasWChar = false;
+      const T *end = inLength>=0 ? inString + inLength : 0;
+      if (end)
+      {
+         for(const T *s = inString; s<end; s++)
+         {
+            unsigned int c = *s;
+            if (c>127)
+               hasWChar = true;
+            c16len += UTF16BytesCheck(c);
+         }
+      }
+      else
+         for(const T *s = inString; *s; s++)
+         {
+            unsigned int c = *s;
+            if (c>127)
+               hasWChar = true;
+            c16len += UTF16BytesCheck(c);
+         }
+
+      if (hasWChar)
+      {
+         char16_t *result = String::allocChar16Ptr(c16len);
+         c16len = 0;
+         for(const T *s = inString; ; s++)
+         {
+            if (end)
+            {
+               if (s>=end) break;
+            }
+            else
+            {
+               if (!*s) break;
+            }
+            unsigned int c = *s;
+            if (c<0x10000)
+               result[c16len++] = c;
+            else
+            {
+               int over = (c-0x10000);
+               result[c16len++] = (over>>10) + 0xd800;
+               result[c16len++] = (over&0x3ff) + 0xdc00;
+            }
+         }
+         return String(result,c16len);
+      }
+      else
+      {
+         char *s = hx::NewString(c16len);
+         for(int i=0;i<c16len;i++)
+            s[i] = (char)inString[i];
+         return String(s,c16len);
+      }
+   #endif
+}
+
+
+String __hxcpp_char_array_to_utf8_string(Array<int> &inChars,int inFirst, int inLen)
+{
+   int len = inChars->length;
+   if (inFirst<0)
+     inFirst = 0;
+   if (inLen<0) inLen = len;
+   if (inFirst+inLen>len)
+      inLen = len-inFirst;
+   if (inLen<=0)
+      return String::emptyString;
+
+   int *base = &inChars[0];
+   #ifdef HX_SMART_STRINGS
+   bool hasBig = false;
+   for(int i=0;i<inLen;i++)
+      if (base[i+inFirst]>127)
+      {
+         hasBig = true;
+         break;
+      }
+
+   if (hasBig)
+   {
+      char16_t *ptr = String::allocChar16Ptr(inLen);
+      for(int i=0;i<inLen;i++)
+         ptr[i] = base[i+inFirst];
+      return String(ptr, inLen);
+   }
+   #endif
+   char *result = TConvertToUTF8(base+inFirst,&len,0,true);
+   return String(result,len);
+}
+
+Array<int> __hxcpp_utf8_string_to_char_array(String &inString)
+{
+   #ifdef HX_SMART_STRINGS
+   Array<int> result = Array_obj<int>::__new(inString.length);
+   if (inString.isUTF16Encoded())
+   {
+      const char16_t *ptr = inString.wc_str();
+      for(int i=0;i<inString.length;i++)
+         result[i] = ptr[i];
+   }
+   else
+   {
+      const char *ptr = inString.raw_ptr();
+      for(int i=0;i<inString.length;i++)
+         result[i] = ptr[i];
+   }
+   #else
+   Array<int> result = Array_obj<int>::__new(0,inString.length);
+
+   const unsigned char *src = (const unsigned char *)inString.__s;
+   const unsigned char *end = src + inString.length;
+   while(src<end)
+       result->push(DecodeAdvanceUTF8(src));
+
+   if (src!=end)
+      hx::Throw(HX_CSTRING("Invalid UTF8"));
+   #endif
+
+   return result;
+}
+
+
+String __hxcpp_char_bytes_to_utf8_string(String &inBytes)
+{
+   #ifdef HX_SMART_STRINGS
+   // This does not really make much sense
+   return inBytes;
+   #else
+   int len = inBytes.length;
+   char *result = TConvertToUTF8((unsigned char *)inBytes.__s,&len,0,true);
+   return String(result,len);
+   #endif
+}
+
+
+String __hxcpp_utf8_string_to_char_bytes(String &inUTF8)
+{
+   #ifdef HX_SMART_STRINGS
+   // This does not really make much sense
+   return inUTF8;
+   #else
+    const unsigned char *src = (unsigned char *)inUTF8.__s;
+    const unsigned char *end = src + inUTF8.length;
+    int char_count = 0;
+    while(src<end)
+    {
+        int c = DecodeAdvanceUTF8(src,end);
+        char_count++;
+        if( c == 8364 ) // euro symbol
+           c = 164;
+        else if ( c == 0xFEFF ) // BOM
+        {
+           char_count--;
+        }
+        else if( c > 255 )
+            hx::Throw(HX_CSTRING("Utf8::decode invalid character"));
+    }
+
+    if (src!=end)
+       hx::Throw(HX_CSTRING("Invalid UTF8"));
+
+    char *result = hx::NewString(char_count);
+
+    src = (unsigned char *)inUTF8.__s;
+    char_count = 0;
+    while(src<end)
+    {
+        int c = DecodeAdvanceUTF8(src);
+        if( c == 8364 ) // euro symbol
+           c = 164;
+        if ( c != 0xFEFF ) // BOM
+           result[char_count++] = c;
+    }
+
+   result[char_count] = '\0';
+   return String(result,char_count);
+   #endif
+}
+
+
+void _hx_utf8_iter(String inString, Dynamic inIter)
+{
+   #ifdef HX_SMART_STRINGS
+   if (inString.isUTF16Encoded())
+      for(int i=0;i<inString.length;i++)
+         inIter( (int)inString.raw_wptr()[i] );
+   else
+      for(int i=0;i<inString.length;i++)
+         inIter( (int)inString.raw_ptr()[i] );
+   #else
+   const unsigned char *src = (const unsigned char *)inString.__s;
+   const unsigned char *end = src + inString.length;
+
+   while(src<end)
+      inIter(DecodeAdvanceUTF8(src,end+1));
+
+   if (src>end)
+      hx::Throw(HX_CSTRING("Invalid UTF8"));
+   #endif
+}
+
+int _hx_utf8_char_code_at(String inString, int inIndex)
+{
+   #ifdef HX_SMART_STRINGS
+   if (!inString.raw_ptr() || inIndex>=inString.length)
+      return 0;
+   if (inString.isUTF16Encoded())
+      return inString.raw_wptr()[inIndex];
+   else
+      return inString.raw_ptr()[inIndex];
+   #else
+   const unsigned char *src = (const unsigned char *)inString.__s;
+   const unsigned char *end = src + inString.length;
+   const unsigned char *sLen = getUtf8LenArray();
+
+   for(int i=0;i<inIndex;i++)
+   {
+      src += sLen[*src];
+      if (src==end)
+         return 0;
+      if (src>end)
+         hx::Throw(HX_CSTRING("Invalid UTF8"));
+   }
+   return DecodeAdvanceUTF8(src,end);
+   #endif
+}
+
+int _hx_utf8_length(String inString)
+{
+   #ifdef HX_SMART_STRINGS
+   return inString.length;
+   #else
+
+   const unsigned char *src = (const unsigned char *)inString.__s;
+   const unsigned char *end = src + inString.length;
+
+   int len = 0;
+   const unsigned char *sLen = getUtf8LenArray();
+   while(src<end)
+   {
+      src += sLen[*src];
+      len++;
+   }
+   if (src>end)
+      hx::Throw(HX_CSTRING("Invalid UTF8"));
+   return len;
+   #endif
+}
+
+bool _hx_utf8_is_valid(String inString)
+{
+   #ifdef HX_SMART_STRINGS
+   return true;
+   #else
+   const unsigned char *src = (const unsigned char *)inString.__s;
+   const unsigned char *end = src + inString.length;
+   const unsigned char *sLen = getUtf8LenArray();
+   while(src<end)
+      src += sLen[*src];
+
+   return src==end;
+   #endif
+}
+
+String _hx_utf8_sub(String inString, int inStart, int inLen)
+{
+   #ifdef HX_SMART_STRINGS
+   return inString.substr(inStart,inLen);
+   #else
+   const unsigned char *src = (const unsigned char *)inString.__s;
+   const unsigned char *end = src + inString.length;
+
+   const unsigned char *sLen = getUtf8LenArray();
+   for(int i=0;i<inStart;i++)
+   {
+      src += sLen[*src];
+
+      if (src==end)
+         return String::emptyString;
+      if (src>end)
+         hx::Throw(HX_CSTRING("Invalid UTF8"));
+   }
+   const unsigned char *start = src;
+   for(int i=0;i<inLen;i++)
+   {
+      src += sLen[*src];
+      if (src==end)
+         break;
+      if (src>end)
+         hx::Throw(HX_CSTRING("Invalid UTF8"));
+   }
+   return String::create((const char *)start, src-start);
+   #endif
+}
+
+
+
+
+
+String String::create(const wchar_t *inString,int inLength) { return TCopyString(inString,inLength); }
+String String::create(const char16_t *inString,int inLength) { return TCopyString(inString,inLength); }
+String String::create(const char *inString,int inLength)
+{
+   if (!inString)
+      return String();
+
+   #ifdef HX_SMART_STRINGS
+   if (inLength<0)
+      for(inLength=0; inString[inLength]; inLength++) { }
+
+   const unsigned char *c = (const unsigned char *)inString;
+   for(int i=0;i<inLength;i++)
+   {
+      if (c[i]>127)
+         return _hx_utf8_to_utf16(c, inLength,false);
+   }
+
+   #endif
+
+   int len = 0;
+   const char *s = GCStringDup(inString,inLength,&len);
+   return String(s,len);
+}
+
+
+
+
+
+
+String::String(const Dynamic &inRHS)
+{
+   if (inRHS.GetPtr())
+      (*this)=const_cast<Dynamic &>(inRHS)->toString();
+   else
+   {
+      __s = 0;
+      length = 0;
+   }
+}
+
+void String::fromInt(int inIdx)
+{
+   char buf[100];
+   SPRINTF(buf,100,HX_INT_PATTERN,inIdx);
+   buf[99]='\0';
+   __s = GCStringDup(buf,-1,&length);
+}
+
+String::String(const int &inRHS)
+{
+   fromInt(inRHS);
+}
+
+
+String::String(const unsigned int &inRHS)
+{
+   char buf[100];
+   SPRINTF(buf,100,HX_UINT_PATTERN,inRHS);
+   buf[99]='\0';
+   __s = GCStringDup(buf,-1,&length);
+}
+
+
+String::String(const cpp::CppInt32__ &inRHS)
+{
+   char buf[100];
+   SPRINTF(buf,100,HX_INT_PATTERN,inRHS.mValue);
+   __s = GCStringDup(buf,-1,&length);
+}
+
+
+
+String::String(const double &inRHS)
+{
+   char buf[100];
+   SPRINTF(buf,100,HX_DOUBLE_PATTERN,inRHS);
+   buf[99]='\0';
+   __s = GCStringDup(buf,-1,&length);
+}
+
+
+String::String(const cpp::Int64 &inRHS)
+{
+   char buf[100];
+   SPRINTF(buf,100,"%lld", (long long int)inRHS);
+   buf[99]='\0';
+   __s = GCStringDup(buf,-1,&length);
+}
+
+
+String::String(const cpp::UInt64 &inRHS)
+{
+   char buf[100];
+   SPRINTF(buf,100,"%llu", (unsigned long long int)inRHS);
+   buf[99]='\0';
+   __s = GCStringDup(buf,-1,&length);
+}
+
+String::String(const unsigned long &inRHS)
+{
+   char buf[100];
+   SPRINTF(buf,100,"%llu", (unsigned long long int)inRHS);
+   buf[99]='\0';
+   __s = GCStringDup(buf,-1,&length);
+}
+
+String::String(const float &inRHS)
+{
+   char buf[100];
+   SPRINTF(buf,100,HX_DOUBLE_PATTERN,inRHS);
+   buf[99]='\0';
+   __s = GCStringDup(buf,-1,&length);
+}
+
+String::String(const bool &inRHS)
+{
+   if (inRHS)
+   {
+      *this = HX_CSTRING("true");
+   }
+   else
+   {
+      *this = HX_CSTRING("false");
+   }
+}
+
+void String::fromPointer(const void *p)
+{
+   char buf[128];
+   SPRINTF(buf,128,"Native(%p)",p);
+   __s = GCStringDup(buf,-1,&length);
+}
+
+#ifdef HX_SMART_STRINGS
+#define ADD_HASH(X) \
+    result = result*223 + (int)(X)
+#endif
+
+unsigned int String::calcSubHash(int start, int inLen) const
+{
+   unsigned int result = 0;
+   #ifdef HX_SMART_STRINGS
+   if (isUTF16Encoded())
+   {
+      const char16_t *w = __w + start;
+      for(int i=0;i<inLen;i++)
+      {
+         int c = w[i];
+         if( c <= 0x7F )
+         {
+            ADD_HASH(c);
+         }
+         else if( c <= 0x7FF )
+         {
+            ADD_HASH(0xC0 | (c >> 6));
+            ADD_HASH(0x80 | (c & 63));
+         }
+         else if( c <= 0xFFFF )
+         {
+            ADD_HASH(0xE0 | (c >> 12));
+            ADD_HASH(0x80 | ((c >> 6) & 63));
+            ADD_HASH(0x80 | (c & 63));
+         }
+         else
+         {
+            ADD_HASH(0xF0 | (c >> 18));
+            ADD_HASH(0x80 | ((c >> 12) & 63));
+            ADD_HASH(0x80 | ((c >> 6) & 63) );
+            ADD_HASH(0x80 | (c & 63) );
+         }
+      }
+   }
+   else
+   #endif
+   {
+      const unsigned char *s = (const unsigned char *)__s + start;
+      for(int i=0;i<inLen;i++)
+         result = result*223 + s[i];
+   }
+
+   return result;
+
+}
+
+unsigned int String::calcHash() const
+{
+   unsigned int result = 0;
+   #ifdef HX_SMART_STRINGS
+   if (isUTF16Encoded())
+   {
+      for(int i=0;i<length;i++)
+      {
+         int c = __w[i];
+         if( c <= 0x7F )
+         {
+            ADD_HASH(c);
+         }
+         else if( c <= 0x7FF )
+         {
+            ADD_HASH(0xC0 | (c >> 6));
+            ADD_HASH(0x80 | (c & 63));
+         }
+         else if( c <= 0xFFFF )
+         {
+            ADD_HASH(0xE0 | (c >> 12));
+            ADD_HASH(0x80 | ((c >> 6) & 63));
+            ADD_HASH(0x80 | (c & 63));
+         }
+         else
+         {
+            ADD_HASH(0xF0 | (c >> 18));
+            ADD_HASH(0x80 | ((c >> 12) & 63));
+            ADD_HASH(0x80 | ((c >> 6) & 63) );
+            ADD_HASH(0x80 | (c & 63) );
+         }
+      }
+   }
+   else
+   #endif
+   for(int i=0;i<length;i++)
+      result = result*223 + ((unsigned char *)__s)[i];
+
+   return result;
+}
+
+
+
+// InternalCreateConstBuffer is not uft16 aware whenit come to hashes
+static void fixHashPerm16(const String &str)
+{
+   unsigned int hash = str.calcHash();
+   ((unsigned int *)str.raw_ptr())[-2] = hash;
+}
+
+
+static unsigned char safeChars[256];
+
+String String::__URLEncode() const
+{
+   Array<unsigned char> bytes(0,length);
+   // utf8-encode
+   __hxcpp_bytes_of_string(bytes,*this);
+
+   int extra = 0;
+   int utf8_chars = bytes->__length();
+   for(int i=0;i<utf8_chars;i++)
+      if (!safeChars[bytes[i]])
+         extra++;
+   if (extra==0)
+      return *this;
+
+   int l = utf8_chars + extra*2;
+   char *result = hx::NewString(l);
+   char *ptr = result;
+
+   for(int i=0;i<utf8_chars;i++)
+   {
+      if (!safeChars[bytes[i]])
+      {
+         static char hex[] = "0123456789ABCDEF";
+         unsigned char b = bytes[i];
+         *ptr++ = '%';
+         *ptr++ = hex[ b>>4 ];
+         *ptr++ = hex[ b & 0x0f ];
+      }
+      else
+         *ptr++ = bytes[i];
+   }
+   return String(result,l);
+}
+
+String String::toUpperCase() const
+{
+   #ifdef HX_SMART_STRINGS
+   if (isUTF16Encoded())
+   {
+      char16_t *result = String::allocChar16Ptr(length);
+      for(int i=0;i<length;i++)
+      {
+         // Surrogates should already may to themselves - no need to check
+         result[i] = unicase_toupper( __w[i] );
+      }
+      return String(result,length);
+   }
+   #endif
+
+   char *result = hx::NewString(length);
+   for(int i=0;i<length;i++)
+      result[i] = toupper( __s[i] );
+   return String(result,length);
+}
+
+String String::toLowerCase() const
+{
+   #ifdef HX_SMART_STRINGS
+   if (isUTF16Encoded())
+   {
+      char16_t *result = String::allocChar16Ptr(length);
+      for(int i=0;i<length;i++)
+      {
+         result[i] = unicase_tolower( __w[i] );
+      }
+      return String(result,length);
+   }
+   #endif
+   char *result = hx::NewString(length);
+   for(int i=0;i<length;i++)
+      result[i] = tolower( __s[i] );
+   return String(result,length);
+}
+
+
+static int hex(int inChar)
+{
+   if (inChar>='0' && inChar<='9')
+      return inChar-'0';
+   if (inChar>='a' && inChar<='f')
+      return inChar-'a' + 10;
+   if (inChar>='A' && inChar<='F')
+      return inChar-'A' + 10;
+   return 0;
+}
+
+
+String String::__URLDecode() const
+{
+   // Create the decoded string; the decoded form might have fewer than
+   // [length] characters, but it won't have more.  If it has fewer than
+   // [length], some memory will be wasted here, but on the assumption that
+   // most URLs have only a few '%NN' encodings in them, don't bother
+   // counting the number of characters in the resulting string first.
+   char *decoded = NewString(length), *d = decoded;
+
+   bool hasBig = false;
+
+   #ifdef HX_SMART_STRINGS
+   if (isUTF16Encoded())
+   {
+      for (int i = 0; i < length; i++)
+      {
+         int c = __w[i];
+         if (c > 127)
+            *d++ = '?';
+         else if (c == '+')
+            *d++ = ' ';
+         else if ((c == '%') && (i < (length - 2)))
+         {
+            int ch = ((hex(__w[i + 1]) << 4) | (hex(__w[i + 2])));
+            if (ch>127)
+               hasBig = true;
+            *d++ = ch;
+            i += 2;
+         }
+         else
+             *d++ = c;
+      }
+   }
+   else
+   #endif
+   {
+      for (int i = 0; i < length; i++)
+      {
+         int c = __s[i];
+         if (c > 127)
+            *d++ = '?';
+         else if (c == '+')
+            *d++ = ' ';
+         else if ((c == '%') && (i < (length - 2)))
+         {
+            int ch = ((hex(__s[i + 1]) << 4) | (hex(__s[i + 2])));
+            #ifdef HX_SMART_STRINGS
+            if (ch>127)
+               hasBig = true;
+            #endif
+            *d++ = ch;
+            i += 2;
+         }
+         else
+             *d++ = c;
+      }
+   }
+
+   #ifdef HX_SMART_STRINGS
+   if (hasBig)
+      return _hx_utf8_to_utf16((const unsigned char *)decoded, d-decoded,false);
+   #endif
+
+   return String( decoded, (d - decoded) );
+}
+
+::String &::String::dup()
+{
+   const char *s = __s;
+   __s = 0;
+   *this = create(s,length);
+   return *this;
+}
+
+const ::String &::String::makePermanent() const
+{
+   if (!__s || (__s[HX_GC_CONST_ALLOC_MARK_OFFSET] & HX_GC_CONST_ALLOC_MARK_BIT) )
+   {
+      // Already permanent
+   }
+   else if (!length)
+   {
+      const_cast<String *>(this)->__s = emptyString.__s;
+   }
+   else if (length==1)
+   {
+      const_cast<String *>(this)->__s = String::fromCharCode(cca(0)).__s;
+   }
+   else
+   {
+      unsigned int myHash = hash();
+      {
+         while(_hx_atomic_compare_exchange(&sPermanentStringSetMutex, 0, 1) != 0)
+            __hxcpp_gc_safe_point();
+         TNonGcStringSet *element = sPermanentStringSet->find(myHash ,  *this);
+         sPermanentStringSetMutex = 0;
+         if (element)
+         {
+            const_cast<String *>(this)->__s = element->key.__s;
+            return *this;
+         }
+      }
+
+      #ifdef HX_SMART_STRINGS
+      if (isUTF16Encoded())
+      {
+         char16_t *w = (char16_t *)InternalCreateConstBuffer(__s,(length+1)*2,true);
+         ((unsigned int *)w)[-1] |= HX_GC_STRING_CHAR16_T;
+         const_cast<String *>(this)->__w = w;
+         fixHashPerm16(*this);
+      }
+      else
+      #endif
+      {
+         char *s  = (char *)InternalCreateConstBuffer(__s,length+1,true);
+         const_cast<String *>(this)->__s = s;
+      }
+
+      while(_hx_atomic_compare_exchange(&sPermanentStringSetMutex, 0, 1) != 0)
+         __hxcpp_gc_safe_point();
+      sPermanentStringSet->set(*this,null());
+      sPermanentStringSetMutex = 0;
+   }
+
+   return *this;
+}
+
+
+String String::createPermanent(const char *inUtf8, int length)
+{
+   if (!inUtf8)
+      return String();
+
+   if (length<0)
+      length = strlen(inUtf8);
+
+   if (!length)
+   {
+      return emptyString;
+   }
+   else if (length==1)
+   {
+      return String::fromCharCode( *(unsigned char *)inUtf8  );
+   }
+   else
+   {
+      String temp = create(inUtf8,length);
+      return temp.makePermanent();
+   }
+}
+
+
+
+
+template<typename T>
+static int TIndexOf(int s, const T *str, int strLen, const T *sought, int soughtLen)
+{
+   if (soughtLen==1)
+   {
+      T test = *sought;
+      while(s<strLen)
+      {
+         if (str[s]==test)
+            return s;
+         ++s;
+      }
+   }
+   else
+   {
+      while(s+soughtLen<=strLen)
+      {
+         if (!memcmp(str + s,sought,soughtLen*sizeof(T)))
+            return s;
+         s++;
+      }
+   }
+   return -1;
+}
+
+static bool StrMatch(const char16_t *src0, const char *src1, int len)
+{
+   for(int i=0;i<len;i++)
+      if (src0[i]!=src1[i])
+         return false;
+   return true;
+}
+
+
+int String::indexOf(const String &inValue, Dynamic inStart) const
+{
+   if (__s==0)
+      return -1;
+   int s = inStart==null() ? 0 : inStart->__ToInt();
+   int l = inValue.length;
+
+   if (l==0) {
+	  return std::max(0, std::min(s, length));
+   }
+
+   #ifdef HX_SMART_STRINGS
+   bool s016 =  isUTF16Encoded();
+   bool s116 = inValue.isUTF16Encoded();
+   if (s016 || s116)
+   {
+      if (s016 && s116)
+         return TIndexOf(s, __w, length, inValue.__w, inValue.length);
+
+      while(s+l<=length)
+      {
+         if (s016 ? StrMatch(__w+s, inValue.__s, l) : StrMatch(inValue.__w, __s+s, l) )
+            return s;
+         s++;
+      }
+      return -1;
+   }
+   #endif
+
+   return TIndexOf(s, __s, length, inValue.__s, inValue.length);
+}
+
+
+template<typename T>
+static int TLastIndexOf(int s, const T *str, int strLen, const T *sought, int soughtLen)
+{
+   if (soughtLen==1)
+   {
+      T test = *sought;
+      while(s>=0)
+      {
+         if (str[s]==test)
+            return s;
+         s--;
+      }
+   }
+   else
+   {
+      while(s>=0)
+      {
+         if (!memcmp(str + s,sought,soughtLen*sizeof(T)))
+            return s;
+         --s;
+      }
+   }
+   return -1;
+}
+
+
+
+int String::lastIndexOf(const String &inValue, Dynamic inStart) const
+{
+   if (__s==0)
+      return -1;
+   int l = inValue.length;
+   int s = inStart==null() ? length : inStart->__ToInt();
+   if (l==0) {
+      return std::max(0, std::min(s, length));
+   }
+   if (l>length) return -1;
+   if (s+l>length) s = length-l;
+
+   #ifdef HX_SMART_STRINGS
+   bool s016 = isUTF16Encoded();
+   bool s116 = inValue.isUTF16Encoded();
+   if (s016 || s116)
+   {
+      if (s016 && s116)
+         return TLastIndexOf(s, __w, length, inValue.__w, inValue.length);
+
+      while(s>=0)
+      {
+         if (s016 ? StrMatch(__w+s, inValue.__s, l) : StrMatch(inValue.__w, __s+s, l) )
+            return s;
+         s--;
+      }
+      return -1;
+   }
+   #endif
+   return TLastIndexOf(s, __s, length, inValue.__s, inValue.length);
+}
+
+
+
+
+
+Dynamic String::charCodeAt(int inPos) const
+{
+   if (inPos<0 || inPos>=length)
+      return null();
+
+   #ifdef HX_SMART_STRINGS
+   if (isUTF16Encoded())
+   {
+      return (int)__w[inPos];
+   }
+   #endif
+   return (int)(((unsigned char *)__s)[inPos]);
+}
+
+String String::fromCharCode( int c )
+{
+   if (c<=255)
+   {
+      return sConstStrings[c];
+   }
+   else
+   {
+      #ifdef HX_SMART_STRINGS
+      if (IsUtf16Surrogate(c)||c>=0x110000)
+         c = 0xFFFD;
+      #endif
+
+      int group = c>>10;
+      if (group>=1088)
+         hx::Throw(HX_CSTRING("Invalid char code"));
+      if (!sCharToString[group])
+      {
+         String *ptr = (String *)malloc( sizeof(String)*1024 );
+         memset(ptr, 0, sizeof(String)*1024 );
+         sCharToString[group] = ptr;
+      }
+      String *ptr = sCharToString[group];
+      int cid = c & ((1<<10)-1);
+      if (!ptr[cid].__s)
+      {
+         #ifdef HX_SMART_STRINGS
+         int l = UTF16BytesCheck(c);
+         char16_t *p = (char16_t *)InternalCreateConstBuffer(0,(l+1)*2,true);
+         ((unsigned int *)p)[-1] |= HX_GC_STRING_CHAR16_T;
+         if (c>=0x10000)
+         {
+            int over = (c-0x10000);
+            p[0] = (over>>10) + 0xd800;
+            p[1] = (over&0x3ff) + 0xdc00;
+         }
+         else
+            p[0] = c;
+
+         ptr[cid].length = l;
+         ptr[cid].__w = p;
+         fixHashPerm16(ptr[cid]);
+         #else
+         char buf[5];
+         int  utf8Len = UTF8Bytes(c);
+         char *p = buf;
+         UTF8EncodeAdvance(p,c);
+         buf[utf8Len] = '\0';
+         const char *s = (char *)InternalCreateConstBuffer(buf,utf8Len+1,true);
+         ptr[cid].length = utf8Len;
+         ptr[cid].__s = s;
+         #endif
+      }
+      return ptr[cid];
+   }
+}
+
+String String::charAt( int at ) const
+{
+   if (at<0 || at>=length)
+      return emptyString;
+
+   #ifdef HX_SMART_STRINGS
+   if (isUTF16Encoded())
+      return fromCharCode(__w[at]);
+   #endif
+   return fromCharCode(__s[at]);
+}
+
+void __hxcpp_bytes_of_string(Array<unsigned char> &outBytes,const String &inString)
+{
+   if (!inString.length)
+      return;
+
+   #ifdef HX_SMART_STRINGS
+   if (inString.isUTF16Encoded())
+   {
+      const char16_t *src = inString.raw_wptr();
+      const char16_t *end = src + inString.length;
+      while(src<end)
+      {
+         int c = Char16Advance(src);
+
+         if( c <= 0x7F )
+            outBytes->push(c);
+         else if( c <= 0x7FF )
+         {
+            outBytes->push( 0xC0 | (c >> 6) );
+            outBytes->push( 0x80 | (c & 63) );
+         }
+         else if( c <= 0xFFFF )
+         {
+            outBytes->push( 0xE0 | (c >> 12) );
+            outBytes->push( 0x80 | ((c >> 6) & 63) );
+            outBytes->push( 0x80 | (c & 63) );
+         }
+         else
+         {
+            outBytes->push( 0xF0 | (c >> 18) );
+            outBytes->push( 0x80 | ((c >> 12) & 63) );
+            outBytes->push( 0x80 | ((c >> 6) & 63) );
+            outBytes->push( 0x80 | (c & 63) );
+         }
+      }
+   }
+   else
+   #endif
+   {
+      outBytes->__SetSize(inString.length);
+      memcpy(outBytes->GetBase(), inString.raw_ptr(),inString.length);
+   }
+}
+
+#ifdef HX_SMART_STRINGS
+String _hx_utf8_to_utf16(const unsigned char *ptr, int inUtf8Len, bool addHash)
+{
+   unsigned int hash = 0;
+   if (addHash)
+      for(int i=0;i<inUtf8Len;i++)
+         hash = hash*223 + ptr[i];
+
+   int char16Count = 0;
+   const unsigned char *u = ptr;
+   const unsigned char *end = ptr + inUtf8Len;
+   while(u<end)
+   {
+      int code = DecodeAdvanceUTF8(u,end);
+      char16Count += UTF16BytesCheck(code);
+   }
+
+   int allocSize = 2*(char16Count+1);
+   if (addHash)
+      allocSize += sizeof(int);
+   char16_t *str = (char16_t *)NewGCPrivate(0,allocSize);
+
+   u = ptr;
+   char16_t *o = str;
+   while(u<end)
+   {
+      int code = DecodeAdvanceUTF8(u,end);
+      Char16AdvanceSet(o,code);
+   }
+   if (addHash)
+   {
+      #ifdef EMSCRIPTEN
+         *((emscripten_align1_int *)(str+char16Count+1) ) = hash;
+      #else
+         *((unsigned int *)(str+char16Count+1) ) = hash;
+      #endif
+      ((unsigned int *)(str))[-1] |= HX_GC_STRING_HASH | HX_GC_STRING_CHAR16_T;
+   }
+   else
+      ((unsigned int *)(str))[-1] |= HX_GC_STRING_CHAR16_T;
+
+   return String(str, char16Count);
+}
+#endif
+
+
+void __hxcpp_string_of_bytes(Array<unsigned char> &inBytes,String &outString,int pos,int len,bool inCopyPointer)
+{
+   if (inCopyPointer)
+      outString = String( (const char *)inBytes->GetBase(), len);
+   else if (len==0)
+      outString = String::emptyString;
+   else
+   {
+      const unsigned char *p0 = (const unsigned char *)inBytes->GetBase();
+      #ifdef HX_SMART_STRINGS
+      bool hasWChar = false;
+      const unsigned char *p = p0 + pos;
+      for(int i=0;i<len;i++)
+         if (p[i]>127)
+         {
+            hasWChar = true;
+            break;
+         }
+      if (hasWChar)
+      {
+         outString = _hx_utf8_to_utf16(p0+pos,len,true);
+      }
+      else
+      #endif
+      outString = String( GCStringDup((const char *)p0+pos, len, 0), len);
+   }
+}
+
+
+
+const char * String::utf8_str(hx::IStringAlloc *inBuffer,bool throwInvalid, int *byteLength) const
+{
+   #ifdef HX_SMART_STRINGS
+   if (isUTF16Encoded())
+      return TConvertToUTF8(__w,byteLength,inBuffer,throwInvalid);
+   #endif
+   if (byteLength != 0)
+   {
+      *byteLength = length;
+   }
+   return __s;
+}
+
+const char *String::ascii_substr(hx::IStringAlloc *inBuffer,int start, int length) const
+{
+   #ifdef HX_SMART_STRINGS
+   if (isUTF16Encoded())
+   {
+      const char16_t *p0 = __w + start;
+      const char16_t *p = p0;
+      const char16_t *limit = p+length;
+      while(p<limit)
+      {
+         if (*p<=0 || *p>=127)
+            break;
+         p++;
+      }
+      int validLen = (int)(p-p0);
+      char *result = (char *)inBuffer->allocBytes(validLen+1);
+      for(int i=0;i<validLen;i++)
+         result[i] = p0[i];
+      result[validLen] = 0;
+      return result;
+   }
+   #endif
+   if (__s[start+length]=='\0')
+      return __s+start;
+   char *result = (char *)inBuffer->allocBytes(length+1);
+   memcpy(result,__s+start,length);
+   result[length] = '\0';
+
+   return result;
+}
+
+#ifdef HX_SMART_STRINGS
+
+bool String::eq(const ::String &inRHS) const
+{
+   if (length != inRHS.length)
+      return false;
+
+   bool s0IsWide = isUTF16Encoded();
+   if (s0IsWide != inRHS.isUTF16Encoded() )
+      return false;
+   return !memcmp(__s, inRHS.__s, s0IsWide ? 2 * length : length );
+}
+
+
+int String::compare(const ::String &inRHS) const
+{
+   if (!__s)
+      return inRHS.__s ? -1 : 0;
+   if (!inRHS.__s)
+      return 1;
+
+   int cmp = 0;
+   int minLen = length<inRHS.length ? length : inRHS.length;
+
+   if (minLen>0)
+   {
+      bool s0IsWide = isUTF16Encoded();
+      bool s1IsWide = inRHS.isUTF16Encoded();
+
+      if (s0IsWide==s1IsWide)
+      {
+         if (!s0IsWide)
+         {
+            cmp = memcmp(__s,inRHS.__s,minLen);
+         }
+         else
+         {
+            for(int i=0;i<minLen;i++)
+            {
+               if (__w[i]!=inRHS.__w[i])
+               {
+                  cmp = __w[i] - inRHS.__w[i];
+                  break;
+               }
+            }
+         }
+      }
+      else
+      {
+         const unsigned char *s = (const unsigned char *)( s0IsWide ? inRHS.__s : __s );
+         const char16_t *w = s0IsWide ? __w : inRHS.__w;
+         for(int i=0;i<minLen;i++)
+            if (s[i]!=w[i])
+            {
+               cmp =  s[i]<w[i] ? -1 : 1;
+               if (s0IsWide)
+                  cmp = - cmp;
+               break;
+            }
+      }
+   }
+   return cmp ? cmp : length - inRHS.length;
+}
+#endif
+
+
+namespace hx
+{
+
+wchar_t *ConvertToWChar(const char *inStr, int *ioLen)
+{
+   int len = ioLen ? *ioLen : strlen(inStr);
+
+   wchar_t *result = (wchar_t *)NewGCPrivate(0,sizeof(wchar_t)*(len+1));
+   int l = 0;
+
+   unsigned char *b = (unsigned char *)inStr;
+   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';
+   if (ioLen)
+      *ioLen = l;
+   return result;
+}
+
+
+
+
+}
+
+
+
+const char16_t * String::wc_str(hx::IStringAlloc *inBuffer, int *outCharLength) const
+{
+   #ifdef HX_SMART_STRINGS
+   if (isUTF16Encoded()) {
+      if (outCharLength != 0) {
+         *outCharLength = length;
+      }
+      return __w;
+   }
+   #endif
+
+   int char16Count = 0;
+   const unsigned char *ptr = (const unsigned char *)__s;
+   const unsigned char *u = ptr;
+   const unsigned char *end = u + length;
+   while(u<end)
+   {
+      int code = DecodeAdvanceUTF8(u,end);
+      char16Count += UTF16BytesCheck(code);
+   }
+
+   char16_t *str = inBuffer ? (char16_t *)inBuffer->allocBytes(2*(char16Count+1)) :
+                              (char16_t *)NewGCPrivate(0,2*(char16Count+1));
+
+   u = ptr;
+   char16_t *o = str;
+   while(u<end)
+   {
+      int code = DecodeAdvanceUTF8(u,end);
+      Char16AdvanceSet(o,code);
+   }
+   *o = 0;
+   if (outCharLength != 0) {
+      *outCharLength = char16Count;
+   }
+   return str;
+}
+
+
+const wchar_t * String::wchar_str(hx::IStringAlloc *inBuffer) const
+{
+   if (!__s)
+      return 0;
+   if (length==0)
+      return L"";
+
+   #ifdef HX_SMART_STRINGS
+   if (isUTF16Encoded())
+   {
+      if (sizeof(wchar_t)==sizeof(char16_t))
+          return (wchar_t *)__w;
+   }
+
+   wchar_t *result = 0;
+   if (inBuffer)
+   {
+      result = (wchar_t *)inBuffer->allocBytes(sizeof(wchar_t)*(length+1) );
+   }
+   else
+   {
+      result = (wchar_t *)NewGCPrivate(0,sizeof(wchar_t)*(length+1) );
+   }
+   if (isUTF16Encoded())
+      for(int i=0;i<length;i++)
+         result[i] = __w[i];
+   else
+      for(int i=0;i<length;i++)
+         result[i] = __s[i];
+   result[length] = 0;
+   return result;
+   #else
+
+   const unsigned char *ptr = (const unsigned char *)__s;
+   const unsigned char *end = ptr + length;
+   int idx = 0;
+   while(ptr<end)
+   {
+      DecodeAdvanceUTF8(ptr,end);
+      idx++;
+   }
+
+   wchar_t *result = 0;
+   if (inBuffer)
+   {
+      result = (wchar_t *)inBuffer->allocBytes(sizeof(wchar_t)*(idx+1) );
+   }
+   else
+   {
+      result = (wchar_t *)NewGCPrivate(0,sizeof(wchar_t)*(idx+1) );
+   }
+
+   ptr = (const unsigned char *)__s;
+   idx = 0;
+   while(ptr<end)
+      result[idx++] = DecodeAdvanceUTF8(ptr,end);
+   result[idx] = 0;
+   return result;
+   #endif
+}
+
+
+
+#ifdef ANDROID
+bool my_wstrneq(const wchar_t *s1, const wchar_t *s2, int len)
+{
+   for(int i=0;i<len;i++)
+      if (s1[i]!=s2[i])
+        return false;
+   return true;
+}
+#endif
+
+static bool isSame(const char16_t *a, const char *b, int count)
+{
+   for(int i=0;i<count;i++)
+      if (a[i]!=b[i])
+         return false;
+   return true;
+}
+
+Array<String> String::split(const String &inDelimiter) const
+{
+   int len = inDelimiter.length;
+   int pos = 0;
+   int last = 0;
+   if (len==0)
+   {
+      // Special case of splitting into characters - use efficient code...
+      int chars = length;
+      Array<String> result(0,chars);
+      int idx = 0;
+      #ifdef HX_SMART_STRINGS
+      if (isUTF16Encoded())
+      {
+         const char16_t *p = __w;
+         for(int i=0;i<length;i++)
+            result[i] = String::fromCharCode(p[i]);
+         /*
+         const char16_t *end = p + length;
+         while(p<end)
+            result[idx++] = String::fromCharCode(Char16Advance(p));
+         */
+      }
+      else
+      {
+         for(int i=0;i<chars;i++)
+            result[i] = String::fromCharCode( __s[i] );
+      }
+      #else
+      for(int i=0;i<chars; )
+      {
+         const unsigned char *start = (const unsigned char *)(__s + i);
+         const unsigned char *ptr = start;
+         DecodeAdvanceUTF8(ptr);
+         int len =  ptr - start;
+         result[idx++] = String::create( __s+i, len );
+         i+=len;
+      }
+      #endif
+      return result;
+   }
+
+
+   Array<String> result(0,1);
+   #if HX_SMART_STRINGS
+   bool s0 = isUTF16Encoded();
+   bool s1 = inDelimiter.isUTF16Encoded();
+   if (s0 || s1)
+   {
+      if (s0 && s1)
+      {
+         while(pos+len <=length )
+            if (!memcmp(__w+pos,inDelimiter.__w,len*2))
+            {
+               result->push( substr(last,pos-last) );
+               pos += len;
+               last = pos;
+            }
+            else
+               pos++;
+      }
+      else if (s0)
+         while(pos+len <=length )
+            if (isSame(__w+pos,inDelimiter.__s,len))
+            {
+               result->push( substr(last,pos-last) );
+               pos += len;
+               last = pos;
+            }
+            else
+               pos++;
+      else
+         while(pos+len <=length )
+            if (isSame(inDelimiter.__w,__s+pos,len))
+            {
+               result->push( substr(last,pos-last) );
+               pos += len;
+               last = pos;
+            }
+            else
+               pos++;
+   }
+   else
+   #endif
+   {
+      while(pos+len <=length )
+         if (!strncmp(__s+pos,inDelimiter.__s,len))
+         {
+            result->push( substr(last,pos-last) );
+            pos += len;
+            last = pos;
+         }
+         else
+            pos++;
+   }
+
+   result->push( substr(last,null()) );
+
+
+   return result;
+}
+
+Dynamic CreateEmptyString() { return sConstEmptyString; }
+
+Dynamic CreateString(DynamicArray inArgs)
+{
+   if (inArgs->__length()>0)
+      return inArgs[0]->toString();
+   return String();
+}
+
+
+String String::substr(int inFirst, Dynamic inLen) const
+{
+   int len = inLen == null() ? length : inLen->__ToInt();
+   if (inFirst<0) inFirst += length;
+   if (inFirst<0) inFirst = 0;
+   if (len<0)
+   {
+      len += length;
+      // This logic matches flash ....
+      if (inFirst + len >=length)
+         len = 0;
+   }
+
+   if (len<=0 || inFirst>=length)
+      return String::emptyString;
+
+   if ((len+inFirst > length) ) len = length - inFirst;
+   if (len==0)
+      return String::emptyString;
+
+
+   #ifdef HX_SMART_STRINGS
+   if (isUTF16Encoded())
+   {
+      if (len==1)
+         return String::fromCharCode(__w[inFirst]);
+      return String( GCStringDup(__w+inFirst, len, 0), len );
+   }
+   #endif
+
+   if (len==1)
+      return String::fromCharCode(__s[inFirst]);
+
+   return String( GCStringDup(__s+inFirst, len, 0), len );
+}
+
+String String::substring(int startIndex, Dynamic inEndIndex) const
+{
+   int endIndex = inEndIndex == null() ? length : inEndIndex->__ToInt();
+   if ( endIndex < 0 ) {
+      endIndex = 0;
+   } else if ( endIndex > length ) {
+      endIndex = length;
+   }
+
+   if ( startIndex < 0 ) {
+      startIndex = 0;
+   } else if ( startIndex > length ) {
+      startIndex = length;
+   }
+
+   if ( startIndex > endIndex ) {
+      int tmp = startIndex;
+      startIndex = endIndex;
+      endIndex = tmp;
+   }
+
+   return substr( startIndex, endIndex - startIndex );
+}
+
+String String::operator+(const String &inRHS) const
+{
+   if (!__s) return HX_CSTRING("null") + inRHS;
+   if (!length)
+   {
+      if (!inRHS.__s)
+         return HX_CSTRING("null");
+      return inRHS;
+   }
+   if (!inRHS.__s) return *this + HX_CSTRING("null");
+   if (!inRHS.length) return *this;
+
+   int l = length + inRHS.length;
+
+   #ifdef HX_SMART_STRINGS
+   bool ws0 = isUTF16Encoded();
+   bool ws1 = inRHS.isUTF16Encoded();
+   if (ws0 || ws1)
+   {
+      char16_t *result = String::allocChar16Ptr(l);
+
+      if (ws0)
+         memcpy(result,__w,length*2);
+      else
+         for(int i=0;i<length;i++)
+            result[i] = __s[i];
+
+      char16_t *r2 = result + length;
+      if (ws1)
+         memcpy(r2, inRHS.__w, inRHS.length*2);
+      else
+         for(int i=0;i<inRHS.length;i++)
+            r2[i] = inRHS.__s[i];
+
+      return String(result,l);
+   }
+   #endif
+
+
+   char *result = hx::NewString(l);
+   memcpy(result,__s,length*sizeof(char));
+   memcpy(result+length,inRHS.__s,inRHS.length*sizeof(char));
+   result[l] = '\0';
+   return String(result,l);
+}
+
+
+String &String::operator+=(const String &inRHS)
+{
+   if (length==0)
+   {
+      *this = inRHS;
+   }
+   else if (inRHS.length>0)
+   {
+      int l = length + inRHS.length;
+      #ifdef HX_SMART_STRINGS
+      bool ws0 = isUTF16Encoded();
+      bool ws1 = inRHS.isUTF16Encoded();
+      if (ws0 || ws1)
+      {
+         char16_t *result = String::allocChar16Ptr(l);
+
+         if (ws0)
+            memcpy(result,__w,length*2);
+         else
+            for(int i=0;i<length;i++)
+               result[i] = __s[i];
+
+         char16_t *r2 = result + length;
+         if (ws1)
+            memcpy(r2, inRHS.__w, inRHS.length*2);
+         else
+            for(int i=0;i<inRHS.length;i++)
+               r2[i] = inRHS.__s[i];
+
+         __w = result;
+      }
+      else
+      #endif
+      {
+      char *s = hx::NewString(l);
+      memcpy(s,__s,length*sizeof(char));
+      memcpy(s+length,inRHS.__s,inRHS.length*sizeof(char));
+      __s = s;
+      }
+
+      length = l;
+   }
+   return *this;
+}
+
+#ifdef HXCPP_VISIT_ALLOCS
+#define STRING_VISIT_FUNC \
+    void __Visit(hx::VisitContext *__inCtx) { HX_VISIT_STRING(mThis.raw_ref()); }
+#else
+#define STRING_VISIT_FUNC
+#endif
+
+#define DEFINE_STRING_FUNC(func,array_list,dynamic_arg_list,arg_list,ARG_C) \
+struct __String_##func : public hx::Object \
+{ \
+   bool __IsFunction() const { return true; } \
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdClosure }; \
+   String mThis; \
+   __String_##func(const String &inThis) : mThis(inThis) { \
+      HX_OBJ_WB_NEW_MARKED_OBJECT(this); \
+   } \
+   String toString() const{ return HX_CSTRING(#func); } \
+   String __ToString() const{ return HX_CSTRING(#func); } \
+   int __GetType() const { return vtFunction; } \
+   void *__GetHandle() const { return const_cast<char *>(mThis.raw_ptr()); } \
+   int __ArgCount() const { return ARG_C; } \
+   Dynamic __Run(const Array<Dynamic> &inArgs) \
+   { \
+      return mThis.func(array_list); return Dynamic(); \
+   } \
+   Dynamic __run(dynamic_arg_list) \
+   { \
+      return mThis.func(arg_list); return Dynamic(); \
+   } \
+   void __Mark(hx::MarkContext *__inCtx) { HX_MARK_STRING(mThis.raw_ptr()); } \
+   STRING_VISIT_FUNC \
+   void  __SetThis(Dynamic inThis) { mThis = inThis; } \
+}; \
+Dynamic String::func##_dyn()  { return new __String_##func(*this);  }
+
+
+#define DEFINE_STRING_FUNC0(func) DEFINE_STRING_FUNC(func,HX_ARR_LIST0,HX_DYNAMIC_ARG_LIST0,HX_ARG_LIST0,0)
+#define DEFINE_STRING_FUNC1(func) DEFINE_STRING_FUNC(func,HX_ARR_LIST1,HX_DYNAMIC_ARG_LIST1,HX_ARG_LIST1,1)
+#define DEFINE_STRING_FUNC2(func) DEFINE_STRING_FUNC(func,HX_ARR_LIST2,HX_DYNAMIC_ARG_LIST2,HX_ARG_LIST2,2)
+
+DEFINE_STRING_FUNC1(charAt);
+DEFINE_STRING_FUNC1(charCodeAt);
+DEFINE_STRING_FUNC2(indexOf);
+DEFINE_STRING_FUNC2(lastIndexOf);
+DEFINE_STRING_FUNC1(split);
+DEFINE_STRING_FUNC2(substr);
+DEFINE_STRING_FUNC2(substring);
+DEFINE_STRING_FUNC0(toLowerCase);
+DEFINE_STRING_FUNC0(toUpperCase);
+DEFINE_STRING_FUNC0(toString);
+
+hx::Val String::__Field(const String &inString, hx::PropertyAccess inCallProp)
+{
+   if (HX_FIELD_EQ(inString,"length")) return length;
+   if (HX_FIELD_EQ(inString,"charAt")) return charAt_dyn();
+   if (HX_FIELD_EQ(inString,"charCodeAt")) return charCodeAt_dyn();
+   if (HX_FIELD_EQ(inString,"indexOf")) return indexOf_dyn();
+   if (HX_FIELD_EQ(inString,"lastIndexOf")) return lastIndexOf_dyn();
+   if (HX_FIELD_EQ(inString,"split")) return split_dyn();
+   if (HX_FIELD_EQ(inString,"substr")) return substr_dyn();
+   if (HX_FIELD_EQ(inString,"substring")) return substring_dyn();
+   if (HX_FIELD_EQ(inString,"toLowerCase")) return toLowerCase_dyn();
+   if (HX_FIELD_EQ(inString,"toUpperCase")) return toUpperCase_dyn();
+   if (HX_FIELD_EQ(inString,"toString")) return toString_dyn();
+   return null();
+}
+
+
+static String sStringStatics[] = {
+   HX_CSTRING("fromCharCode"),
+   String(null())
+};
+static String sStringFields[] = {
+   HX_CSTRING("length"),
+   HX_CSTRING("charAt"),
+   HX_CSTRING("charCodeAt"),
+   HX_CSTRING("indexOf"),
+   HX_CSTRING("lastIndexOf"),
+   HX_CSTRING("split"),
+   HX_CSTRING("substr"),
+   HX_CSTRING("substring"),
+   HX_CSTRING("toLowerCase"),
+   HX_CSTRING("toUpperCase"),
+   HX_CSTRING("toString"),
+   String(null())
+};
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(String,fromCharCode,return )
+
+namespace hx
+{
+
+
+
+#ifndef HX_WINDOWS
+inline double _wtof(const wchar_t *inStr)
+{
+   #ifdef ANDROID
+   char buf[101];
+   int i;
+   for(i=0;i<100 && inStr[i];i++)
+      buf[i] = inStr[i];
+   buf[i] = '\0';
+   return strtod(buf, 0);
+   #else
+   return wcstod(inStr,0);
+   #endif
+}
+
+#ifdef HX_ANDROID
+int my_wtol(const wchar_t *inStr,wchar_t ** end, int inBase)
+{
+   char buf[101];
+   int i;
+   for(i=0;i<100 && inStr[i];i++)
+      buf[i] = inStr[i];
+   buf[i] = '\0';
+   char *cend = buf;
+   int result = strtol(buf,&cend,inBase);
+   *end = (wchar_t *)inStr + (cend-buf);
+   return result;
+}
+#define wcstol my_wtol
+#endif
+
+inline int _wtoi(const wchar_t *inStr)
+{
+   wchar_t *end = 0;
+   if (!inStr) return 0;
+   long result = 0;
+   if (inStr[0]=='0' && (inStr[1]=='x' || inStr[1]=='X'))
+      result = wcstol(inStr,&end,16);
+   else
+      result = wcstol(inStr,&end,10);
+   return result;
+}
+#endif
+
+
+
+class StringData : public hx::Object
+{
+public:
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdString };
+
+   inline void *operator new( size_t inSize, hx::NewObjectType inAlloc=hx::NewObjContainer)
+      { return hx::Object::operator new(inSize,inAlloc); }
+
+
+   StringData(String inValue) : mValue(inValue) {
+      HX_OBJ_WB_GET(this,mValue.raw_ref());
+   };
+
+   hx::Class __GetClass() const { return __StringClass; }
+   bool __Is(hx::Object *inClass) const { return dynamic_cast< StringData *>(inClass); }
+
+   virtual int __GetType() const { return vtString; }
+   String __ToString() const { return mValue; }
+   String toString() { return mValue; }
+   double __ToDouble() const
+   {
+      if (!mValue.raw_ptr()) return 0;
+
+      #ifdef HX_ANDROID
+      return strtod(mValue.utf8_str(),0);
+      #else
+      return atof(mValue.utf8_str());
+      #endif
+   }
+   int __length() const { return mValue.length; }
+
+   void __Mark(hx::MarkContext *__inCtx)
+   {
+      HX_MARK_MEMBER(mValue);
+   }
+
+   #ifdef HXCPP_VISIT_ALLOCS
+   void __Visit(hx::VisitContext *__inCtx)
+   {
+      HX_VISIT_MEMBER(mValue);
+   }
+   #endif
+
+
+   int __ToInt() const
+   {
+      if (!mValue.raw_ptr()) return 0;
+      return atoi(mValue.utf8_str());
+   }
+
+   int __Compare(const hx::Object *inRHS) const
+   {
+      return mValue.compare( const_cast<hx::Object*>(inRHS)->toString() );
+   }
+
+   hx::Val __Field(const String &inString, hx::PropertyAccess inCallProp)
+   {
+      return mValue.__Field(inString, inCallProp);
+   }
+
+
+   String mValue;
+};
+
+
+
+
+hx::Class &GetStringClass() { return __StringClass; }
+
+} // end namespace hx
+
+hx::Object *String::__ToObject() const
+{
+   if (!__s)
+      return 0;
+
+   if (length==0)
+   {
+      return sConstEmptyString.mPtr;
+   }
+   else if (length==1)
+   {
+      #ifdef HX_SMART_STRINGS
+      int idx = isUTF16Encoded() ? __w[0] : ((unsigned char *)__s)[0];
+      #else
+      int idx = ((unsigned char *)__s)[0];
+      #endif
+
+      if (idx<=255)
+      {
+         if (sConstDynamicStrings[idx].mPtr)
+            return  sConstDynamicStrings[idx].mPtr;
+
+         return sConstDynamicStrings[idx].mPtr = new (hx::NewObjConst)StringData(fromCharCode(idx));
+      }
+   }
+
+   bool isConst = __s[HX_GC_CONST_ALLOC_MARK_OFFSET] & HX_GC_CONST_ALLOC_MARK_BIT;
+   NewObjectType type = isConst ?  NewObjAlloc : NewObjContainer;
+   return new (type) StringData(*this);
+}
+
+hx::Object * String::makePermanentObject() const
+{
+   return new (hx::NewObjConst)StringData(makePermanent());
+}
+
+
+
+void String::__boot()
+{
+   #ifdef HXCPP_COMBINE_STRINGS
+   InitIdent();
+   #endif
+
+   sPermanentStringSet = new StringSet();
+   GCAddRoot((hx::Object **)&sPermanentStringSet);
+
+   for(int i=0;i<256;i++)
+      safeChars[i] = i>32 && i<127;
+   unsigned char dodgy[] = { 36, 38, 43, 44, 47, 58, 59, 61, 63, 64,
+      34, 60, 62, 35, 37, 123, 125, 124, 92, 94, 126, 91, 93, 96 };
+   for(int i=0;i<sizeof(dodgy);i++)
+      safeChars[ dodgy[i] ] = 0;
+
+   for(int c=0;c<256;c++)
+   {
+      #ifdef HX_SMART_STRINGS
+      if (c>127)
+      #endif
+      {
+         char16_t buf[20];
+         buf[0] = c;
+         buf[1] = '\0';
+         sConstStrings[c].length = 1;
+         char16_t *w = (char16_t *)InternalCreateConstBuffer(buf,2*2,true);
+         ((unsigned int *)w)[-1] |= HX_GC_STRING_CHAR16_T;
+         sConstStrings[c].__w = w;
+         fixHashPerm16(sConstStrings[c]);
+      }
+      #ifdef HX_SMART_STRINGS
+      else
+      {
+         char buf[20];
+         int  utf8Len = UTF8Bytes(c);
+         char *p = buf;
+         UTF8EncodeAdvance(p,c);
+         buf[utf8Len] = '\0';
+         sConstStrings[c].__s = (char *)InternalCreateConstBuffer(buf,utf8Len+1,true);
+         sConstStrings[c].length = utf8Len;
+      }
+      #endif
+   }
+
+   sConstEmptyString.mPtr = new (hx::NewObjConst)StringData(emptyString);
+
+   Static(__StringClass) = hx::_hx_RegisterClass(HX_CSTRING("String"),TCanCast<StringData>,sStringStatics, sStringFields,
+           &CreateEmptyString, &CreateString, 0, 0, 0
+    );
+}
diff --git a/Sources/c_snikket/src/StringBuf.cpp b/Sources/c_snikket/src/StringBuf.cpp
new file mode 100644
index 0000000..de1eed6
--- /dev/null
+++ b/Sources/c_snikket/src/StringBuf.cpp
@@ -0,0 +1,219 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_StringBuf
+#include <StringBuf.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_8b63e6eaf513c097_35_new,"StringBuf","new",0xaaa8f4b4,"StringBuf.new","/usr/local/lib/haxe/std/cpp/_std/StringBuf.hx",35,0x6c227dbe)
+HX_LOCAL_STACK_FRAME(_hx_pos_8b63e6eaf513c097_37_charBufAsString,"StringBuf","charBufAsString",0x54d38cd4,"StringBuf.charBufAsString","/usr/local/lib/haxe/std/cpp/_std/StringBuf.hx",37,0x6c227dbe)
+HX_LOCAL_STACK_FRAME(_hx_pos_8b63e6eaf513c097_43_flush,"StringBuf","flush",0xc7c14418,"StringBuf.flush","/usr/local/lib/haxe/std/cpp/_std/StringBuf.hx",43,0x6c227dbe)
+HX_LOCAL_STACK_FRAME(_hx_pos_8b63e6eaf513c097_51_get_length,"StringBuf","get_length",0xe673d2db,"StringBuf.get_length","/usr/local/lib/haxe/std/cpp/_std/StringBuf.hx",51,0x6c227dbe)
+HX_LOCAL_STACK_FRAME(_hx_pos_8b63e6eaf513c097_92_toString,"StringBuf","toString",0x68f17bd8,"StringBuf.toString","/usr/local/lib/haxe/std/cpp/_std/StringBuf.hx",92,0x6c227dbe)
+
+void StringBuf_obj::__construct(){
+            	HX_STACKFRAME(&_hx_pos_8b63e6eaf513c097_35_new)
+            	}
+
+Dynamic StringBuf_obj::__CreateEmpty() { return new StringBuf_obj; }
+
+void *StringBuf_obj::_hx_vtable = 0;
+
+Dynamic StringBuf_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< StringBuf_obj > _hx_result = new StringBuf_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool StringBuf_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x2cc74002;
+}
+
+::String StringBuf_obj::charBufAsString(){
+            	HX_STACKFRAME(&_hx_pos_8b63e6eaf513c097_37_charBufAsString)
+HXLINE(  38)		int len = this->charBuf->length;
+HXLINE(  39)		this->charBuf->push(0);
+HXLINE(  40)		::cpp::Pointer< char > inPtr = ( (::cpp::Pointer< char >)(::cpp::Pointer_obj::arrayElem(this->charBuf,0)) );
+HXDLIN(  40)		return  ::String(inPtr->ptr,len);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(StringBuf_obj,charBufAsString,return )
+
+void StringBuf_obj::flush(){
+            	HX_STACKFRAME(&_hx_pos_8b63e6eaf513c097_43_flush)
+HXLINE(  44)		if (::hx::IsNull( this->b )) {
+HXLINE(  45)			this->b = ::Array_obj< ::String >::__new(1)->init(0,this->charBufAsString());
+            		}
+            		else {
+HXLINE(  47)			::Array< ::String > _hx_tmp = this->b;
+HXDLIN(  47)			_hx_tmp->push(this->charBufAsString());
+            		}
+HXLINE(  48)		this->charBuf = null();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(StringBuf_obj,flush,(void))
+
+int StringBuf_obj::get_length(){
+            	HX_STACKFRAME(&_hx_pos_8b63e6eaf513c097_51_get_length)
+HXLINE(  52)		int len = 0;
+HXLINE(  53)		if (::hx::IsNotNull( this->charBuf )) {
+HXLINE(  54)			len = this->charBuf->length;
+            		}
+HXLINE(  55)		if (::hx::IsNotNull( this->b )) {
+HXLINE(  56)			int _g = 0;
+HXDLIN(  56)			::Array< ::String > _g1 = this->b;
+HXDLIN(  56)			while((_g < _g1->length)){
+HXLINE(  56)				::String s = _g1->__get(_g);
+HXDLIN(  56)				_g = (_g + 1);
+HXLINE(  57)				int len1;
+HXDLIN(  57)				if (::hx::IsNull( s )) {
+HXLINE(  57)					len1 = 4;
+            				}
+            				else {
+HXLINE(  57)					len1 = s.length;
+            				}
+HXDLIN(  57)				len = (len + len1);
+            			}
+            		}
+HXLINE(  58)		return len;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(StringBuf_obj,get_length,return )
+
+::String StringBuf_obj::toString(){
+            	HX_STACKFRAME(&_hx_pos_8b63e6eaf513c097_92_toString)
+HXLINE(  93)		if (::hx::IsNotNull( this->charBuf )) {
+HXLINE(  94)			this->flush();
+            		}
+HXLINE(  95)		bool _hx_tmp;
+HXDLIN(  95)		if (::hx::IsNotNull( this->b )) {
+HXLINE(  95)			_hx_tmp = (this->b->length == 0);
+            		}
+            		else {
+HXLINE(  95)			_hx_tmp = true;
+            		}
+HXDLIN(  95)		if (_hx_tmp) {
+HXLINE(  96)			return HX_("",00,00,00,00);
+            		}
+HXLINE(  97)		if ((this->b->length == 1)) {
+HXLINE(  98)			return this->b->__get(0);
+            		}
+HXLINE(  99)		return this->b->join(HX_("",00,00,00,00));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(StringBuf_obj,toString,return )
+
+
+StringBuf_obj::StringBuf_obj()
+{
+}
+
+void StringBuf_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(StringBuf);
+	HX_MARK_MEMBER_NAME(b,"b");
+	HX_MARK_MEMBER_NAME(charBuf,"charBuf");
+	HX_MARK_END_CLASS();
+}
+
+void StringBuf_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(b,"b");
+	HX_VISIT_MEMBER_NAME(charBuf,"charBuf");
+}
+
+::hx::Val StringBuf_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 1:
+		if (HX_FIELD_EQ(inName,"b") ) { return ::hx::Val( b ); }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"flush") ) { return ::hx::Val( flush_dyn() ); }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"length") ) { if (inCallProp == ::hx::paccAlways) return ::hx::Val( get_length() ); }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"charBuf") ) { return ::hx::Val( charBuf ); }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"toString") ) { return ::hx::Val( toString_dyn() ); }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"get_length") ) { return ::hx::Val( get_length_dyn() ); }
+		break;
+	case 15:
+		if (HX_FIELD_EQ(inName,"charBufAsString") ) { return ::hx::Val( charBufAsString_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val StringBuf_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 1:
+		if (HX_FIELD_EQ(inName,"b") ) { b=inValue.Cast< ::Array< ::String > >(); return inValue; }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"charBuf") ) { charBuf=inValue.Cast< ::Array< char > >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void StringBuf_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("b",62,00,00,00));
+	outFields->push(HX_("length",e6,94,07,9f));
+	outFields->push(HX_("charBuf",fd,85,55,cf));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo StringBuf_obj_sMemberStorageInfo[] = {
+	{::hx::fsObject /* ::Array< ::String > */ ,(int)offsetof(StringBuf_obj,b),HX_("b",62,00,00,00)},
+	{::hx::fsObject /* ::Array< char > */ ,(int)offsetof(StringBuf_obj,charBuf),HX_("charBuf",fd,85,55,cf)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *StringBuf_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String StringBuf_obj_sMemberFields[] = {
+	HX_("b",62,00,00,00),
+	HX_("charBuf",fd,85,55,cf),
+	HX_("charBufAsString",80,3a,2f,0a),
+	HX_("flush",c4,62,9b,02),
+	HX_("get_length",af,04,8f,8f),
+	HX_("toString",ac,d0,6e,38),
+	::String(null()) };
+
+::hx::Class StringBuf_obj::__mClass;
+
+void StringBuf_obj::__register()
+{
+	StringBuf_obj _hx_dummy;
+	StringBuf_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("StringBuf",c2,ca,83,69);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(StringBuf_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< StringBuf_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = StringBuf_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = StringBuf_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
diff --git a/Sources/c_snikket/src/StringTools.cpp b/Sources/c_snikket/src/StringTools.cpp
new file mode 100644
index 0000000..6f05edb
--- /dev/null
+++ b/Sources/c_snikket/src/StringTools.cpp
@@ -0,0 +1,494 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Std
+#include <Std.h>
+#endif
+#ifndef INCLUDED_StringBuf
+#include <StringBuf.h>
+#endif
+#ifndef INCLUDED_StringTools
+#include <StringTools.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_0e615b5827179e15_50_urlEncode,"StringTools","urlEncode",0x06afdce1,"StringTools.urlEncode","/usr/local/lib/haxe/std/StringTools.hx",50,0x3f930611)
+HX_LOCAL_STACK_FRAME(_hx_pos_0e615b5827179e15_158_htmlEscape,"StringTools","htmlEscape",0x0e1a5dd0,"StringTools.htmlEscape","/usr/local/lib/haxe/std/StringTools.hx",158,0x3f930611)
+static const ::String _hx_array_data_0363db6a_3[] = {
+	HX_("&quot;",2c,d9,81,8f),
+};
+static const ::String _hx_array_data_0363db6a_4[] = {
+	HX_("&amp;",dd,d4,aa,21),
+};
+static const ::String _hx_array_data_0363db6a_5[] = {
+	HX_("&#039;",62,26,77,78),
+};
+static const ::String _hx_array_data_0363db6a_6[] = {
+	HX_("&lt;",4d,74,70,19),
+};
+static const ::String _hx_array_data_0363db6a_7[] = {
+	HX_("&gt;",08,a9,6c,19),
+};
+HX_LOCAL_STACK_FRAME(_hx_pos_0e615b5827179e15_240_startsWith,"StringTools","startsWith",0x5f4e6efb,"StringTools.startsWith","/usr/local/lib/haxe/std/StringTools.hx",240,0x3f930611)
+HX_LOCAL_STACK_FRAME(_hx_pos_0e615b5827179e15_251_endsWith,"StringTools","endsWith",0x0eb5bfe2,"StringTools.endsWith","/usr/local/lib/haxe/std/StringTools.hx",251,0x3f930611)
+HX_LOCAL_STACK_FRAME(_hx_pos_0e615b5827179e15_282_isSpace,"StringTools","isSpace",0xe0290778,"StringTools.isSpace","/usr/local/lib/haxe/std/StringTools.hx",282,0x3f930611)
+HX_LOCAL_STACK_FRAME(_hx_pos_0e615b5827179e15_300_ltrim,"StringTools","ltrim",0x24d2234a,"StringTools.ltrim","/usr/local/lib/haxe/std/StringTools.hx",300,0x3f930611)
+HX_LOCAL_STACK_FRAME(_hx_pos_0e615b5827179e15_325_rtrim,"StringTools","rtrim",0x99399e50,"StringTools.rtrim","/usr/local/lib/haxe/std/StringTools.hx",325,0x3f930611)
+HX_LOCAL_STACK_FRAME(_hx_pos_0e615b5827179e15_353_trim,"StringTools","trim",0x2908d066,"StringTools.trim","/usr/local/lib/haxe/std/StringTools.hx",353,0x3f930611)
+HX_LOCAL_STACK_FRAME(_hx_pos_0e615b5827179e15_369_lpad,"StringTools","lpad",0x23bd8feb,"StringTools.lpad","/usr/local/lib/haxe/std/StringTools.hx",369,0x3f930611)
+HX_LOCAL_STACK_FRAME(_hx_pos_0e615b5827179e15_428_replace,"StringTools","replace",0x6d651f30,"StringTools.replace","/usr/local/lib/haxe/std/StringTools.hx",428,0x3f930611)
+HX_LOCAL_STACK_FRAME(_hx_pos_0e615b5827179e15_438_hex,"StringTools","hex",0xd91debd7,"StringTools.hex","/usr/local/lib/haxe/std/StringTools.hx",438,0x3f930611)
+
+void StringTools_obj::__construct() { }
+
+Dynamic StringTools_obj::__CreateEmpty() { return new StringTools_obj; }
+
+void *StringTools_obj::_hx_vtable = 0;
+
+Dynamic StringTools_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< StringTools_obj > _hx_result = new StringTools_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool StringTools_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x084f186e;
+}
+
+::String StringTools_obj::urlEncode(::String s){
+            	HX_STACKFRAME(&_hx_pos_0e615b5827179e15_50_urlEncode)
+HXDLIN(  50)		return ( (::String)(s.__URLEncode()) );
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(StringTools_obj,urlEncode,return )
+
+::String StringTools_obj::htmlEscape(::String s, ::Dynamic quotes){
+            	HX_GC_STACKFRAME(&_hx_pos_0e615b5827179e15_158_htmlEscape)
+HXLINE( 159)		 ::StringBuf buf =  ::StringBuf_obj::__alloc( HX_CTX );
+HXLINE( 160)		{
+HXLINE( 160)			int _g_offset = 0;
+HXDLIN( 160)			::String _g_s = s;
+HXDLIN( 160)			while((_g_offset < _g_s.length)){
+HXLINE( 160)				::String s1 = _g_s;
+HXDLIN( 160)				_g_offset = (_g_offset + 1);
+HXDLIN( 160)				int index = (_g_offset - 1);
+HXDLIN( 160)				int c = s1.cca(index);
+HXDLIN( 160)				bool _hx_tmp;
+HXDLIN( 160)				if ((c >= 55296)) {
+HXLINE( 160)					_hx_tmp = (c <= 56319);
+            				}
+            				else {
+HXLINE( 160)					_hx_tmp = false;
+            				}
+HXDLIN( 160)				if (_hx_tmp) {
+HXLINE( 639)					c = (((c - 55232) << 10) | (s1.cca((index + 1)) & 1023));
+            				}
+HXLINE( 160)				int c1 = c;
+HXDLIN( 160)				if ((c1 >= 65536)) {
+HXLINE( 160)					_g_offset = (_g_offset + 1);
+            				}
+HXDLIN( 160)				int code = c1;
+HXLINE( 161)				switch((int)(code)){
+            					case (int)34: {
+HXLINE( 168)						if (( (bool)(quotes) )) {
+HXLINE( 169)							if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 169)								buf->flush();
+            							}
+HXDLIN( 169)							if (::hx::IsNull( buf->b )) {
+HXLINE( 169)								buf->b = ::Array_obj< ::String >::fromData( _hx_array_data_0363db6a_3,1);
+            							}
+            							else {
+HXLINE( 169)								buf->b->push(HX_("&quot;",2c,d9,81,8f));
+            							}
+            						}
+            						else {
+HXLINE( 173)							if ((code >= 127)) {
+HXLINE( 173)								::String x = ::String::fromCharCode(code);
+HXDLIN( 173)								if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 173)									buf->flush();
+            								}
+HXDLIN( 173)								if (::hx::IsNull( buf->b )) {
+HXLINE( 173)									buf->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(x));
+            								}
+            								else {
+HXLINE( 173)									::Array< ::String > buf1 = buf->b;
+HXDLIN( 173)									buf1->push(::Std_obj::string(x));
+            								}
+            							}
+            							else {
+HXLINE( 173)								if (::hx::IsNull( buf->charBuf )) {
+HXLINE( 173)									buf->charBuf = ::Array_obj< char >::__new();
+            								}
+HXDLIN( 173)								buf->charBuf->push(code);
+            							}
+            						}
+            					}
+            					break;
+            					case (int)38: {
+HXLINE( 163)						if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 163)							buf->flush();
+            						}
+HXDLIN( 163)						if (::hx::IsNull( buf->b )) {
+HXLINE( 163)							buf->b = ::Array_obj< ::String >::fromData( _hx_array_data_0363db6a_4,1);
+            						}
+            						else {
+HXLINE( 163)							buf->b->push(HX_("&amp;",dd,d4,aa,21));
+            						}
+            					}
+            					break;
+            					case (int)39: {
+HXLINE( 170)						if (( (bool)(quotes) )) {
+HXLINE( 171)							if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 171)								buf->flush();
+            							}
+HXDLIN( 171)							if (::hx::IsNull( buf->b )) {
+HXLINE( 171)								buf->b = ::Array_obj< ::String >::fromData( _hx_array_data_0363db6a_5,1);
+            							}
+            							else {
+HXLINE( 171)								buf->b->push(HX_("&#039;",62,26,77,78));
+            							}
+            						}
+            						else {
+HXLINE( 173)							if ((code >= 127)) {
+HXLINE( 173)								::String x1 = ::String::fromCharCode(code);
+HXDLIN( 173)								if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 173)									buf->flush();
+            								}
+HXDLIN( 173)								if (::hx::IsNull( buf->b )) {
+HXLINE( 173)									buf->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(x1));
+            								}
+            								else {
+HXLINE( 173)									::Array< ::String > buf2 = buf->b;
+HXDLIN( 173)									buf2->push(::Std_obj::string(x1));
+            								}
+            							}
+            							else {
+HXLINE( 173)								if (::hx::IsNull( buf->charBuf )) {
+HXLINE( 173)									buf->charBuf = ::Array_obj< char >::__new();
+            								}
+HXDLIN( 173)								buf->charBuf->push(code);
+            							}
+            						}
+            					}
+            					break;
+            					case (int)60: {
+HXLINE( 165)						if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 165)							buf->flush();
+            						}
+HXDLIN( 165)						if (::hx::IsNull( buf->b )) {
+HXLINE( 165)							buf->b = ::Array_obj< ::String >::fromData( _hx_array_data_0363db6a_6,1);
+            						}
+            						else {
+HXLINE( 165)							buf->b->push(HX_("&lt;",4d,74,70,19));
+            						}
+            					}
+            					break;
+            					case (int)62: {
+HXLINE( 167)						if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 167)							buf->flush();
+            						}
+HXDLIN( 167)						if (::hx::IsNull( buf->b )) {
+HXLINE( 167)							buf->b = ::Array_obj< ::String >::fromData( _hx_array_data_0363db6a_7,1);
+            						}
+            						else {
+HXLINE( 167)							buf->b->push(HX_("&gt;",08,a9,6c,19));
+            						}
+            					}
+            					break;
+            					default:{
+HXLINE( 173)						if ((code >= 127)) {
+HXLINE( 173)							::String x2 = ::String::fromCharCode(code);
+HXDLIN( 173)							if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 173)								buf->flush();
+            							}
+HXDLIN( 173)							if (::hx::IsNull( buf->b )) {
+HXLINE( 173)								buf->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(x2));
+            							}
+            							else {
+HXLINE( 173)								::Array< ::String > buf3 = buf->b;
+HXDLIN( 173)								buf3->push(::Std_obj::string(x2));
+            							}
+            						}
+            						else {
+HXLINE( 173)							if (::hx::IsNull( buf->charBuf )) {
+HXLINE( 173)								buf->charBuf = ::Array_obj< char >::__new();
+            							}
+HXDLIN( 173)							buf->charBuf->push(code);
+            						}
+            					}
+            				}
+            			}
+            		}
+HXLINE( 176)		return buf->toString();
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(StringTools_obj,htmlEscape,return )
+
+bool StringTools_obj::startsWith(::String s,::String start){
+            	HX_STACKFRAME(&_hx_pos_0e615b5827179e15_240_startsWith)
+HXDLIN( 240)		if ((s.length >= start.length)) {
+HXDLIN( 240)			return (s.lastIndexOf(start,0) == 0);
+            		}
+            		else {
+HXDLIN( 240)			return false;
+            		}
+HXDLIN( 240)		return false;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(StringTools_obj,startsWith,return )
+
+bool StringTools_obj::endsWith(::String s,::String end){
+            	HX_STACKFRAME(&_hx_pos_0e615b5827179e15_251_endsWith)
+HXLINE( 267)		int elen = end.length;
+HXLINE( 268)		int slen = s.length;
+HXLINE( 269)		if ((slen >= elen)) {
+HXLINE( 269)			return (s.indexOf(end,(slen - elen)) == (slen - elen));
+            		}
+            		else {
+HXLINE( 269)			return false;
+            		}
+HXDLIN( 269)		return false;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(StringTools_obj,endsWith,return )
+
+bool StringTools_obj::isSpace(::String s,int pos){
+            	HX_STACKFRAME(&_hx_pos_0e615b5827179e15_282_isSpace)
+HXLINE( 287)		 ::Dynamic c = s.charCodeAt(pos);
+HXLINE( 288)		bool _hx_tmp;
+HXDLIN( 288)		if (::hx::IsGreater( c,8 )) {
+HXLINE( 288)			_hx_tmp = ::hx::IsLess( c,14 );
+            		}
+            		else {
+HXLINE( 288)			_hx_tmp = false;
+            		}
+HXDLIN( 288)		if (!(_hx_tmp)) {
+HXLINE( 288)			return ::hx::IsEq( c,32 );
+            		}
+            		else {
+HXLINE( 288)			return true;
+            		}
+HXDLIN( 288)		return false;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(StringTools_obj,isSpace,return )
+
+::String StringTools_obj::ltrim(::String s){
+            	HX_STACKFRAME(&_hx_pos_0e615b5827179e15_300_ltrim)
+HXLINE( 304)		int l = s.length;
+HXLINE( 305)		int r = 0;
+HXLINE( 306)		while(true){
+HXLINE( 306)			bool _hx_tmp;
+HXDLIN( 306)			if ((r < l)) {
+HXLINE( 306)				_hx_tmp = ::StringTools_obj::isSpace(s,r);
+            			}
+            			else {
+HXLINE( 306)				_hx_tmp = false;
+            			}
+HXDLIN( 306)			if (!(_hx_tmp)) {
+HXLINE( 306)				goto _hx_goto_11;
+            			}
+HXLINE( 307)			r = (r + 1);
+            		}
+            		_hx_goto_11:;
+HXLINE( 309)		if ((r > 0)) {
+HXLINE( 310)			return s.substr(r,(l - r));
+            		}
+            		else {
+HXLINE( 312)			return s;
+            		}
+HXLINE( 309)		return null();
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(StringTools_obj,ltrim,return )
+
+::String StringTools_obj::rtrim(::String s){
+            	HX_STACKFRAME(&_hx_pos_0e615b5827179e15_325_rtrim)
+HXLINE( 329)		int l = s.length;
+HXLINE( 330)		int r = 0;
+HXLINE( 331)		while(true){
+HXLINE( 331)			bool _hx_tmp;
+HXDLIN( 331)			if ((r < l)) {
+HXLINE( 331)				_hx_tmp = ::StringTools_obj::isSpace(s,((l - r) - 1));
+            			}
+            			else {
+HXLINE( 331)				_hx_tmp = false;
+            			}
+HXDLIN( 331)			if (!(_hx_tmp)) {
+HXLINE( 331)				goto _hx_goto_13;
+            			}
+HXLINE( 332)			r = (r + 1);
+            		}
+            		_hx_goto_13:;
+HXLINE( 334)		if ((r > 0)) {
+HXLINE( 335)			return s.substr(0,(l - r));
+            		}
+            		else {
+HXLINE( 337)			return s;
+            		}
+HXLINE( 334)		return null();
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(StringTools_obj,rtrim,return )
+
+::String StringTools_obj::trim(::String s){
+            	HX_STACKFRAME(&_hx_pos_0e615b5827179e15_353_trim)
+HXDLIN( 353)		return ::StringTools_obj::ltrim(::StringTools_obj::rtrim(s));
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(StringTools_obj,trim,return )
+
+::String StringTools_obj::lpad(::String s,::String c,int l){
+            	HX_GC_STACKFRAME(&_hx_pos_0e615b5827179e15_369_lpad)
+HXLINE( 370)		if ((c.length <= 0)) {
+HXLINE( 371)			return s;
+            		}
+HXLINE( 373)		 ::StringBuf buf =  ::StringBuf_obj::__alloc( HX_CTX );
+HXLINE( 374)		l = (l - s.length);
+HXLINE( 375)		while((buf->get_length() < l)){
+HXLINE( 376)			if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 376)				buf->flush();
+            			}
+HXDLIN( 376)			if (::hx::IsNull( buf->b )) {
+HXLINE( 376)				buf->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(c));
+            			}
+            			else {
+HXLINE( 376)				::Array< ::String > buf1 = buf->b;
+HXDLIN( 376)				buf1->push(::Std_obj::string(c));
+            			}
+            		}
+HXLINE( 378)		{
+HXLINE( 378)			if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 378)				buf->flush();
+            			}
+HXDLIN( 378)			if (::hx::IsNull( buf->b )) {
+HXLINE( 378)				buf->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(s));
+            			}
+            			else {
+HXLINE( 378)				::Array< ::String > buf2 = buf->b;
+HXDLIN( 378)				buf2->push(::Std_obj::string(s));
+            			}
+            		}
+HXLINE( 379)		return buf->toString();
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC3(StringTools_obj,lpad,return )
+
+::String StringTools_obj::replace(::String s,::String sub,::String by){
+            	HX_STACKFRAME(&_hx_pos_0e615b5827179e15_428_replace)
+HXDLIN( 428)		return s.split(sub)->join(by);
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC3(StringTools_obj,replace,return )
+
+::String StringTools_obj::hex(int n, ::Dynamic digits){
+            	HX_STACKFRAME(&_hx_pos_0e615b5827179e15_438_hex)
+HXLINE( 444)		::String s = HX_("",00,00,00,00);
+HXLINE( 445)		::String hexChars = HX_("0123456789ABCDEF",68,2a,58,a2);
+HXLINE( 446)		do {
+HXLINE( 447)			s = (hexChars.charAt((n & 15)) + s);
+HXLINE( 448)			n = ::hx::UShr(n,4);
+            		} while((n > 0));
+;
+HXLINE( 459)		if (::hx::IsNotNull( digits )) {
+HXLINE( 460)			while(::hx::IsLess( s.length,digits )){
+HXLINE( 461)				s = (HX_("0",30,00,00,00) + s);
+            			}
+            		}
+HXLINE( 463)		return s;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(StringTools_obj,hex,return )
+
+
+StringTools_obj::StringTools_obj()
+{
+}
+
+bool StringTools_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"hex") ) { outValue = hex_dyn(); return true; }
+		break;
+	case 4:
+		if (HX_FIELD_EQ(inName,"trim") ) { outValue = trim_dyn(); return true; }
+		if (HX_FIELD_EQ(inName,"lpad") ) { outValue = lpad_dyn(); return true; }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"ltrim") ) { outValue = ltrim_dyn(); return true; }
+		if (HX_FIELD_EQ(inName,"rtrim") ) { outValue = rtrim_dyn(); return true; }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"isSpace") ) { outValue = isSpace_dyn(); return true; }
+		if (HX_FIELD_EQ(inName,"replace") ) { outValue = replace_dyn(); return true; }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"endsWith") ) { outValue = endsWith_dyn(); return true; }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"urlEncode") ) { outValue = urlEncode_dyn(); return true; }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"htmlEscape") ) { outValue = htmlEscape_dyn(); return true; }
+		if (HX_FIELD_EQ(inName,"startsWith") ) { outValue = startsWith_dyn(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *StringTools_obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo *StringTools_obj_sStaticStorageInfo = 0;
+#endif
+
+::hx::Class StringTools_obj::__mClass;
+
+static ::String StringTools_obj_sStaticFields[] = {
+	HX_("urlEncode",e5,4e,52,9a),
+	HX_("htmlEscape",4c,af,9b,a8),
+	HX_("startsWith",77,c0,cf,f9),
+	HX_("endsWith",5e,7a,b6,db),
+	HX_("isSpace",7c,30,ec,1d),
+	HX_("ltrim",4e,43,4a,7c),
+	HX_("rtrim",54,be,b1,f0),
+	HX_("trim",e2,9c,03,4d),
+	HX_("lpad",67,5c,b8,47),
+	HX_("replace",34,48,28,ab),
+	HX_("hex",db,42,4f,00),
+	::String(null())
+};
+
+void StringTools_obj::__register()
+{
+	StringTools_obj _hx_dummy;
+	StringTools_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("StringTools",6a,db,63,03);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &StringTools_obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(StringTools_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< StringTools_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = StringTools_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = StringTools_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
diff --git a/Sources/c_snikket/src/Sys.cpp b/Sources/c_snikket/src/Sys.cpp
new file mode 100644
index 0000000..39a5076
--- /dev/null
+++ b/Sources/c_snikket/src/Sys.cpp
@@ -0,0 +1,124 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Sys
+#include <Sys.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_39f5eab4124248fe_59_getEnv,"Sys","getEnv",0xd9e05658,"Sys.getEnv","/usr/local/lib/haxe/std/cpp/_std/Sys.hx",59,0xd23c22f3)
+HX_LOCAL_STACK_FRAME(_hx_pos_39f5eab4124248fe_79_getCwd,"Sys","getCwd",0xd9ded99b,"Sys.getCwd","/usr/local/lib/haxe/std/cpp/_std/Sys.hx",79,0xd23c22f3)
+HX_LOCAL_STACK_FRAME(_hx_pos_39f5eab4124248fe_87_systemName,"Sys","systemName",0xbea5b6bb,"Sys.systemName","/usr/local/lib/haxe/std/cpp/_std/Sys.hx",87,0xd23c22f3)
+HX_LOCAL_STACK_FRAME(_hx_pos_39f5eab4124248fe_113_time,"Sys","time",0xf7761b2e,"Sys.time","/usr/local/lib/haxe/std/cpp/_std/Sys.hx",113,0xd23c22f3)
+
+void Sys_obj::__construct() { }
+
+Dynamic Sys_obj::__CreateEmpty() { return new Sys_obj; }
+
+void *Sys_obj::_hx_vtable = 0;
+
+Dynamic Sys_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Sys_obj > _hx_result = new Sys_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool Sys_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x7ee3a981;
+}
+
+::String Sys_obj::getEnv(::String s){
+            	HX_STACKFRAME(&_hx_pos_39f5eab4124248fe_59_getEnv)
+HXLINE(  60)		::String v = _hx_std_get_env(s);
+HXLINE(  61)		if (::hx::IsNull( v )) {
+HXLINE(  62)			return null();
+            		}
+HXLINE(  63)		return v;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Sys_obj,getEnv,return )
+
+::String Sys_obj::getCwd(){
+            	HX_STACKFRAME(&_hx_pos_39f5eab4124248fe_79_getCwd)
+HXDLIN(  79)		return _hx_std_get_cwd();
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC0(Sys_obj,getCwd,return )
+
+::String Sys_obj::systemName(){
+            	HX_STACKFRAME(&_hx_pos_39f5eab4124248fe_87_systemName)
+HXDLIN(  87)		return _hx_std_sys_string();
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC0(Sys_obj,systemName,return )
+
+Float Sys_obj::time(){
+            	HX_STACKFRAME(&_hx_pos_39f5eab4124248fe_113_time)
+HXDLIN( 113)		return _hx_std_sys_time();
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC0(Sys_obj,time,return )
+
+
+Sys_obj::Sys_obj()
+{
+}
+
+bool Sys_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"time") ) { outValue = time_dyn(); return true; }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"getEnv") ) { outValue = getEnv_dyn(); return true; }
+		if (HX_FIELD_EQ(inName,"getCwd") ) { outValue = getCwd_dyn(); return true; }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"systemName") ) { outValue = systemName_dyn(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *Sys_obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo *Sys_obj_sStaticStorageInfo = 0;
+#endif
+
+::hx::Class Sys_obj::__mClass;
+
+static ::String Sys_obj_sStaticFields[] = {
+	HX_("getEnv",f7,3c,1c,a3),
+	HX_("getCwd",3a,c0,1a,a3),
+	HX_("systemName",da,d8,82,f7),
+	HX_("time",0d,cc,fc,4c),
+	::String(null())
+};
+
+void Sys_obj::__register()
+{
+	Sys_obj _hx_dummy;
+	Sys_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("Sys",ed,64,3f,00);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &Sys_obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(Sys_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< Sys_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Sys_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Sys_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
diff --git a/Sources/c_snikket/src/Type.cpp b/Sources/c_snikket/src/Type.cpp
new file mode 100644
index 0000000..bc5cd54
--- /dev/null
+++ b/Sources/c_snikket/src/Type.cpp
@@ -0,0 +1,199 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Reflect
+#include <Reflect.h>
+#endif
+#ifndef INCLUDED_Type
+#include <Type.h>
+#endif
+#ifndef INCLUDED_ValueType
+#include <ValueType.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_6ebc4c1d0351a436_36_getClass,"Type","getClass",0xc4e49bd6,"Type.getClass","/usr/local/lib/haxe/std/cpp/_std/Type.hx",36,0xb5f2d6e2)
+HX_LOCAL_STACK_FRAME(_hx_pos_6ebc4c1d0351a436_61_getClassName,"Type","getClassName",0x8e66dd41,"Type.getClassName","/usr/local/lib/haxe/std/cpp/_std/Type.hx",61,0xb5f2d6e2)
+HX_LOCAL_STACK_FRAME(_hx_pos_6ebc4c1d0351a436_111_getInstanceFields,"Type","getInstanceFields",0xe970f890,"Type.getInstanceFields","/usr/local/lib/haxe/std/cpp/_std/Type.hx",111,0xb5f2d6e2)
+HX_LOCAL_STACK_FRAME(_hx_pos_6ebc4c1d0351a436_124_typeof,"Type","typeof",0xd6c51d65,"Type.typeof","/usr/local/lib/haxe/std/cpp/_std/Type.hx",124,0xb5f2d6e2)
+HX_LOCAL_STACK_FRAME(_hx_pos_6ebc4c1d0351a436_158_enumParameters,"Type","enumParameters",0xf9e1b41f,"Type.enumParameters","/usr/local/lib/haxe/std/cpp/_std/Type.hx",158,0xb5f2d6e2)
+
+void Type_obj::__construct() { }
+
+Dynamic Type_obj::__CreateEmpty() { return new Type_obj; }
+
+void *Type_obj::_hx_vtable = 0;
+
+Dynamic Type_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Type_obj > _hx_result = new Type_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool Type_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x0c3514fe;
+}
+
+::hx::Class Type_obj::getClass( ::Dynamic o){
+            	HX_STACKFRAME(&_hx_pos_6ebc4c1d0351a436_36_getClass)
+HXLINE(  37)		bool _hx_tmp;
+HXDLIN(  37)		if (::hx::IsNotNull( o )) {
+HXLINE(  37)			_hx_tmp = !(::Reflect_obj::isObject(o));
+            		}
+            		else {
+HXLINE(  37)			_hx_tmp = true;
+            		}
+HXDLIN(  37)		if (_hx_tmp) {
+HXLINE(  38)			return null();
+            		}
+HXLINE(  39)		 ::Dynamic c = o->__GetClass();
+HXLINE(  40)		::String _hx_switch_0 = ( (::String)(c->toString()) );
+            		if (  (_hx_switch_0==HX_("Class",18,e8,85,db)) ){
+HXLINE(  44)			return null();
+HXDLIN(  44)			goto _hx_goto_0;
+            		}
+            		if (  (_hx_switch_0==HX_("__Anon",8c,1a,43,da)) ){
+HXLINE(  42)			return null();
+HXDLIN(  42)			goto _hx_goto_0;
+            		}
+            		_hx_goto_0:;
+HXLINE(  46)		return c;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Type_obj,getClass,return )
+
+::String Type_obj::getClassName(::hx::Class c){
+            	HX_STACKFRAME(&_hx_pos_6ebc4c1d0351a436_61_getClassName)
+HXLINE(  62)		if (::hx::IsNull( c )) {
+HXLINE(  63)			return null();
+            		}
+HXLINE(  64)		return c->mName;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Type_obj,getClassName,return )
+
+::Array< ::String > Type_obj::getInstanceFields(::hx::Class c){
+            	HX_STACKFRAME(&_hx_pos_6ebc4c1d0351a436_111_getInstanceFields)
+HXDLIN( 111)		return ( (::Array< ::String >)(c->GetInstanceFields()) );
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Type_obj,getInstanceFields,return )
+
+ ::ValueType Type_obj::_hx_typeof( ::Dynamic v){
+            	HX_STACKFRAME(&_hx_pos_6ebc4c1d0351a436_124_typeof)
+HXLINE( 125)		if (::hx::IsNull( v )) {
+HXLINE( 126)			return ::ValueType_obj::TNull_dyn();
+            		}
+HXLINE( 127)		int t = ( (int)(v->__GetType()) );
+HXLINE( 128)		switch((int)(t)){
+            			case (int)1: {
+HXLINE( 134)				return ::ValueType_obj::TFloat_dyn();
+            			}
+            			break;
+            			case (int)2: {
+HXLINE( 130)				return ::ValueType_obj::TBool_dyn();
+            			}
+            			break;
+            			case (int)4: {
+HXLINE( 138)				return ::ValueType_obj::TObject_dyn();
+            			}
+            			break;
+            			case (int)6: {
+HXLINE( 136)				return ::ValueType_obj::TFunction_dyn();
+            			}
+            			break;
+            			case (int)7: {
+HXLINE( 140)				return ::ValueType_obj::TEnum(v->__GetClass());
+            			}
+            			break;
+            			case (int)255: {
+HXLINE( 132)				return ::ValueType_obj::TInt_dyn();
+            			}
+            			break;
+            			default:{
+HXLINE( 142)				return ::ValueType_obj::TClass(v->__GetClass());
+            			}
+            		}
+HXLINE( 128)		return null();
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Type_obj,_hx_typeof,return )
+
+::cpp::VirtualArray Type_obj::enumParameters( ::Dynamic e){
+            	HX_STACKFRAME(&_hx_pos_6ebc4c1d0351a436_158_enumParameters)
+HXLINE( 159)		 hx::EnumBase value = ( ( hx::EnumBase)(e) );
+HXLINE( 160)		return value->_hx_getParameters();
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Type_obj,enumParameters,return )
+
+
+Type_obj::Type_obj()
+{
+}
+
+bool Type_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 6:
+		if (HX_FIELD_EQ(inName,"typeof") ) { outValue = _hx_typeof_dyn(); return true; }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"getClass") ) { outValue = getClass_dyn(); return true; }
+		break;
+	case 12:
+		if (HX_FIELD_EQ(inName,"getClassName") ) { outValue = getClassName_dyn(); return true; }
+		break;
+	case 14:
+		if (HX_FIELD_EQ(inName,"enumParameters") ) { outValue = enumParameters_dyn(); return true; }
+		break;
+	case 17:
+		if (HX_FIELD_EQ(inName,"getInstanceFields") ) { outValue = getInstanceFields_dyn(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *Type_obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo *Type_obj_sStaticStorageInfo = 0;
+#endif
+
+::hx::Class Type_obj::__mClass;
+
+static ::String Type_obj_sStaticFields[] = {
+	HX_("getClass",c2,87,2f,a8),
+	HX_("getClassName",2d,2f,94,eb),
+	HX_("getInstanceFields",24,2f,97,ed),
+	HX_("typeof",51,f6,36,57),
+	HX_("enumParameters",0b,59,78,fa),
+	::String(null())
+};
+
+void Type_obj::__register()
+{
+	Type_obj _hx_dummy;
+	Type_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("Type",da,1e,e2,37);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &Type_obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(Type_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< Type_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Type_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Type_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
diff --git a/Sources/c_snikket/src/ValueType.cpp b/Sources/c_snikket/src/ValueType.cpp
new file mode 100644
index 0000000..f8f6801
--- /dev/null
+++ b/Sources/c_snikket/src/ValueType.cpp
@@ -0,0 +1,138 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_ValueType
+#include <ValueType.h>
+#endif
+
+::ValueType ValueType_obj::TBool;
+
+::ValueType ValueType_obj::TClass(::hx::Class c)
+{
+	return ::hx::CreateEnum< ValueType_obj >(HX_("TClass",44,37,80,71),6,1)->_hx_init(0,c);
+}
+
+::ValueType ValueType_obj::TEnum(::hx::Class e)
+{
+	return ::hx::CreateEnum< ValueType_obj >(HX_("TEnum",75,51,98,8b),7,1)->_hx_init(0,e);
+}
+
+::ValueType ValueType_obj::TFloat;
+
+::ValueType ValueType_obj::TFunction;
+
+::ValueType ValueType_obj::TInt;
+
+::ValueType ValueType_obj::TNull;
+
+::ValueType ValueType_obj::TObject;
+
+::ValueType ValueType_obj::TUnknown;
+
+bool ValueType_obj::__GetStatic(const ::String &inName, ::Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	if (inName==HX_("TBool",9e,6a,9d,89)) { outValue = ValueType_obj::TBool; return true; }
+	if (inName==HX_("TClass",44,37,80,71)) { outValue = ValueType_obj::TClass_dyn(); return true; }
+	if (inName==HX_("TEnum",75,51,98,8b)) { outValue = ValueType_obj::TEnum_dyn(); return true; }
+	if (inName==HX_("TFloat",a8,84,be,2b)) { outValue = ValueType_obj::TFloat; return true; }
+	if (inName==HX_("TFunction",8c,db,3a,25)) { outValue = ValueType_obj::TFunction; return true; }
+	if (inName==HX_("TInt",fb,b0,bd,37)) { outValue = ValueType_obj::TInt; return true; }
+	if (inName==HX_("TNull",fb,84,90,91)) { outValue = ValueType_obj::TNull; return true; }
+	if (inName==HX_("TObject",33,ea,de,ee)) { outValue = ValueType_obj::TObject; return true; }
+	if (inName==HX_("TUnknown",96,bd,59,73)) { outValue = ValueType_obj::TUnknown; return true; }
+	return super::__GetStatic(inName, outValue, inCallProp);
+}
+
+HX_DEFINE_CREATE_ENUM(ValueType_obj)
+
+int ValueType_obj::__FindIndex(::String inName)
+{
+	if (inName==HX_("TBool",9e,6a,9d,89)) return 3;
+	if (inName==HX_("TClass",44,37,80,71)) return 6;
+	if (inName==HX_("TEnum",75,51,98,8b)) return 7;
+	if (inName==HX_("TFloat",a8,84,be,2b)) return 2;
+	if (inName==HX_("TFunction",8c,db,3a,25)) return 5;
+	if (inName==HX_("TInt",fb,b0,bd,37)) return 1;
+	if (inName==HX_("TNull",fb,84,90,91)) return 0;
+	if (inName==HX_("TObject",33,ea,de,ee)) return 4;
+	if (inName==HX_("TUnknown",96,bd,59,73)) return 8;
+	return super::__FindIndex(inName);
+}
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(ValueType_obj,TClass,return)
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(ValueType_obj,TEnum,return)
+
+int ValueType_obj::__FindArgCount(::String inName)
+{
+	if (inName==HX_("TBool",9e,6a,9d,89)) return 0;
+	if (inName==HX_("TClass",44,37,80,71)) return 1;
+	if (inName==HX_("TEnum",75,51,98,8b)) return 1;
+	if (inName==HX_("TFloat",a8,84,be,2b)) return 0;
+	if (inName==HX_("TFunction",8c,db,3a,25)) return 0;
+	if (inName==HX_("TInt",fb,b0,bd,37)) return 0;
+	if (inName==HX_("TNull",fb,84,90,91)) return 0;
+	if (inName==HX_("TObject",33,ea,de,ee)) return 0;
+	if (inName==HX_("TUnknown",96,bd,59,73)) return 0;
+	return super::__FindArgCount(inName);
+}
+
+::hx::Val ValueType_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	if (inName==HX_("TBool",9e,6a,9d,89)) return TBool;
+	if (inName==HX_("TClass",44,37,80,71)) return TClass_dyn();
+	if (inName==HX_("TEnum",75,51,98,8b)) return TEnum_dyn();
+	if (inName==HX_("TFloat",a8,84,be,2b)) return TFloat;
+	if (inName==HX_("TFunction",8c,db,3a,25)) return TFunction;
+	if (inName==HX_("TInt",fb,b0,bd,37)) return TInt;
+	if (inName==HX_("TNull",fb,84,90,91)) return TNull;
+	if (inName==HX_("TObject",33,ea,de,ee)) return TObject;
+	if (inName==HX_("TUnknown",96,bd,59,73)) return TUnknown;
+	return super::__Field(inName,inCallProp);
+}
+
+static ::String ValueType_obj_sStaticFields[] = {
+	HX_("TNull",fb,84,90,91),
+	HX_("TInt",fb,b0,bd,37),
+	HX_("TFloat",a8,84,be,2b),
+	HX_("TBool",9e,6a,9d,89),
+	HX_("TObject",33,ea,de,ee),
+	HX_("TFunction",8c,db,3a,25),
+	HX_("TClass",44,37,80,71),
+	HX_("TEnum",75,51,98,8b),
+	HX_("TUnknown",96,bd,59,73),
+	::String(null())
+};
+
+::hx::Class ValueType_obj::__mClass;
+
+Dynamic __Create_ValueType_obj() { return new ValueType_obj; }
+
+void ValueType_obj::__register()
+{
+
+::hx::Static(__mClass) = ::hx::_hx_RegisterClass(HX_("ValueType",ab,8a,60,3b), ::hx::TCanCast< ValueType_obj >,ValueType_obj_sStaticFields,0,
+	&__Create_ValueType_obj, &__Create,
+	&super::__SGetClass(), &CreateValueType_obj, 0
+#ifdef HXCPP_VISIT_ALLOCS
+    , 0
+#endif
+#ifdef HXCPP_SCRIPTABLE
+    , 0
+#endif
+);
+	__mClass->mGetStaticField = &ValueType_obj::__GetStatic;
+}
+
+void ValueType_obj::__boot()
+{
+TBool = ::hx::CreateConstEnum< ValueType_obj >(HX_("TBool",9e,6a,9d,89),3);
+TFloat = ::hx::CreateConstEnum< ValueType_obj >(HX_("TFloat",a8,84,be,2b),2);
+TFunction = ::hx::CreateConstEnum< ValueType_obj >(HX_("TFunction",8c,db,3a,25),5);
+TInt = ::hx::CreateConstEnum< ValueType_obj >(HX_("TInt",fb,b0,bd,37),1);
+TNull = ::hx::CreateConstEnum< ValueType_obj >(HX_("TNull",fb,84,90,91),0);
+TObject = ::hx::CreateConstEnum< ValueType_obj >(HX_("TObject",33,ea,de,ee),4);
+TUnknown = ::hx::CreateConstEnum< ValueType_obj >(HX_("TUnknown",96,bd,59,73),8);
+}
+
+
diff --git a/Sources/c_snikket/src/Xml.cpp b/Sources/c_snikket/src/Xml.cpp
new file mode 100644
index 0000000..38309a3
--- /dev/null
+++ b/Sources/c_snikket/src/Xml.cpp
@@ -0,0 +1,660 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Xml
+#include <Xml.h>
+#endif
+#ifndef INCLUDED__Xml_XmlType_Impl_
+#include <_Xml/XmlType_Impl_.h>
+#endif
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+#ifndef INCLUDED_haxe_ds_StringMap
+#include <haxe/ds/StringMap.h>
+#endif
+#ifndef INCLUDED_haxe_xml_Parser
+#include <haxe/xml/Parser.h>
+#endif
+#ifndef INCLUDED_haxe_xml_Printer
+#include <haxe/xml/Printer.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_7e4d842269e66db1_397_new,"Xml","new",0x2e496e29,"Xml.new","/usr/local/lib/haxe/std/Xml.hx",397,0x5c1024e4)
+HX_LOCAL_STACK_FRAME(_hx_pos_7e4d842269e66db1_244_get,"Xml","get",0x2e441e5f,"Xml.get","/usr/local/lib/haxe/std/Xml.hx",244,0x5c1024e4)
+HX_LOCAL_STACK_FRAME(_hx_pos_7e4d842269e66db1_255_set,"Xml","set",0x2e4d396b,"Xml.set","/usr/local/lib/haxe/std/Xml.hx",255,0x5c1024e4)
+HX_LOCAL_STACK_FRAME(_hx_pos_7e4d842269e66db1_277_exists,"Xml","exists",0x446683b3,"Xml.exists","/usr/local/lib/haxe/std/Xml.hx",277,0x5c1024e4)
+HX_LOCAL_STACK_FRAME(_hx_pos_7e4d842269e66db1_287_attributes,"Xml","attributes",0x1ab5462e,"Xml.attributes","/usr/local/lib/haxe/std/Xml.hx",287,0x5c1024e4)
+HX_LOCAL_STACK_FRAME(_hx_pos_7e4d842269e66db1_337_firstElement,"Xml","firstElement",0xc103a583,"Xml.firstElement","/usr/local/lib/haxe/std/Xml.hx",337,0x5c1024e4)
+HX_LOCAL_STACK_FRAME(_hx_pos_7e4d842269e66db1_353_addChild,"Xml","addChild",0x3e639952,"Xml.addChild","/usr/local/lib/haxe/std/Xml.hx",353,0x5c1024e4)
+HX_LOCAL_STACK_FRAME(_hx_pos_7e4d842269e66db1_366_removeChild,"Xml","removeChild",0x9bd39581,"Xml.removeChild","/usr/local/lib/haxe/std/Xml.hx",366,0x5c1024e4)
+HX_LOCAL_STACK_FRAME(_hx_pos_7e4d842269e66db1_394_toString,"Xml","toString",0xb7bb9a43,"Xml.toString","/usr/local/lib/haxe/std/Xml.hx",394,0x5c1024e4)
+HX_LOCAL_STACK_FRAME(_hx_pos_7e4d842269e66db1_122_parse,"Xml","parse",0x8a44f23c,"Xml.parse","/usr/local/lib/haxe/std/Xml.hx",122,0x5c1024e4)
+HX_LOCAL_STACK_FRAME(_hx_pos_7e4d842269e66db1_182_createElement,"Xml","createElement",0x97359a29,"Xml.createElement","/usr/local/lib/haxe/std/Xml.hx",182,0x5c1024e4)
+HX_LOCAL_STACK_FRAME(_hx_pos_7e4d842269e66db1_191_createPCData,"Xml","createPCData",0x3cc9ead0,"Xml.createPCData","/usr/local/lib/haxe/std/Xml.hx",191,0x5c1024e4)
+HX_LOCAL_STACK_FRAME(_hx_pos_7e4d842269e66db1_200_createCData,"Xml","createCData",0xaf49365a,"Xml.createCData","/usr/local/lib/haxe/std/Xml.hx",200,0x5c1024e4)
+HX_LOCAL_STACK_FRAME(_hx_pos_7e4d842269e66db1_209_createComment,"Xml","createComment",0x125165cc,"Xml.createComment","/usr/local/lib/haxe/std/Xml.hx",209,0x5c1024e4)
+HX_LOCAL_STACK_FRAME(_hx_pos_7e4d842269e66db1_218_createDocType,"Xml","createDocType",0x696de8bf,"Xml.createDocType","/usr/local/lib/haxe/std/Xml.hx",218,0x5c1024e4)
+HX_LOCAL_STACK_FRAME(_hx_pos_7e4d842269e66db1_227_createProcessingInstruction,"Xml","createProcessingInstruction",0x632a1f28,"Xml.createProcessingInstruction","/usr/local/lib/haxe/std/Xml.hx",227,0x5c1024e4)
+HX_LOCAL_STACK_FRAME(_hx_pos_7e4d842269e66db1_237_createDocument,"Xml","createDocument",0xcf00030e,"Xml.createDocument","/usr/local/lib/haxe/std/Xml.hx",237,0x5c1024e4)
+HX_LOCAL_STACK_FRAME(_hx_pos_7e4d842269e66db1_86_boot,"Xml","boot",0x4a0ff649,"Xml.boot","/usr/local/lib/haxe/std/Xml.hx",86,0x5c1024e4)
+HX_LOCAL_STACK_FRAME(_hx_pos_7e4d842269e66db1_91_boot,"Xml","boot",0x4a0ff649,"Xml.boot","/usr/local/lib/haxe/std/Xml.hx",91,0x5c1024e4)
+HX_LOCAL_STACK_FRAME(_hx_pos_7e4d842269e66db1_96_boot,"Xml","boot",0x4a0ff649,"Xml.boot","/usr/local/lib/haxe/std/Xml.hx",96,0x5c1024e4)
+HX_LOCAL_STACK_FRAME(_hx_pos_7e4d842269e66db1_101_boot,"Xml","boot",0x4a0ff649,"Xml.boot","/usr/local/lib/haxe/std/Xml.hx",101,0x5c1024e4)
+HX_LOCAL_STACK_FRAME(_hx_pos_7e4d842269e66db1_106_boot,"Xml","boot",0x4a0ff649,"Xml.boot","/usr/local/lib/haxe/std/Xml.hx",106,0x5c1024e4)
+HX_LOCAL_STACK_FRAME(_hx_pos_7e4d842269e66db1_111_boot,"Xml","boot",0x4a0ff649,"Xml.boot","/usr/local/lib/haxe/std/Xml.hx",111,0x5c1024e4)
+HX_LOCAL_STACK_FRAME(_hx_pos_7e4d842269e66db1_116_boot,"Xml","boot",0x4a0ff649,"Xml.boot","/usr/local/lib/haxe/std/Xml.hx",116,0x5c1024e4)
+
+void Xml_obj::__construct(int nodeType){
+            	HX_GC_STACKFRAME(&_hx_pos_7e4d842269e66db1_397_new)
+HXLINE( 398)		this->nodeType = nodeType;
+HXLINE( 399)		this->children = ::Array_obj< ::Dynamic>::__new(0);
+HXLINE( 400)		this->attributeMap =  ::haxe::ds::StringMap_obj::__alloc( HX_CTX );
+            	}
+
+Dynamic Xml_obj::__CreateEmpty() { return new Xml_obj; }
+
+void *Xml_obj::_hx_vtable = 0;
+
+Dynamic Xml_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Xml_obj > _hx_result = new Xml_obj();
+	_hx_result->__construct(inArgs[0]);
+	return _hx_result;
+}
+
+bool Xml_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x7ee76a4b;
+}
+
+::String Xml_obj::get(::String att){
+            	HX_STACKFRAME(&_hx_pos_7e4d842269e66db1_244_get)
+HXLINE( 245)		if ((this->nodeType != ::Xml_obj::Element)) {
+HXLINE( 246)			HX_STACK_DO_THROW((HX_("Bad node type, expected Element but found ",d8,90,8b,bb) + ::_Xml::XmlType_Impl__obj::toString(this->nodeType)));
+            		}
+HXLINE( 248)		return this->attributeMap->get_string(att);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Xml_obj,get,return )
+
+void Xml_obj::set(::String att,::String value){
+            	HX_STACKFRAME(&_hx_pos_7e4d842269e66db1_255_set)
+HXLINE( 256)		if ((this->nodeType != ::Xml_obj::Element)) {
+HXLINE( 257)			HX_STACK_DO_THROW((HX_("Bad node type, expected Element but found ",d8,90,8b,bb) + ::_Xml::XmlType_Impl__obj::toString(this->nodeType)));
+            		}
+HXLINE( 259)		this->attributeMap->set(att,value);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(Xml_obj,set,(void))
+
+bool Xml_obj::exists(::String att){
+            	HX_STACKFRAME(&_hx_pos_7e4d842269e66db1_277_exists)
+HXLINE( 278)		if ((this->nodeType != ::Xml_obj::Element)) {
+HXLINE( 279)			HX_STACK_DO_THROW((HX_("Bad node type, expected Element but found ",d8,90,8b,bb) + ::_Xml::XmlType_Impl__obj::toString(this->nodeType)));
+            		}
+HXLINE( 281)		return this->attributeMap->exists(att);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Xml_obj,exists,return )
+
+ ::Dynamic Xml_obj::attributes(){
+            	HX_STACKFRAME(&_hx_pos_7e4d842269e66db1_287_attributes)
+HXLINE( 288)		if ((this->nodeType != ::Xml_obj::Element)) {
+HXLINE( 289)			HX_STACK_DO_THROW((HX_("Bad node type, expected Element but found ",d8,90,8b,bb) + ::_Xml::XmlType_Impl__obj::toString(this->nodeType)));
+            		}
+HXLINE( 291)		return this->attributeMap->keys();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Xml_obj,attributes,return )
+
+ ::Xml Xml_obj::firstElement(){
+            	HX_STACKFRAME(&_hx_pos_7e4d842269e66db1_337_firstElement)
+HXLINE( 338)		bool _hx_tmp;
+HXDLIN( 338)		if ((this->nodeType != ::Xml_obj::Document)) {
+HXLINE( 338)			_hx_tmp = (this->nodeType != ::Xml_obj::Element);
+            		}
+            		else {
+HXLINE( 338)			_hx_tmp = false;
+            		}
+HXDLIN( 338)		if (_hx_tmp) {
+HXLINE( 338)			HX_STACK_DO_THROW((HX_("Bad node type, expected Element or Document but found ",a0,d6,ba,79) + ::_Xml::XmlType_Impl__obj::toString(this->nodeType)));
+            		}
+HXLINE( 339)		{
+HXLINE( 339)			int _g = 0;
+HXDLIN( 339)			::Array< ::Dynamic> _g1 = this->children;
+HXDLIN( 339)			while((_g < _g1->length)){
+HXLINE( 339)				 ::Xml child = _g1->__get(_g).StaticCast<  ::Xml >();
+HXDLIN( 339)				_g = (_g + 1);
+HXLINE( 340)				if ((child->nodeType == ::Xml_obj::Element)) {
+HXLINE( 341)					return child;
+            				}
+            			}
+            		}
+HXLINE( 344)		return null();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Xml_obj,firstElement,return )
+
+void Xml_obj::addChild( ::Xml x){
+            	HX_STACKFRAME(&_hx_pos_7e4d842269e66db1_353_addChild)
+HXLINE( 354)		bool _hx_tmp;
+HXDLIN( 354)		if ((this->nodeType != ::Xml_obj::Document)) {
+HXLINE( 354)			_hx_tmp = (this->nodeType != ::Xml_obj::Element);
+            		}
+            		else {
+HXLINE( 354)			_hx_tmp = false;
+            		}
+HXDLIN( 354)		if (_hx_tmp) {
+HXLINE( 354)			HX_STACK_DO_THROW((HX_("Bad node type, expected Element or Document but found ",a0,d6,ba,79) + ::_Xml::XmlType_Impl__obj::toString(this->nodeType)));
+            		}
+HXLINE( 355)		if (::hx::IsNotNull( x->parent )) {
+HXLINE( 356)			x->parent->removeChild(x);
+            		}
+HXLINE( 358)		this->children->push(x);
+HXLINE( 359)		x->parent = ::hx::ObjectPtr<OBJ_>(this);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Xml_obj,addChild,(void))
+
+bool Xml_obj::removeChild( ::Xml x){
+            	HX_STACKFRAME(&_hx_pos_7e4d842269e66db1_366_removeChild)
+HXLINE( 367)		bool _hx_tmp;
+HXDLIN( 367)		if ((this->nodeType != ::Xml_obj::Document)) {
+HXLINE( 367)			_hx_tmp = (this->nodeType != ::Xml_obj::Element);
+            		}
+            		else {
+HXLINE( 367)			_hx_tmp = false;
+            		}
+HXDLIN( 367)		if (_hx_tmp) {
+HXLINE( 367)			HX_STACK_DO_THROW((HX_("Bad node type, expected Element or Document but found ",a0,d6,ba,79) + ::_Xml::XmlType_Impl__obj::toString(this->nodeType)));
+            		}
+HXLINE( 368)		if (this->children->remove(x)) {
+HXLINE( 369)			x->parent = null();
+HXLINE( 370)			return true;
+            		}
+HXLINE( 372)		return false;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Xml_obj,removeChild,return )
+
+::String Xml_obj::toString(){
+            	HX_STACKFRAME(&_hx_pos_7e4d842269e66db1_394_toString)
+HXDLIN( 394)		return ::haxe::xml::Printer_obj::print(::hx::ObjectPtr<OBJ_>(this),null());
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Xml_obj,toString,return )
+
+int Xml_obj::Element;
+
+int Xml_obj::PCData;
+
+int Xml_obj::CData;
+
+int Xml_obj::Comment;
+
+int Xml_obj::DocType;
+
+int Xml_obj::ProcessingInstruction;
+
+int Xml_obj::Document;
+
+ ::Xml Xml_obj::parse(::String str){
+            	HX_STACKFRAME(&_hx_pos_7e4d842269e66db1_122_parse)
+HXDLIN( 122)		return ::haxe::xml::Parser_obj::parse(str,null());
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Xml_obj,parse,return )
+
+ ::Xml Xml_obj::createElement(::String name){
+            	HX_GC_STACKFRAME(&_hx_pos_7e4d842269e66db1_182_createElement)
+HXLINE( 183)		 ::Xml xml =  ::Xml_obj::__alloc( HX_CTX ,::Xml_obj::Element);
+HXLINE( 184)		{
+HXLINE( 184)			if ((xml->nodeType != ::Xml_obj::Element)) {
+HXLINE( 184)				HX_STACK_DO_THROW((HX_("Bad node type, expected Element but found ",d8,90,8b,bb) + ::_Xml::XmlType_Impl__obj::toString(xml->nodeType)));
+            			}
+HXDLIN( 184)			xml->nodeName = name;
+            		}
+HXLINE( 185)		return xml;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Xml_obj,createElement,return )
+
+ ::Xml Xml_obj::createPCData(::String data){
+            	HX_GC_STACKFRAME(&_hx_pos_7e4d842269e66db1_191_createPCData)
+HXLINE( 192)		 ::Xml xml =  ::Xml_obj::__alloc( HX_CTX ,::Xml_obj::PCData);
+HXLINE( 193)		{
+HXLINE( 193)			bool _hx_tmp;
+HXDLIN( 193)			if ((xml->nodeType != ::Xml_obj::Document)) {
+HXLINE( 193)				_hx_tmp = (xml->nodeType == ::Xml_obj::Element);
+            			}
+            			else {
+HXLINE( 193)				_hx_tmp = true;
+            			}
+HXDLIN( 193)			if (_hx_tmp) {
+HXLINE( 193)				HX_STACK_DO_THROW((HX_("Bad node type, unexpected ",be,79,d5,11) + ::_Xml::XmlType_Impl__obj::toString(xml->nodeType)));
+            			}
+HXDLIN( 193)			xml->nodeValue = data;
+            		}
+HXLINE( 194)		return xml;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Xml_obj,createPCData,return )
+
+ ::Xml Xml_obj::createCData(::String data){
+            	HX_GC_STACKFRAME(&_hx_pos_7e4d842269e66db1_200_createCData)
+HXLINE( 201)		 ::Xml xml =  ::Xml_obj::__alloc( HX_CTX ,::Xml_obj::CData);
+HXLINE( 202)		{
+HXLINE( 202)			bool _hx_tmp;
+HXDLIN( 202)			if ((xml->nodeType != ::Xml_obj::Document)) {
+HXLINE( 202)				_hx_tmp = (xml->nodeType == ::Xml_obj::Element);
+            			}
+            			else {
+HXLINE( 202)				_hx_tmp = true;
+            			}
+HXDLIN( 202)			if (_hx_tmp) {
+HXLINE( 202)				HX_STACK_DO_THROW((HX_("Bad node type, unexpected ",be,79,d5,11) + ::_Xml::XmlType_Impl__obj::toString(xml->nodeType)));
+            			}
+HXDLIN( 202)			xml->nodeValue = data;
+            		}
+HXLINE( 203)		return xml;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Xml_obj,createCData,return )
+
+ ::Xml Xml_obj::createComment(::String data){
+            	HX_GC_STACKFRAME(&_hx_pos_7e4d842269e66db1_209_createComment)
+HXLINE( 210)		 ::Xml xml =  ::Xml_obj::__alloc( HX_CTX ,::Xml_obj::Comment);
+HXLINE( 211)		{
+HXLINE( 211)			bool _hx_tmp;
+HXDLIN( 211)			if ((xml->nodeType != ::Xml_obj::Document)) {
+HXLINE( 211)				_hx_tmp = (xml->nodeType == ::Xml_obj::Element);
+            			}
+            			else {
+HXLINE( 211)				_hx_tmp = true;
+            			}
+HXDLIN( 211)			if (_hx_tmp) {
+HXLINE( 211)				HX_STACK_DO_THROW((HX_("Bad node type, unexpected ",be,79,d5,11) + ::_Xml::XmlType_Impl__obj::toString(xml->nodeType)));
+            			}
+HXDLIN( 211)			xml->nodeValue = data;
+            		}
+HXLINE( 212)		return xml;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Xml_obj,createComment,return )
+
+ ::Xml Xml_obj::createDocType(::String data){
+            	HX_GC_STACKFRAME(&_hx_pos_7e4d842269e66db1_218_createDocType)
+HXLINE( 219)		 ::Xml xml =  ::Xml_obj::__alloc( HX_CTX ,::Xml_obj::DocType);
+HXLINE( 220)		{
+HXLINE( 220)			bool _hx_tmp;
+HXDLIN( 220)			if ((xml->nodeType != ::Xml_obj::Document)) {
+HXLINE( 220)				_hx_tmp = (xml->nodeType == ::Xml_obj::Element);
+            			}
+            			else {
+HXLINE( 220)				_hx_tmp = true;
+            			}
+HXDLIN( 220)			if (_hx_tmp) {
+HXLINE( 220)				HX_STACK_DO_THROW((HX_("Bad node type, unexpected ",be,79,d5,11) + ::_Xml::XmlType_Impl__obj::toString(xml->nodeType)));
+            			}
+HXDLIN( 220)			xml->nodeValue = data;
+            		}
+HXLINE( 221)		return xml;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Xml_obj,createDocType,return )
+
+ ::Xml Xml_obj::createProcessingInstruction(::String data){
+            	HX_GC_STACKFRAME(&_hx_pos_7e4d842269e66db1_227_createProcessingInstruction)
+HXLINE( 228)		 ::Xml xml =  ::Xml_obj::__alloc( HX_CTX ,::Xml_obj::ProcessingInstruction);
+HXLINE( 229)		{
+HXLINE( 229)			bool _hx_tmp;
+HXDLIN( 229)			if ((xml->nodeType != ::Xml_obj::Document)) {
+HXLINE( 229)				_hx_tmp = (xml->nodeType == ::Xml_obj::Element);
+            			}
+            			else {
+HXLINE( 229)				_hx_tmp = true;
+            			}
+HXDLIN( 229)			if (_hx_tmp) {
+HXLINE( 229)				HX_STACK_DO_THROW((HX_("Bad node type, unexpected ",be,79,d5,11) + ::_Xml::XmlType_Impl__obj::toString(xml->nodeType)));
+            			}
+HXDLIN( 229)			xml->nodeValue = data;
+            		}
+HXLINE( 230)		return xml;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Xml_obj,createProcessingInstruction,return )
+
+ ::Xml Xml_obj::createDocument(){
+            	HX_GC_STACKFRAME(&_hx_pos_7e4d842269e66db1_237_createDocument)
+HXDLIN( 237)		return  ::Xml_obj::__alloc( HX_CTX ,::Xml_obj::Document);
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC0(Xml_obj,createDocument,return )
+
+
+::hx::ObjectPtr< Xml_obj > Xml_obj::__new(int nodeType) {
+	::hx::ObjectPtr< Xml_obj > __this = new Xml_obj();
+	__this->__construct(nodeType);
+	return __this;
+}
+
+::hx::ObjectPtr< Xml_obj > Xml_obj::__alloc(::hx::Ctx *_hx_ctx,int nodeType) {
+	Xml_obj *__this = (Xml_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Xml_obj), true, "Xml"));
+	*(void **)__this = Xml_obj::_hx_vtable;
+	__this->__construct(nodeType);
+	return __this;
+}
+
+Xml_obj::Xml_obj()
+{
+}
+
+void Xml_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(Xml);
+	HX_MARK_MEMBER_NAME(nodeType,"nodeType");
+	HX_MARK_MEMBER_NAME(nodeName,"nodeName");
+	HX_MARK_MEMBER_NAME(nodeValue,"nodeValue");
+	HX_MARK_MEMBER_NAME(parent,"parent");
+	HX_MARK_MEMBER_NAME(children,"children");
+	HX_MARK_MEMBER_NAME(attributeMap,"attributeMap");
+	HX_MARK_END_CLASS();
+}
+
+void Xml_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(nodeType,"nodeType");
+	HX_VISIT_MEMBER_NAME(nodeName,"nodeName");
+	HX_VISIT_MEMBER_NAME(nodeValue,"nodeValue");
+	HX_VISIT_MEMBER_NAME(parent,"parent");
+	HX_VISIT_MEMBER_NAME(children,"children");
+	HX_VISIT_MEMBER_NAME(attributeMap,"attributeMap");
+}
+
+::hx::Val Xml_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"get") ) { return ::hx::Val( get_dyn() ); }
+		if (HX_FIELD_EQ(inName,"set") ) { return ::hx::Val( set_dyn() ); }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"parent") ) { return ::hx::Val( parent ); }
+		if (HX_FIELD_EQ(inName,"exists") ) { return ::hx::Val( exists_dyn() ); }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"nodeType") ) { return ::hx::Val( nodeType ); }
+		if (HX_FIELD_EQ(inName,"nodeName") ) { return ::hx::Val( nodeName ); }
+		if (HX_FIELD_EQ(inName,"children") ) { return ::hx::Val( children ); }
+		if (HX_FIELD_EQ(inName,"addChild") ) { return ::hx::Val( addChild_dyn() ); }
+		if (HX_FIELD_EQ(inName,"toString") ) { return ::hx::Val( toString_dyn() ); }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"nodeValue") ) { return ::hx::Val( nodeValue ); }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"attributes") ) { return ::hx::Val( attributes_dyn() ); }
+		break;
+	case 11:
+		if (HX_FIELD_EQ(inName,"removeChild") ) { return ::hx::Val( removeChild_dyn() ); }
+		break;
+	case 12:
+		if (HX_FIELD_EQ(inName,"attributeMap") ) { return ::hx::Val( attributeMap ); }
+		if (HX_FIELD_EQ(inName,"firstElement") ) { return ::hx::Val( firstElement_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+bool Xml_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 5:
+		if (HX_FIELD_EQ(inName,"CData") ) { outValue = ( CData ); return true; }
+		if (HX_FIELD_EQ(inName,"parse") ) { outValue = parse_dyn(); return true; }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"PCData") ) { outValue = ( PCData ); return true; }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"Element") ) { outValue = ( Element ); return true; }
+		if (HX_FIELD_EQ(inName,"Comment") ) { outValue = ( Comment ); return true; }
+		if (HX_FIELD_EQ(inName,"DocType") ) { outValue = ( DocType ); return true; }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"Document") ) { outValue = ( Document ); return true; }
+		break;
+	case 11:
+		if (HX_FIELD_EQ(inName,"createCData") ) { outValue = createCData_dyn(); return true; }
+		break;
+	case 12:
+		if (HX_FIELD_EQ(inName,"createPCData") ) { outValue = createPCData_dyn(); return true; }
+		break;
+	case 13:
+		if (HX_FIELD_EQ(inName,"createElement") ) { outValue = createElement_dyn(); return true; }
+		if (HX_FIELD_EQ(inName,"createComment") ) { outValue = createComment_dyn(); return true; }
+		if (HX_FIELD_EQ(inName,"createDocType") ) { outValue = createDocType_dyn(); return true; }
+		break;
+	case 14:
+		if (HX_FIELD_EQ(inName,"createDocument") ) { outValue = createDocument_dyn(); return true; }
+		break;
+	case 21:
+		if (HX_FIELD_EQ(inName,"ProcessingInstruction") ) { outValue = ( ProcessingInstruction ); return true; }
+		break;
+	case 27:
+		if (HX_FIELD_EQ(inName,"createProcessingInstruction") ) { outValue = createProcessingInstruction_dyn(); return true; }
+	}
+	return false;
+}
+
+::hx::Val Xml_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 6:
+		if (HX_FIELD_EQ(inName,"parent") ) { parent=inValue.Cast<  ::Xml >(); return inValue; }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"nodeType") ) { nodeType=inValue.Cast< int >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"nodeName") ) { nodeName=inValue.Cast< ::String >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"children") ) { children=inValue.Cast< ::Array< ::Dynamic> >(); return inValue; }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"nodeValue") ) { nodeValue=inValue.Cast< ::String >(); return inValue; }
+		break;
+	case 12:
+		if (HX_FIELD_EQ(inName,"attributeMap") ) { attributeMap=inValue.Cast<  ::haxe::ds::StringMap >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+bool Xml_obj::__SetStatic(const ::String &inName,Dynamic &ioValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 5:
+		if (HX_FIELD_EQ(inName,"CData") ) { CData=ioValue.Cast< int >(); return true; }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"PCData") ) { PCData=ioValue.Cast< int >(); return true; }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"Element") ) { Element=ioValue.Cast< int >(); return true; }
+		if (HX_FIELD_EQ(inName,"Comment") ) { Comment=ioValue.Cast< int >(); return true; }
+		if (HX_FIELD_EQ(inName,"DocType") ) { DocType=ioValue.Cast< int >(); return true; }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"Document") ) { Document=ioValue.Cast< int >(); return true; }
+		break;
+	case 21:
+		if (HX_FIELD_EQ(inName,"ProcessingInstruction") ) { ProcessingInstruction=ioValue.Cast< int >(); return true; }
+	}
+	return false;
+}
+
+void Xml_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("nodeType",dc,51,86,f6));
+	outFields->push(HX_("nodeName",6d,d1,7c,f2));
+	outFields->push(HX_("nodeValue",0f,5e,ee,d5));
+	outFields->push(HX_("parent",2a,05,7e,ed));
+	outFields->push(HX_("children",3f,19,6a,70));
+	outFields->push(HX_("attributeMap",e0,4b,b2,95));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo Xml_obj_sMemberStorageInfo[] = {
+	{::hx::fsInt,(int)offsetof(Xml_obj,nodeType),HX_("nodeType",dc,51,86,f6)},
+	{::hx::fsString,(int)offsetof(Xml_obj,nodeName),HX_("nodeName",6d,d1,7c,f2)},
+	{::hx::fsString,(int)offsetof(Xml_obj,nodeValue),HX_("nodeValue",0f,5e,ee,d5)},
+	{::hx::fsObject /*  ::Xml */ ,(int)offsetof(Xml_obj,parent),HX_("parent",2a,05,7e,ed)},
+	{::hx::fsObject /* ::Array< ::Dynamic> */ ,(int)offsetof(Xml_obj,children),HX_("children",3f,19,6a,70)},
+	{::hx::fsObject /*  ::haxe::ds::StringMap */ ,(int)offsetof(Xml_obj,attributeMap),HX_("attributeMap",e0,4b,b2,95)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo Xml_obj_sStaticStorageInfo[] = {
+	{::hx::fsInt,(void *) &Xml_obj::Element,HX_("Element",9c,d6,a5,d3)},
+	{::hx::fsInt,(void *) &Xml_obj::PCData,HX_("PCData",bd,3d,a2,bd)},
+	{::hx::fsInt,(void *) &Xml_obj::CData,HX_("CData",0d,60,15,c1)},
+	{::hx::fsInt,(void *) &Xml_obj::Comment,HX_("Comment",3f,a2,c1,4e)},
+	{::hx::fsInt,(void *) &Xml_obj::DocType,HX_("DocType",32,25,de,a5)},
+	{::hx::fsInt,(void *) &Xml_obj::ProcessingInstruction,HX_("ProcessingInstruction",db,1e,14,6a)},
+	{::hx::fsInt,(void *) &Xml_obj::Document,HX_("Document",3b,ab,c4,74)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+#endif
+
+static ::String Xml_obj_sMemberFields[] = {
+	HX_("nodeType",dc,51,86,f6),
+	HX_("nodeName",6d,d1,7c,f2),
+	HX_("nodeValue",0f,5e,ee,d5),
+	HX_("parent",2a,05,7e,ed),
+	HX_("children",3f,19,6a,70),
+	HX_("attributeMap",e0,4b,b2,95),
+	HX_("get",96,80,4e,00),
+	HX_("set",a2,9b,57,00),
+	HX_("exists",dc,1d,e0,bf),
+	HX_("attributes",d7,a8,71,97),
+	HX_("firstElement",6c,c4,9c,2f),
+	HX_("addChild",bb,cf,16,bf),
+	HX_("removeChild",b8,86,ed,43),
+	HX_("toString",ac,d0,6e,38),
+	::String(null()) };
+
+static void Xml_obj_sMarkStatics(HX_MARK_PARAMS) {
+	HX_MARK_MEMBER_NAME(Xml_obj::Element,"Element");
+	HX_MARK_MEMBER_NAME(Xml_obj::PCData,"PCData");
+	HX_MARK_MEMBER_NAME(Xml_obj::CData,"CData");
+	HX_MARK_MEMBER_NAME(Xml_obj::Comment,"Comment");
+	HX_MARK_MEMBER_NAME(Xml_obj::DocType,"DocType");
+	HX_MARK_MEMBER_NAME(Xml_obj::ProcessingInstruction,"ProcessingInstruction");
+	HX_MARK_MEMBER_NAME(Xml_obj::Document,"Document");
+};
+
+#ifdef HXCPP_VISIT_ALLOCS
+static void Xml_obj_sVisitStatics(HX_VISIT_PARAMS) {
+	HX_VISIT_MEMBER_NAME(Xml_obj::Element,"Element");
+	HX_VISIT_MEMBER_NAME(Xml_obj::PCData,"PCData");
+	HX_VISIT_MEMBER_NAME(Xml_obj::CData,"CData");
+	HX_VISIT_MEMBER_NAME(Xml_obj::Comment,"Comment");
+	HX_VISIT_MEMBER_NAME(Xml_obj::DocType,"DocType");
+	HX_VISIT_MEMBER_NAME(Xml_obj::ProcessingInstruction,"ProcessingInstruction");
+	HX_VISIT_MEMBER_NAME(Xml_obj::Document,"Document");
+};
+
+#endif
+
+::hx::Class Xml_obj::__mClass;
+
+static ::String Xml_obj_sStaticFields[] = {
+	HX_("Element",9c,d6,a5,d3),
+	HX_("PCData",bd,3d,a2,bd),
+	HX_("CData",0d,60,15,c1),
+	HX_("Comment",3f,a2,c1,4e),
+	HX_("DocType",32,25,de,a5),
+	HX_("ProcessingInstruction",db,1e,14,6a),
+	HX_("Document",3b,ab,c4,74),
+	HX_("parse",33,90,55,bd),
+	HX_("createElement",20,87,97,ee),
+	HX_("createPCData",b9,09,63,ab),
+	HX_("createCData",91,27,63,57),
+	HX_("createComment",c3,52,b3,69),
+	HX_("createDocType",b6,d5,cf,c0),
+	HX_("createProcessingInstruction",5f,2e,58,38),
+	HX_("createDocument",37,6e,4d,ed),
+	::String(null())
+};
+
+void Xml_obj::__register()
+{
+	Xml_obj _hx_dummy;
+	Xml_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("Xml",b7,25,43,00);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &Xml_obj::__GetStatic;
+	__mClass->mSetStaticField = &Xml_obj::__SetStatic;
+	__mClass->mMarkFunc = Xml_obj_sMarkStatics;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(Xml_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(Xml_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< Xml_obj >;
+#ifdef HXCPP_VISIT_ALLOCS
+	__mClass->mVisitFunc = Xml_obj_sVisitStatics;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Xml_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Xml_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+void Xml_obj::__boot()
+{
+{
+            	HX_STACKFRAME(&_hx_pos_7e4d842269e66db1_86_boot)
+HXDLIN(  86)		Element = 0;
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_7e4d842269e66db1_91_boot)
+HXDLIN(  91)		PCData = 1;
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_7e4d842269e66db1_96_boot)
+HXDLIN(  96)		CData = 2;
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_7e4d842269e66db1_101_boot)
+HXDLIN( 101)		Comment = 3;
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_7e4d842269e66db1_106_boot)
+HXDLIN( 106)		DocType = 4;
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_7e4d842269e66db1_111_boot)
+HXDLIN( 111)		ProcessingInstruction = 5;
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_7e4d842269e66db1_116_boot)
+HXDLIN( 116)		Document = 6;
+            	}
+}
+
diff --git a/Sources/c_snikket/src/_HaxeCBridge/Int64Map_Impl_.cpp b/Sources/c_snikket/src/_HaxeCBridge/Int64Map_Impl_.cpp
new file mode 100644
index 0000000..8ce460f
--- /dev/null
+++ b/Sources/c_snikket/src/_HaxeCBridge/Int64Map_Impl_.cpp
@@ -0,0 +1,91 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED__HaxeCBridge_Int64Map_Impl_
+#include <_HaxeCBridge/Int64Map_Impl_.h>
+#endif
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+#ifndef INCLUDED_haxe_ds_IntMap
+#include <haxe/ds/IntMap.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_d939fa764c7c1922_2072__new,"_HaxeCBridge.Int64Map_Impl_","_new",0x93ec2b39,"_HaxeCBridge.Int64Map_Impl_._new","HaxeCBridge.hx",2072,0xa18550d8)
+namespace _HaxeCBridge{
+
+void Int64Map_Impl__obj::__construct() { }
+
+Dynamic Int64Map_Impl__obj::__CreateEmpty() { return new Int64Map_Impl__obj; }
+
+void *Int64Map_Impl__obj::_hx_vtable = 0;
+
+Dynamic Int64Map_Impl__obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Int64Map_Impl__obj > _hx_result = new Int64Map_Impl__obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool Int64Map_Impl__obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x09ceba9e;
+}
+
+ ::haxe::ds::IntMap Int64Map_Impl__obj::_new(){
+            	HX_GC_STACKFRAME(&_hx_pos_d939fa764c7c1922_2072__new)
+HXDLIN(2072)		return  ::haxe::ds::IntMap_obj::__alloc( HX_CTX );
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC0(Int64Map_Impl__obj,_new,return )
+
+
+Int64Map_Impl__obj::Int64Map_Impl__obj()
+{
+}
+
+bool Int64Map_Impl__obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"_new") ) { outValue = _new_dyn(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *Int64Map_Impl__obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo *Int64Map_Impl__obj_sStaticStorageInfo = 0;
+#endif
+
+::hx::Class Int64Map_Impl__obj::__mClass;
+
+static ::String Int64Map_Impl__obj_sStaticFields[] = {
+	HX_("_new",61,15,1f,3f),
+	::String(null())
+};
+
+void Int64Map_Impl__obj::__register()
+{
+	Int64Map_Impl__obj _hx_dummy;
+	Int64Map_Impl__obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("_HaxeCBridge.Int64Map_Impl_",96,19,cf,fe);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &Int64Map_Impl__obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(Int64Map_Impl__obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< Int64Map_Impl__obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Int64Map_Impl__obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Int64Map_Impl__obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace _HaxeCBridge
diff --git a/Sources/c_snikket/src/_HaxeCBridge/Internal.cpp b/Sources/c_snikket/src/_HaxeCBridge/Internal.cpp
new file mode 100644
index 0000000..845cacc
--- /dev/null
+++ b/Sources/c_snikket/src/_HaxeCBridge/Internal.cpp
@@ -0,0 +1,184 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED__HaxeCBridge_Int64Map_Impl_
+#include <_HaxeCBridge/Int64Map_Impl_.h>
+#endif
+#ifndef INCLUDED__HaxeCBridge_Internal
+#include <_HaxeCBridge/Internal.h>
+#endif
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+#ifndef INCLUDED_haxe_ds_IntMap
+#include <haxe/ds/IntMap.h>
+#endif
+#ifndef INCLUDED_sys_thread_Lock
+#include <sys/thread/Lock.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_afd834d22acce778_2060_boot,"_HaxeCBridge.Internal","boot",0xcd005bdc,"_HaxeCBridge.Internal.boot","HaxeCBridge.hx",2060,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_afd834d22acce778_2061_boot,"_HaxeCBridge.Internal","boot",0xcd005bdc,"_HaxeCBridge.Internal.boot","HaxeCBridge.hx",2061,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_afd834d22acce778_2062_boot,"_HaxeCBridge.Internal","boot",0xcd005bdc,"_HaxeCBridge.Internal.boot","HaxeCBridge.hx",2062,0xa18550d8)
+namespace _HaxeCBridge{
+
+void Internal_obj::__construct() { }
+
+Dynamic Internal_obj::__CreateEmpty() { return new Internal_obj; }
+
+void *Internal_obj::_hx_vtable = 0;
+
+Dynamic Internal_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Internal_obj > _hx_result = new Internal_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool Internal_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x0f2147a8;
+}
+
+::cpp::Function< bool  () > Internal_obj::isMainThreadCb;
+
+ ::sys::thread::Lock Internal_obj::mainThreadWaitLock;
+
+bool Internal_obj::mainThreadLoopActive;
+
+bool Internal_obj::mainThreadEndIfNoPending;
+
+ ::haxe::ds::IntMap Internal_obj::gcRetainMap;
+
+
+Internal_obj::Internal_obj()
+{
+}
+
+bool Internal_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 11:
+		if (HX_FIELD_EQ(inName,"gcRetainMap") ) { outValue = ( gcRetainMap ); return true; }
+		break;
+	case 14:
+		if (HX_FIELD_EQ(inName,"isMainThreadCb") ) { outValue = ( isMainThreadCb ); return true; }
+		break;
+	case 18:
+		if (HX_FIELD_EQ(inName,"mainThreadWaitLock") ) { outValue = ( mainThreadWaitLock ); return true; }
+		break;
+	case 20:
+		if (HX_FIELD_EQ(inName,"mainThreadLoopActive") ) { outValue = ( mainThreadLoopActive ); return true; }
+		break;
+	case 24:
+		if (HX_FIELD_EQ(inName,"mainThreadEndIfNoPending") ) { outValue = ( mainThreadEndIfNoPending ); return true; }
+	}
+	return false;
+}
+
+bool Internal_obj::__SetStatic(const ::String &inName,Dynamic &ioValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 11:
+		if (HX_FIELD_EQ(inName,"gcRetainMap") ) { gcRetainMap=ioValue.Cast<  ::haxe::ds::IntMap >(); return true; }
+		break;
+	case 14:
+		if (HX_FIELD_EQ(inName,"isMainThreadCb") ) { isMainThreadCb=ioValue.Cast< ::cpp::Function< bool  () > >(); return true; }
+		break;
+	case 18:
+		if (HX_FIELD_EQ(inName,"mainThreadWaitLock") ) { mainThreadWaitLock=ioValue.Cast<  ::sys::thread::Lock >(); return true; }
+		break;
+	case 20:
+		if (HX_FIELD_EQ(inName,"mainThreadLoopActive") ) { mainThreadLoopActive=ioValue.Cast< bool >(); return true; }
+		break;
+	case 24:
+		if (HX_FIELD_EQ(inName,"mainThreadEndIfNoPending") ) { mainThreadEndIfNoPending=ioValue.Cast< bool >(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *Internal_obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo Internal_obj_sStaticStorageInfo[] = {
+	{::hx::fsObject /* ::cpp::Function< bool  () > */ ,(void *) &Internal_obj::isMainThreadCb,HX_("isMainThreadCb",6c,b0,87,f1)},
+	{::hx::fsObject /*  ::sys::thread::Lock */ ,(void *) &Internal_obj::mainThreadWaitLock,HX_("mainThreadWaitLock",03,70,b0,ec)},
+	{::hx::fsBool,(void *) &Internal_obj::mainThreadLoopActive,HX_("mainThreadLoopActive",0d,b5,07,81)},
+	{::hx::fsBool,(void *) &Internal_obj::mainThreadEndIfNoPending,HX_("mainThreadEndIfNoPending",a1,49,76,fa)},
+	{::hx::fsObject /*  ::haxe::ds::IntMap */ ,(void *) &Internal_obj::gcRetainMap,HX_("gcRetainMap",1b,1e,df,b6)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+#endif
+
+static void Internal_obj_sMarkStatics(HX_MARK_PARAMS) {
+	HX_MARK_MEMBER_NAME(Internal_obj::isMainThreadCb,"isMainThreadCb");
+	HX_MARK_MEMBER_NAME(Internal_obj::mainThreadWaitLock,"mainThreadWaitLock");
+	HX_MARK_MEMBER_NAME(Internal_obj::mainThreadLoopActive,"mainThreadLoopActive");
+	HX_MARK_MEMBER_NAME(Internal_obj::mainThreadEndIfNoPending,"mainThreadEndIfNoPending");
+	HX_MARK_MEMBER_NAME(Internal_obj::gcRetainMap,"gcRetainMap");
+};
+
+#ifdef HXCPP_VISIT_ALLOCS
+static void Internal_obj_sVisitStatics(HX_VISIT_PARAMS) {
+	HX_VISIT_MEMBER_NAME(Internal_obj::isMainThreadCb,"isMainThreadCb");
+	HX_VISIT_MEMBER_NAME(Internal_obj::mainThreadWaitLock,"mainThreadWaitLock");
+	HX_VISIT_MEMBER_NAME(Internal_obj::mainThreadLoopActive,"mainThreadLoopActive");
+	HX_VISIT_MEMBER_NAME(Internal_obj::mainThreadEndIfNoPending,"mainThreadEndIfNoPending");
+	HX_VISIT_MEMBER_NAME(Internal_obj::gcRetainMap,"gcRetainMap");
+};
+
+#endif
+
+::hx::Class Internal_obj::__mClass;
+
+static ::String Internal_obj_sStaticFields[] = {
+	HX_("isMainThreadCb",6c,b0,87,f1),
+	HX_("mainThreadWaitLock",03,70,b0,ec),
+	HX_("mainThreadLoopActive",0d,b5,07,81),
+	HX_("mainThreadEndIfNoPending",a1,49,76,fa),
+	HX_("gcRetainMap",1b,1e,df,b6),
+	::String(null())
+};
+
+void Internal_obj::__register()
+{
+	Internal_obj _hx_dummy;
+	Internal_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("_HaxeCBridge.Internal",04,a9,b2,94);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &Internal_obj::__GetStatic;
+	__mClass->mSetStaticField = &Internal_obj::__SetStatic;
+	__mClass->mMarkFunc = Internal_obj_sMarkStatics;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(Internal_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< Internal_obj >;
+#ifdef HXCPP_VISIT_ALLOCS
+	__mClass->mVisitFunc = Internal_obj_sVisitStatics;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Internal_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Internal_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+void Internal_obj::__boot()
+{
+{
+            	HX_STACKFRAME(&_hx_pos_afd834d22acce778_2060_boot)
+HXDLIN(2060)		mainThreadLoopActive = true;
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_afd834d22acce778_2061_boot)
+HXDLIN(2061)		mainThreadEndIfNoPending = false;
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_afd834d22acce778_2062_boot)
+HXDLIN(2062)		gcRetainMap = ::_HaxeCBridge::Int64Map_Impl__obj::_new();
+            	}
+}
+
+} // end namespace _HaxeCBridge
diff --git a/Sources/c_snikket/src/_UnicodeString/UnicodeString_Impl_.cpp b/Sources/c_snikket/src/_UnicodeString/UnicodeString_Impl_.cpp
new file mode 100644
index 0000000..b6a1db1
--- /dev/null
+++ b/Sources/c_snikket/src/_UnicodeString/UnicodeString_Impl_.cpp
@@ -0,0 +1,230 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED__UnicodeString_UnicodeString_Impl_
+#include <_UnicodeString/UnicodeString_Impl_.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_916f2d3bacb9c7fb_149_charAt,"_UnicodeString.UnicodeString_Impl_","charAt",0xef11cb28,"_UnicodeString.UnicodeString_Impl_.charAt","/usr/local/lib/haxe/std/UnicodeString.hx",149,0x872b4b8d)
+HX_LOCAL_STACK_FRAME(_hx_pos_916f2d3bacb9c7fb_320_substr,"_UnicodeString.UnicodeString_Impl_","substr",0xd1a740f0,"_UnicodeString.UnicodeString_Impl_.substr","/usr/local/lib/haxe/std/UnicodeString.hx",320,0x872b4b8d)
+HX_LOCAL_STACK_FRAME(_hx_pos_916f2d3bacb9c7fb_420_get_length,"_UnicodeString.UnicodeString_Impl_","get_length",0x33b0a1ee,"_UnicodeString.UnicodeString_Impl_.get_length","/usr/local/lib/haxe/std/UnicodeString.hx",420,0x872b4b8d)
+namespace _UnicodeString{
+
+void UnicodeString_Impl__obj::__construct() { }
+
+Dynamic UnicodeString_Impl__obj::__CreateEmpty() { return new UnicodeString_Impl__obj; }
+
+void *UnicodeString_Impl__obj::_hx_vtable = 0;
+
+Dynamic UnicodeString_Impl__obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< UnicodeString_Impl__obj > _hx_result = new UnicodeString_Impl__obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool UnicodeString_Impl__obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x699a1cff;
+}
+
+::String UnicodeString_Impl__obj::charAt(::String this1,int index){
+            	HX_STACKFRAME(&_hx_pos_916f2d3bacb9c7fb_149_charAt)
+HXLINE( 150)		if ((index < 0)) {
+HXLINE( 151)			return HX_("",00,00,00,00);
+            		}
+HXLINE( 152)		int unicodeOffset = 0;
+HXLINE( 153)		int nativeOffset = 0;
+HXLINE( 154)		while((nativeOffset < this1.length)){
+HXLINE( 155)			nativeOffset = (nativeOffset + 1);
+HXDLIN( 155)			int index1 = (nativeOffset - 1);
+HXDLIN( 155)			int c = this1.cca(index1);
+HXDLIN( 155)			bool _hx_tmp;
+HXDLIN( 155)			if ((c >= 55296)) {
+HXLINE( 155)				_hx_tmp = (c <= 56319);
+            			}
+            			else {
+HXLINE( 155)				_hx_tmp = false;
+            			}
+HXDLIN( 155)			if (_hx_tmp) {
+HXLINE( 155)				c = (((c - 55232) << 10) | (this1.cca((index1 + 1)) & 1023));
+            			}
+HXDLIN( 155)			int c1 = c;
+HXLINE( 156)			if ((unicodeOffset == index)) {
+HXLINE( 157)				return ::String::fromCharCode(c1);
+            			}
+HXLINE( 159)			if ((c1 >= 65536)) {
+HXLINE( 160)				nativeOffset = (nativeOffset + 1);
+            			}
+HXLINE( 162)			unicodeOffset = (unicodeOffset + 1);
+            		}
+HXLINE( 164)		return HX_("",00,00,00,00);
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(UnicodeString_Impl__obj,charAt,return )
+
+::String UnicodeString_Impl__obj::substr(::String this1,int pos, ::Dynamic len){
+            	HX_STACKFRAME(&_hx_pos_916f2d3bacb9c7fb_320_substr)
+HXLINE( 321)		if ((pos < 0)) {
+HXLINE( 322)			pos = (::_UnicodeString::UnicodeString_Impl__obj::get_length(this1) + pos);
+HXLINE( 323)			if ((pos < 0)) {
+HXLINE( 324)				pos = 0;
+            			}
+            		}
+HXLINE( 327)		if (::hx::IsNotNull( len )) {
+HXLINE( 328)			if (::hx::IsLess( len,0 )) {
+HXLINE( 329)				len = (::_UnicodeString::UnicodeString_Impl__obj::get_length(this1) + len);
+            			}
+HXLINE( 331)			if (::hx::IsLessEq( len,0 )) {
+HXLINE( 332)				return HX_("",00,00,00,00);
+            			}
+            		}
+HXLINE( 335)		int unicodeOffset = 0;
+HXLINE( 336)		int nativeOffset = 0;
+HXLINE( 337)		int fromOffset = -1;
+HXLINE( 338)		int subLength = 0;
+HXLINE( 339)		while((nativeOffset < this1.length)){
+HXLINE( 340)			int c = this1.cca(nativeOffset);
+HXDLIN( 340)			bool _hx_tmp;
+HXDLIN( 340)			if ((c >= 55296)) {
+HXLINE( 340)				_hx_tmp = (c <= 56319);
+            			}
+            			else {
+HXLINE( 340)				_hx_tmp = false;
+            			}
+HXDLIN( 340)			if (_hx_tmp) {
+HXLINE( 340)				c = (((c - 55232) << 10) | (this1.cca((nativeOffset + 1)) & 1023));
+            			}
+HXDLIN( 340)			int c1 = c;
+HXLINE( 342)			if ((unicodeOffset >= pos)) {
+HXLINE( 343)				if ((fromOffset < 0)) {
+HXLINE( 344)					if (::hx::IsNull( len )) {
+HXLINE( 345)						return this1.substr(nativeOffset,null());
+            					}
+HXLINE( 347)					fromOffset = nativeOffset;
+            				}
+HXLINE( 349)				subLength = (subLength + 1);
+HXLINE( 350)				if (::hx::IsGreaterEq( subLength,len )) {
+HXLINE( 351)					int lastOffset;
+HXDLIN( 351)					if ((c1 < 65536)) {
+HXLINE( 351)						lastOffset = nativeOffset;
+            					}
+            					else {
+HXLINE( 351)						lastOffset = (nativeOffset + 1);
+            					}
+HXLINE( 352)					return this1.substr(fromOffset,((lastOffset - fromOffset) + 1));
+            				}
+            			}
+HXLINE( 356)			int nativeOffset1;
+HXDLIN( 356)			if ((c1 >= 65536)) {
+HXLINE( 356)				nativeOffset1 = 2;
+            			}
+            			else {
+HXLINE( 356)				nativeOffset1 = 1;
+            			}
+HXDLIN( 356)			nativeOffset = (nativeOffset + nativeOffset1);
+HXLINE( 357)			unicodeOffset = (unicodeOffset + 1);
+            		}
+HXLINE( 359)		if ((fromOffset < 0)) {
+HXLINE( 359)			return HX_("",00,00,00,00);
+            		}
+            		else {
+HXLINE( 359)			return this1.substr(fromOffset,null());
+            		}
+HXDLIN( 359)		return null();
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC3(UnicodeString_Impl__obj,substr,return )
+
+int UnicodeString_Impl__obj::get_length(::String this1){
+            	HX_STACKFRAME(&_hx_pos_916f2d3bacb9c7fb_420_get_length)
+HXLINE( 421)		int l = 0;
+HXLINE( 422)		{
+HXLINE( 422)			int _g_offset = 0;
+HXDLIN( 422)			::String _g_s = this1;
+HXDLIN( 422)			while((_g_offset < _g_s.length)){
+HXLINE( 422)				::String s = _g_s;
+HXDLIN( 422)				_g_offset = (_g_offset + 1);
+HXDLIN( 422)				int index = (_g_offset - 1);
+HXDLIN( 422)				int c = s.cca(index);
+HXDLIN( 422)				bool _hx_tmp;
+HXDLIN( 422)				if ((c >= 55296)) {
+HXLINE( 422)					_hx_tmp = (c <= 56319);
+            				}
+            				else {
+HXLINE( 422)					_hx_tmp = false;
+            				}
+HXDLIN( 422)				if (_hx_tmp) {
+HXLINE( 639)					c = (((c - 55232) << 10) | (s.cca((index + 1)) & 1023));
+            				}
+HXLINE( 422)				int c1 = c;
+HXDLIN( 422)				if ((c1 >= 65536)) {
+HXLINE( 422)					_g_offset = (_g_offset + 1);
+            				}
+HXDLIN( 422)				int c2 = c1;
+HXLINE( 423)				l = (l + 1);
+            			}
+            		}
+HXLINE( 425)		return l;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(UnicodeString_Impl__obj,get_length,return )
+
+
+UnicodeString_Impl__obj::UnicodeString_Impl__obj()
+{
+}
+
+bool UnicodeString_Impl__obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 6:
+		if (HX_FIELD_EQ(inName,"charAt") ) { outValue = charAt_dyn(); return true; }
+		if (HX_FIELD_EQ(inName,"substr") ) { outValue = substr_dyn(); return true; }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"get_length") ) { outValue = get_length_dyn(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *UnicodeString_Impl__obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo *UnicodeString_Impl__obj_sStaticStorageInfo = 0;
+#endif
+
+::hx::Class UnicodeString_Impl__obj::__mClass;
+
+static ::String UnicodeString_Impl__obj_sStaticFields[] = {
+	HX_("charAt",69,79,75,b7),
+	HX_("substr",31,ef,0a,9a),
+	HX_("get_length",af,04,8f,8f),
+	::String(null())
+};
+
+void UnicodeString_Impl__obj::__register()
+{
+	UnicodeString_Impl__obj _hx_dummy;
+	UnicodeString_Impl__obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("_UnicodeString.UnicodeString_Impl_",cf,cc,3a,6f);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &UnicodeString_Impl__obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(UnicodeString_Impl__obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< UnicodeString_Impl__obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = UnicodeString_Impl__obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = UnicodeString_Impl__obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace _UnicodeString
diff --git a/Sources/c_snikket/src/_Xml/XmlType_Impl_.cpp b/Sources/c_snikket/src/_Xml/XmlType_Impl_.cpp
new file mode 100644
index 0000000..5e98c94
--- /dev/null
+++ b/Sources/c_snikket/src/_Xml/XmlType_Impl_.cpp
@@ -0,0 +1,115 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED__Xml_XmlType_Impl_
+#include <_Xml/XmlType_Impl_.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_ae9d30f993cc7475_65_toString,"_Xml.XmlType_Impl_","toString",0x16b62c3f,"_Xml.XmlType_Impl_.toString","/usr/local/lib/haxe/std/Xml.hx",65,0x5c1024e4)
+namespace _Xml{
+
+void XmlType_Impl__obj::__construct() { }
+
+Dynamic XmlType_Impl__obj::__CreateEmpty() { return new XmlType_Impl__obj; }
+
+void *XmlType_Impl__obj::_hx_vtable = 0;
+
+Dynamic XmlType_Impl__obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< XmlType_Impl__obj > _hx_result = new XmlType_Impl__obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool XmlType_Impl__obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x29df0a39;
+}
+
+::String XmlType_Impl__obj::toString(int this1){
+            	HX_STACKFRAME(&_hx_pos_ae9d30f993cc7475_65_toString)
+HXDLIN(  65)		switch((int)(this1)){
+            			case (int)0: {
+HXLINE(  66)				return HX_("Element",9c,d6,a5,d3);
+            			}
+            			break;
+            			case (int)1: {
+HXLINE(  67)				return HX_("PCData",bd,3d,a2,bd);
+            			}
+            			break;
+            			case (int)2: {
+HXLINE(  68)				return HX_("CData",0d,60,15,c1);
+            			}
+            			break;
+            			case (int)3: {
+HXLINE(  69)				return HX_("Comment",3f,a2,c1,4e);
+            			}
+            			break;
+            			case (int)4: {
+HXLINE(  70)				return HX_("DocType",32,25,de,a5);
+            			}
+            			break;
+            			case (int)5: {
+HXLINE(  71)				return HX_("ProcessingInstruction",db,1e,14,6a);
+            			}
+            			break;
+            			case (int)6: {
+HXLINE(  72)				return HX_("Document",3b,ab,c4,74);
+            			}
+            			break;
+            		}
+HXLINE(  65)		return null();
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(XmlType_Impl__obj,toString,return )
+
+
+XmlType_Impl__obj::XmlType_Impl__obj()
+{
+}
+
+bool XmlType_Impl__obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 8:
+		if (HX_FIELD_EQ(inName,"toString") ) { outValue = toString_dyn(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *XmlType_Impl__obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo *XmlType_Impl__obj_sStaticStorageInfo = 0;
+#endif
+
+::hx::Class XmlType_Impl__obj::__mClass;
+
+static ::String XmlType_Impl__obj_sStaticFields[] = {
+	HX_("toString",ac,d0,6e,38),
+	::String(null())
+};
+
+void XmlType_Impl__obj::__register()
+{
+	XmlType_Impl__obj _hx_dummy;
+	XmlType_Impl__obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("_Xml.XmlType_Impl_",3b,c3,52,59);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &XmlType_Impl__obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(XmlType_Impl__obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< XmlType_Impl__obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = XmlType_Impl__obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = XmlType_Impl__obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace _Xml
diff --git a/Sources/c_snikket/src/__HaxeCBridgeBindings__.cpp b/Sources/c_snikket/src/__HaxeCBridgeBindings__.cpp
new file mode 100644
index 0000000..5b6f6b2
--- /dev/null
+++ b/Sources/c_snikket/src/__HaxeCBridgeBindings__.cpp
@@ -0,0 +1,7043 @@
+/**
+ * HaxeCBridge Function Binding Implementation
+ * Automatically generated by HaxeCBridge
+ */
+#include <hxcpp.h>
+#include <hx/Native.h>
+#include <hx/Thread.h>
+#include <hx/StdLibs.h>
+#include <hx/GC.h>
+#include <HaxeCBridge.h>
+#include <assert.h>
+#include <queue>
+#include <utility>
+#include <atomic>
+
+// include generated bindings header
+// set prefix when exporting dll symbols on windows
+#ifdef _WIN32
+	#define API_PREFIX __declspec(dllexport)
+#endif
+#include "snikket.h"
+
+#define HAXE_C_BRIDGE_LINKAGE HXCPP_EXTERN_CLASS_ATTRIBUTES
+#include <snikket/persistence/MediaStoreFS.h>
+#include <snikket/persistence/Sqlite.h>
+#include <snikket/persistence/MediaStore.h>
+#include <snikket/ChatMessage.h>
+#include <snikket/ChatMessageBuilder.h>
+#include <snikket/ChatAttachment.h>
+#include <snikket/Hash.h>
+#include <snikket/persistence/Dummy.h>
+#include <snikket/Client.h>
+#include <snikket/Persistence.h>
+#include <snikket/AttachmentSource.h>
+#include <snikket/AvailableChat.h>
+#include <snikket/Chat.h>
+#include <snikket/Participant.h>
+#include <snikket/Reaction.h>
+#include <snikket/jingle/DTMFSender.h>
+#include <snikket/jingle/MediaStreamTrack.h>
+#include <snikket/jingle/AudioFormat.h>
+#include <snikket/jingle/InitiatedSession.h>
+#include <snikket/jingle/MediaStream.h>
+#include <snikket/Channel.h>
+#include <snikket/DirectChat.h>
+#include <snikket/CustomEmojiReaction.h>
+
+namespace HaxeCBridgeInternal {
+
+	// we cannot use hxcpps HxCreateDetachedThread() because we cannot wait on these threads to end on unix because they are detached threads
+	#if defined(HX_WINDOWS)
+	HANDLE haxeThreadNativeHandle = nullptr;
+	DWORD haxeThreadNativeId = 0; // 0 is not valid thread id
+	bool createHaxeThread(DWORD (WINAPI *func)(void *), void *param) {
+		haxeThreadNativeHandle = CreateThread(NULL, 0, func, param, 0, &haxeThreadNativeId);
+		return haxeThreadNativeHandle != 0;
+	}
+	bool waitForThreadExit(HANDLE handle) {
+		DWORD result = WaitForSingleObject(handle, INFINITE);
+		return result != WAIT_FAILED;
+	}
+	#else
+	pthread_t haxeThreadNativeHandle;
+	bool createHaxeThread(void *(*func)(void *), void *param) {
+		// same as HxCreateDetachedThread(func, param) but without detaching the thread
+
+		pthread_attr_t attr;
+		if (pthread_attr_init(&attr) != 0)
+			return false;
+		if (pthread_create(&haxeThreadNativeHandle, &attr, func, param) != 0 )
+			return false;
+		if (pthread_attr_destroy(&attr) != 0)
+			return false;
+		return true;
+	}
+	bool waitForThreadExit(pthread_t handle) {
+		int result = pthread_join(handle, NULL);
+		return result == 0;
+	}
+	#endif
+
+	std::atomic<bool> threadStarted = { false };
+	std::atomic<bool> threadRunning = { false };
+	// once haxe statics are initialized we cannot clear them for a clean restart
+	std::atomic<bool> staticsInitialized = { false };
+
+	struct HaxeThreadData {
+		snikket_panic_callback haxeExceptionCallback;
+		const char* initExceptionInfo;
+	};
+
+	HxSemaphore threadInitSemaphore;
+	HxMutex threadManageMutex;
+
+	void defaultExceptionHandler(const char* info) {
+		printf("Unhandled haxe exception: %s\n", info);
+	}
+
+	typedef void (* MainThreadCallback)(void* data);
+	HxMutex queueMutex;
+	std::queue<std::pair<MainThreadCallback, void*>> queue;
+
+	void runInMainThread(MainThreadCallback callback, void* data) {
+		queueMutex.Lock();
+		queue.push(std::make_pair(callback, data));
+		queueMutex.Unlock();
+		HaxeCBridge::wakeMainThread();
+	}
+
+	// called on the haxe main thread
+	void processNativeCalls() {
+		AutoLock lock(queueMutex);
+		while(!queue.empty()) {
+			std::pair<MainThreadCallback, void*> pair = queue.front();
+			queue.pop();
+			pair.first(pair.second);
+		}
+	}
+				
+	#if defined(HX_WINDOWS)
+	bool isHaxeMainThread() {
+		return threadRunning &&
+		(GetCurrentThreadId() == haxeThreadNativeId) &&
+		(haxeThreadNativeId != 0);
+	}
+	#else
+	bool isHaxeMainThread() {
+		return threadRunning && pthread_equal(haxeThreadNativeHandle, pthread_self());
+	}
+	#endif
+}
+
+THREAD_FUNC_TYPE haxeMainThreadFunc(void *data) {
+	HX_TOP_OF_STACK
+	HaxeCBridgeInternal::HaxeThreadData* threadData = (HaxeCBridgeInternal::HaxeThreadData*) data;
+
+	HaxeCBridgeInternal::threadRunning = true;
+
+	threadData->initExceptionInfo = nullptr;
+
+	// copy out callback
+	snikket_panic_callback haxeExceptionCallback = threadData->haxeExceptionCallback;
+
+	bool firstRun = !HaxeCBridgeInternal::staticsInitialized;
+
+	// See hx::Init in StdLibs.cpp for reference
+	if (!HaxeCBridgeInternal::staticsInitialized) try {
+		::hx::Boot();
+		__boot_all();
+		HaxeCBridgeInternal::staticsInitialized = true;
+	} catch(Dynamic initException) {
+		// hxcpp init failure or uncaught haxe runtime exception
+		threadData->initExceptionInfo = initException->toString().utf8_str();
+	}
+
+	if (HaxeCBridgeInternal::staticsInitialized) { // initialized without error
+		// blocks running the event loop
+		// keeps alive until manual stop is called
+		HaxeCBridge::mainThreadInit(HaxeCBridgeInternal::isHaxeMainThread);
+		HaxeCBridgeInternal::threadInitSemaphore.Set();
+		HaxeCBridge::mainThreadRun(HaxeCBridgeInternal::processNativeCalls, haxeExceptionCallback);
+	} else {
+		// failed to initialize statics; unlock init semaphore so _initializeHaxeThread can continue and report the exception 
+		HaxeCBridgeInternal::threadInitSemaphore.Set();
+	}
+
+	HaxeCBridgeInternal::threadRunning = false;
+
+	THREAD_FUNC_RET
+}
+			
+HAXE_C_BRIDGE_LINKAGE
+const char* snikket_setup(snikket_panic_callback unhandledExceptionCallback) {
+	HaxeCBridgeInternal::HaxeThreadData threadData;
+	threadData.haxeExceptionCallback = unhandledExceptionCallback == nullptr ? HaxeCBridgeInternal::defaultExceptionHandler : unhandledExceptionCallback;
+	threadData.initExceptionInfo = nullptr;
+
+	{
+		// mutex prevents two threads calling this function from being able to start two haxe threads
+		AutoLock lock(HaxeCBridgeInternal::threadManageMutex);
+		if (!HaxeCBridgeInternal::threadStarted) {
+			// startup the haxe main thread
+			HaxeCBridgeInternal::createHaxeThread(haxeMainThreadFunc, &threadData);
+
+			HaxeCBridgeInternal::threadStarted = true;
+
+			// wait until the thread is initialized and ready
+			HaxeCBridgeInternal::threadInitSemaphore.Wait();
+		} else {
+			threadData.initExceptionInfo = "haxe thread cannot be started twice";
+		}
+	}
+				
+	if (threadData.initExceptionInfo != nullptr) {
+		snikket_stop(false);
+
+		const int returnInfoMax = 1024;
+		static char returnInfo[returnInfoMax] = ""; // statically allocated for return safety
+		strncpy(returnInfo, threadData.initExceptionInfo, returnInfoMax);
+		return returnInfo;
+	} else {
+		return nullptr;
+	}
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_stop(bool waitOnScheduledEvents) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		// it is possible for stopHaxeThread to be called from within the haxe thread, while another thread is waiting on for the thread to end
+		// so it is important the haxe thread does not wait on certain locks
+		HaxeCBridge::endMainThread(waitOnScheduledEvents);
+	} else {
+		AutoLock lock(HaxeCBridgeInternal::threadManageMutex);
+		if (HaxeCBridgeInternal::threadRunning) {
+			struct Callback {
+				static void run(void* data) {
+					bool* b = (bool*) data;
+					HaxeCBridge::endMainThread(*b);
+				}
+			};
+
+			HaxeCBridgeInternal::runInMainThread(Callback::run, &waitOnScheduledEvents);
+
+			HaxeCBridgeInternal::waitForThreadExit(HaxeCBridgeInternal::haxeThreadNativeHandle);
+		}
+	}
+}
+			
+HAXE_C_BRIDGE_LINKAGE
+void snikket_release(const void* ptr) {
+	struct Callback {
+		static void run(void* data) {
+			HaxeCBridge::releaseHaxePtr(data);
+		}
+	};
+	HaxeCBridgeInternal::runInMainThread(Callback::run, (void*)ptr);
+}
+HAXE_C_BRIDGE_LINKAGE
+void *snikket_persistence_media_store_f_s_new(const char *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeObject(snikket::persistence::MediaStoreFS_obj::__new(a0));
+	}
+	struct Data {
+		struct {const char * a0;} args;
+		HxSemaphore lock;
+		void * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeObject(snikket::persistence::MediaStoreFS_obj::__new(data->args.a0));
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute new() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_persistence_media_store_f_s_get_media_path(void *a0, const char *a1, void (*a2) (const char*, void*), void *a3) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::persistence::MediaStoreFS((hx::Object *)a0, true))->getMediaPath__fromC(a1, cpp::Function<void(const char*, void*)>(a2), a3);
+	}
+	struct Data {
+		struct {void * a0; const char * a1; void (* a2) (const char*, void*); void* a3;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::persistence::MediaStoreFS((hx::Object *)data->args.a0, true))->getMediaPath__fromC(data->args.a1, cpp::Function<void(const char*, void*)>(data->args.a2), data->args.a3);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2, a3} };
+
+	// queue a callback to execute getMediaPath__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void *snikket_persistence_sqlite_new(const char *a0, void *a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeObject(snikket::persistence::Sqlite_obj::__new(a0, Dynamic((hx::Object *)a1)));
+	}
+	struct Data {
+		struct {const char * a0; void * a1;} args;
+		HxSemaphore lock;
+		void * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeObject(snikket::persistence::Sqlite_obj::__new(data->args.a0, Dynamic((hx::Object *)data->args.a1)));
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute new() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_persistence_sqlite_get_message(void *a0, const char *a1, const char *a2, const char *a3, const char *a4, void (*a5) (void*, void*), void *a6) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::persistence::Sqlite((hx::Object *)a0, true))->getMessage__fromC(a1, a2, a3, a4, cpp::Function<void(void*, void*)>(a5), a6);
+	}
+	struct Data {
+		struct {void * a0; const char * a1; const char * a2; const char * a3; const char * a4; void (* a5) (void*, void*); void* a6;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::persistence::Sqlite((hx::Object *)data->args.a0, true))->getMessage__fromC(data->args.a1, data->args.a2, data->args.a3, data->args.a4, cpp::Function<void(void*, void*)>(data->args.a5), data->args.a6);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2, a3, a4, a5, a6} };
+
+	// queue a callback to execute getMessage__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_persistence_sqlite_remove_account(void *a0, const char *a1, bool a2) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::persistence::Sqlite((hx::Object *)a0, true))->removeAccount(a1, a2);
+	}
+	struct Data {
+		struct {void * a0; const char * a1; bool a2;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::persistence::Sqlite((hx::Object *)data->args.a0, true))->removeAccount(data->args.a1, data->args.a2);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2} };
+
+	// queue a callback to execute removeAccount() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_persistence_sqlite_list_accounts(void *a0, void (*a1) (const char**, size_t, void*), void *a2) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::persistence::Sqlite((hx::Object *)a0, true))->listAccounts__fromC(cpp::Function<void(const char**, size_t, void*)>(a1), a2);
+	}
+	struct Data {
+		struct {void * a0; void (* a1) (const char**, size_t, void*); void* a2;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::persistence::Sqlite((hx::Object *)data->args.a0, true))->listAccounts__fromC(cpp::Function<void(const char**, size_t, void*)>(data->args.a1), data->args.a2);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2} };
+
+	// queue a callback to execute listAccounts__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_message_local_id(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)a0, true))->localId__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)data->args.a0, true))->localId__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute localId__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_message_server_id(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)a0, true))->serverId__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)data->args.a0, true))->serverId__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute serverId__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_message_server_id_by(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)a0, true))->serverIdBy__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)data->args.a0, true))->serverIdBy__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute serverIdBy__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+enum snikket_message_type snikket_chat_message_type(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return static_cast<enum snikket_message_type>((snikket::ChatMessage((hx::Object *)a0, true))->type__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		enum snikket_message_type ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = static_cast<enum snikket_message_type>((snikket::ChatMessage((hx::Object *)data->args.a0, true))->type__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute type__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_message_timestamp(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)a0, true))->timestamp__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)data->args.a0, true))->timestamp__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute timestamp__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_message_sender_id(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)a0, true))->senderId__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)data->args.a0, true))->senderId__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute senderId__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void *snikket_chat_message_reply_to_message(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeObject((snikket::ChatMessage((hx::Object *)a0, true))->replyToMessage__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		void * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeObject((snikket::ChatMessage((hx::Object *)data->args.a0, true))->replyToMessage__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute replyToMessage__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_message_thread_id(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)a0, true))->threadId__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)data->args.a0, true))->threadId__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute threadId__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+size_t snikket_chat_message_attachments(void *a0, void ***a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::ChatMessage((hx::Object *)a0, true))->attachments__fromC(a1);
+	}
+	struct Data {
+		struct {void * a0; void*** a1;} args;
+		HxSemaphore lock;
+		size_t ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::ChatMessage((hx::Object *)data->args.a0, true))->attachments__fromC(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute attachments__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_message_text(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)a0, true))->text__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)data->args.a0, true))->text__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute text__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_message_lang(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)a0, true))->lang__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)data->args.a0, true))->lang__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute lang__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+enum snikket_message_direction snikket_chat_message_direction(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return static_cast<enum snikket_message_direction>((snikket::ChatMessage((hx::Object *)a0, true))->direction__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		enum snikket_message_direction ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = static_cast<enum snikket_message_direction>((snikket::ChatMessage((hx::Object *)data->args.a0, true))->direction__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute direction__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+enum snikket_message_status snikket_chat_message_status(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return static_cast<enum snikket_message_status>((snikket::ChatMessage((hx::Object *)a0, true))->status__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		enum snikket_message_status ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = static_cast<enum snikket_message_status>((snikket::ChatMessage((hx::Object *)data->args.a0, true))->status__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute status__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_message_set_status(void *a0, enum snikket_message_status a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::ChatMessage((hx::Object *)a0, true))->set_status__fromC(a1);
+	}
+	struct Data {
+		struct {void * a0; enum snikket_message_status a1;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::ChatMessage((hx::Object *)data->args.a0, true))->set_status__fromC(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute set_status__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+size_t snikket_chat_message_versions(void *a0, void ***a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::ChatMessage((hx::Object *)a0, true))->versions__fromC(a1);
+	}
+	struct Data {
+		struct {void * a0; void*** a1;} args;
+		HxSemaphore lock;
+		size_t ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::ChatMessage((hx::Object *)data->args.a0, true))->versions__fromC(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute versions__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void *snikket_chat_message_reply(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeObject((snikket::ChatMessage((hx::Object *)a0, true))->reply());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		void * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeObject((snikket::ChatMessage((hx::Object *)data->args.a0, true))->reply());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute reply() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_message_get_reply_id(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)a0, true))->getReplyId());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)data->args.a0, true))->getReplyId());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute getReplyId() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_message_html(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)a0, true))->html());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)data->args.a0, true))->html());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute html() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_message_chat_id(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)a0, true))->chatId());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)data->args.a0, true))->chatId());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute chatId() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_message_account(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)a0, true))->account());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)data->args.a0, true))->account());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute account() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+bool snikket_chat_message_is_incoming(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::ChatMessage((hx::Object *)a0, true))->isIncoming();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		bool ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::ChatMessage((hx::Object *)data->args.a0, true))->isIncoming();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute isIncoming() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_message_thread_icon(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)a0, true))->threadIcon());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)data->args.a0, true))->threadIcon());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute threadIcon() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_message_call_status(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)a0, true))->callStatus());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)data->args.a0, true))->callStatus());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute callStatus() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_message_call_sid(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)a0, true))->callSid());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)data->args.a0, true))->callSid());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute callSid() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_message_call_duration(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)a0, true))->callDuration());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatMessage((hx::Object *)data->args.a0, true))->callDuration());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute callDuration() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void *snikket_chat_attachment_create(const char *a0, const char *a1, int a2, const char *a3) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeObject(snikket::ChatAttachment_obj::create(a0, a1, a2, a3));
+	}
+	struct Data {
+		struct {const char * a0; const char * a1; int a2; const char * a3;} args;
+		HxSemaphore lock;
+		void * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeObject(snikket::ChatAttachment_obj::create(data->args.a0, data->args.a1, data->args.a2, data->args.a3));
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2, a3} };
+
+	// queue a callback to execute create() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_attachment_name(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatAttachment((hx::Object *)a0, true))->name__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatAttachment((hx::Object *)data->args.a0, true))->name__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute name__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_attachment_mime(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatAttachment((hx::Object *)a0, true))->mime__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatAttachment((hx::Object *)data->args.a0, true))->mime__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute mime__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+int snikket_chat_attachment_size(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::ChatAttachment((hx::Object *)a0, true))->size__fromC();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		int ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::ChatAttachment((hx::Object *)data->args.a0, true))->size__fromC();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute size__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+size_t snikket_chat_attachment_uris(void *a0, const char ***a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::ChatAttachment((hx::Object *)a0, true))->uris__fromC(a1);
+	}
+	struct Data {
+		struct {void * a0; const char*** a1;} args;
+		HxSemaphore lock;
+		size_t ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::ChatAttachment((hx::Object *)data->args.a0, true))->uris__fromC(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute uris__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+size_t snikket_chat_attachment_hashes(void *a0, void ***a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::ChatAttachment((hx::Object *)a0, true))->hashes__fromC(a1);
+	}
+	struct Data {
+		struct {void * a0; void*** a1;} args;
+		HxSemaphore lock;
+		size_t ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::ChatAttachment((hx::Object *)data->args.a0, true))->hashes__fromC(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute hashes__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void *snikket_hash_from_hex(const char *a0, const char *a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeObject(snikket::Hash_obj::fromHex(a0, a1));
+	}
+	struct Data {
+		struct {const char * a0; const char * a1;} args;
+		HxSemaphore lock;
+		void * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeObject(snikket::Hash_obj::fromHex(data->args.a0, data->args.a1));
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute fromHex() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void *snikket_hash_from_uri(const char *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeObject(snikket::Hash_obj::fromUri(a0));
+	}
+	struct Data {
+		struct {const char * a0;} args;
+		HxSemaphore lock;
+		void * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeObject(snikket::Hash_obj::fromUri(data->args.a0));
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute fromUri() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_hash_algorithm(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::Hash((hx::Object *)a0, true))->algorithm__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::Hash((hx::Object *)data->args.a0, true))->algorithm__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute algorithm__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_hash_to_uri(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::Hash((hx::Object *)a0, true))->toUri());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::Hash((hx::Object *)data->args.a0, true))->toUri());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute toUri() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_hash_to_hex(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::Hash((hx::Object *)a0, true))->toHex());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::Hash((hx::Object *)data->args.a0, true))->toHex());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute toHex() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_hash_to_base_64(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::Hash((hx::Object *)a0, true))->toBase64());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::Hash((hx::Object *)data->args.a0, true))->toBase64());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute toBase64() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_hash_to_base_64_url(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::Hash((hx::Object *)a0, true))->toBase64Url());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::Hash((hx::Object *)data->args.a0, true))->toBase64Url());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute toBase64Url() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void *snikket_chat_message_builder_new() {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeObject(snikket::ChatMessageBuilder_obj::__new());
+	}
+	struct Data {
+		struct {} args;
+		HxSemaphore lock;
+		void * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeObject(snikket::ChatMessageBuilder_obj::__new());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {} };
+
+	// queue a callback to execute new() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_message_builder_local_id(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatMessageBuilder((hx::Object *)a0, true))->localId__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->localId__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute localId__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_message_builder_set_local_id(void *a0, const char *a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::ChatMessageBuilder((hx::Object *)a0, true))->set_localId__fromC(a1);
+	}
+	struct Data {
+		struct {void * a0; const char * a1;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->set_localId__fromC(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute set_localId__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_message_builder_server_id(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatMessageBuilder((hx::Object *)a0, true))->serverId__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->serverId__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute serverId__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_message_builder_set_server_id(void *a0, const char *a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::ChatMessageBuilder((hx::Object *)a0, true))->set_serverId__fromC(a1);
+	}
+	struct Data {
+		struct {void * a0; const char * a1;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->set_serverId__fromC(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute set_serverId__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_message_builder_server_id_by(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatMessageBuilder((hx::Object *)a0, true))->serverIdBy__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->serverIdBy__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute serverIdBy__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_message_builder_set_server_id_by(void *a0, const char *a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::ChatMessageBuilder((hx::Object *)a0, true))->set_serverIdBy__fromC(a1);
+	}
+	struct Data {
+		struct {void * a0; const char * a1;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->set_serverIdBy__fromC(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute set_serverIdBy__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+enum snikket_message_type snikket_chat_message_builder_type(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return static_cast<enum snikket_message_type>((snikket::ChatMessageBuilder((hx::Object *)a0, true))->type__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		enum snikket_message_type ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = static_cast<enum snikket_message_type>((snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->type__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute type__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_message_builder_set_type(void *a0, enum snikket_message_type a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::ChatMessageBuilder((hx::Object *)a0, true))->set_type__fromC(a1);
+	}
+	struct Data {
+		struct {void * a0; enum snikket_message_type a1;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->set_type__fromC(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute set_type__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_message_builder_timestamp(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatMessageBuilder((hx::Object *)a0, true))->timestamp__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->timestamp__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute timestamp__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_message_builder_set_timestamp(void *a0, const char *a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::ChatMessageBuilder((hx::Object *)a0, true))->set_timestamp__fromC(a1);
+	}
+	struct Data {
+		struct {void * a0; const char * a1;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->set_timestamp__fromC(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute set_timestamp__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_message_builder_sender_id(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatMessageBuilder((hx::Object *)a0, true))->senderId__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->senderId__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute senderId__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_message_builder_set_sender_id(void *a0, const char *a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::ChatMessageBuilder((hx::Object *)a0, true))->set_senderId__fromC(a1);
+	}
+	struct Data {
+		struct {void * a0; const char * a1;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->set_senderId__fromC(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute set_senderId__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void *snikket_chat_message_builder_reply_to_message(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeObject((snikket::ChatMessageBuilder((hx::Object *)a0, true))->replyToMessage__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		void * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeObject((snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->replyToMessage__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute replyToMessage__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_message_builder_set_reply_to_message(void *a0, void *a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::ChatMessageBuilder((hx::Object *)a0, true))->set_replyToMessage__fromC(Dynamic((hx::Object *)a1));
+	}
+	struct Data {
+		struct {void * a0; void * a1;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->set_replyToMessage__fromC(Dynamic((hx::Object *)data->args.a1));
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute set_replyToMessage__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_message_builder_thread_id(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatMessageBuilder((hx::Object *)a0, true))->threadId__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->threadId__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute threadId__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_message_builder_set_thread_id(void *a0, const char *a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::ChatMessageBuilder((hx::Object *)a0, true))->set_threadId__fromC(a1);
+	}
+	struct Data {
+		struct {void * a0; const char * a1;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->set_threadId__fromC(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute set_threadId__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+size_t snikket_chat_message_builder_attachments(void *a0, void ***a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::ChatMessageBuilder((hx::Object *)a0, true))->attachments__fromC(a1);
+	}
+	struct Data {
+		struct {void * a0; void*** a1;} args;
+		HxSemaphore lock;
+		size_t ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->attachments__fromC(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute attachments__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_message_builder_text(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatMessageBuilder((hx::Object *)a0, true))->text__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->text__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute text__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_message_builder_set_text(void *a0, const char *a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::ChatMessageBuilder((hx::Object *)a0, true))->set_text__fromC(a1);
+	}
+	struct Data {
+		struct {void * a0; const char * a1;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->set_text__fromC(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute set_text__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_message_builder_lang(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatMessageBuilder((hx::Object *)a0, true))->lang__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->lang__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute lang__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_message_builder_set_lang(void *a0, const char *a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::ChatMessageBuilder((hx::Object *)a0, true))->set_lang__fromC(a1);
+	}
+	struct Data {
+		struct {void * a0; const char * a1;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->set_lang__fromC(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute set_lang__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+enum snikket_message_direction snikket_chat_message_builder_direction(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return static_cast<enum snikket_message_direction>((snikket::ChatMessageBuilder((hx::Object *)a0, true))->direction__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		enum snikket_message_direction ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = static_cast<enum snikket_message_direction>((snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->direction__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute direction__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_message_builder_set_direction(void *a0, enum snikket_message_direction a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::ChatMessageBuilder((hx::Object *)a0, true))->set_direction__fromC(a1);
+	}
+	struct Data {
+		struct {void * a0; enum snikket_message_direction a1;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->set_direction__fromC(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute set_direction__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+enum snikket_message_status snikket_chat_message_builder_status(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return static_cast<enum snikket_message_status>((snikket::ChatMessageBuilder((hx::Object *)a0, true))->status__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		enum snikket_message_status ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = static_cast<enum snikket_message_status>((snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->status__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute status__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_message_builder_set_status(void *a0, enum snikket_message_status a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::ChatMessageBuilder((hx::Object *)a0, true))->set_status__fromC(a1);
+	}
+	struct Data {
+		struct {void * a0; enum snikket_message_status a1;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->set_status__fromC(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute set_status__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+size_t snikket_chat_message_builder_versions(void *a0, void ***a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::ChatMessageBuilder((hx::Object *)a0, true))->versions__fromC(a1);
+	}
+	struct Data {
+		struct {void * a0; void*** a1;} args;
+		HxSemaphore lock;
+		size_t ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->versions__fromC(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute versions__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_message_builder_add_attachment(void *a0, void *a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::ChatMessageBuilder((hx::Object *)a0, true))->addAttachment(Dynamic((hx::Object *)a1));
+	}
+	struct Data {
+		struct {void * a0; void * a1;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->addAttachment(Dynamic((hx::Object *)data->args.a1));
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute addAttachment() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_message_builder_set_html(void *a0, const char *a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::ChatMessageBuilder((hx::Object *)a0, true))->setHtml(a1);
+	}
+	struct Data {
+		struct {void * a0; const char * a1;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->setHtml(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute setHtml() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_message_builder_chat_id(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatMessageBuilder((hx::Object *)a0, true))->chatId());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->chatId());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute chatId() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_message_builder_get_sender_id(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::ChatMessageBuilder((hx::Object *)a0, true))->get_senderId());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->get_senderId());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute get_senderId() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+bool snikket_chat_message_builder_is_incoming(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::ChatMessageBuilder((hx::Object *)a0, true))->isIncoming();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		bool ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->isIncoming();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute isIncoming() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void *snikket_chat_message_builder_build(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeObject((snikket::ChatMessageBuilder((hx::Object *)a0, true))->build());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		void * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeObject((snikket::ChatMessageBuilder((hx::Object *)data->args.a0, true))->build());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute build() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void *snikket_persistence_dummy_new() {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeObject(snikket::persistence::Dummy_obj::__new());
+	}
+	struct Data {
+		struct {} args;
+		HxSemaphore lock;
+		void * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeObject(snikket::persistence::Dummy_obj::__new());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {} };
+
+	// queue a callback to execute new() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void *snikket_client_new(const char *a0, void *a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeObject(snikket::Client_obj::__new(a0, Dynamic((hx::Object *)a1)));
+	}
+	struct Data {
+		struct {const char * a0; void * a1;} args;
+		HxSemaphore lock;
+		void * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeObject(snikket::Client_obj::__new(data->args.a0, Dynamic((hx::Object *)data->args.a1)));
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute new() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_client_set_send_available(void *a0, bool a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Client((hx::Object *)a0, true))->set_sendAvailable__fromC(a1);
+	}
+	struct Data {
+		struct {void * a0; bool a1;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Client((hx::Object *)data->args.a0, true))->set_sendAvailable__fromC(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute set_sendAvailable__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_client_start(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Client((hx::Object *)a0, true))->start();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Client((hx::Object *)data->args.a0, true))->start();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute start() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_client_logout(void *a0, bool a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Client((hx::Object *)a0, true))->logout(a1);
+	}
+	struct Data {
+		struct {void * a0; bool a1;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Client((hx::Object *)data->args.a0, true))->logout(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute logout() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_client_use_password(void *a0, const char *a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Client((hx::Object *)a0, true))->usePassword(a1);
+	}
+	struct Data {
+		struct {void * a0; const char * a1;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Client((hx::Object *)data->args.a0, true))->usePassword(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute usePassword() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_client_account_id(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::Client((hx::Object *)a0, true))->accountId());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::Client((hx::Object *)data->args.a0, true))->accountId());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute accountId() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_client_display_name(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::Client((hx::Object *)a0, true))->displayName());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::Client((hx::Object *)data->args.a0, true))->displayName());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute displayName() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_client_set_display_name(void *a0, const char *a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Client((hx::Object *)a0, true))->setDisplayName(a1);
+	}
+	struct Data {
+		struct {void * a0; const char * a1;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Client((hx::Object *)data->args.a0, true))->setDisplayName(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute setDisplayName() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_client_prepare_attachment(void *a0, void *a1, void (*a2) (void*, void*), void *a3) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Client((hx::Object *)a0, true))->prepareAttachment__fromC(Dynamic((hx::Object *)a1), cpp::Function<void(void*, void*)>(a2), a3);
+	}
+	struct Data {
+		struct {void * a0; void * a1; void (* a2) (void*, void*); void* a3;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Client((hx::Object *)data->args.a0, true))->prepareAttachment__fromC(Dynamic((hx::Object *)data->args.a1), cpp::Function<void(void*, void*)>(data->args.a2), data->args.a3);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2, a3} };
+
+	// queue a callback to execute prepareAttachment__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+size_t snikket_client_get_chats(void *a0, void ***a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Client((hx::Object *)a0, true))->getChats__fromC(a1);
+	}
+	struct Data {
+		struct {void * a0; void*** a1;} args;
+		HxSemaphore lock;
+		size_t ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::Client((hx::Object *)data->args.a0, true))->getChats__fromC(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute getChats__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_client_find_available_chats(void *a0, const char *a1, void (*a2) (const char*, void**, size_t, void*), void *a3) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Client((hx::Object *)a0, true))->findAvailableChats__fromC(a1, cpp::Function<void(const char*, void**, size_t, void*)>(a2), a3);
+	}
+	struct Data {
+		struct {void * a0; const char * a1; void (* a2) (const char*, void**, size_t, void*); void* a3;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Client((hx::Object *)data->args.a0, true))->findAvailableChats__fromC(data->args.a1, cpp::Function<void(const char*, void**, size_t, void*)>(data->args.a2), data->args.a3);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2, a3} };
+
+	// queue a callback to execute findAvailableChats__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void *snikket_client_start_chat(void *a0, void *a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeObject((snikket::Client((hx::Object *)a0, true))->startChat(Dynamic((hx::Object *)a1)));
+	}
+	struct Data {
+		struct {void * a0; void * a1;} args;
+		HxSemaphore lock;
+		void * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeObject((snikket::Client((hx::Object *)data->args.a0, true))->startChat(Dynamic((hx::Object *)data->args.a1)));
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute startChat() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void *snikket_client_get_chat(void *a0, const char *a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeObject((snikket::Client((hx::Object *)a0, true))->getChat(a1));
+	}
+	struct Data {
+		struct {void * a0; const char * a1;} args;
+		HxSemaphore lock;
+		void * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeObject((snikket::Client((hx::Object *)data->args.a0, true))->getChat(data->args.a1));
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute getChat() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_client_add_password_needed_listener(void *a0, void (*a1) (void*, void*), void *a2) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Client((hx::Object *)a0, true))->addPasswordNeededListener__fromC(cpp::Function<void(void*, void*)>(a1), a2);
+	}
+	struct Data {
+		struct {void * a0; void (* a1) (void*, void*); void* a2;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Client((hx::Object *)data->args.a0, true))->addPasswordNeededListener__fromC(cpp::Function<void(void*, void*)>(data->args.a1), data->args.a2);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2} };
+
+	// queue a callback to execute addPasswordNeededListener__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_client_add_status_online_listener(void *a0, void (*a1) (void*), void *a2) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Client((hx::Object *)a0, true))->addStatusOnlineListener__fromC(cpp::Function<void(void*)>(a1), a2);
+	}
+	struct Data {
+		struct {void * a0; void (* a1) (void*); void* a2;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Client((hx::Object *)data->args.a0, true))->addStatusOnlineListener__fromC(cpp::Function<void(void*)>(data->args.a1), data->args.a2);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2} };
+
+	// queue a callback to execute addStatusOnlineListener__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_client_add_status_offline_listener(void *a0, void (*a1) (void*), void *a2) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Client((hx::Object *)a0, true))->addStatusOfflineListener__fromC(cpp::Function<void(void*)>(a1), a2);
+	}
+	struct Data {
+		struct {void * a0; void (* a1) (void*); void* a2;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Client((hx::Object *)data->args.a0, true))->addStatusOfflineListener__fromC(cpp::Function<void(void*)>(data->args.a1), data->args.a2);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2} };
+
+	// queue a callback to execute addStatusOfflineListener__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_client_add_connection_failed_listener(void *a0, void (*a1) (void*), void *a2) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Client((hx::Object *)a0, true))->addConnectionFailedListener__fromC(cpp::Function<void(void*)>(a1), a2);
+	}
+	struct Data {
+		struct {void * a0; void (* a1) (void*); void* a2;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Client((hx::Object *)data->args.a0, true))->addConnectionFailedListener__fromC(cpp::Function<void(void*)>(data->args.a1), data->args.a2);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2} };
+
+	// queue a callback to execute addConnectionFailedListener__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_client_add_chat_message_listener(void *a0, void (*a1) (void*, int, void*), void *a2) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Client((hx::Object *)a0, true))->addChatMessageListener__fromC(cpp::Function<void(void*, int, void*)>(a1), a2);
+	}
+	struct Data {
+		struct {void * a0; void (* a1) (void*, int, void*); void* a2;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Client((hx::Object *)data->args.a0, true))->addChatMessageListener__fromC(cpp::Function<void(void*, int, void*)>(data->args.a1), data->args.a2);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2} };
+
+	// queue a callback to execute addChatMessageListener__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_client_add_sync_message_listener(void *a0, void (*a1) (void*, void*), void *a2) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Client((hx::Object *)a0, true))->addSyncMessageListener__fromC(cpp::Function<void(void*, void*)>(a1), a2);
+	}
+	struct Data {
+		struct {void * a0; void (* a1) (void*, void*); void* a2;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Client((hx::Object *)data->args.a0, true))->addSyncMessageListener__fromC(cpp::Function<void(void*, void*)>(data->args.a1), data->args.a2);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2} };
+
+	// queue a callback to execute addSyncMessageListener__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_client_add_chats_updated_listener(void *a0, void (*a1) (void**, size_t, void*), void *a2) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Client((hx::Object *)a0, true))->addChatsUpdatedListener__fromC(cpp::Function<void(void**, size_t, void*)>(a1), a2);
+	}
+	struct Data {
+		struct {void * a0; void (* a1) (void**, size_t, void*); void* a2;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Client((hx::Object *)data->args.a0, true))->addChatsUpdatedListener__fromC(cpp::Function<void(void**, size_t, void*)>(data->args.a1), data->args.a2);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2} };
+
+	// queue a callback to execute addChatsUpdatedListener__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_client_add_call_ring_listener(void *a0, void (*a1) (void*, const char*, void*), void *a2) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Client((hx::Object *)a0, true))->addCallRingListener__fromC(cpp::Function<void(void*, const char*, void*)>(a1), a2);
+	}
+	struct Data {
+		struct {void * a0; void (* a1) (void*, const char*, void*); void* a2;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Client((hx::Object *)data->args.a0, true))->addCallRingListener__fromC(cpp::Function<void(void*, const char*, void*)>(data->args.a1), data->args.a2);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2} };
+
+	// queue a callback to execute addCallRingListener__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_client_add_call_retract_listener(void *a0, void (*a1) (const char*, void*), void *a2) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Client((hx::Object *)a0, true))->addCallRetractListener__fromC(cpp::Function<void(const char*, void*)>(a1), a2);
+	}
+	struct Data {
+		struct {void * a0; void (* a1) (const char*, void*); void* a2;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Client((hx::Object *)data->args.a0, true))->addCallRetractListener__fromC(cpp::Function<void(const char*, void*)>(data->args.a1), data->args.a2);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2} };
+
+	// queue a callback to execute addCallRetractListener__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_client_add_call_ringing_listener(void *a0, void (*a1) (const char*, void*), void *a2) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Client((hx::Object *)a0, true))->addCallRingingListener__fromC(cpp::Function<void(const char*, void*)>(a1), a2);
+	}
+	struct Data {
+		struct {void * a0; void (* a1) (const char*, void*); void* a2;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Client((hx::Object *)data->args.a0, true))->addCallRingingListener__fromC(cpp::Function<void(const char*, void*)>(data->args.a1), data->args.a2);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2} };
+
+	// queue a callback to execute addCallRingingListener__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_client_add_call_media_listener(void *a0, void (*a1) (void*, bool, bool, void*), void *a2) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Client((hx::Object *)a0, true))->addCallMediaListener__fromC(cpp::Function<void(void*, bool, bool, void*)>(a1), a2);
+	}
+	struct Data {
+		struct {void * a0; void (* a1) (void*, bool, bool, void*); void* a2;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Client((hx::Object *)data->args.a0, true))->addCallMediaListener__fromC(cpp::Function<void(void*, bool, bool, void*)>(data->args.a1), data->args.a2);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2} };
+
+	// queue a callback to execute addCallMediaListener__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_client_add_call_track_listener(void *a0, void (*a1) (const char*, void*, void**, size_t, void*), void *a2) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Client((hx::Object *)a0, true))->addCallTrackListener__fromC(cpp::Function<void(const char*, void*, void**, size_t, void*)>(a1), a2);
+	}
+	struct Data {
+		struct {void * a0; void (* a1) (const char*, void*, void**, size_t, void*); void* a2;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Client((hx::Object *)data->args.a0, true))->addCallTrackListener__fromC(cpp::Function<void(const char*, void*, void**, size_t, void*)>(data->args.a1), data->args.a2);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2} };
+
+	// queue a callback to execute addCallTrackListener__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_client_set_in_foreground(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Client((hx::Object *)a0, true))->setInForeground();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Client((hx::Object *)data->args.a0, true))->setInForeground();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute setInForeground() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_client_set_not_in_foreground(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Client((hx::Object *)a0, true))->setNotInForeground();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Client((hx::Object *)data->args.a0, true))->setNotInForeground();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute setNotInForeground() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_chat_id(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::Chat((hx::Object *)a0, true))->chatId__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::Chat((hx::Object *)data->args.a0, true))->chatId__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute chatId__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+enum snikket_ui_state snikket_chat_ui_state(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return static_cast<enum snikket_ui_state>((snikket::Chat((hx::Object *)a0, true))->uiState__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		enum snikket_ui_state ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = static_cast<enum snikket_ui_state>((snikket::Chat((hx::Object *)data->args.a0, true))->uiState__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute uiState__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+bool snikket_chat_is_blocked(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->isBlocked__fromC();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		bool ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::Chat((hx::Object *)data->args.a0, true))->isBlocked__fromC();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute isBlocked__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_get_messages_before(void *a0, const char *a1, const char *a2, void (*a3) (void**, size_t, void*), void *a4) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->getMessagesBefore__fromC(a1, a2, cpp::Function<void(void**, size_t, void*)>(a3), a4);
+	}
+	struct Data {
+		struct {void * a0; const char * a1; const char * a2; void (* a3) (void**, size_t, void*); void* a4;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Chat((hx::Object *)data->args.a0, true))->getMessagesBefore__fromC(data->args.a1, data->args.a2, cpp::Function<void(void**, size_t, void*)>(data->args.a3), data->args.a4);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2, a3, a4} };
+
+	// queue a callback to execute getMessagesBefore__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_get_messages_after(void *a0, const char *a1, const char *a2, void (*a3) (void**, size_t, void*), void *a4) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->getMessagesAfter__fromC(a1, a2, cpp::Function<void(void**, size_t, void*)>(a3), a4);
+	}
+	struct Data {
+		struct {void * a0; const char * a1; const char * a2; void (* a3) (void**, size_t, void*); void* a4;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Chat((hx::Object *)data->args.a0, true))->getMessagesAfter__fromC(data->args.a1, data->args.a2, cpp::Function<void(void**, size_t, void*)>(data->args.a3), data->args.a4);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2, a3, a4} };
+
+	// queue a callback to execute getMessagesAfter__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_get_messages_around(void *a0, const char *a1, const char *a2, void (*a3) (void**, size_t, void*), void *a4) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->getMessagesAround__fromC(a1, a2, cpp::Function<void(void**, size_t, void*)>(a3), a4);
+	}
+	struct Data {
+		struct {void * a0; const char * a1; const char * a2; void (* a3) (void**, size_t, void*); void* a4;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Chat((hx::Object *)data->args.a0, true))->getMessagesAround__fromC(data->args.a1, data->args.a2, cpp::Function<void(void**, size_t, void*)>(data->args.a3), data->args.a4);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2, a3, a4} };
+
+	// queue a callback to execute getMessagesAround__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_send_message(void *a0, void *a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->sendMessage__fromC(Dynamic((hx::Object *)a1));
+	}
+	struct Data {
+		struct {void * a0; void * a1;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Chat((hx::Object *)data->args.a0, true))->sendMessage__fromC(Dynamic((hx::Object *)data->args.a1));
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute sendMessage__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_mark_read_up_to(void *a0, void *a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->markReadUpTo__fromC(Dynamic((hx::Object *)a1));
+	}
+	struct Data {
+		struct {void * a0; void * a1;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Chat((hx::Object *)data->args.a0, true))->markReadUpTo__fromC(Dynamic((hx::Object *)data->args.a1));
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute markReadUpTo__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_bookmark(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->bookmark__fromC();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Chat((hx::Object *)data->args.a0, true))->bookmark__fromC();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute bookmark__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+size_t snikket_chat_get_participants(void *a0, const char ***a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->getParticipants__fromC(a1);
+	}
+	struct Data {
+		struct {void * a0; const char*** a1;} args;
+		HxSemaphore lock;
+		size_t ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::Chat((hx::Object *)data->args.a0, true))->getParticipants__fromC(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute getParticipants__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void *snikket_chat_get_participant_details(void *a0, const char *a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeObject((snikket::Chat((hx::Object *)a0, true))->getParticipantDetails__fromC(a1));
+	}
+	struct Data {
+		struct {void * a0; const char * a1;} args;
+		HxSemaphore lock;
+		void * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeObject((snikket::Chat((hx::Object *)data->args.a0, true))->getParticipantDetails__fromC(data->args.a1));
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute getParticipantDetails__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_correct_message(void *a0, const char *a1, void *a2) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->correctMessage__fromC(a1, Dynamic((hx::Object *)a2));
+	}
+	struct Data {
+		struct {void * a0; const char * a1; void * a2;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Chat((hx::Object *)data->args.a0, true))->correctMessage__fromC(data->args.a1, Dynamic((hx::Object *)data->args.a2));
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2} };
+
+	// queue a callback to execute correctMessage__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_add_reaction(void *a0, void *a1, void *a2) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->addReaction(Dynamic((hx::Object *)a1), Dynamic((hx::Object *)a2));
+	}
+	struct Data {
+		struct {void * a0; void * a1; void * a2;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Chat((hx::Object *)data->args.a0, true))->addReaction(Dynamic((hx::Object *)data->args.a1), Dynamic((hx::Object *)data->args.a2));
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2} };
+
+	// queue a callback to execute addReaction() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_remove_reaction(void *a0, void *a1, void *a2) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->removeReaction__fromC(Dynamic((hx::Object *)a1), Dynamic((hx::Object *)a2));
+	}
+	struct Data {
+		struct {void * a0; void * a1; void * a2;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Chat((hx::Object *)data->args.a0, true))->removeReaction__fromC(Dynamic((hx::Object *)data->args.a1), Dynamic((hx::Object *)data->args.a2));
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2} };
+
+	// queue a callback to execute removeReaction__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_typing(void *a0, const char *a1, const char *a2) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->typing(a1, a2);
+	}
+	struct Data {
+		struct {void * a0; const char * a1; const char * a2;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Chat((hx::Object *)data->args.a0, true))->typing(data->args.a1, data->args.a2);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2} };
+
+	// queue a callback to execute typing() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_set_active(void *a0, bool a1, const char *a2) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->setActive(a1, a2);
+	}
+	struct Data {
+		struct {void * a0; bool a1; const char * a2;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Chat((hx::Object *)data->args.a0, true))->setActive(data->args.a1, data->args.a2);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2} };
+
+	// queue a callback to execute setActive() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_close(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->close__fromC();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Chat((hx::Object *)data->args.a0, true))->close__fromC();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute close__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_toggle_pinned(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->togglePinned();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Chat((hx::Object *)data->args.a0, true))->togglePinned();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute togglePinned() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_block(void *a0, void *a1, bool a2) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->block(Dynamic((hx::Object *)a1), a2);
+	}
+	struct Data {
+		struct {void * a0; void * a1; bool a2;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Chat((hx::Object *)data->args.a0, true))->block(Dynamic((hx::Object *)data->args.a1), data->args.a2);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2} };
+
+	// queue a callback to execute block() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_unblock(void *a0, bool a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->unblock(a1);
+	}
+	struct Data {
+		struct {void * a0; bool a1;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Chat((hx::Object *)data->args.a0, true))->unblock(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute unblock() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_set_notifications(void *a0, bool a1, bool a2, bool a3) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->setNotifications(a1, a2, a3);
+	}
+	struct Data {
+		struct {void * a0; bool a1; bool a2; bool a3;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Chat((hx::Object *)data->args.a0, true))->setNotifications(data->args.a1, data->args.a2, data->args.a3);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2, a3} };
+
+	// queue a callback to execute setNotifications() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+bool snikket_chat_notifications_filtered(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->notificationsFiltered();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		bool ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::Chat((hx::Object *)data->args.a0, true))->notificationsFiltered();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute notificationsFiltered() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+bool snikket_chat_notify_mention(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->notifyMention();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		bool ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::Chat((hx::Object *)data->args.a0, true))->notifyMention();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute notifyMention() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+bool snikket_chat_notify_reply(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->notifyReply();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		bool ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::Chat((hx::Object *)data->args.a0, true))->notifyReply();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute notifyReply() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_last_message_id(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::Chat((hx::Object *)a0, true))->lastMessageId__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::Chat((hx::Object *)data->args.a0, true))->lastMessageId__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute lastMessageId__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_last_message_timestamp(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::Chat((hx::Object *)a0, true))->lastMessageTimestamp());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::Chat((hx::Object *)data->args.a0, true))->lastMessageTimestamp());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute lastMessageTimestamp() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_get_photo(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::Chat((hx::Object *)a0, true))->getPhoto());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::Chat((hx::Object *)data->args.a0, true))->getPhoto());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute getPhoto() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_get_placeholder(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::Chat((hx::Object *)a0, true))->getPlaceholder());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::Chat((hx::Object *)data->args.a0, true))->getPlaceholder());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute getPlaceholder() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_read_up_to(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::Chat((hx::Object *)a0, true))->readUpTo());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::Chat((hx::Object *)data->args.a0, true))->readUpTo());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute readUpTo() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+int snikket_chat_unread_count(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->unreadCount();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		int ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::Chat((hx::Object *)data->args.a0, true))->unreadCount();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute unreadCount() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_preview(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::Chat((hx::Object *)a0, true))->preview());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::Chat((hx::Object *)data->args.a0, true))->preview());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute preview() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_set_display_name(void *a0, const char *a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->setDisplayName(a1);
+	}
+	struct Data {
+		struct {void * a0; const char * a1;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Chat((hx::Object *)data->args.a0, true))->setDisplayName(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute setDisplayName() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_get_display_name(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::Chat((hx::Object *)a0, true))->getDisplayName());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::Chat((hx::Object *)data->args.a0, true))->getDisplayName());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute getDisplayName() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_set_trusted(void *a0, bool a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->setTrusted(a1);
+	}
+	struct Data {
+		struct {void * a0; bool a1;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Chat((hx::Object *)data->args.a0, true))->setTrusted(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute setTrusted() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+bool snikket_chat_is_trusted(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->isTrusted();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		bool ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::Chat((hx::Object *)data->args.a0, true))->isTrusted();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute isTrusted() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+bool snikket_chat_syncing(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->syncing();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		bool ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::Chat((hx::Object *)data->args.a0, true))->syncing();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute syncing() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+bool snikket_chat_can_audio_call(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->canAudioCall();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		bool ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::Chat((hx::Object *)data->args.a0, true))->canAudioCall();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute canAudioCall() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+bool snikket_chat_can_video_call(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->canVideoCall();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		bool ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::Chat((hx::Object *)data->args.a0, true))->canVideoCall();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute canVideoCall() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_start_call(void *a0, bool a1, bool a2) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->startCall(a1, a2);
+	}
+	struct Data {
+		struct {void * a0; bool a1; bool a2;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Chat((hx::Object *)data->args.a0, true))->startCall(data->args.a1, data->args.a2);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2} };
+
+	// queue a callback to execute startCall() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_accept_call(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->acceptCall();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Chat((hx::Object *)data->args.a0, true))->acceptCall();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute acceptCall() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_chat_hangup(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->hangup();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::Chat((hx::Object *)data->args.a0, true))->hangup();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute hangup() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_chat_call_status(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::Chat((hx::Object *)a0, true))->callStatus());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::Chat((hx::Object *)data->args.a0, true))->callStatus());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute callStatus() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void *snikket_chat_dtmf(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeObject((snikket::Chat((hx::Object *)a0, true))->dtmf());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		void * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeObject((snikket::Chat((hx::Object *)data->args.a0, true))->dtmf());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute dtmf() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+size_t snikket_chat_video_tracks(void *a0, void ***a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Chat((hx::Object *)a0, true))->videoTracks__fromC(a1);
+	}
+	struct Data {
+		struct {void * a0; void*** a1;} args;
+		HxSemaphore lock;
+		size_t ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::Chat((hx::Object *)data->args.a0, true))->videoTracks__fromC(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute videoTracks__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_jingle_media_stream_track_id(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::jingle::MediaStreamTrack((hx::Object *)a0, true))->id__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::jingle::MediaStreamTrack((hx::Object *)data->args.a0, true))->id__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute id__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+bool snikket_jingle_media_stream_track_muted(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::jingle::MediaStreamTrack((hx::Object *)a0, true))->muted__fromC();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		bool ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::jingle::MediaStreamTrack((hx::Object *)data->args.a0, true))->muted__fromC();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute muted__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_jingle_media_stream_track_kind(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::jingle::MediaStreamTrack((hx::Object *)a0, true))->kind__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::jingle::MediaStreamTrack((hx::Object *)data->args.a0, true))->kind__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute kind__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+size_t snikket_jingle_media_stream_track_supported_audio_formats(void *a0, void ***a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::jingle::MediaStreamTrack((hx::Object *)a0, true))->supportedAudioFormats__fromC(a1);
+	}
+	struct Data {
+		struct {void * a0; void*** a1;} args;
+		HxSemaphore lock;
+		size_t ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::jingle::MediaStreamTrack((hx::Object *)data->args.a0, true))->supportedAudioFormats__fromC(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute supportedAudioFormats__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_jingle_media_stream_track_add_pcm_listener(void *a0, void (*a1) (short*, size_t, int, int, void*), void *a2) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::jingle::MediaStreamTrack((hx::Object *)a0, true))->addPCMListener__fromC(cpp::Function<void(short*, size_t, int, int, void*)>(a1), a2);
+	}
+	struct Data {
+		struct {void * a0; void (* a1) (short*, size_t, int, int, void*); void* a2;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::jingle::MediaStreamTrack((hx::Object *)data->args.a0, true))->addPCMListener__fromC(cpp::Function<void(short*, size_t, int, int, void*)>(data->args.a1), data->args.a2);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2} };
+
+	// queue a callback to execute addPCMListener__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_jingle_media_stream_track_add_ready_for_pcm_listener(void *a0, void (*a1) (void*), void *a2) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::jingle::MediaStreamTrack((hx::Object *)a0, true))->addReadyForPCMListener__fromC(cpp::Function<void(void*)>(a1), a2);
+	}
+	struct Data {
+		struct {void * a0; void (* a1) (void*); void* a2;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::jingle::MediaStreamTrack((hx::Object *)data->args.a0, true))->addReadyForPCMListener__fromC(cpp::Function<void(void*)>(data->args.a1), data->args.a2);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2} };
+
+	// queue a callback to execute addReadyForPCMListener__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_jingle_media_stream_track_write_pcm(void *a0, const short *a1, size_t a2, int a3, int a4) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::jingle::MediaStreamTrack((hx::Object *)a0, true))->writePCM__fromC(a1, a2, a3, a4);
+	}
+	struct Data {
+		struct {void * a0; const short* a1; size_t a2; int a3; int a4;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::jingle::MediaStreamTrack((hx::Object *)data->args.a0, true))->writePCM__fromC(data->args.a1, data->args.a2, data->args.a3, data->args.a4);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2, a3, a4} };
+
+	// queue a callback to execute writePCM__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_jingle_media_stream_track_stop(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::jingle::MediaStreamTrack((hx::Object *)a0, true))->stop();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::jingle::MediaStreamTrack((hx::Object *)data->args.a0, true))->stop();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute stop() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void *snikket_jingle_audio_format_new(const char *a0, unsigned char a1, int a2, int a3) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeObject(snikket::jingle::AudioFormat_obj::__new(a0, a1, a2, a3));
+	}
+	struct Data {
+		struct {const char * a0; unsigned char a1; int a2; int a3;} args;
+		HxSemaphore lock;
+		void * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeObject(snikket::jingle::AudioFormat_obj::__new(data->args.a0, data->args.a1, data->args.a2, data->args.a3));
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2, a3} };
+
+	// queue a callback to execute new() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+int snikket_jingle_audio_format_clock_rate(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::jingle::AudioFormat((hx::Object *)a0, true))->clockRate__fromC();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		int ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::jingle::AudioFormat((hx::Object *)data->args.a0, true))->clockRate__fromC();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute clockRate__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+int snikket_jingle_audio_format_channels(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::jingle::AudioFormat((hx::Object *)a0, true))->channels__fromC();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		int ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::jingle::AudioFormat((hx::Object *)data->args.a0, true))->channels__fromC();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute channels__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_available_chat_chat_id(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::AvailableChat((hx::Object *)a0, true))->chatId__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::AvailableChat((hx::Object *)data->args.a0, true))->chatId__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute chatId__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_available_chat_display_name(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::AvailableChat((hx::Object *)a0, true))->displayName__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::AvailableChat((hx::Object *)data->args.a0, true))->displayName__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute displayName__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_available_chat_note(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::AvailableChat((hx::Object *)a0, true))->note__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::AvailableChat((hx::Object *)data->args.a0, true))->note__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute note__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+bool snikket_available_chat_is_channel(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::AvailableChat((hx::Object *)a0, true))->isChannel();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		bool ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::AvailableChat((hx::Object *)data->args.a0, true))->isChannel();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute isChannel() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_jingle_initiated_session_sid(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::jingle::InitiatedSession((hx::Object *)a0, true))->sid__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::jingle::InitiatedSession((hx::Object *)data->args.a0, true))->sid__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute sid__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_jingle_initiated_session_accept(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::jingle::InitiatedSession((hx::Object *)a0, true))->accept();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::jingle::InitiatedSession((hx::Object *)data->args.a0, true))->accept();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute accept() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_jingle_initiated_session_hangup(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::jingle::InitiatedSession((hx::Object *)a0, true))->hangup();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::jingle::InitiatedSession((hx::Object *)data->args.a0, true))->hangup();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute hangup() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_jingle_initiated_session_add_media(void *a0, void *const *a1, size_t a2) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::jingle::InitiatedSession((hx::Object *)a0, true))->addMedia__fromC(a1, a2);
+	}
+	struct Data {
+		struct {void * a0; void* const* a1; size_t a2;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::jingle::InitiatedSession((hx::Object *)data->args.a0, true))->addMedia__fromC(data->args.a1, data->args.a2);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2} };
+
+	// queue a callback to execute addMedia__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_jingle_initiated_session_call_status(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::jingle::InitiatedSession((hx::Object *)a0, true))->callStatus());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::jingle::InitiatedSession((hx::Object *)data->args.a0, true))->callStatus());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute callStatus() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+size_t snikket_jingle_initiated_session_video_tracks(void *a0, void ***a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::jingle::InitiatedSession((hx::Object *)a0, true))->videoTracks__fromC(a1);
+	}
+	struct Data {
+		struct {void * a0; void*** a1;} args;
+		HxSemaphore lock;
+		size_t ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::jingle::InitiatedSession((hx::Object *)data->args.a0, true))->videoTracks__fromC(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute videoTracks__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void *snikket_jingle_initiated_session_dtmf(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeObject((snikket::jingle::InitiatedSession((hx::Object *)a0, true))->dtmf());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		void * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeObject((snikket::jingle::InitiatedSession((hx::Object *)data->args.a0, true))->dtmf());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute dtmf() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_jingle_initiated_session_supply_media(void *a0, void *const *a1, size_t a2) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::jingle::InitiatedSession((hx::Object *)a0, true))->supplyMedia__fromC(a1, a2);
+	}
+	struct Data {
+		struct {void * a0; void* const* a1; size_t a2;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::jingle::InitiatedSession((hx::Object *)data->args.a0, true))->supplyMedia__fromC(data->args.a1, data->args.a2);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1, a2} };
+
+	// queue a callback to execute supplyMedia__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void *snikket_jingle_media_stream_new() {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeObject(snikket::jingle::MediaStream_obj::__new());
+	}
+	struct Data {
+		struct {} args;
+		HxSemaphore lock;
+		void * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeObject(snikket::jingle::MediaStream_obj::__new());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {} };
+
+	// queue a callback to execute new() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void *snikket_jingle_media_stream_make_audio() {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeObject(snikket::jingle::MediaStream_obj::makeAudio());
+	}
+	struct Data {
+		struct {} args;
+		HxSemaphore lock;
+		void * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeObject(snikket::jingle::MediaStream_obj::makeAudio());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {} };
+
+	// queue a callback to execute makeAudio() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_jingle_media_stream_add_track(void *a0, void *a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::jingle::MediaStream((hx::Object *)a0, true))->addTrack(Dynamic((hx::Object *)a1));
+	}
+	struct Data {
+		struct {void * a0; void * a1;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::jingle::MediaStream((hx::Object *)data->args.a0, true))->addTrack(Dynamic((hx::Object *)data->args.a1));
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute addTrack() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
+HAXE_C_BRIDGE_LINKAGE
+size_t snikket_jingle_media_stream_get_tracks(void *a0, void ***a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::jingle::MediaStream((hx::Object *)a0, true))->getTracks__fromC(a1);
+	}
+	struct Data {
+		struct {void * a0; void*** a1;} args;
+		HxSemaphore lock;
+		size_t ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::jingle::MediaStream((hx::Object *)data->args.a0, true))->getTracks__fromC(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute getTracks__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void *snikket_attachment_source_new(const char *a0, const char *a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeObject(snikket::AttachmentSource_obj::__new(a0, a1));
+	}
+	struct Data {
+		struct {const char * a0; const char * a1;} args;
+		HxSemaphore lock;
+		void * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeObject(snikket::AttachmentSource_obj::__new(data->args.a0, data->args.a1));
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute new() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_attachment_source_path(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::AttachmentSource((hx::Object *)a0, true))->path__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::AttachmentSource((hx::Object *)data->args.a0, true))->path__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute path__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_attachment_source_type(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::AttachmentSource((hx::Object *)a0, true))->type__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::AttachmentSource((hx::Object *)data->args.a0, true))->type__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute type__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_attachment_source_name(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::AttachmentSource((hx::Object *)a0, true))->name__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::AttachmentSource((hx::Object *)data->args.a0, true))->name__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute name__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+int snikket_attachment_source_size(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::AttachmentSource((hx::Object *)a0, true))->size__fromC();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		int ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::AttachmentSource((hx::Object *)data->args.a0, true))->size__fromC();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute size__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_participant_display_name(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::Participant((hx::Object *)a0, true))->displayName__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::Participant((hx::Object *)data->args.a0, true))->displayName__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute displayName__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_participant_photo_uri(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::Participant((hx::Object *)a0, true))->photoUri__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::Participant((hx::Object *)data->args.a0, true))->photoUri__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute photoUri__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_participant_placeholder_uri(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::Participant((hx::Object *)a0, true))->placeholderUri__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::Participant((hx::Object *)data->args.a0, true))->placeholderUri__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute placeholderUri__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+bool snikket_participant_is_self(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Participant((hx::Object *)a0, true))->isSelf__fromC();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		bool ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::Participant((hx::Object *)data->args.a0, true))->isSelf__fromC();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute isSelf__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+bool snikket_channel_is_private(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::Channel((hx::Object *)a0, true))->isPrivate();
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		bool ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = (snikket::Channel((hx::Object *)data->args.a0, true))->isPrivate();
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute isPrivate() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_reaction_sender_id(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::Reaction((hx::Object *)a0, true))->senderId__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::Reaction((hx::Object *)data->args.a0, true))->senderId__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute senderId__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_reaction_timestamp(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::Reaction((hx::Object *)a0, true))->timestamp__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::Reaction((hx::Object *)data->args.a0, true))->timestamp__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute timestamp__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_reaction_text(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::Reaction((hx::Object *)a0, true))->text__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::Reaction((hx::Object *)data->args.a0, true))->text__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute text__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_reaction_key(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::Reaction((hx::Object *)a0, true))->key__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::Reaction((hx::Object *)data->args.a0, true))->key__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute key__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_reaction_envelope_id(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::Reaction((hx::Object *)a0, true))->envelopeId__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::Reaction((hx::Object *)data->args.a0, true))->envelopeId__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute envelopeId__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+const char *snikket_custom_emoji_reaction_uri(void *a0) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return HaxeCBridge::retainHaxeString((snikket::CustomEmojiReaction((hx::Object *)a0, true))->uri__fromC());
+	}
+	struct Data {
+		struct {void * a0;} args;
+		HxSemaphore lock;
+		const char * ret;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				data->ret = HaxeCBridge::retainHaxeString((snikket::CustomEmojiReaction((hx::Object *)data->args.a0, true))->uri__fromC());
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0} };
+
+	// queue a callback to execute uri__fromC() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+	return data.ret;
+}
+
+HAXE_C_BRIDGE_LINKAGE
+void snikket_jingle_dtmf_sender_insert_dtmf(void *a0, const char *a1) {
+	if (HaxeCBridgeInternal::isHaxeMainThread()) {
+		return (snikket::jingle::DTMFSender((hx::Object *)a0, true))->insertDTMF(a1);
+	}
+	struct Data {
+		struct {void * a0; const char * a1;} args;
+		HxSemaphore lock;
+	};
+	struct Callback {
+		static void run(void* p) {
+			// executed within the haxe main thread
+			Data* data = (Data*) p;
+			try {
+				(snikket::jingle::DTMFSender((hx::Object *)data->args.a0, true))->insertDTMF(data->args.a1);
+				data->lock.Set();
+			} catch(Dynamic runtimeException) {
+				data->lock.Set();
+				throw runtimeException;
+			}
+		}
+	};
+
+	#ifdef HXCPP_DEBUG
+	assert(HaxeCBridgeInternal::threadRunning && "haxe thread not running, use snikket_initializeHaxeThread() to activate the haxe thread");
+	#endif
+
+	Data data = { {a0, a1} };
+
+	// queue a callback to execute insertDTMF() on the main thread and wait until execution completes
+	HaxeCBridgeInternal::runInMainThread(Callback::run, &data);
+	data.lock.Wait();
+}
+
diff --git a/Sources/c_snikket/src/__boot__.cpp b/Sources/c_snikket/src/__boot__.cpp
new file mode 100644
index 0000000..7ce0df6
--- /dev/null
+++ b/Sources/c_snikket/src/__boot__.cpp
@@ -0,0 +1,1355 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_tink_streams_Step
+#include <tink/streams/Step.h>
+#endif
+#ifndef INCLUDED_tink_streams_Reduction
+#include <tink/streams/Reduction.h>
+#endif
+#ifndef INCLUDED_tink_streams_ReductionStep
+#include <tink/streams/ReductionStep.h>
+#endif
+#ifndef INCLUDED_tink_streams_Conclusion
+#include <tink/streams/Conclusion.h>
+#endif
+#ifndef INCLUDED_tink_streams_Handled
+#include <tink/streams/Handled.h>
+#endif
+#ifndef INCLUDED_tink_streams_RegroupResult
+#include <tink/streams/RegroupResult.h>
+#endif
+#ifndef INCLUDED_tink_streams_RegroupStatus
+#include <tink/streams/RegroupStatus.h>
+#endif
+#ifndef INCLUDED_tink_io_ParseResult
+#include <tink/io/ParseResult.h>
+#endif
+#ifndef INCLUDED_tink_io_PipeResult
+#include <tink/io/PipeResult.h>
+#endif
+#ifndef INCLUDED_tink_http_BodyPart
+#include <tink/http/BodyPart.h>
+#endif
+#ifndef INCLUDED_tink_http_IncomingRequestBody
+#include <tink/http/IncomingRequestBody.h>
+#endif
+#ifndef INCLUDED_tink_io_ParseStep
+#include <tink/io/ParseStep.h>
+#endif
+#ifndef INCLUDED_tink_http_ClientType
+#include <tink/http/ClientType.h>
+#endif
+#ifndef INCLUDED_tink_core_Outcome
+#include <tink/core/Outcome.h>
+#endif
+#ifndef INCLUDED_tink_core_FutureStatus
+#include <tink/core/FutureStatus.h>
+#endif
+#ifndef INCLUDED_thenshim_fallback_PromiseState
+#include <thenshim/fallback/PromiseState.h>
+#endif
+#ifndef INCLUDED_snikket_IqRequestType
+#include <snikket/IqRequestType.h>
+#endif
+#ifndef INCLUDED_snikket_Node
+#include <snikket/Node.h>
+#endif
+#ifndef INCLUDED_snikket_MessageStanza
+#include <snikket/MessageStanza.h>
+#endif
+#ifndef INCLUDED_snikket_IqResult
+#include <snikket/IqResult.h>
+#endif
+#ifndef INCLUDED_snikket_EventResult
+#include <snikket/EventResult.h>
+#endif
+#ifndef INCLUDED_hx_strings_internal__Either2__Either2
+#include <hx/strings/internal/_Either2/_Either2.h>
+#endif
+#ifndef INCLUDED_haxe_io_Error
+#include <haxe/io/Error.h>
+#endif
+#ifndef INCLUDED_haxe_io_Encoding
+#include <haxe/io/Encoding.h>
+#endif
+#ifndef INCLUDED_haxe_ds_Option
+#include <haxe/ds/Option.h>
+#endif
+#ifndef INCLUDED_haxe_ds_Either
+#include <haxe/ds/Either.h>
+#endif
+#ifndef INCLUDED_haxe_StackItem
+#include <haxe/StackItem.h>
+#endif
+#ifndef INCLUDED_ValueType
+#include <ValueType.h>
+#endif
+#ifndef INCLUDED_tink_io__Worker_Worker_Impl_
+#include <tink/io/_Worker/Worker_Impl_.h>
+#endif
+#ifndef INCLUDED_tink_io__Source_Source_Impl_
+#include <tink/io/_Source/Source_Impl_.h>
+#endif
+#ifndef INCLUDED_tink_streams_Empty
+#include <tink/streams/Empty.h>
+#endif
+#ifndef INCLUDED_tink_http_Fetch
+#include <tink/http/Fetch.h>
+#endif
+#ifndef INCLUDED_tink_core__Future_Future_Impl_
+#include <tink/core/_Future/Future_Impl_.h>
+#endif
+#ifndef INCLUDED_tink_core__Callback_Callback_Impl_
+#include <tink/core/_Callback/Callback_Impl_.h>
+#endif
+#ifndef INCLUDED_tink__Chunk_Chunk_Impl_
+#include <tink/_Chunk/Chunk_Impl_.h>
+#endif
+#ifndef INCLUDED_tink__Chunk_EmptyChunk
+#include <tink/_Chunk/EmptyChunk.h>
+#endif
+#ifndef INCLUDED_thenshim__Promise_Promise_Impl_
+#include <thenshim/_Promise/Promise_Impl_.h>
+#endif
+#ifndef INCLUDED_sys_ssl_Socket
+#include <sys/ssl/Socket.h>
+#endif
+#ifndef INCLUDED_sys_ssl_Key
+#include <sys/ssl/Key.h>
+#endif
+#ifndef INCLUDED_sys_ssl_Certificate
+#include <sys/ssl/Certificate.h>
+#endif
+#ifndef INCLUDED_sys_net_Host
+#include <sys/net/Host.h>
+#endif
+#ifndef INCLUDED_sys_Http
+#include <sys/Http.h>
+#endif
+#ifndef INCLUDED_snikket_persistence_Sqlite
+#include <snikket/persistence/Sqlite.h>
+#endif
+#ifndef INCLUDED_snikket_persistence_MediaStoreFS
+#include <snikket/persistence/MediaStoreFS.h>
+#endif
+#ifndef INCLUDED_snikket_persistence_Dummy
+#include <snikket/persistence/Dummy.h>
+#endif
+#ifndef INCLUDED_snikket_jingle_InitiatedSession
+#include <snikket/jingle/InitiatedSession.h>
+#endif
+#ifndef INCLUDED_snikket_jingle_MediaStream
+#include <snikket/jingle/MediaStream.h>
+#endif
+#ifndef INCLUDED_snikket_jingle_MediaStreamTrack
+#include <snikket/jingle/MediaStreamTrack.h>
+#endif
+#ifndef INCLUDED_snikket_jingle_AudioFormat
+#include <snikket/jingle/AudioFormat.h>
+#endif
+#ifndef INCLUDED_snikket_jingle_DTMFSender
+#include <snikket/jingle/DTMFSender.h>
+#endif
+#ifndef INCLUDED_snikket_CustomEmojiReaction
+#include <snikket/CustomEmojiReaction.h>
+#endif
+#ifndef INCLUDED_snikket_Reaction
+#include <snikket/Reaction.h>
+#endif
+#ifndef INCLUDED_snikket_Persistence
+#include <snikket/Persistence.h>
+#endif
+#ifndef INCLUDED_snikket_Participant
+#include <snikket/Participant.h>
+#endif
+#ifndef INCLUDED_snikket_Hash
+#include <snikket/Hash.h>
+#endif
+#ifndef INCLUDED_snikket_EmojiUtil
+#include <snikket/EmojiUtil.h>
+#endif
+#ifndef INCLUDED_snikket_Config
+#include <snikket/Config.h>
+#endif
+#ifndef INCLUDED_snikket_Client
+#include <snikket/Client.h>
+#endif
+#ifndef INCLUDED_snikket_ChatMessageBuilder
+#include <snikket/ChatMessageBuilder.h>
+#endif
+#ifndef INCLUDED_snikket_ChatMessage
+#include <snikket/ChatMessage.h>
+#endif
+#ifndef INCLUDED_snikket_ChatAttachment
+#include <snikket/ChatAttachment.h>
+#endif
+#ifndef INCLUDED_snikket_AvailableChat
+#include <snikket/AvailableChat.h>
+#endif
+#ifndef INCLUDED_snikket_Channel
+#include <snikket/Channel.h>
+#endif
+#ifndef INCLUDED_snikket_DirectChat
+#include <snikket/DirectChat.h>
+#endif
+#ifndef INCLUDED_snikket_Chat
+#include <snikket/Chat.h>
+#endif
+#ifndef INCLUDED_snikket_Autolink
+#include <snikket/Autolink.h>
+#endif
+#ifndef INCLUDED_snikket_AttachmentSource
+#include <snikket/AttachmentSource.h>
+#endif
+#ifndef INCLUDED_sha__SHA256_SHA256_Fields_
+#include <sha/_SHA256/SHA256_Fields_.h>
+#endif
+#ifndef INCLUDED_hx_strings_StringBuilder
+#include <hx/strings/StringBuilder.h>
+#endif
+#ifndef INCLUDED_hx_strings_RandomStrings
+#include <hx/strings/RandomStrings.h>
+#endif
+#ifndef INCLUDED_htmlparser_HtmlParser
+#include <htmlparser/HtmlParser.h>
+#endif
+#ifndef INCLUDED_hsluv_Hsluv
+#include <hsluv/Hsluv.h>
+#endif
+#ifndef INCLUDED_haxe_xml_Parser
+#include <haxe/xml/Parser.h>
+#endif
+#ifndef INCLUDED_haxe_crypto_Base64
+#include <haxe/crypto/Base64.h>
+#endif
+#ifndef INCLUDED_haxe_Log
+#include <haxe/Log.h>
+#endif
+#ifndef INCLUDED_sys_thread__Thread_HaxeThread
+#include <sys/thread/_Thread/HaxeThread.h>
+#endif
+#ifndef INCLUDED_Xml
+#include <Xml.h>
+#endif
+#ifndef INCLUDED__HaxeCBridge_Internal
+#include <_HaxeCBridge/Internal.h>
+#endif
+#ifndef INCLUDED_tink_url__Path_Path_Impl_
+#include <tink/url/_Path/Path_Impl_.h>
+#endif
+#ifndef INCLUDED_tink_url__Host_Host_Impl_
+#include <tink/url/_Host/Host_Impl_.h>
+#endif
+#ifndef INCLUDED_tink_streams_FutureStream
+#include <tink/streams/FutureStream.h>
+#endif
+#ifndef INCLUDED_tink_streams__Stream_Reducer_Impl_
+#include <tink/streams/_Stream/Reducer_Impl_.h>
+#endif
+#ifndef INCLUDED_tink_streams__Stream_Handler_Impl_
+#include <tink/streams/_Stream/Handler_Impl_.h>
+#endif
+#ifndef INCLUDED_tink_streams_Single
+#include <tink/streams/Single.h>
+#endif
+#ifndef INCLUDED_tink_streams_IdealizeStream
+#include <tink/streams/IdealizeStream.h>
+#endif
+#ifndef INCLUDED_tink_streams__Stream_ErrorStream
+#include <tink/streams/_Stream/ErrorStream.h>
+#endif
+#ifndef INCLUDED_tink_streams__Stream_RegroupStream
+#include <tink/streams/_Stream/RegroupStream.h>
+#endif
+#ifndef INCLUDED_tink_streams__Stream_CompoundStream
+#include <tink/streams/_Stream/CompoundStream.h>
+#endif
+#ifndef INCLUDED_tink_streams__Stream_Regrouper_Impl_
+#include <tink/streams/_Stream/Regrouper_Impl_.h>
+#endif
+#ifndef INCLUDED_tink_streams__Stream_Stream_Impl_
+#include <tink/streams/_Stream/Stream_Impl_.h>
+#endif
+#ifndef INCLUDED_tink_streams_IdealStreamBase
+#include <tink/streams/IdealStreamBase.h>
+#endif
+#ifndef INCLUDED_tink_io_std_OutputSink
+#include <tink/io/std/OutputSink.h>
+#endif
+#ifndef INCLUDED_tink_io_std_InputSource
+#include <tink/io/std/InputSource.h>
+#endif
+#ifndef INCLUDED_tink_streams_Generator
+#include <tink/streams/Generator.h>
+#endif
+#ifndef INCLUDED_tink_io__Worker_EagerWorker
+#include <tink/io/_Worker/EagerWorker.h>
+#endif
+#ifndef INCLUDED_tink_io_WorkerObject
+#include <tink/io/WorkerObject.h>
+#endif
+#ifndef INCLUDED_tink_io__StreamParser_StreamParser_Impl_
+#include <tink/io/_StreamParser/StreamParser_Impl_.h>
+#endif
+#ifndef INCLUDED_tink_io_IdealSourceTools
+#include <tink/io/IdealSourceTools.h>
+#endif
+#ifndef INCLUDED_tink_io_RealSourceTools
+#include <tink/io/RealSourceTools.h>
+#endif
+#ifndef INCLUDED_tink_streams_StreamBase
+#include <tink/streams/StreamBase.h>
+#endif
+#ifndef INCLUDED_tink_streams_StreamObject
+#include <tink/streams/StreamObject.h>
+#endif
+#ifndef INCLUDED_tink_io__Sink_SinkYielding_Impl_
+#include <tink/io/_Sink/SinkYielding_Impl_.h>
+#endif
+#ifndef INCLUDED_tink_io_SinkBase
+#include <tink/io/SinkBase.h>
+#endif
+#ifndef INCLUDED_tink_io_SinkObject
+#include <tink/io/SinkObject.h>
+#endif
+#ifndef INCLUDED_tink_io_PipeResultTools
+#include <tink/io/PipeResultTools.h>
+#endif
+#ifndef INCLUDED_tink_http_containers_LocalContainer
+#include <tink/http/containers/LocalContainer.h>
+#endif
+#ifndef INCLUDED_tink_http_clients_StdClient
+#include <tink/http/clients/StdClient.h>
+#endif
+#ifndef INCLUDED_tink_http_clients_SocketClient
+#include <tink/http/clients/SocketClient.h>
+#endif
+#ifndef INCLUDED_tink_http_clients_LocalContainerClient
+#include <tink/http/clients/LocalContainerClient.h>
+#endif
+#ifndef INCLUDED_tink_http_clients_Helpers
+#include <tink/http/clients/Helpers.h>
+#endif
+#ifndef INCLUDED_tink_http_clients_CurlClient
+#include <tink/http/clients/CurlClient.h>
+#endif
+#ifndef INCLUDED_tink_http_IncomingResponse
+#include <tink/http/IncomingResponse.h>
+#endif
+#ifndef INCLUDED_tink_http__Response_OutgoingResponseData
+#include <tink/http/_Response/OutgoingResponseData.h>
+#endif
+#ifndef INCLUDED_tink_http_ResponseHeaderBase
+#include <tink/http/ResponseHeaderBase.h>
+#endif
+#ifndef INCLUDED_tink_http_IncomingRequest
+#include <tink/http/IncomingRequest.h>
+#endif
+#ifndef INCLUDED_tink_http_OutgoingRequest
+#include <tink/http/OutgoingRequest.h>
+#endif
+#ifndef INCLUDED_tink_http_OutgoingRequestHeader
+#include <tink/http/OutgoingRequestHeader.h>
+#endif
+#ifndef INCLUDED_tink_http_IncomingRequestHeader
+#include <tink/http/IncomingRequestHeader.h>
+#endif
+#ifndef INCLUDED_tink_http_RequestHeader
+#include <tink/http/RequestHeader.h>
+#endif
+#ifndef INCLUDED_tink_http_Message
+#include <tink/http/Message.h>
+#endif
+#ifndef INCLUDED_tink_http_HeaderParser
+#include <tink/http/HeaderParser.h>
+#endif
+#ifndef INCLUDED_tink_io_BytewiseParser
+#include <tink/io/BytewiseParser.h>
+#endif
+#ifndef INCLUDED_tink_http_HeaderField
+#include <tink/http/HeaderField.h>
+#endif
+#ifndef INCLUDED_tink_http__Header_HeaderValue_Impl_
+#include <tink/http/_Header/HeaderValue_Impl_.h>
+#endif
+#ifndef INCLUDED_tink_http_Header
+#include <tink/http/Header.h>
+#endif
+#ifndef INCLUDED_tink_http_HandlerObject
+#include <tink/http/HandlerObject.h>
+#endif
+#ifndef INCLUDED_tink_http__Fetch_FetchResponse_Impl_
+#include <tink/http/_Fetch/FetchResponse_Impl_.h>
+#endif
+#ifndef INCLUDED_tink_http_Container
+#include <tink/http/Container.h>
+#endif
+#ifndef INCLUDED_tink_http__Client_CustomClient
+#include <tink/http/_Client/CustomClient.h>
+#endif
+#ifndef INCLUDED_tink_http_ClientObject
+#include <tink/http/ClientObject.h>
+#endif
+#ifndef INCLUDED_tink_io_StreamParserObject
+#include <tink/io/StreamParserObject.h>
+#endif
+#ifndef INCLUDED_tink_core__Promise_Promise_Impl_
+#include <tink/core/_Promise/Promise_Impl_.h>
+#endif
+#ifndef INCLUDED_tink_core_MPair
+#include <tink/core/MPair.h>
+#endif
+#ifndef INCLUDED_tink_core_NamedWith
+#include <tink/core/NamedWith.h>
+#endif
+#ifndef INCLUDED_tink_core__Lazy_LazyFunc
+#include <tink/core/_Lazy/LazyFunc.h>
+#endif
+#ifndef INCLUDED_tink_core__Lazy_Lazy_Impl_
+#include <tink/core/_Lazy/Lazy_Impl_.h>
+#endif
+#ifndef INCLUDED_tink_core__Future_SuspendableFuture
+#include <tink/core/_Future/SuspendableFuture.h>
+#endif
+#ifndef INCLUDED_tink_core__Future_SyncFuture
+#include <tink/core/_Future/SyncFuture.h>
+#endif
+#ifndef INCLUDED_tink_core__Lazy_LazyConst
+#include <tink/core/_Lazy/LazyConst.h>
+#endif
+#ifndef INCLUDED_tink_core__Lazy_LazyObject
+#include <tink/core/_Lazy/LazyObject.h>
+#endif
+#ifndef INCLUDED_tink_core__Lazy_Computable
+#include <tink/core/_Lazy/Computable.h>
+#endif
+#ifndef INCLUDED_tink_core__Future_FutureObject
+#include <tink/core/_Future/FutureObject.h>
+#endif
+#ifndef INCLUDED_tink_core_TypedError
+#include <tink/core/TypedError.h>
+#endif
+#ifndef INCLUDED_tink_core_CallbackList
+#include <tink/core/CallbackList.h>
+#endif
+#ifndef INCLUDED_tink_core_SimpleDisposable
+#include <tink/core/SimpleDisposable.h>
+#endif
+#ifndef INCLUDED_tink_core_OwnedDisposable
+#include <tink/core/OwnedDisposable.h>
+#endif
+#ifndef INCLUDED_tink_core_Disposable
+#include <tink/core/Disposable.h>
+#endif
+#ifndef INCLUDED_tink_core__Callback_ListCell
+#include <tink/core/_Callback/ListCell.h>
+#endif
+#ifndef INCLUDED_tink_core__Callback_LinkPair
+#include <tink/core/_Callback/LinkPair.h>
+#endif
+#ifndef INCLUDED_tink_core_CallbackLinkRef
+#include <tink/core/CallbackLinkRef.h>
+#endif
+#ifndef INCLUDED_tink_core_LinkObject
+#include <tink/core/LinkObject.h>
+#endif
+#ifndef INCLUDED_tink_chunk_CompoundChunk
+#include <tink/chunk/CompoundChunk.h>
+#endif
+#ifndef INCLUDED_tink_chunk_ChunkCursor
+#include <tink/chunk/ChunkCursor.h>
+#endif
+#ifndef INCLUDED_tink_chunk_ByteChunk
+#include <tink/chunk/ByteChunk.h>
+#endif
+#ifndef INCLUDED_tink__Url_Url_Impl_
+#include <tink/_Url/Url_Impl_.h>
+#endif
+#ifndef INCLUDED_tink_chunk_ChunkObject
+#include <tink/chunk/ChunkObject.h>
+#endif
+#ifndef INCLUDED_tink_chunk_ChunkBase
+#include <tink/chunk/ChunkBase.h>
+#endif
+#ifndef INCLUDED_thenshim_fallback_HandlerSession
+#include <thenshim/fallback/HandlerSession.h>
+#endif
+#ifndef INCLUDED_thenshim_fallback_FallbackPromise
+#include <thenshim/fallback/FallbackPromise.h>
+#endif
+#ifndef INCLUDED_thenshim_Thenable
+#include <thenshim/Thenable.h>
+#endif
+#ifndef INCLUDED_thenshim_PromiseTools
+#include <thenshim/PromiseTools.h>
+#endif
+#ifndef INCLUDED_thenshim_fallback_TaskScheduler
+#include <thenshim/fallback/TaskScheduler.h>
+#endif
+#ifndef INCLUDED_thenshim_fallback_FallbackPromiseFactory
+#include <thenshim/fallback/FallbackPromiseFactory.h>
+#endif
+#ifndef INCLUDED_thenshim_PromiseFactory
+#include <thenshim/PromiseFactory.h>
+#endif
+#ifndef INCLUDED_sys_thread__Thread_Thread_Impl_
+#include <sys/thread/_Thread/Thread_Impl_.h>
+#endif
+#ifndef INCLUDED_sys_thread_NoEventLoopException
+#include <sys/thread/NoEventLoopException.h>
+#endif
+#ifndef INCLUDED_sys_thread_Lock
+#include <sys/thread/Lock.h>
+#endif
+#ifndef INCLUDED_sys_thread__EventLoop_RegularEvent
+#include <sys/thread/_EventLoop/RegularEvent.h>
+#endif
+#ifndef INCLUDED_sys_ssl__Socket_SocketOutput
+#include <sys/ssl/_Socket/SocketOutput.h>
+#endif
+#ifndef INCLUDED_sys_ssl__Socket_SocketInput
+#include <sys/ssl/_Socket/SocketInput.h>
+#endif
+#ifndef INCLUDED_sys_net_Socket
+#include <sys/net/Socket.h>
+#endif
+#ifndef INCLUDED_sys_net__Socket_SocketOutput
+#include <sys/net/_Socket/SocketOutput.h>
+#endif
+#ifndef INCLUDED_sys_net__Socket_SocketInput
+#include <sys/net/_Socket/SocketInput.h>
+#endif
+#ifndef INCLUDED_sys_io_Process
+#include <sys/io/Process.h>
+#endif
+#ifndef INCLUDED_sys_io__Process_Stdout
+#include <sys/io/_Process/Stdout.h>
+#endif
+#ifndef INCLUDED_sys_io__Process_Stdin
+#include <sys/io/_Process/Stdin.h>
+#endif
+#ifndef INCLUDED_sys_io_FileOutput
+#include <sys/io/FileOutput.h>
+#endif
+#ifndef INCLUDED_sys_io_FileInput
+#include <sys/io/FileInput.h>
+#endif
+#ifndef INCLUDED_sys_io_File
+#include <sys/io/File.h>
+#endif
+#ifndef INCLUDED_sys_db_Sqlite
+#include <sys/db/Sqlite.h>
+#endif
+#ifndef INCLUDED_sys_db__Sqlite_SqliteResultSet
+#include <sys/db/_Sqlite/SqliteResultSet.h>
+#endif
+#ifndef INCLUDED_sys_db__Sqlite_SqliteConnection
+#include <sys/db/_Sqlite/SqliteConnection.h>
+#endif
+#ifndef INCLUDED_sys_db_ResultSet
+#include <sys/db/ResultSet.h>
+#endif
+#ifndef INCLUDED_sys_db_Connection
+#include <sys/db/Connection.h>
+#endif
+#ifndef INCLUDED_sys_FileSystem
+#include <sys/FileSystem.h>
+#endif
+#ifndef INCLUDED_snikket_streams_XmppStropheStream
+#include <snikket/streams/XmppStropheStream.h>
+#endif
+#ifndef INCLUDED_snikket_queries_VcardTempGet
+#include <snikket/queries/VcardTempGet.h>
+#endif
+#ifndef INCLUDED_snikket_queries_RosterGet
+#include <snikket/queries/RosterGet.h>
+#endif
+#ifndef INCLUDED_snikket_queries_Push2Disable
+#include <snikket/queries/Push2Disable.h>
+#endif
+#ifndef INCLUDED_snikket_queries_PubsubGet
+#include <snikket/queries/PubsubGet.h>
+#endif
+#ifndef INCLUDED_snikket_queries_MAMQuery
+#include <snikket/queries/MAMQuery.h>
+#endif
+#ifndef INCLUDED_snikket_queries_JabberIqGatewayGet
+#include <snikket/queries/JabberIqGatewayGet.h>
+#endif
+#ifndef INCLUDED_snikket_queries_HttpUploadSlot
+#include <snikket/queries/HttpUploadSlot.h>
+#endif
+#ifndef INCLUDED_snikket_queries_ExtDiscoGet
+#include <snikket/queries/ExtDiscoGet.h>
+#endif
+#ifndef INCLUDED_snikket_queries_DiscoItemsGet
+#include <snikket/queries/DiscoItemsGet.h>
+#endif
+#ifndef INCLUDED_snikket_queries_DiscoInfoGet
+#include <snikket/queries/DiscoInfoGet.h>
+#endif
+#ifndef INCLUDED_snikket_queries_BoB
+#include <snikket/queries/BoB.h>
+#endif
+#ifndef INCLUDED_snikket_queries_BlocklistGet
+#include <snikket/queries/BlocklistGet.h>
+#endif
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#include <snikket/queries/GenericQuery.h>
+#endif
+#ifndef INCLUDED_snikket_persistence_SqliteDriver
+#include <snikket/persistence/SqliteDriver.h>
+#endif
+#ifndef INCLUDED_snikket_persistence_MediaStore
+#include <snikket/persistence/MediaStore.h>
+#endif
+#ifndef INCLUDED_snikket_persistence_KeyValueStore
+#include <snikket/persistence/KeyValueStore.h>
+#endif
+#ifndef INCLUDED_snikket_jingle_Attribute
+#include <snikket/jingle/Attribute.h>
+#endif
+#ifndef INCLUDED_snikket_jingle_IceCandidate
+#include <snikket/jingle/IceCandidate.h>
+#endif
+#ifndef INCLUDED_snikket_jingle_Media
+#include <snikket/jingle/Media.h>
+#endif
+#ifndef INCLUDED_snikket_jingle_TransportInfo
+#include <snikket/jingle/TransportInfo.h>
+#endif
+#ifndef INCLUDED_snikket_jingle_SessionDescription
+#include <snikket/jingle/SessionDescription.h>
+#endif
+#ifndef INCLUDED_snikket_jingle__Session_Session_Fields_
+#include <snikket/jingle/_Session/Session_Fields_.h>
+#endif
+#ifndef INCLUDED_snikket_jingle_OutgoingSession
+#include <snikket/jingle/OutgoingSession.h>
+#endif
+#ifndef INCLUDED_snikket_jingle_OutgoingProposedSession
+#include <snikket/jingle/OutgoingProposedSession.h>
+#endif
+#ifndef INCLUDED_snikket_jingle_IncomingProposedSession
+#include <snikket/jingle/IncomingProposedSession.h>
+#endif
+#ifndef INCLUDED_snikket_jingle_Session
+#include <snikket/jingle/Session.h>
+#endif
+#ifndef INCLUDED_snikket_jingle_PeerConnection
+#include <snikket/jingle/PeerConnection.h>
+#endif
+#ifndef INCLUDED_snikket_jingle_Group
+#include <snikket/jingle/Group.h>
+#endif
+#ifndef INCLUDED_snikket_XEP0393
+#include <snikket/XEP0393.h>
+#endif
+#ifndef INCLUDED_snikket__Util_Util_Fields_
+#include <snikket/_Util/Util_Fields_.h>
+#endif
+#ifndef INCLUDED_snikket_StringUtil
+#include <snikket/StringUtil.h>
+#endif
+#ifndef INCLUDED_snikket_Stanza
+#include <snikket/Stanza.h>
+#endif
+#ifndef INCLUDED_snikket_StanzaError
+#include <snikket/StanzaError.h>
+#endif
+#ifndef INCLUDED_snikket_TextNode
+#include <snikket/TextNode.h>
+#endif
+#ifndef INCLUDED_snikket__Stanza_NodeInterface
+#include <snikket/_Stanza/NodeInterface.h>
+#endif
+#ifndef INCLUDED_snikket_ReactionUpdate
+#include <snikket/ReactionUpdate.h>
+#endif
+#ifndef INCLUDED_snikket__Push_Push_Fields_
+#include <snikket/_Push/Push_Fields_.h>
+#endif
+#ifndef INCLUDED_snikket_PubsubEvent
+#include <snikket/PubsubEvent.h>
+#endif
+#ifndef INCLUDED_snikket_Presence
+#include <snikket/Presence.h>
+#endif
+#ifndef INCLUDED_snikket_Notification
+#include <snikket/Notification.h>
+#endif
+#ifndef INCLUDED_snikket_ModerationAction
+#include <snikket/ModerationAction.h>
+#endif
+#ifndef INCLUDED_snikket_MessageSync
+#include <snikket/MessageSync.h>
+#endif
+#ifndef INCLUDED_snikket_Message
+#include <snikket/Message.h>
+#endif
+#ifndef INCLUDED_snikket_JID
+#include <snikket/JID.h>
+#endif
+#ifndef INCLUDED_snikket_Identicon
+#include <snikket/Identicon.h>
+#endif
+#ifndef INCLUDED_snikket_ID
+#include <snikket/ID.h>
+#endif
+#ifndef INCLUDED_snikket_GenericStream
+#include <snikket/GenericStream.h>
+#endif
+#ifndef INCLUDED_snikket_EventHandler
+#include <snikket/EventHandler.h>
+#endif
+#ifndef INCLUDED_snikket_Builder
+#include <snikket/Builder.h>
+#endif
+#ifndef INCLUDED_snikket_Other
+#include <snikket/Other.h>
+#endif
+#ifndef INCLUDED_snikket_Emoji
+#include <snikket/Emoji.h>
+#endif
+#ifndef INCLUDED_snikket_Symbol
+#include <snikket/Symbol.h>
+#endif
+#ifndef INCLUDED_snikket_UnicodeBlocks
+#include <snikket/UnicodeBlocks.h>
+#endif
+#ifndef INCLUDED_snikket_UnicodeRange
+#include <snikket/UnicodeRange.h>
+#endif
+#ifndef INCLUDED_snikket_UnicodeList
+#include <snikket/UnicodeList.h>
+#endif
+#ifndef INCLUDED_snikket_UnicodeSet
+#include <snikket/UnicodeSet.h>
+#endif
+#ifndef INCLUDED_snikket_Date
+#include <snikket/Date.h>
+#endif
+#ifndef INCLUDED_snikket_Color
+#include <snikket/Color.h>
+#endif
+#ifndef INCLUDED_snikket_EventEmitter
+#include <snikket/EventEmitter.h>
+#endif
+#ifndef INCLUDED_snikket_SerializedChat
+#include <snikket/SerializedChat.h>
+#endif
+#ifndef INCLUDED_snikket_Identity
+#include <snikket/Identity.h>
+#endif
+#ifndef INCLUDED_snikket_Caps
+#include <snikket/Caps.h>
+#endif
+#ifndef INCLUDED_sha_SHA256
+#include <sha/SHA256.h>
+#endif
+#ifndef INCLUDED_sha_Hash
+#include <sha/Hash.h>
+#endif
+#ifndef INCLUDED_hx_strings_Strings
+#include <hx/strings/Strings.h>
+#endif
+#ifndef INCLUDED_httpstatus__HttpStatusMessage_HttpStatusMessage_Impl_
+#include <httpstatus/_HttpStatusMessage/HttpStatusMessage_Impl_.h>
+#endif
+#ifndef INCLUDED_htmlparser_HtmlTools
+#include <htmlparser/HtmlTools.h>
+#endif
+#ifndef INCLUDED_htmlparser_HtmlParserException
+#include <htmlparser/HtmlParserException.h>
+#endif
+#ifndef INCLUDED_htmlparser_HtmlNodeText
+#include <htmlparser/HtmlNodeText.h>
+#endif
+#ifndef INCLUDED_htmlparser_HtmlNodeElement
+#include <htmlparser/HtmlNodeElement.h>
+#endif
+#ifndef INCLUDED_htmlparser_HtmlNode
+#include <htmlparser/HtmlNode.h>
+#endif
+#ifndef INCLUDED_htmlparser_HtmlAttribute
+#include <htmlparser/HtmlAttribute.h>
+#endif
+#ifndef INCLUDED_haxe_xml_Printer
+#include <haxe/xml/Printer.h>
+#endif
+#ifndef INCLUDED_haxe_xml_XmlParserException
+#include <haxe/xml/XmlParserException.h>
+#endif
+#ifndef INCLUDED_haxe_iterators_MapKeyValueIterator
+#include <haxe/iterators/MapKeyValueIterator.h>
+#endif
+#ifndef INCLUDED_haxe_iterators_ArrayIterator
+#include <haxe/iterators/ArrayIterator.h>
+#endif
+#ifndef INCLUDED_haxe_io_Path
+#include <haxe/io/Path.h>
+#endif
+#ifndef INCLUDED_haxe_io_Eof
+#include <haxe/io/Eof.h>
+#endif
+#ifndef INCLUDED_haxe_io_BytesOutput
+#include <haxe/io/BytesOutput.h>
+#endif
+#ifndef INCLUDED_haxe_io_Output
+#include <haxe/io/Output.h>
+#endif
+#ifndef INCLUDED_haxe_io_BytesInput
+#include <haxe/io/BytesInput.h>
+#endif
+#ifndef INCLUDED_haxe_io_Input
+#include <haxe/io/Input.h>
+#endif
+#ifndef INCLUDED_haxe_io_BytesBuffer
+#include <haxe/io/BytesBuffer.h>
+#endif
+#ifndef INCLUDED_haxe_http_HttpBase
+#include <haxe/http/HttpBase.h>
+#endif
+#ifndef INCLUDED_haxe_format_JsonPrinter
+#include <haxe/format/JsonPrinter.h>
+#endif
+#ifndef INCLUDED_haxe_format_JsonParser
+#include <haxe/format/JsonParser.h>
+#endif
+#ifndef INCLUDED_haxe_exceptions_NotImplementedException
+#include <haxe/exceptions/NotImplementedException.h>
+#endif
+#ifndef INCLUDED_haxe_exceptions_PosException
+#include <haxe/exceptions/PosException.h>
+#endif
+#ifndef INCLUDED_haxe_ds_StringMap
+#include <haxe/ds/StringMap.h>
+#endif
+#ifndef INCLUDED_haxe_ds_ObjectMap
+#include <haxe/ds/ObjectMap.h>
+#endif
+#ifndef INCLUDED_haxe_ds__List_ListNode
+#include <haxe/ds/_List/ListNode.h>
+#endif
+#ifndef INCLUDED_haxe_ds_List
+#include <haxe/ds/List.h>
+#endif
+#ifndef INCLUDED_haxe_ds_IntMap
+#include <haxe/ds/IntMap.h>
+#endif
+#ifndef INCLUDED_haxe_ds_EnumValueMap
+#include <haxe/ds/EnumValueMap.h>
+#endif
+#ifndef INCLUDED_haxe_ds_TreeNode
+#include <haxe/ds/TreeNode.h>
+#endif
+#ifndef INCLUDED_haxe_ds_BalancedTree
+#include <haxe/ds/BalancedTree.h>
+#endif
+#ifndef INCLUDED_haxe_crypto_Sha256
+#include <haxe/crypto/Sha256.h>
+#endif
+#ifndef INCLUDED_haxe_crypto_Sha1
+#include <haxe/crypto/Sha1.h>
+#endif
+#ifndef INCLUDED_haxe_crypto_BaseCode
+#include <haxe/crypto/BaseCode.h>
+#endif
+#ifndef INCLUDED_haxe_io_Bytes
+#include <haxe/io/Bytes.h>
+#endif
+#ifndef INCLUDED_haxe_ValueException
+#include <haxe/ValueException.h>
+#endif
+#ifndef INCLUDED_haxe_Timer
+#include <haxe/Timer.h>
+#endif
+#ifndef INCLUDED_haxe_NativeStackTrace
+#include <haxe/NativeStackTrace.h>
+#endif
+#ifndef INCLUDED_haxe_MainLoop
+#include <haxe/MainLoop.h>
+#endif
+#ifndef INCLUDED_haxe_MainEvent
+#include <haxe/MainEvent.h>
+#endif
+#ifndef INCLUDED_haxe_Exception
+#include <haxe/Exception.h>
+#endif
+#ifndef INCLUDED_haxe_EntryPoint
+#include <haxe/EntryPoint.h>
+#endif
+#ifndef INCLUDED_sys_thread_EventLoop
+#include <sys/thread/EventLoop.h>
+#endif
+#ifndef INCLUDED_sys_thread_Mutex
+#include <sys/thread/Mutex.h>
+#endif
+#ifndef INCLUDED_datetime_utils_DateTimeUtils
+#include <datetime/utils/DateTimeUtils.h>
+#endif
+#ifndef INCLUDED_datetime_utils_DateTimeMonthUtils
+#include <datetime/utils/DateTimeMonthUtils.h>
+#endif
+#ifndef INCLUDED_datetime_utils_DateTimeIntervalUtils
+#include <datetime/utils/DateTimeIntervalUtils.h>
+#endif
+#ifndef INCLUDED_datetime_cores_DateTimeIntervalCore
+#include <datetime/cores/DateTimeIntervalCore.h>
+#endif
+#ifndef INCLUDED_datetime__DateTimeInterval_DateTimeInterval_Impl_
+#include <datetime/_DateTimeInterval/DateTimeInterval_Impl_.h>
+#endif
+#ifndef INCLUDED_datetime__DateTime_DateTime_Impl_
+#include <datetime/_DateTime/DateTime_Impl_.h>
+#endif
+#ifndef INCLUDED_cpp_Lib
+#include <cpp/Lib.h>
+#endif
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+#ifndef INCLUDED__Xml_XmlType_Impl_
+#include <_Xml/XmlType_Impl_.h>
+#endif
+#ifndef INCLUDED__UnicodeString_UnicodeString_Impl_
+#include <_UnicodeString/UnicodeString_Impl_.h>
+#endif
+#ifndef INCLUDED_Type
+#include <Type.h>
+#endif
+#ifndef INCLUDED_Sys
+#include <Sys.h>
+#endif
+#ifndef INCLUDED_StringTools
+#include <StringTools.h>
+#endif
+#ifndef INCLUDED_StringBuf
+#include <StringBuf.h>
+#endif
+#ifndef INCLUDED_Std
+#include <Std.h>
+#endif
+#ifndef INCLUDED_Reflect
+#include <Reflect.h>
+#endif
+#ifndef INCLUDED_Lambda
+#include <Lambda.h>
+#endif
+#ifndef INCLUDED__HaxeCBridge_Int64Map_Impl_
+#include <_HaxeCBridge/Int64Map_Impl_.h>
+#endif
+#ifndef INCLUDED_EReg
+#include <EReg.h>
+#endif
+#ifndef INCLUDED_Date
+#include <Date.h>
+#endif
+
+void __files__boot();
+
+void __boot_all()
+{
+__files__boot();
+::hx::RegisterResources( ::hx::GetResources() );
+::tink::streams::Step_obj::__register();
+::tink::streams::Reduction_obj::__register();
+::tink::streams::ReductionStep_obj::__register();
+::tink::streams::Conclusion_obj::__register();
+::tink::streams::Handled_obj::__register();
+::tink::streams::RegroupResult_obj::__register();
+::tink::streams::RegroupStatus_obj::__register();
+::tink::io::ParseResult_obj::__register();
+::tink::io::PipeResult_obj::__register();
+::tink::http::BodyPart_obj::__register();
+::tink::http::IncomingRequestBody_obj::__register();
+::tink::io::ParseStep_obj::__register();
+::tink::http::ClientType_obj::__register();
+::tink::core::Outcome_obj::__register();
+::tink::core::FutureStatus_obj::__register();
+::thenshim::fallback::PromiseState_obj::__register();
+::snikket::IqRequestType_obj::__register();
+::snikket::Node_obj::__register();
+::snikket::MessageStanza_obj::__register();
+::snikket::IqResult_obj::__register();
+::snikket::EventResult_obj::__register();
+::hx::strings::internal::_Either2::_Either2_obj::__register();
+::haxe::io::Error_obj::__register();
+::haxe::io::Encoding_obj::__register();
+::haxe::ds::Option_obj::__register();
+::haxe::ds::Either_obj::__register();
+::haxe::StackItem_obj::__register();
+::ValueType_obj::__register();
+::tink::io::_Worker::Worker_Impl__obj::__register();
+::tink::io::_Source::Source_Impl__obj::__register();
+::tink::streams::Empty_obj::__register();
+::tink::http::Fetch_obj::__register();
+::tink::core::_Future::Future_Impl__obj::__register();
+::tink::core::_Callback::Callback_Impl__obj::__register();
+::tink::_Chunk::Chunk_Impl__obj::__register();
+::tink::_Chunk::EmptyChunk_obj::__register();
+::thenshim::_Promise::Promise_Impl__obj::__register();
+::sys::ssl::Socket_obj::__register();
+::sys::ssl::Key_obj::__register();
+::sys::ssl::Certificate_obj::__register();
+::sys::net::Host_obj::__register();
+::sys::Http_obj::__register();
+::snikket::persistence::Sqlite_obj::__register();
+::snikket::persistence::MediaStoreFS_obj::__register();
+::snikket::persistence::Dummy_obj::__register();
+::snikket::jingle::InitiatedSession_obj::__register();
+::snikket::jingle::MediaStream_obj::__register();
+::snikket::jingle::MediaStreamTrack_obj::__register();
+::snikket::jingle::AudioFormat_obj::__register();
+::snikket::jingle::DTMFSender_obj::__register();
+::snikket::CustomEmojiReaction_obj::__register();
+::snikket::Reaction_obj::__register();
+::snikket::Persistence_obj::__register();
+::snikket::Participant_obj::__register();
+::snikket::Hash_obj::__register();
+::snikket::EmojiUtil_obj::__register();
+::snikket::Config_obj::__register();
+::snikket::Client_obj::__register();
+::snikket::ChatMessageBuilder_obj::__register();
+::snikket::ChatMessage_obj::__register();
+::snikket::ChatAttachment_obj::__register();
+::snikket::AvailableChat_obj::__register();
+::snikket::Channel_obj::__register();
+::snikket::DirectChat_obj::__register();
+::snikket::Chat_obj::__register();
+::snikket::Autolink_obj::__register();
+::snikket::AttachmentSource_obj::__register();
+::sha::_SHA256::SHA256_Fields__obj::__register();
+::hx::strings::StringBuilder_obj::__register();
+::hx::strings::RandomStrings_obj::__register();
+::htmlparser::HtmlParser_obj::__register();
+::hsluv::Hsluv_obj::__register();
+::haxe::xml::Parser_obj::__register();
+::haxe::crypto::Base64_obj::__register();
+::haxe::Log_obj::__register();
+::sys::thread::_Thread::HaxeThread_obj::__register();
+::Xml_obj::__register();
+::_HaxeCBridge::Internal_obj::__register();
+::tink::url::_Path::Path_Impl__obj::__register();
+::tink::url::_Host::Host_Impl__obj::__register();
+::tink::streams::FutureStream_obj::__register();
+::tink::streams::_Stream::Reducer_Impl__obj::__register();
+::tink::streams::_Stream::Handler_Impl__obj::__register();
+::tink::streams::Single_obj::__register();
+::tink::streams::IdealizeStream_obj::__register();
+::tink::streams::_Stream::ErrorStream_obj::__register();
+::tink::streams::_Stream::RegroupStream_obj::__register();
+::tink::streams::_Stream::CompoundStream_obj::__register();
+::tink::streams::_Stream::Regrouper_Impl__obj::__register();
+::tink::streams::_Stream::Stream_Impl__obj::__register();
+::tink::streams::IdealStreamBase_obj::__register();
+::tink::io::std::OutputSink_obj::__register();
+::tink::io::std::InputSource_obj::__register();
+::tink::streams::Generator_obj::__register();
+::tink::io::_Worker::EagerWorker_obj::__register();
+::tink::io::WorkerObject_obj::__register();
+::tink::io::_StreamParser::StreamParser_Impl__obj::__register();
+::tink::io::IdealSourceTools_obj::__register();
+::tink::io::RealSourceTools_obj::__register();
+::tink::streams::StreamBase_obj::__register();
+::tink::streams::StreamObject_obj::__register();
+::tink::io::_Sink::SinkYielding_Impl__obj::__register();
+::tink::io::SinkBase_obj::__register();
+::tink::io::SinkObject_obj::__register();
+::tink::io::PipeResultTools_obj::__register();
+::tink::http::containers::LocalContainer_obj::__register();
+::tink::http::clients::StdClient_obj::__register();
+::tink::http::clients::SocketClient_obj::__register();
+::tink::http::clients::LocalContainerClient_obj::__register();
+::tink::http::clients::Helpers_obj::__register();
+::tink::http::clients::CurlClient_obj::__register();
+::tink::http::IncomingResponse_obj::__register();
+::tink::http::_Response::OutgoingResponseData_obj::__register();
+::tink::http::ResponseHeaderBase_obj::__register();
+::tink::http::IncomingRequest_obj::__register();
+::tink::http::OutgoingRequest_obj::__register();
+::tink::http::OutgoingRequestHeader_obj::__register();
+::tink::http::IncomingRequestHeader_obj::__register();
+::tink::http::RequestHeader_obj::__register();
+::tink::http::Message_obj::__register();
+::tink::http::HeaderParser_obj::__register();
+::tink::io::BytewiseParser_obj::__register();
+::tink::http::HeaderField_obj::__register();
+::tink::http::_Header::HeaderValue_Impl__obj::__register();
+::tink::http::Header_obj::__register();
+::tink::http::HandlerObject_obj::__register();
+::tink::http::_Fetch::FetchResponse_Impl__obj::__register();
+::tink::http::Container_obj::__register();
+::tink::http::_Client::CustomClient_obj::__register();
+::tink::http::ClientObject_obj::__register();
+::tink::io::StreamParserObject_obj::__register();
+::tink::core::_Promise::Promise_Impl__obj::__register();
+::tink::core::MPair_obj::__register();
+::tink::core::NamedWith_obj::__register();
+::tink::core::_Lazy::LazyFunc_obj::__register();
+::tink::core::_Lazy::Lazy_Impl__obj::__register();
+::tink::core::_Future::SuspendableFuture_obj::__register();
+::tink::core::_Future::SyncFuture_obj::__register();
+::tink::core::_Lazy::LazyConst_obj::__register();
+::tink::core::_Lazy::LazyObject_obj::__register();
+::tink::core::_Lazy::Computable_obj::__register();
+::tink::core::_Future::FutureObject_obj::__register();
+::tink::core::TypedError_obj::__register();
+::tink::core::CallbackList_obj::__register();
+::tink::core::SimpleDisposable_obj::__register();
+::tink::core::OwnedDisposable_obj::__register();
+::tink::core::Disposable_obj::__register();
+::tink::core::_Callback::ListCell_obj::__register();
+::tink::core::_Callback::LinkPair_obj::__register();
+::tink::core::CallbackLinkRef_obj::__register();
+::tink::core::LinkObject_obj::__register();
+::tink::chunk::CompoundChunk_obj::__register();
+::tink::chunk::ChunkCursor_obj::__register();
+::tink::chunk::ByteChunk_obj::__register();
+::tink::_Url::Url_Impl__obj::__register();
+::tink::chunk::ChunkObject_obj::__register();
+::tink::chunk::ChunkBase_obj::__register();
+::thenshim::fallback::HandlerSession_obj::__register();
+::thenshim::fallback::FallbackPromise_obj::__register();
+::thenshim::Thenable_obj::__register();
+::thenshim::PromiseTools_obj::__register();
+::thenshim::fallback::TaskScheduler_obj::__register();
+::thenshim::fallback::FallbackPromiseFactory_obj::__register();
+::thenshim::PromiseFactory_obj::__register();
+::sys::thread::_Thread::Thread_Impl__obj::__register();
+::sys::thread::NoEventLoopException_obj::__register();
+::sys::thread::Lock_obj::__register();
+::sys::thread::_EventLoop::RegularEvent_obj::__register();
+::sys::ssl::_Socket::SocketOutput_obj::__register();
+::sys::ssl::_Socket::SocketInput_obj::__register();
+::sys::net::Socket_obj::__register();
+::sys::net::_Socket::SocketOutput_obj::__register();
+::sys::net::_Socket::SocketInput_obj::__register();
+::sys::io::Process_obj::__register();
+::sys::io::_Process::Stdout_obj::__register();
+::sys::io::_Process::Stdin_obj::__register();
+::sys::io::FileOutput_obj::__register();
+::sys::io::FileInput_obj::__register();
+::sys::io::File_obj::__register();
+::sys::db::Sqlite_obj::__register();
+::sys::db::_Sqlite::SqliteResultSet_obj::__register();
+::sys::db::_Sqlite::SqliteConnection_obj::__register();
+::sys::db::ResultSet_obj::__register();
+::sys::db::Connection_obj::__register();
+::sys::FileSystem_obj::__register();
+::snikket::streams::XmppStropheStream_obj::__register();
+::snikket::queries::VcardTempGet_obj::__register();
+::snikket::queries::RosterGet_obj::__register();
+::snikket::queries::Push2Disable_obj::__register();
+::snikket::queries::PubsubGet_obj::__register();
+::snikket::queries::MAMQuery_obj::__register();
+::snikket::queries::JabberIqGatewayGet_obj::__register();
+::snikket::queries::HttpUploadSlot_obj::__register();
+::snikket::queries::ExtDiscoGet_obj::__register();
+::snikket::queries::DiscoItemsGet_obj::__register();
+::snikket::queries::DiscoInfoGet_obj::__register();
+::snikket::queries::BoB_obj::__register();
+::snikket::queries::BlocklistGet_obj::__register();
+::snikket::queries::GenericQuery_obj::__register();
+::snikket::persistence::SqliteDriver_obj::__register();
+::snikket::persistence::MediaStore_obj::__register();
+::snikket::persistence::KeyValueStore_obj::__register();
+::snikket::jingle::Attribute_obj::__register();
+::snikket::jingle::IceCandidate_obj::__register();
+::snikket::jingle::Media_obj::__register();
+::snikket::jingle::TransportInfo_obj::__register();
+::snikket::jingle::SessionDescription_obj::__register();
+::snikket::jingle::_Session::Session_Fields__obj::__register();
+::snikket::jingle::OutgoingSession_obj::__register();
+::snikket::jingle::OutgoingProposedSession_obj::__register();
+::snikket::jingle::IncomingProposedSession_obj::__register();
+::snikket::jingle::Session_obj::__register();
+::snikket::jingle::PeerConnection_obj::__register();
+::snikket::jingle::Group_obj::__register();
+::snikket::XEP0393_obj::__register();
+::snikket::_Util::Util_Fields__obj::__register();
+::snikket::StringUtil_obj::__register();
+::snikket::Stanza_obj::__register();
+::snikket::StanzaError_obj::__register();
+::snikket::TextNode_obj::__register();
+::snikket::_Stanza::NodeInterface_obj::__register();
+::snikket::ReactionUpdate_obj::__register();
+::snikket::_Push::Push_Fields__obj::__register();
+::snikket::PubsubEvent_obj::__register();
+::snikket::Presence_obj::__register();
+::snikket::Notification_obj::__register();
+::snikket::ModerationAction_obj::__register();
+::snikket::MessageSync_obj::__register();
+::snikket::Message_obj::__register();
+::snikket::JID_obj::__register();
+::snikket::Identicon_obj::__register();
+::snikket::ID_obj::__register();
+::snikket::GenericStream_obj::__register();
+::snikket::EventHandler_obj::__register();
+::snikket::Builder_obj::__register();
+::snikket::Other_obj::__register();
+::snikket::Emoji_obj::__register();
+::snikket::Symbol_obj::__register();
+::snikket::UnicodeBlocks_obj::__register();
+::snikket::UnicodeRange_obj::__register();
+::snikket::UnicodeList_obj::__register();
+::snikket::UnicodeSet_obj::__register();
+::snikket::Date_obj::__register();
+::snikket::Color_obj::__register();
+::snikket::EventEmitter_obj::__register();
+::snikket::SerializedChat_obj::__register();
+::snikket::Identity_obj::__register();
+::snikket::Caps_obj::__register();
+::sha::SHA256_obj::__register();
+::sha::Hash_obj::__register();
+::hx::strings::Strings_obj::__register();
+::httpstatus::_HttpStatusMessage::HttpStatusMessage_Impl__obj::__register();
+::htmlparser::HtmlTools_obj::__register();
+::htmlparser::HtmlParserException_obj::__register();
+::htmlparser::HtmlNodeText_obj::__register();
+::htmlparser::HtmlNodeElement_obj::__register();
+::htmlparser::HtmlNode_obj::__register();
+::htmlparser::HtmlAttribute_obj::__register();
+::haxe::xml::Printer_obj::__register();
+::haxe::xml::XmlParserException_obj::__register();
+::haxe::iterators::MapKeyValueIterator_obj::__register();
+::haxe::iterators::ArrayIterator_obj::__register();
+::haxe::io::Path_obj::__register();
+::haxe::io::Eof_obj::__register();
+::haxe::io::BytesOutput_obj::__register();
+::haxe::io::Output_obj::__register();
+::haxe::io::BytesInput_obj::__register();
+::haxe::io::Input_obj::__register();
+::haxe::io::BytesBuffer_obj::__register();
+::haxe::http::HttpBase_obj::__register();
+::haxe::format::JsonPrinter_obj::__register();
+::haxe::format::JsonParser_obj::__register();
+::haxe::exceptions::NotImplementedException_obj::__register();
+::haxe::exceptions::PosException_obj::__register();
+::haxe::ds::StringMap_obj::__register();
+::haxe::ds::ObjectMap_obj::__register();
+::haxe::ds::_List::ListNode_obj::__register();
+::haxe::ds::List_obj::__register();
+::haxe::ds::IntMap_obj::__register();
+::haxe::ds::EnumValueMap_obj::__register();
+::haxe::ds::TreeNode_obj::__register();
+::haxe::ds::BalancedTree_obj::__register();
+::haxe::crypto::Sha256_obj::__register();
+::haxe::crypto::Sha1_obj::__register();
+::haxe::crypto::BaseCode_obj::__register();
+::haxe::io::Bytes_obj::__register();
+::haxe::ValueException_obj::__register();
+::haxe::Timer_obj::__register();
+::haxe::NativeStackTrace_obj::__register();
+::haxe::MainLoop_obj::__register();
+::haxe::MainEvent_obj::__register();
+::haxe::Exception_obj::__register();
+::haxe::EntryPoint_obj::__register();
+::sys::thread::EventLoop_obj::__register();
+::sys::thread::Mutex_obj::__register();
+::datetime::utils::DateTimeUtils_obj::__register();
+::datetime::utils::DateTimeMonthUtils_obj::__register();
+::datetime::utils::DateTimeIntervalUtils_obj::__register();
+::datetime::cores::DateTimeIntervalCore_obj::__register();
+::datetime::_DateTimeInterval::DateTimeInterval_Impl__obj::__register();
+::datetime::_DateTime::DateTime_Impl__obj::__register();
+::cpp::Lib_obj::__register();
+::haxe::IMap_obj::__register();
+::_Xml::XmlType_Impl__obj::__register();
+::_UnicodeString::UnicodeString_Impl__obj::__register();
+::Type_obj::__register();
+::Sys_obj::__register();
+::StringTools_obj::__register();
+::StringBuf_obj::__register();
+::Std_obj::__register();
+::Reflect_obj::__register();
+::Lambda_obj::__register();
+::_HaxeCBridge::Int64Map_Impl__obj::__register();
+::EReg_obj::__register();
+::Date_obj::__register();
+::tink::streams::Step_obj::__boot();
+::tink::streams::Reduction_obj::__boot();
+::tink::streams::ReductionStep_obj::__boot();
+::tink::streams::Conclusion_obj::__boot();
+::tink::streams::Handled_obj::__boot();
+::tink::streams::RegroupResult_obj::__boot();
+::tink::streams::RegroupStatus_obj::__boot();
+::tink::io::ParseResult_obj::__boot();
+::tink::io::PipeResult_obj::__boot();
+::tink::http::BodyPart_obj::__boot();
+::tink::http::IncomingRequestBody_obj::__boot();
+::tink::io::ParseStep_obj::__boot();
+::tink::http::ClientType_obj::__boot();
+::tink::core::Outcome_obj::__boot();
+::tink::core::FutureStatus_obj::__boot();
+::thenshim::fallback::PromiseState_obj::__boot();
+::snikket::IqRequestType_obj::__boot();
+::snikket::Node_obj::__boot();
+::snikket::MessageStanza_obj::__boot();
+::snikket::IqResult_obj::__boot();
+::snikket::EventResult_obj::__boot();
+::hx::strings::internal::_Either2::_Either2_obj::__boot();
+::haxe::io::Error_obj::__boot();
+::haxe::io::Encoding_obj::__boot();
+::haxe::ds::Option_obj::__boot();
+::haxe::ds::Either_obj::__boot();
+::haxe::StackItem_obj::__boot();
+::ValueType_obj::__boot();
+::sys::thread::_Thread::HaxeThread_obj::__init__();
+::sys::net::Host_obj::__init__();
+::sys::ssl::Certificate_obj::__init__();
+::sys::ssl::Key_obj::__init__();
+::sys::ssl::Socket_obj::__init__();
+::haxe::Log_obj::__boot();
+::_HaxeCBridge::Internal_obj::__boot();
+::Xml_obj::__boot();
+::sys::thread::_Thread::HaxeThread_obj::__boot();
+::haxe::crypto::Base64_obj::__boot();
+::haxe::xml::Parser_obj::__boot();
+::hsluv::Hsluv_obj::__boot();
+::htmlparser::HtmlParser_obj::__boot();
+::hx::strings::RandomStrings_obj::__boot();
+::hx::strings::StringBuilder_obj::__boot();
+::sha::_SHA256::SHA256_Fields__obj::__boot();
+::snikket::AttachmentSource_obj::__boot();
+::snikket::Autolink_obj::__boot();
+::snikket::Chat_obj::__boot();
+::snikket::DirectChat_obj::__boot();
+::snikket::Channel_obj::__boot();
+::snikket::AvailableChat_obj::__boot();
+::snikket::ChatAttachment_obj::__boot();
+::snikket::ChatMessage_obj::__boot();
+::snikket::ChatMessageBuilder_obj::__boot();
+::snikket::Client_obj::__boot();
+::snikket::Config_obj::__boot();
+::snikket::EmojiUtil_obj::__boot();
+::snikket::Hash_obj::__boot();
+::snikket::Participant_obj::__boot();
+::snikket::Persistence_obj::__boot();
+::snikket::Reaction_obj::__boot();
+::snikket::CustomEmojiReaction_obj::__boot();
+::snikket::jingle::DTMFSender_obj::__boot();
+::snikket::jingle::AudioFormat_obj::__boot();
+::snikket::jingle::MediaStreamTrack_obj::__boot();
+::snikket::jingle::MediaStream_obj::__boot();
+::snikket::jingle::InitiatedSession_obj::__boot();
+::snikket::persistence::Dummy_obj::__boot();
+::snikket::persistence::MediaStoreFS_obj::__boot();
+::snikket::persistence::Sqlite_obj::__boot();
+::sys::Http_obj::__boot();
+::sys::net::Host_obj::__boot();
+::sys::ssl::Certificate_obj::__boot();
+::sys::ssl::Key_obj::__boot();
+::sys::ssl::Socket_obj::__boot();
+::thenshim::_Promise::Promise_Impl__obj::__boot();
+::tink::_Chunk::EmptyChunk_obj::__boot();
+::tink::_Chunk::Chunk_Impl__obj::__boot();
+::tink::core::_Callback::Callback_Impl__obj::__boot();
+::tink::core::_Future::Future_Impl__obj::__boot();
+::tink::http::Fetch_obj::__boot();
+::tink::streams::Empty_obj::__boot();
+::tink::io::_Source::Source_Impl__obj::__boot();
+::tink::io::_Worker::Worker_Impl__obj::__boot();
+}
+
diff --git a/Sources/c_snikket/src/__files__.cpp b/Sources/c_snikket/src/__files__.cpp
new file mode 100644
index 0000000..ee2081b
--- /dev/null
+++ b/Sources/c_snikket/src/__files__.cpp
@@ -0,0 +1,644 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+namespace hx {
+const char *__hxcpp_all_files[] = {
+#ifdef HXCPP_DEBUGGER
+"/usr/local/lib/haxe/std/Lambda.hx",
+"/usr/local/lib/haxe/std/StringTools.hx",
+"/usr/local/lib/haxe/std/UnicodeString.hx",
+"/usr/local/lib/haxe/std/Xml.hx",
+"/usr/local/lib/haxe/std/cpp/_std/Date.hx",
+"/usr/local/lib/haxe/std/cpp/_std/EReg.hx",
+"/usr/local/lib/haxe/std/cpp/_std/Reflect.hx",
+"/usr/local/lib/haxe/std/cpp/_std/Std.hx",
+"/usr/local/lib/haxe/std/cpp/_std/StringBuf.hx",
+"/usr/local/lib/haxe/std/cpp/_std/Sys.hx",
+"/usr/local/lib/haxe/std/cpp/_std/Type.hx",
+"/usr/local/lib/haxe/std/cpp/_std/haxe/Exception.hx",
+"/usr/local/lib/haxe/std/cpp/_std/haxe/Log.hx",
+"/usr/local/lib/haxe/std/cpp/_std/haxe/NativeStackTrace.hx",
+"/usr/local/lib/haxe/std/cpp/_std/haxe/ds/IntMap.hx",
+"/usr/local/lib/haxe/std/cpp/_std/haxe/ds/ObjectMap.hx",
+"/usr/local/lib/haxe/std/cpp/_std/haxe/ds/StringMap.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/FileSystem.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/db/Sqlite.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/io/File.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/io/FileInput.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/io/FileOutput.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/io/Process.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/net/Host.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/net/Socket.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/ssl/Certificate.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/ssl/Key.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/ssl/Socket.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/thread/Lock.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/thread/Mutex.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/thread/Thread.hx",
+"/usr/local/lib/haxe/std/haxe/EntryPoint.hx",
+"/usr/local/lib/haxe/std/haxe/MainLoop.hx",
+"/usr/local/lib/haxe/std/haxe/Timer.hx",
+"/usr/local/lib/haxe/std/haxe/ValueException.hx",
+"/usr/local/lib/haxe/std/haxe/crypto/Base64.hx",
+"/usr/local/lib/haxe/std/haxe/crypto/BaseCode.hx",
+"/usr/local/lib/haxe/std/haxe/crypto/Sha1.hx",
+"/usr/local/lib/haxe/std/haxe/crypto/Sha256.hx",
+"/usr/local/lib/haxe/std/haxe/ds/BalancedTree.hx",
+"/usr/local/lib/haxe/std/haxe/ds/EnumValueMap.hx",
+"/usr/local/lib/haxe/std/haxe/ds/List.hx",
+"/usr/local/lib/haxe/std/haxe/exceptions/NotImplementedException.hx",
+"/usr/local/lib/haxe/std/haxe/exceptions/PosException.hx",
+"/usr/local/lib/haxe/std/haxe/format/JsonParser.hx",
+"/usr/local/lib/haxe/std/haxe/format/JsonPrinter.hx",
+"/usr/local/lib/haxe/std/haxe/http/HttpBase.hx",
+"/usr/local/lib/haxe/std/haxe/io/Bytes.hx",
+"/usr/local/lib/haxe/std/haxe/io/BytesBuffer.hx",
+"/usr/local/lib/haxe/std/haxe/io/BytesInput.hx",
+"/usr/local/lib/haxe/std/haxe/io/BytesOutput.hx",
+"/usr/local/lib/haxe/std/haxe/io/Eof.hx",
+"/usr/local/lib/haxe/std/haxe/io/Input.hx",
+"/usr/local/lib/haxe/std/haxe/io/Output.hx",
+"/usr/local/lib/haxe/std/haxe/io/Path.hx",
+"/usr/local/lib/haxe/std/haxe/iterators/ArrayIterator.hx",
+"/usr/local/lib/haxe/std/haxe/iterators/MapKeyValueIterator.hx",
+"/usr/local/lib/haxe/std/haxe/xml/Parser.hx",
+"/usr/local/lib/haxe/std/haxe/xml/Printer.hx",
+"/usr/local/lib/haxe/std/sys/Http.hx",
+"/usr/local/lib/haxe/std/sys/thread/EventLoop.hx",
+"/usr/local/lib/haxe/std/sys/thread/NoEventLoopException.hx",
+"HaxeCBridge.hx",
+"datetime/DateTime.hx",
+"datetime/DateTimeInterval.hx",
+"datetime/cores/DateTimeIntervalCore.hx",
+"datetime/utils/DateTimeIntervalUtils.hx",
+"datetime/utils/DateTimeMonthUtils.hx",
+"datetime/utils/DateTimeUtils.hx",
+"hsluv/Hsluv.hx",
+"htmlparser/HtmlAttribute.hx",
+"htmlparser/HtmlNodeElement.hx",
+"htmlparser/HtmlNodeText.hx",
+"htmlparser/HtmlParser.hx",
+"htmlparser/HtmlParserException.hx",
+"htmlparser/HtmlTools.hx",
+"httpstatus/HttpStatusMessage.hx",
+"hx/strings/RandomStrings.hx",
+"hx/strings/StringBuilder.hx",
+"hx/strings/Strings.hx",
+"sha/Hash.hx",
+"sha/SHA256.hx",
+"snikket/AttachmentSource.cpp.hx",
+"snikket/Autolink.hx",
+"snikket/Caps.hx",
+"snikket/Chat.hx",
+"snikket/ChatMessage.hx",
+"snikket/ChatMessageBuilder.hx",
+"snikket/Client.hx",
+"snikket/Color.hx",
+"snikket/Config.hx",
+"snikket/Date.hx",
+"snikket/EmojiUtil.hx",
+"snikket/EventEmitter.hx",
+"snikket/EventHandler.hx",
+"snikket/GenericStream.hx",
+"snikket/Hash.hx",
+"snikket/ID.hx",
+"snikket/Identicon.hx",
+"snikket/JID.hx",
+"snikket/Message.hx",
+"snikket/MessageSync.hx",
+"snikket/ModerationAction.hx",
+"snikket/Notification.hx",
+"snikket/Participant.hx",
+"snikket/Persistence.hx",
+"snikket/Presence.hx",
+"snikket/PubsubEvent.hx",
+"snikket/Push.hx",
+"snikket/Reaction.hx",
+"snikket/ReactionUpdate.hx",
+"snikket/Stanza.hx",
+"snikket/StringUtil.hx",
+"snikket/Util.hx",
+"snikket/XEP0393.hx",
+"snikket/jingle/Group.hx",
+"snikket/jingle/PeerConnection.cpp.hx",
+"snikket/jingle/Session.hx",
+"snikket/jingle/SessionDescription.hx",
+"snikket/persistence/Dummy.hx",
+"snikket/persistence/MediaStoreFS.hx",
+"snikket/persistence/Sqlite.hx",
+"snikket/persistence/SqliteDriver.hx",
+"snikket/queries/BlocklistGet.hx",
+"snikket/queries/BoB.hx",
+"snikket/queries/DiscoInfoGet.hx",
+"snikket/queries/DiscoItemsGet.hx",
+"snikket/queries/ExtDiscoGet.hx",
+"snikket/queries/GenericQuery.hx",
+"snikket/queries/HttpUploadSlot.hx",
+"snikket/queries/JabberIqGatewayGet.hx",
+"snikket/queries/MAMQuery.hx",
+"snikket/queries/PubsubGet.hx",
+"snikket/queries/Push2Disable.hx",
+"snikket/queries/RosterGet.hx",
+"snikket/queries/VcardTempGet.hx",
+"snikket/streams/XmppStropheStream.hx",
+"thenshim/Promise.hx",
+"thenshim/PromiseTools.hx",
+"thenshim/fallback/FallbackPromise.hx",
+"thenshim/fallback/FallbackPromiseFactory.hx",
+"thenshim/fallback/HandlerSession.hx",
+"thenshim/fallback/TaskScheduler.hx",
+"tink/Chunk.hx",
+"tink/Url.hx",
+"tink/chunk/ByteChunk.hx",
+"tink/chunk/ChunkBase.hx",
+"tink/chunk/ChunkCursor.hx",
+"tink/chunk/CompoundChunk.hx",
+"tink/core/Callback.hx",
+"tink/core/Disposable.hx",
+"tink/core/Error.hx",
+"tink/core/Future.hx",
+"tink/core/Lazy.hx",
+"tink/core/Named.hx",
+"tink/core/Pair.hx",
+"tink/core/Promise.hx",
+"tink/http/Client.hx",
+"tink/http/Fetch.hx",
+"tink/http/Header.hx",
+"tink/http/Message.hx",
+"tink/http/Request.hx",
+"tink/http/Response.hx",
+"tink/http/clients/CurlClient.hx",
+"tink/http/clients/Helpers.hx",
+"tink/http/clients/LocalContainerClient.hx",
+"tink/http/clients/SocketClient.hx",
+"tink/http/clients/StdClient.hx",
+"tink/http/containers/LocalContainer.hx",
+"tink/io/PipeResult.hx",
+"tink/io/Sink.hx",
+"tink/io/Source.hx",
+"tink/io/StreamParser.hx",
+"tink/io/Worker.hx",
+"tink/io/std/InputSource.hx",
+"tink/io/std/OutputSink.hx",
+"tink/streams/IdealStream.hx",
+"tink/streams/Stream.hx",
+"tink/url/Host.hx",
+"tink/url/Path.hx",
+#endif
+ 0 };
+
+const char *__hxcpp_all_files_fullpath[] = {
+#ifdef HXCPP_DEBUGGER
+"/usr/local/lib/haxe/std/Lambda.hx",
+"/usr/local/lib/haxe/std/StringTools.hx",
+"/usr/local/lib/haxe/std/UnicodeString.hx",
+"/usr/local/lib/haxe/std/Xml.hx",
+"/usr/local/lib/haxe/std/cpp/_std/Date.hx",
+"/usr/local/lib/haxe/std/cpp/_std/EReg.hx",
+"/usr/local/lib/haxe/std/cpp/_std/Reflect.hx",
+"/usr/local/lib/haxe/std/cpp/_std/Std.hx",
+"/usr/local/lib/haxe/std/cpp/_std/StringBuf.hx",
+"/usr/local/lib/haxe/std/cpp/_std/Sys.hx",
+"/usr/local/lib/haxe/std/cpp/_std/Type.hx",
+"/usr/local/lib/haxe/std/cpp/_std/haxe/Exception.hx",
+"/usr/local/lib/haxe/std/cpp/_std/haxe/Log.hx",
+"/usr/local/lib/haxe/std/cpp/_std/haxe/NativeStackTrace.hx",
+"/usr/local/lib/haxe/std/cpp/_std/haxe/ds/IntMap.hx",
+"/usr/local/lib/haxe/std/cpp/_std/haxe/ds/ObjectMap.hx",
+"/usr/local/lib/haxe/std/cpp/_std/haxe/ds/StringMap.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/FileSystem.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/db/Sqlite.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/io/File.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/io/FileInput.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/io/FileOutput.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/io/Process.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/net/Host.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/net/Socket.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/ssl/Certificate.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/ssl/Key.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/ssl/Socket.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/thread/Lock.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/thread/Mutex.hx",
+"/usr/local/lib/haxe/std/cpp/_std/sys/thread/Thread.hx",
+"/usr/local/lib/haxe/std/haxe/EntryPoint.hx",
+"/usr/local/lib/haxe/std/haxe/MainLoop.hx",
+"/usr/local/lib/haxe/std/haxe/Timer.hx",
+"/usr/local/lib/haxe/std/haxe/ValueException.hx",
+"/usr/local/lib/haxe/std/haxe/crypto/Base64.hx",
+"/usr/local/lib/haxe/std/haxe/crypto/BaseCode.hx",
+"/usr/local/lib/haxe/std/haxe/crypto/Sha1.hx",
+"/usr/local/lib/haxe/std/haxe/crypto/Sha256.hx",
+"/usr/local/lib/haxe/std/haxe/ds/BalancedTree.hx",
+"/usr/local/lib/haxe/std/haxe/ds/EnumValueMap.hx",
+"/usr/local/lib/haxe/std/haxe/ds/List.hx",
+"/usr/local/lib/haxe/std/haxe/exceptions/NotImplementedException.hx",
+"/usr/local/lib/haxe/std/haxe/exceptions/PosException.hx",
+"/usr/local/lib/haxe/std/haxe/format/JsonParser.hx",
+"/usr/local/lib/haxe/std/haxe/format/JsonPrinter.hx",
+"/usr/local/lib/haxe/std/haxe/http/HttpBase.hx",
+"/usr/local/lib/haxe/std/haxe/io/Bytes.hx",
+"/usr/local/lib/haxe/std/haxe/io/BytesBuffer.hx",
+"/usr/local/lib/haxe/std/haxe/io/BytesInput.hx",
+"/usr/local/lib/haxe/std/haxe/io/BytesOutput.hx",
+"/usr/local/lib/haxe/std/haxe/io/Eof.hx",
+"/usr/local/lib/haxe/std/haxe/io/Input.hx",
+"/usr/local/lib/haxe/std/haxe/io/Output.hx",
+"/usr/local/lib/haxe/std/haxe/io/Path.hx",
+"/usr/local/lib/haxe/std/haxe/iterators/ArrayIterator.hx",
+"/usr/local/lib/haxe/std/haxe/iterators/MapKeyValueIterator.hx",
+"/usr/local/lib/haxe/std/haxe/xml/Parser.hx",
+"/usr/local/lib/haxe/std/haxe/xml/Printer.hx",
+"/usr/local/lib/haxe/std/sys/Http.hx",
+"/usr/local/lib/haxe/std/sys/thread/EventLoop.hx",
+"/usr/local/lib/haxe/std/sys/thread/NoEventLoopException.hx",
+"/Users/singpolyma/src/snikket-sdk/HaxeCBridge.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/datetime/3,1,4/src/datetime/DateTime.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/datetime/3,1,4/src/datetime/DateTimeInterval.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/datetime/3,1,4/src/datetime/cores/DateTimeIntervalCore.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/datetime/3,1,4/src/datetime/utils/DateTimeIntervalUtils.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/datetime/3,1,4/src/datetime/utils/DateTimeMonthUtils.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/datetime/3,1,4/src/datetime/utils/DateTimeUtils.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/hsluv/0,1,1/src/hsluv/Hsluv.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/HtmlParser/3,4,0/htmlparser/HtmlAttribute.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/HtmlParser/3,4,0/htmlparser/HtmlNodeElement.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/HtmlParser/3,4,0/htmlparser/HtmlNodeText.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/HtmlParser/3,4,0/htmlparser/HtmlParser.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/HtmlParser/3,4,0/htmlparser/HtmlParserException.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/HtmlParser/3,4,0/htmlparser/HtmlTools.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/http-status/1,3,1/src/httpstatus/HttpStatusMessage.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/haxe-strings/7,0,5/src/hx/strings/RandomStrings.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/haxe-strings/7,0,5/src/hx/strings/StringBuilder.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/haxe-strings/7,0,5/src/hx/strings/Strings.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/sha/0,0,1/src/sha/Hash.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/sha/0,0,1/src/sha/SHA256.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/AttachmentSource.cpp.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/Autolink.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/Caps.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/Chat.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/ChatMessage.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/ChatMessageBuilder.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/Client.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/Color.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/Config.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/Date.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/EmojiUtil.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/EventEmitter.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/EventHandler.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/GenericStream.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/Hash.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/ID.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/Identicon.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/JID.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/Message.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/MessageSync.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/ModerationAction.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/Notification.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/Participant.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/Persistence.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/Presence.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/PubsubEvent.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/Push.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/Reaction.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/ReactionUpdate.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/Stanza.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/StringUtil.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/Util.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/XEP0393.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/jingle/Group.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/jingle/PeerConnection.cpp.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/jingle/Session.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/jingle/SessionDescription.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/persistence/Dummy.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/persistence/MediaStoreFS.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/persistence/Sqlite.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/persistence/SqliteDriver.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/queries/BlocklistGet.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/queries/BoB.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/queries/DiscoInfoGet.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/queries/DiscoItemsGet.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/queries/ExtDiscoGet.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/queries/GenericQuery.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/queries/HttpUploadSlot.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/queries/JabberIqGatewayGet.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/queries/MAMQuery.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/queries/PubsubGet.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/queries/Push2Disable.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/queries/RosterGet.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/queries/VcardTempGet.hx",
+"/Users/singpolyma/src/snikket-sdk/snikket/streams/XmppStropheStream.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/thenshim/1,1,2/src/thenshim/Promise.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/thenshim/1,1,2/src/thenshim/PromiseTools.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/thenshim/1,1,2/src/thenshim/fallback/FallbackPromise.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/thenshim/1,1,2/src/thenshim/fallback/FallbackPromiseFactory.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/thenshim/1,1,2/src/thenshim/fallback/HandlerSession.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/thenshim/1,1,2/src/thenshim/fallback/TaskScheduler.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_chunk/0,4,0/src/tink/Chunk.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_url/0,5,0/src/tink/Url.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_chunk/0,4,0/src/tink/chunk/ByteChunk.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_chunk/0,4,0/src/tink/chunk/ChunkBase.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_chunk/0,4,0/src/tink/chunk/ChunkCursor.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_chunk/0,4,0/src/tink/chunk/CompoundChunk.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_core/2,1,1/src/tink/core/Callback.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_core/2,1,1/src/tink/core/Disposable.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_core/2,1,1/src/tink/core/Error.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_core/2,1,1/src/tink/core/Future.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_core/2,1,1/src/tink/core/Lazy.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_core/2,1,1/src/tink/core/Named.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_core/2,1,1/src/tink/core/Pair.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_core/2,1,1/src/tink/core/Promise.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_http/0,10,0/src/tink/http/Client.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_http/0,10,0/src/tink/http/Fetch.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_http/0,10,0/src/tink/http/Header.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_http/0,10,0/src/tink/http/Message.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_http/0,10,0/src/tink/http/Request.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_http/0,10,0/src/tink/http/Response.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_http/0,10,0/src/tink/http/clients/CurlClient.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_http/0,10,0/src/tink/http/clients/Helpers.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_http/0,10,0/src/tink/http/clients/LocalContainerClient.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_http/0,10,0/src/tink/http/clients/SocketClient.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_http/0,10,0/src/tink/http/clients/StdClient.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_http/0,10,0/src/tink/http/containers/LocalContainer.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_io/0,9,0/src/tink/io/PipeResult.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_io/0,9,0/src/tink/io/Sink.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_io/0,9,0/src/tink/io/Source.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_io/0,9,0/src/tink/io/StreamParser.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_io/0,9,0/src/tink/io/Worker.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_io/0,9,0/src/tink/io/std/InputSource.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_io/0,9,0/src/tink/io/std/OutputSink.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_streams/0,4,0/src/tink/streams/IdealStream.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_streams/0,4,0/src/tink/streams/Stream.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_url/0,5,0/src/tink/url/Host.hx",
+"/Users/singpolyma/.local/lib/haxe/lib/tink_url/0,5,0/src/tink/url/Path.hx",
+#endif
+ 0 };
+
+const char *__hxcpp_all_classes[] = {
+#ifdef HXCPP_DEBUGGER
+"Date",
+"EReg",
+"HaxeCBridge",
+"_HaxeCBridge.Int64Map_Impl_",
+"_HaxeCBridge.Internal",
+"Lambda",
+"Reflect",
+"Std",
+"StringBuf",
+"StringTools",
+"Sys",
+"Type",
+"_UnicodeString.UnicodeString_Impl_",
+"_Xml.XmlType_Impl_",
+"Xml",
+"cpp.Lib",
+"datetime._DateTime.DateTime_Impl_",
+"datetime._DateTimeInterval.DateTimeInterval_Impl_",
+"datetime.cores.DateTimeIntervalCore",
+"datetime.utils.DateTimeIntervalUtils",
+"datetime.utils.DateTimeMonthUtils",
+"datetime.utils.DateTimeUtils",
+"sys.thread.Mutex",
+"sys.thread.EventLoop",
+"sys.thread._Thread.HaxeThread",
+"haxe.EntryPoint",
+"haxe.Exception",
+"haxe.Log",
+"haxe.MainEvent",
+"haxe.MainLoop",
+"haxe.NativeStackTrace",
+"haxe.Timer",
+"haxe.ValueException",
+"haxe.io.Bytes",
+"haxe.crypto.Base64",
+"haxe.crypto.BaseCode",
+"haxe.crypto.Sha1",
+"haxe.crypto.Sha256",
+"haxe.ds.BalancedTree",
+"haxe.ds.TreeNode",
+"haxe.ds.EnumValueMap",
+"haxe.ds.IntMap",
+"haxe.ds.List",
+"haxe.ds._List.ListNode",
+"haxe.ds.ObjectMap",
+"haxe.ds.StringMap",
+"haxe.exceptions.PosException",
+"haxe.exceptions.NotImplementedException",
+"haxe.format.JsonParser",
+"haxe.format.JsonPrinter",
+"haxe.http.HttpBase",
+"haxe.io.BytesBuffer",
+"haxe.io.Input",
+"haxe.io.BytesInput",
+"haxe.io.Output",
+"haxe.io.BytesOutput",
+"haxe.io.Eof",
+"haxe.io.Path",
+"haxe.iterators.ArrayIterator",
+"haxe.iterators.MapKeyValueIterator",
+"haxe.xml.XmlParserException",
+"haxe.xml.Parser",
+"haxe.xml.Printer",
+"hsluv.Hsluv",
+"htmlparser.HtmlAttribute",
+"htmlparser.HtmlNode",
+"htmlparser.HtmlNodeElement",
+"htmlparser.HtmlNodeText",
+"htmlparser.HtmlParser",
+"htmlparser.HtmlParserException",
+"htmlparser.HtmlTools",
+"httpstatus._HttpStatusMessage.HttpStatusMessage_Impl_",
+"hx.strings.Strings",
+"hx.strings.RandomStrings",
+"hx.strings.StringBuilder",
+"sha.Hash",
+"sha.SHA256",
+"sha._SHA256.SHA256_Fields_",
+"snikket.AttachmentSource",
+"snikket.Autolink",
+"snikket.Caps",
+"snikket.Identity",
+"snikket.Chat",
+"snikket.DirectChat",
+"snikket.Channel",
+"snikket.AvailableChat",
+"snikket.SerializedChat",
+"snikket.ChatAttachment",
+"snikket.ChatMessage",
+"snikket.ChatMessageBuilder",
+"snikket.EventEmitter",
+"snikket.Client",
+"snikket.Color",
+"snikket.Config",
+"snikket.Date",
+"snikket.UnicodeList",
+"snikket.UnicodeRange",
+"snikket.UnicodeBlocks",
+"snikket.EmojiUtil",
+"snikket.Symbol",
+"snikket.Emoji",
+"snikket.Other",
+"snikket.Builder",
+"snikket.EventHandler",
+"snikket.GenericStream",
+"snikket.Hash",
+"snikket.ID",
+"snikket.Identicon",
+"snikket.JID",
+"snikket.Message",
+"snikket.MessageSync",
+"snikket.ModerationAction",
+"snikket.Notification",
+"snikket.Participant",
+"snikket.Presence",
+"snikket.PubsubEvent",
+"snikket._Push.Push_Fields_",
+"snikket.Reaction",
+"snikket.CustomEmojiReaction",
+"snikket.ReactionUpdate",
+"snikket.TextNode",
+"snikket.StanzaError",
+"snikket.Stanza",
+"snikket.StringUtil",
+"snikket._Util.Util_Fields_",
+"snikket.XEP0393",
+"snikket.jingle.Group",
+"snikket.jingle.DTMFSender",
+"snikket.jingle.AudioFormat",
+"snikket.jingle.MediaStreamTrack",
+"snikket.jingle.MediaStream",
+"snikket.jingle.PeerConnection",
+"snikket.jingle.IncomingProposedSession",
+"snikket.jingle.OutgoingProposedSession",
+"snikket.jingle.InitiatedSession",
+"snikket.jingle.OutgoingSession",
+"snikket.jingle._Session.Session_Fields_",
+"snikket.jingle.SessionDescription",
+"snikket.jingle.TransportInfo",
+"snikket.jingle.Media",
+"snikket.jingle.IceCandidate",
+"snikket.jingle.Attribute",
+"snikket.persistence.Dummy",
+"snikket.persistence.MediaStoreFS",
+"snikket.persistence.Sqlite",
+"snikket.persistence.SqliteDriver",
+"snikket.queries.GenericQuery",
+"snikket.queries.BlocklistGet",
+"snikket.queries.BoB",
+"snikket.queries.DiscoInfoGet",
+"snikket.queries.DiscoItemsGet",
+"snikket.queries.ExtDiscoGet",
+"snikket.queries.HttpUploadSlot",
+"snikket.queries.JabberIqGatewayGet",
+"snikket.queries.MAMQuery",
+"snikket.queries.PubsubGet",
+"snikket.queries.Push2Disable",
+"snikket.queries.RosterGet",
+"snikket.queries.VcardTempGet",
+"snikket.streams.XmppStropheStream",
+"sys.FileSystem",
+"sys.Http",
+"sys.db._Sqlite.SqliteConnection",
+"sys.db._Sqlite.SqliteResultSet",
+"sys.db.Sqlite",
+"sys.io.File",
+"sys.io.FileInput",
+"sys.io.FileOutput",
+"sys.io._Process.Stdin",
+"sys.io._Process.Stdout",
+"sys.io.Process",
+"sys.net.Host",
+"sys.net._Socket.SocketInput",
+"sys.net._Socket.SocketOutput",
+"sys.net.Socket",
+"sys.ssl.Certificate",
+"sys.ssl.Key",
+"sys.ssl._Socket.SocketInput",
+"sys.ssl._Socket.SocketOutput",
+"sys.ssl.Socket",
+"sys.thread._EventLoop.RegularEvent",
+"sys.thread.Lock",
+"sys.thread.NoEventLoopException",
+"sys.thread._Thread.Thread_Impl_",
+"thenshim.fallback.FallbackPromiseFactory",
+"thenshim.fallback.TaskScheduler",
+"thenshim._Promise.Promise_Impl_",
+"thenshim.PromiseTools",
+"thenshim.fallback.FallbackPromise",
+"thenshim.fallback.HandlerSession",
+"tink.chunk.ChunkBase",
+"tink._Chunk.EmptyChunk",
+"tink._Chunk.Chunk_Impl_",
+"tink._Url.Url_Impl_",
+"tink.chunk.ByteChunk",
+"tink.chunk.ChunkCursor",
+"tink.chunk.CompoundChunk",
+"tink.core._Callback.Callback_Impl_",
+"tink.core.CallbackLinkRef",
+"tink.core._Callback.LinkPair",
+"tink.core._Callback.ListCell",
+"tink.core.SimpleDisposable",
+"tink.core.CallbackList",
+"tink.core.TypedError",
+"tink.core._Future.FutureObject",
+"tink.core._Lazy.LazyConst",
+"tink.core._Future.SyncFuture",
+"tink.core._Future.Future_Impl_",
+"tink.core._Future.SuspendableFuture",
+"tink.core._Lazy.Lazy_Impl_",
+"tink.core._Lazy.LazyFunc",
+"tink.core.NamedWith",
+"tink.core.MPair",
+"tink.core._Promise.Promise_Impl_",
+"tink.http._Client.CustomClient",
+"tink.http.Fetch",
+"tink.http._Fetch.FetchResponse_Impl_",
+"tink.http.Header",
+"tink.http._Header.HeaderValue_Impl_",
+"tink.http.HeaderField",
+"tink.io.BytewiseParser",
+"tink.http.HeaderParser",
+"tink.http.Message",
+"tink.http.RequestHeader",
+"tink.http.IncomingRequestHeader",
+"tink.http.OutgoingRequestHeader",
+"tink.http.OutgoingRequest",
+"tink.http.IncomingRequest",
+"tink.http.ResponseHeaderBase",
+"tink.http._Response.OutgoingResponseData",
+"tink.http.IncomingResponse",
+"tink.http.clients.CurlClient",
+"tink.http.clients.Helpers",
+"tink.http.clients.LocalContainerClient",
+"tink.http.clients.SocketClient",
+"tink.http.clients.StdClient",
+"tink.http.containers.LocalContainer",
+"tink.io.PipeResultTools",
+"tink.io.SinkBase",
+"tink.io._Sink.SinkYielding_Impl_",
+"tink.streams.StreamBase",
+"tink.streams.Empty",
+"tink.io._Source.Source_Impl_",
+"tink.io.RealSourceTools",
+"tink.io.IdealSourceTools",
+"tink.io._StreamParser.StreamParser_Impl_",
+"tink.io._Worker.EagerWorker",
+"tink.io._Worker.Worker_Impl_",
+"tink.streams.Generator",
+"tink.io.std.InputSource",
+"tink.io.std.OutputSink",
+"tink.streams.IdealStreamBase",
+"tink.streams._Stream.Stream_Impl_",
+"tink.streams._Stream.Regrouper_Impl_",
+"tink.streams._Stream.CompoundStream",
+"tink.streams._Stream.RegroupStream",
+"tink.streams._Stream.ErrorStream",
+"tink.streams.IdealizeStream",
+"tink.streams.Single",
+"tink.streams._Stream.Handler_Impl_",
+"tink.streams._Stream.Reducer_Impl_",
+"tink.streams.FutureStream",
+"tink.url._Host.Host_Impl_",
+"tink.url._Path.Path_Impl_",
+#endif
+ 0 };
+} // namespace hx
+void __files__boot() { __hxcpp_set_debugger_info(::hx::__hxcpp_all_classes, ::hx::__hxcpp_all_files_fullpath); }
diff --git a/Sources/c_snikket/src/__lib__.cpp b/Sources/c_snikket/src/__lib__.cpp
new file mode 100644
index 0000000..86255b2
--- /dev/null
+++ b/Sources/c_snikket/src/__lib__.cpp
@@ -0,0 +1,18 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#include <stdio.h>
+
+extern "C" void __hxcpp_main();
+
+extern "C" void __hxcpp_lib_main();
+
+void __hxcpp_main() {
+	}
+
+void __hxcpp_lib_main() {
+	HX_TOP_OF_STACK
+	::hx::Boot();
+	__boot_all();
+	__hxcpp_main();
+	}
diff --git a/Sources/c_snikket/src/__resources__.cpp b/Sources/c_snikket/src/__resources__.cpp
new file mode 100644
index 0000000..da8d947
--- /dev/null
+++ b/Sources/c_snikket/src/__resources__.cpp
@@ -0,0 +1,11 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+namespace hx {
+}
+
+::hx::Resource __Resources[] = {
+	{ ::String(null()),0,0 }
+};
+
+namespace hx { Resource *GetResources() { return __Resources; } }
diff --git a/Sources/c_snikket/src/cpp/Lib.cpp b/Sources/c_snikket/src/cpp/Lib.cpp
new file mode 100644
index 0000000..233e526
--- /dev/null
+++ b/Sources/c_snikket/src/cpp/Lib.cpp
@@ -0,0 +1,62 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_cpp_Lib
+#include <cpp/Lib.h>
+#endif
+
+namespace cpp{
+
+void Lib_obj::__construct() { }
+
+Dynamic Lib_obj::__CreateEmpty() { return new Lib_obj; }
+
+void *Lib_obj::_hx_vtable = 0;
+
+Dynamic Lib_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Lib_obj > _hx_result = new Lib_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool Lib_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x561f6486;
+}
+
+
+Lib_obj::Lib_obj()
+{
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *Lib_obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo *Lib_obj_sStaticStorageInfo = 0;
+#endif
+
+::hx::Class Lib_obj::__mClass;
+
+void Lib_obj::__register()
+{
+	Lib_obj _hx_dummy;
+	Lib_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("cpp.Lib",5a,26,48,78);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< Lib_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Lib_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Lib_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace cpp
diff --git a/Sources/c_snikket/src/datetime/_DateTime/DateTime_Impl_.cpp b/Sources/c_snikket/src/datetime/_DateTime/DateTime_Impl_.cpp
new file mode 100644
index 0000000..b9712e3
--- /dev/null
+++ b/Sources/c_snikket/src/datetime/_DateTime/DateTime_Impl_.cpp
@@ -0,0 +1,155 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Std
+#include <Std.h>
+#endif
+#ifndef INCLUDED_datetime__DateTime_DateTime_Impl_
+#include <datetime/_DateTime/DateTime_Impl_.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_5a09d285486cbbfe_312_getYear,"datetime._DateTime.DateTime_Impl_","getYear",0x24acbe07,"datetime._DateTime.DateTime_Impl_.getYear","datetime/DateTime.hx",312,0xa456c60f)
+HX_LOCAL_STACK_FRAME(_hx_pos_5a09d285486cbbfe_333_yearStart,"datetime._DateTime.DateTime_Impl_","yearStart",0xa4f73ef9,"datetime._DateTime.DateTime_Impl_.yearStart","datetime/DateTime.hx",333,0xa456c60f)
+HX_LOCAL_STACK_FRAME(_hx_pos_5a09d285486cbbfe_376_isLeapYear,"datetime._DateTime.DateTime_Impl_","isLeapYear",0xb042cf7b,"datetime._DateTime.DateTime_Impl_.isLeapYear","datetime/DateTime.hx",376,0xa456c60f)
+namespace datetime{
+namespace _DateTime{
+
+void DateTime_Impl__obj::__construct() { }
+
+Dynamic DateTime_Impl__obj::__CreateEmpty() { return new DateTime_Impl__obj; }
+
+void *DateTime_Impl__obj::_hx_vtable = 0;
+
+Dynamic DateTime_Impl__obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< DateTime_Impl__obj > _hx_result = new DateTime_Impl__obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool DateTime_Impl__obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x3ae93836;
+}
+
+int DateTime_Impl__obj::getYear(Float this1){
+            	HX_STACKFRAME(&_hx_pos_5a09d285486cbbfe_312_getYear)
+HXLINE( 313)		Float cquads = (( (Float)(::Std_obj::_hx_int((this1 / ((Float)12622780800.0)))) ) * ((Float)12622780800.0));
+HXLINE( 314)		Float centuries = (( (Float)(::Std_obj::_hx_int(((this1 - cquads) / ((Float)3155673600.0)))) ) * ((Float)3155673600.0));
+HXLINE( 315)		if ((centuries > ((Float)9467020800.))) {
+HXLINE( 316)			centuries = (centuries - ((Float)3155673600.0));
+            		}
+HXLINE( 318)		Float quads = (( (Float)(::Std_obj::_hx_int((((this1 - cquads) - centuries) / ((Float)126230400.0)))) ) * ((Float)126230400.0));
+HXLINE( 319)		int years = ::Std_obj::_hx_int(((((this1 - cquads) - centuries) - quads) / ( (Float)(31536000) )));
+HXLINE( 322)		int _hx_tmp = (::Std_obj::_hx_int((cquads / ((Float)12622780800.0))) * 400);
+HXDLIN( 322)		int _hx_tmp1 = (_hx_tmp + (::Std_obj::_hx_int((centuries / ((Float)3155673600.0))) * 100));
+HXDLIN( 322)		int _hx_tmp2 = (_hx_tmp1 + (::Std_obj::_hx_int((quads / ((Float)126230400.0))) * 4));
+HXLINE( 325)		int _hx_tmp3;
+HXDLIN( 325)		if ((years == 4)) {
+HXLINE( 325)			_hx_tmp3 = years;
+            		}
+            		else {
+HXLINE( 325)			_hx_tmp3 = (years + 1);
+            		}
+HXLINE( 321)		return (_hx_tmp2 + _hx_tmp3);
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(DateTime_Impl__obj,getYear,return )
+
+Float DateTime_Impl__obj::yearStart(Float this1){
+            	HX_STACKFRAME(&_hx_pos_5a09d285486cbbfe_333_yearStart)
+HXLINE( 334)		Float cquads = (( (Float)(::Std_obj::_hx_int((this1 / ((Float)12622780800.0)))) ) * ((Float)12622780800.0));
+HXLINE( 335)		Float centuries = (( (Float)(::Std_obj::_hx_int(((this1 - cquads) / ((Float)3155673600.0)))) ) * ((Float)3155673600.0));
+HXLINE( 336)		if ((centuries > ((Float)9467020800.))) {
+HXLINE( 337)			centuries = (centuries - ((Float)3155673600.0));
+            		}
+HXLINE( 339)		Float quads = (( (Float)(::Std_obj::_hx_int((((this1 - cquads) - centuries) / ((Float)126230400.0)))) ) * ((Float)126230400.0));
+HXLINE( 341)		int years = ::Std_obj::_hx_int(((((this1 - cquads) - centuries) - quads) / ( (Float)(31536000) )));
+HXLINE( 342)		if ((years == 4)) {
+HXLINE( 343)			years = (years - 1);
+            		}
+HXLINE( 346)		return ((((cquads + centuries) + quads) + (years * 31536000)) - ((Float)62135596800.0));
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(DateTime_Impl__obj,yearStart,return )
+
+bool DateTime_Impl__obj::isLeapYear(Float this1){
+            	HX_STACKFRAME(&_hx_pos_5a09d285486cbbfe_376_isLeapYear)
+HXDLIN( 376)		int year = ::datetime::_DateTime::DateTime_Impl__obj::getYear(this1);
+HXDLIN( 376)		if ((::hx::Mod(year,4) == 0)) {
+HXDLIN( 376)			if ((::hx::Mod(year,100) == 0)) {
+HXDLIN( 376)				return (::hx::Mod(year,400) == 0);
+            			}
+            			else {
+HXDLIN( 376)				return true;
+            			}
+            		}
+            		else {
+HXDLIN( 376)			return false;
+            		}
+HXDLIN( 376)		return false;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(DateTime_Impl__obj,isLeapYear,return )
+
+
+DateTime_Impl__obj::DateTime_Impl__obj()
+{
+}
+
+bool DateTime_Impl__obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 7:
+		if (HX_FIELD_EQ(inName,"getYear") ) { outValue = getYear_dyn(); return true; }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"yearStart") ) { outValue = yearStart_dyn(); return true; }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"isLeapYear") ) { outValue = isLeapYear_dyn(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *DateTime_Impl__obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo *DateTime_Impl__obj_sStaticStorageInfo = 0;
+#endif
+
+::hx::Class DateTime_Impl__obj::__mClass;
+
+static ::String DateTime_Impl__obj_sStaticFields[] = {
+	HX_("getYear",73,79,ca,22),
+	HX_("yearStart",65,ad,8b,b2),
+	HX_("isLeapYear",8f,ff,8e,84),
+	::String(null())
+};
+
+void DateTime_Impl__obj::__register()
+{
+	DateTime_Impl__obj _hx_dummy;
+	DateTime_Impl__obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("datetime._DateTime.DateTime_Impl_",02,f1,15,34);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &DateTime_Impl__obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(DateTime_Impl__obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< DateTime_Impl__obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = DateTime_Impl__obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = DateTime_Impl__obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace datetime
+} // end namespace _DateTime
diff --git a/Sources/c_snikket/src/datetime/_DateTimeInterval/DateTimeInterval_Impl_.cpp b/Sources/c_snikket/src/datetime/_DateTimeInterval/DateTimeInterval_Impl_.cpp
new file mode 100644
index 0000000..26e96d6
--- /dev/null
+++ b/Sources/c_snikket/src/datetime/_DateTimeInterval/DateTimeInterval_Impl_.cpp
@@ -0,0 +1,108 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_datetime__DateTimeInterval_DateTimeInterval_Impl_
+#include <datetime/_DateTimeInterval/DateTimeInterval_Impl_.h>
+#endif
+#ifndef INCLUDED_datetime_cores_DateTimeIntervalCore
+#include <datetime/cores/DateTimeIntervalCore.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_685e120148cc45a9_22_create,"datetime._DateTimeInterval.DateTimeInterval_Impl_","create",0xb737c388,"datetime._DateTimeInterval.DateTimeInterval_Impl_.create","datetime/DateTimeInterval.hx",22,0x301776ca)
+namespace datetime{
+namespace _DateTimeInterval{
+
+void DateTimeInterval_Impl__obj::__construct() { }
+
+Dynamic DateTimeInterval_Impl__obj::__CreateEmpty() { return new DateTimeInterval_Impl__obj; }
+
+void *DateTimeInterval_Impl__obj::_hx_vtable = 0;
+
+Dynamic DateTimeInterval_Impl__obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< DateTimeInterval_Impl__obj > _hx_result = new DateTimeInterval_Impl__obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool DateTimeInterval_Impl__obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x35e51cc0;
+}
+
+ ::datetime::cores::DateTimeIntervalCore DateTimeInterval_Impl__obj::create(Float begin,Float end){
+            	HX_GC_STACKFRAME(&_hx_pos_685e120148cc45a9_22_create)
+HXLINE(  23)		 ::datetime::cores::DateTimeIntervalCore dtic =  ::datetime::cores::DateTimeIntervalCore_obj::__alloc( HX_CTX );
+HXLINE(  24)		Float _hx_tmp;
+HXDLIN(  24)		if (((end - ((Float)62135596800.0)) < (begin - ((Float)62135596800.0)))) {
+HXLINE(  24)			_hx_tmp = end;
+            		}
+            		else {
+HXLINE(  24)			_hx_tmp = begin;
+            		}
+HXDLIN(  24)		dtic->begin = _hx_tmp;
+HXLINE(  25)		Float _hx_tmp1;
+HXDLIN(  25)		if (((end - ((Float)62135596800.0)) < (begin - ((Float)62135596800.0)))) {
+HXLINE(  25)			_hx_tmp1 = begin;
+            		}
+            		else {
+HXLINE(  25)			_hx_tmp1 = end;
+            		}
+HXDLIN(  25)		dtic->end = _hx_tmp1;
+HXLINE(  26)		dtic->negative = ((end - ((Float)62135596800.0)) < (begin - ((Float)62135596800.0)));
+HXLINE(  28)		return dtic;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(DateTimeInterval_Impl__obj,create,return )
+
+
+DateTimeInterval_Impl__obj::DateTimeInterval_Impl__obj()
+{
+}
+
+bool DateTimeInterval_Impl__obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 6:
+		if (HX_FIELD_EQ(inName,"create") ) { outValue = create_dyn(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *DateTimeInterval_Impl__obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo *DateTimeInterval_Impl__obj_sStaticStorageInfo = 0;
+#endif
+
+::hx::Class DateTimeInterval_Impl__obj::__mClass;
+
+static ::String DateTimeInterval_Impl__obj_sStaticFields[] = {
+	HX_("create",fc,66,0f,7c),
+	::String(null())
+};
+
+void DateTimeInterval_Impl__obj::__register()
+{
+	DateTimeInterval_Impl__obj _hx_dummy;
+	DateTimeInterval_Impl__obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("datetime._DateTimeInterval.DateTimeInterval_Impl_",62,ea,b3,6b);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &DateTimeInterval_Impl__obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(DateTimeInterval_Impl__obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< DateTimeInterval_Impl__obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = DateTimeInterval_Impl__obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = DateTimeInterval_Impl__obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace datetime
+} // end namespace _DateTimeInterval
diff --git a/Sources/c_snikket/src/datetime/cores/DateTimeIntervalCore.cpp b/Sources/c_snikket/src/datetime/cores/DateTimeIntervalCore.cpp
new file mode 100644
index 0000000..cff5650
--- /dev/null
+++ b/Sources/c_snikket/src/datetime/cores/DateTimeIntervalCore.cpp
@@ -0,0 +1,572 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_95f339a1d026d52c
+#define INCLUDED_95f339a1d026d52c
+#include "hxMath.h"
+#endif
+#ifndef INCLUDED_Std
+#include <Std.h>
+#endif
+#ifndef INCLUDED_datetime__DateTime_DateTime_Impl_
+#include <datetime/_DateTime/DateTime_Impl_.h>
+#endif
+#ifndef INCLUDED_datetime_cores_DateTimeIntervalCore
+#include <datetime/cores/DateTimeIntervalCore.h>
+#endif
+#ifndef INCLUDED_datetime_utils_DateTimeMonthUtils
+#include <datetime/utils/DateTimeMonthUtils.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_83aeac1808ae1ded_17_new,"datetime.cores.DateTimeIntervalCore","new",0xdc5b211e,"datetime.cores.DateTimeIntervalCore.new","datetime/cores/DateTimeIntervalCore.hx",17,0xa7130d90)
+HX_LOCAL_STACK_FRAME(_hx_pos_83aeac1808ae1ded_54_getYears,"datetime.cores.DateTimeIntervalCore","getYears",0xfda50a22,"datetime.cores.DateTimeIntervalCore.getYears","datetime/cores/DateTimeIntervalCore.hx",54,0xa7130d90)
+HX_LOCAL_STACK_FRAME(_hx_pos_83aeac1808ae1ded_93_getMonths,"datetime.cores.DateTimeIntervalCore","getMonths",0xf1168da7,"datetime.cores.DateTimeIntervalCore.getMonths","datetime/cores/DateTimeIntervalCore.hx",93,0xa7130d90)
+HX_LOCAL_STACK_FRAME(_hx_pos_83aeac1808ae1ded_135_getTotalMonths,"datetime.cores.DateTimeIntervalCore","getTotalMonths",0x56f0e323,"datetime.cores.DateTimeIntervalCore.getTotalMonths","datetime/cores/DateTimeIntervalCore.hx",135,0xa7130d90)
+HX_LOCAL_STACK_FRAME(_hx_pos_83aeac1808ae1ded_143_getDays,"datetime.cores.DateTimeIntervalCore","getDays",0x74f7920b,"datetime.cores.DateTimeIntervalCore.getDays","datetime/cores/DateTimeIntervalCore.hx",143,0xa7130d90)
+HX_LOCAL_STACK_FRAME(_hx_pos_83aeac1808ae1ded_178_getTotalDays,"datetime.cores.DateTimeIntervalCore","getTotalDays",0x56485087,"datetime.cores.DateTimeIntervalCore.getTotalDays","datetime/cores/DateTimeIntervalCore.hx",178,0xa7130d90)
+HX_LOCAL_STACK_FRAME(_hx_pos_83aeac1808ae1ded_186_getHours,"datetime.cores.DateTimeIntervalCore","getHours",0x3a807cdb,"datetime.cores.DateTimeIntervalCore.getHours","datetime/cores/DateTimeIntervalCore.hx",186,0xa7130d90)
+HX_LOCAL_STACK_FRAME(_hx_pos_83aeac1808ae1ded_215_getTotalHours,"datetime.cores.DateTimeIntervalCore","getTotalHours",0x7fd66adf,"datetime.cores.DateTimeIntervalCore.getTotalHours","datetime/cores/DateTimeIntervalCore.hx",215,0xa7130d90)
+HX_LOCAL_STACK_FRAME(_hx_pos_83aeac1808ae1ded_223_getMinutes,"datetime.cores.DateTimeIntervalCore","getMinutes",0x9d33802b,"datetime.cores.DateTimeIntervalCore.getMinutes","datetime/cores/DateTimeIntervalCore.hx",223,0xa7130d90)
+HX_LOCAL_STACK_FRAME(_hx_pos_83aeac1808ae1ded_248_getTotalMinutes,"datetime.cores.DateTimeIntervalCore","getTotalMinutes",0x5663f72f,"datetime.cores.DateTimeIntervalCore.getTotalMinutes","datetime/cores/DateTimeIntervalCore.hx",248,0xa7130d90)
+HX_LOCAL_STACK_FRAME(_hx_pos_83aeac1808ae1ded_256_getSeconds,"datetime.cores.DateTimeIntervalCore","getSeconds",0xa3e29f8b,"datetime.cores.DateTimeIntervalCore.getSeconds","datetime/cores/DateTimeIntervalCore.hx",256,0xa7130d90)
+HX_LOCAL_STACK_FRAME(_hx_pos_83aeac1808ae1ded_277_getTotalSeconds,"datetime.cores.DateTimeIntervalCore","getTotalSeconds",0x5d13168f,"datetime.cores.DateTimeIntervalCore.getTotalSeconds","datetime/cores/DateTimeIntervalCore.hx",277,0xa7130d90)
+namespace datetime{
+namespace cores{
+
+void DateTimeIntervalCore_obj::__construct(){
+            	HX_STACKFRAME(&_hx_pos_83aeac1808ae1ded_17_new)
+HXLINE(  37)		this->seconds = -1;
+HXLINE(  35)		this->minutes = -1;
+HXLINE(  33)		this->hours = -1;
+HXLINE(  31)		this->days = -1;
+HXLINE(  29)		this->months = -1;
+HXLINE(  27)		this->years = -1;
+HXLINE(  19)		this->negative = false;
+            	}
+
+Dynamic DateTimeIntervalCore_obj::__CreateEmpty() { return new DateTimeIntervalCore_obj; }
+
+void *DateTimeIntervalCore_obj::_hx_vtable = 0;
+
+Dynamic DateTimeIntervalCore_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< DateTimeIntervalCore_obj > _hx_result = new DateTimeIntervalCore_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool DateTimeIntervalCore_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x2dc1c9d4;
+}
+
+int DateTimeIntervalCore_obj::getYears(){
+            	HX_STACKFRAME(&_hx_pos_83aeac1808ae1ded_54_getYears)
+HXLINE(  55)		if ((this->years < 0)) {
+HXLINE(  56)			int _hx_tmp = ::datetime::_DateTime::DateTime_Impl__obj::getYear(this->end);
+HXDLIN(  56)			this->years = (_hx_tmp - ::datetime::_DateTime::DateTime_Impl__obj::getYear(this->begin));
+HXLINE(  58)			Float this1 = this->begin;
+HXDLIN(  58)			int days = (::Std_obj::_hx_int((((this1 - ((Float)62135596800.0)) - ::datetime::_DateTime::DateTime_Impl__obj::yearStart(this1)) / ( (Float)(86400) ))) + 1);
+HXDLIN(  58)			int m1 = ::datetime::utils::DateTimeMonthUtils_obj::getMonth(days,::datetime::_DateTime::DateTime_Impl__obj::isLeapYear(this1));
+HXLINE(  59)			Float this2 = this->end;
+HXDLIN(  59)			int days1 = (::Std_obj::_hx_int((((this2 - ((Float)62135596800.0)) - ::datetime::_DateTime::DateTime_Impl__obj::yearStart(this2)) / ( (Float)(86400) ))) + 1);
+HXDLIN(  59)			int m2 = ::datetime::utils::DateTimeMonthUtils_obj::getMonth(days1,::datetime::_DateTime::DateTime_Impl__obj::isLeapYear(this2));
+HXLINE(  60)			if ((m2 < m1)) {
+HXLINE(  61)				this->years--;
+            			}
+            			else {
+HXLINE(  62)				if ((m1 == m2)) {
+HXLINE(  63)					Float this3 = this->begin;
+HXDLIN(  63)					int days2 = (::Std_obj::_hx_int((((this3 - ((Float)62135596800.0)) - ::datetime::_DateTime::DateTime_Impl__obj::yearStart(this3)) / ( (Float)(86400) ))) + 1);
+HXDLIN(  63)					int d1 = ::datetime::utils::DateTimeMonthUtils_obj::getMonthDay(days2,::datetime::_DateTime::DateTime_Impl__obj::isLeapYear(this3));
+HXLINE(  64)					Float this4 = this->end;
+HXDLIN(  64)					int days3 = (::Std_obj::_hx_int((((this4 - ((Float)62135596800.0)) - ::datetime::_DateTime::DateTime_Impl__obj::yearStart(this4)) / ( (Float)(86400) ))) + 1);
+HXDLIN(  64)					int d2 = ::datetime::utils::DateTimeMonthUtils_obj::getMonthDay(days3,::datetime::_DateTime::DateTime_Impl__obj::isLeapYear(this4));
+HXLINE(  65)					if ((d2 < d1)) {
+HXLINE(  66)						this->years--;
+            					}
+            					else {
+HXLINE(  67)						if ((d1 == d2)) {
+HXLINE(  68)							Float this5 = this->begin;
+HXDLIN(  68)							int h1 = ::Std_obj::_hx_int(((this5 - (::Math_obj::ffloor((this5 / ( (Float)(86400) ))) * ( (Float)(86400) ))) / ( (Float)(3600) )));
+HXLINE(  69)							Float this6 = this->end;
+HXDLIN(  69)							int h2 = ::Std_obj::_hx_int(((this6 - (::Math_obj::ffloor((this6 / ( (Float)(86400) ))) * ( (Float)(86400) ))) / ( (Float)(3600) )));
+HXLINE(  70)							if ((h2 < h1)) {
+HXLINE(  71)								this->years--;
+            							}
+            							else {
+HXLINE(  72)								if ((h2 == h1)) {
+HXLINE(  73)									Float this7 = this->begin;
+HXDLIN(  73)									int m11 = ::Std_obj::_hx_int(((this7 - (::Math_obj::ffloor((this7 / ( (Float)(3600) ))) * ( (Float)(3600) ))) / ( (Float)(60) )));
+HXLINE(  74)									Float this8 = this->end;
+HXDLIN(  74)									int m21 = ::Std_obj::_hx_int(((this8 - (::Math_obj::ffloor((this8 / ( (Float)(3600) ))) * ( (Float)(3600) ))) / ( (Float)(60) )));
+HXLINE(  75)									if ((m21 < m11)) {
+HXLINE(  76)										this->years--;
+            									}
+            									else {
+HXLINE(  77)										bool _hx_tmp1;
+HXDLIN(  77)										if ((m21 == m11)) {
+HXLINE(  77)											Float this9 = this->end;
+HXDLIN(  77)											int _hx_tmp2 = ::Std_obj::_hx_int((this9 - (::Math_obj::ffloor((this9 / ( (Float)(60) ))) * ( (Float)(60) ))));
+HXDLIN(  77)											Float this10 = this->begin;
+HXDLIN(  77)											_hx_tmp1 = (_hx_tmp2 < ::Std_obj::_hx_int((this10 - (::Math_obj::ffloor((this10 / ( (Float)(60) ))) * ( (Float)(60) )))));
+            										}
+            										else {
+HXLINE(  77)											_hx_tmp1 = false;
+            										}
+HXDLIN(  77)										if (_hx_tmp1) {
+HXLINE(  78)											this->years--;
+            										}
+            									}
+            								}
+            							}
+            						}
+            					}
+            				}
+            			}
+            		}
+HXLINE(  85)		return this->years;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(DateTimeIntervalCore_obj,getYears,return )
+
+int DateTimeIntervalCore_obj::getMonths(){
+            	HX_STACKFRAME(&_hx_pos_83aeac1808ae1ded_93_getMonths)
+HXLINE(  94)		if ((this->months < 0)) {
+HXLINE(  95)			Float this1 = this->begin;
+HXDLIN(  95)			int days = (::Std_obj::_hx_int((((this1 - ((Float)62135596800.0)) - ::datetime::_DateTime::DateTime_Impl__obj::yearStart(this1)) / ( (Float)(86400) ))) + 1);
+HXDLIN(  95)			int monthBegin = ::datetime::utils::DateTimeMonthUtils_obj::getMonth(days,::datetime::_DateTime::DateTime_Impl__obj::isLeapYear(this1));
+HXLINE(  96)			Float this2 = this->end;
+HXDLIN(  96)			int days1 = (::Std_obj::_hx_int((((this2 - ((Float)62135596800.0)) - ::datetime::_DateTime::DateTime_Impl__obj::yearStart(this2)) / ( (Float)(86400) ))) + 1);
+HXDLIN(  96)			int monthEnd = ::datetime::utils::DateTimeMonthUtils_obj::getMonth(days1,::datetime::_DateTime::DateTime_Impl__obj::isLeapYear(this2));
+HXLINE(  98)			int _hx_tmp;
+HXDLIN(  98)			if ((monthBegin <= monthEnd)) {
+HXLINE(  98)				_hx_tmp = (monthEnd - monthBegin);
+            			}
+            			else {
+HXLINE(  98)				_hx_tmp = ((12 - monthBegin) + monthEnd);
+            			}
+HXDLIN(  98)			this->months = _hx_tmp;
+HXLINE( 104)			Float this3 = this->begin;
+HXDLIN( 104)			int days2 = (::Std_obj::_hx_int((((this3 - ((Float)62135596800.0)) - ::datetime::_DateTime::DateTime_Impl__obj::yearStart(this3)) / ( (Float)(86400) ))) + 1);
+HXDLIN( 104)			int d1 = ::datetime::utils::DateTimeMonthUtils_obj::getMonthDay(days2,::datetime::_DateTime::DateTime_Impl__obj::isLeapYear(this3));
+HXLINE( 105)			Float this4 = this->end;
+HXDLIN( 105)			int days3 = (::Std_obj::_hx_int((((this4 - ((Float)62135596800.0)) - ::datetime::_DateTime::DateTime_Impl__obj::yearStart(this4)) / ( (Float)(86400) ))) + 1);
+HXDLIN( 105)			int d2 = ::datetime::utils::DateTimeMonthUtils_obj::getMonthDay(days3,::datetime::_DateTime::DateTime_Impl__obj::isLeapYear(this4));
+HXLINE( 106)			if ((d2 < d1)) {
+HXLINE( 107)				this->months--;
+            			}
+            			else {
+HXLINE( 108)				if ((d1 == d2)) {
+HXLINE( 109)					Float this5 = this->begin;
+HXDLIN( 109)					int h1 = ::Std_obj::_hx_int(((this5 - (::Math_obj::ffloor((this5 / ( (Float)(86400) ))) * ( (Float)(86400) ))) / ( (Float)(3600) )));
+HXLINE( 110)					Float this6 = this->end;
+HXDLIN( 110)					int h2 = ::Std_obj::_hx_int(((this6 - (::Math_obj::ffloor((this6 / ( (Float)(86400) ))) * ( (Float)(86400) ))) / ( (Float)(3600) )));
+HXLINE( 111)					if ((h2 < h1)) {
+HXLINE( 112)						this->months--;
+            					}
+            					else {
+HXLINE( 113)						if ((h2 == h1)) {
+HXLINE( 114)							Float this7 = this->begin;
+HXDLIN( 114)							int m1 = ::Std_obj::_hx_int(((this7 - (::Math_obj::ffloor((this7 / ( (Float)(3600) ))) * ( (Float)(3600) ))) / ( (Float)(60) )));
+HXLINE( 115)							Float this8 = this->end;
+HXDLIN( 115)							int m2 = ::Std_obj::_hx_int(((this8 - (::Math_obj::ffloor((this8 / ( (Float)(3600) ))) * ( (Float)(3600) ))) / ( (Float)(60) )));
+HXLINE( 116)							if ((m2 < m1)) {
+HXLINE( 117)								this->months--;
+            							}
+            							else {
+HXLINE( 118)								bool _hx_tmp1;
+HXDLIN( 118)								if ((m2 == m1)) {
+HXLINE( 118)									Float this9 = this->end;
+HXDLIN( 118)									int _hx_tmp2 = ::Std_obj::_hx_int((this9 - (::Math_obj::ffloor((this9 / ( (Float)(60) ))) * ( (Float)(60) ))));
+HXDLIN( 118)									Float this10 = this->begin;
+HXDLIN( 118)									_hx_tmp1 = (_hx_tmp2 < ::Std_obj::_hx_int((this10 - (::Math_obj::ffloor((this10 / ( (Float)(60) ))) * ( (Float)(60) )))));
+            								}
+            								else {
+HXLINE( 118)									_hx_tmp1 = false;
+            								}
+HXDLIN( 118)								if (_hx_tmp1) {
+HXLINE( 119)									this->months--;
+            								}
+            							}
+            						}
+            					}
+            				}
+            			}
+            		}
+HXLINE( 125)		return this->months;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(DateTimeIntervalCore_obj,getMonths,return )
+
+int DateTimeIntervalCore_obj::getTotalMonths(){
+            	HX_STACKFRAME(&_hx_pos_83aeac1808ae1ded_135_getTotalMonths)
+HXDLIN( 135)		int _hx_tmp = (this->getYears() * 12);
+HXDLIN( 135)		return (_hx_tmp + this->getMonths());
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(DateTimeIntervalCore_obj,getTotalMonths,return )
+
+int DateTimeIntervalCore_obj::getDays(){
+            	HX_STACKFRAME(&_hx_pos_83aeac1808ae1ded_143_getDays)
+HXLINE( 144)		if ((this->days < 0)) {
+HXLINE( 145)			Float this1 = this->begin;
+HXDLIN( 145)			int days = (::Std_obj::_hx_int((((this1 - ((Float)62135596800.0)) - ::datetime::_DateTime::DateTime_Impl__obj::yearStart(this1)) / ( (Float)(86400) ))) + 1);
+HXDLIN( 145)			int dayBegin = ::datetime::utils::DateTimeMonthUtils_obj::getMonthDay(days,::datetime::_DateTime::DateTime_Impl__obj::isLeapYear(this1));
+HXLINE( 146)			Float this2 = this->end;
+HXDLIN( 146)			int days1 = (::Std_obj::_hx_int((((this2 - ((Float)62135596800.0)) - ::datetime::_DateTime::DateTime_Impl__obj::yearStart(this2)) / ( (Float)(86400) ))) + 1);
+HXDLIN( 146)			int dayEnd = ::datetime::utils::DateTimeMonthUtils_obj::getMonthDay(days1,::datetime::_DateTime::DateTime_Impl__obj::isLeapYear(this2));
+HXLINE( 148)			int _hx_tmp;
+HXDLIN( 148)			if ((dayBegin <= dayEnd)) {
+HXLINE( 148)				_hx_tmp = (dayEnd - dayBegin);
+            			}
+            			else {
+HXLINE( 151)				Float this3 = this->begin;
+HXDLIN( 151)				int days2 = (::Std_obj::_hx_int((((this3 - ((Float)62135596800.0)) - ::datetime::_DateTime::DateTime_Impl__obj::yearStart(this3)) / ( (Float)(86400) ))) + 1);
+HXDLIN( 151)				int _hx_tmp1 = ::datetime::utils::DateTimeMonthUtils_obj::getMonth(days2,::datetime::_DateTime::DateTime_Impl__obj::isLeapYear(this3));
+HXLINE( 148)				_hx_tmp = ((::datetime::utils::DateTimeMonthUtils_obj::days(_hx_tmp1,::datetime::_DateTime::DateTime_Impl__obj::isLeapYear(this->begin)) - dayBegin) + dayEnd);
+            			}
+HXDLIN( 148)			this->days = _hx_tmp;
+HXLINE( 154)			Float this4 = this->begin;
+HXDLIN( 154)			int h1 = ::Std_obj::_hx_int(((this4 - (::Math_obj::ffloor((this4 / ( (Float)(86400) ))) * ( (Float)(86400) ))) / ( (Float)(3600) )));
+HXLINE( 155)			Float this5 = this->end;
+HXDLIN( 155)			int h2 = ::Std_obj::_hx_int(((this5 - (::Math_obj::ffloor((this5 / ( (Float)(86400) ))) * ( (Float)(86400) ))) / ( (Float)(3600) )));
+HXLINE( 156)			if ((h2 < h1)) {
+HXLINE( 157)				this->days--;
+            			}
+            			else {
+HXLINE( 158)				if ((h2 == h1)) {
+HXLINE( 159)					Float this6 = this->begin;
+HXDLIN( 159)					int m1 = ::Std_obj::_hx_int(((this6 - (::Math_obj::ffloor((this6 / ( (Float)(3600) ))) * ( (Float)(3600) ))) / ( (Float)(60) )));
+HXLINE( 160)					Float this7 = this->end;
+HXDLIN( 160)					int m2 = ::Std_obj::_hx_int(((this7 - (::Math_obj::ffloor((this7 / ( (Float)(3600) ))) * ( (Float)(3600) ))) / ( (Float)(60) )));
+HXLINE( 161)					if ((m2 < m1)) {
+HXLINE( 162)						this->days--;
+            					}
+            					else {
+HXLINE( 163)						bool _hx_tmp2;
+HXDLIN( 163)						if ((m2 == m1)) {
+HXLINE( 163)							Float this8 = this->end;
+HXDLIN( 163)							int _hx_tmp3 = ::Std_obj::_hx_int((this8 - (::Math_obj::ffloor((this8 / ( (Float)(60) ))) * ( (Float)(60) ))));
+HXDLIN( 163)							Float this9 = this->begin;
+HXDLIN( 163)							_hx_tmp2 = (_hx_tmp3 < ::Std_obj::_hx_int((this9 - (::Math_obj::ffloor((this9 / ( (Float)(60) ))) * ( (Float)(60) )))));
+            						}
+            						else {
+HXLINE( 163)							_hx_tmp2 = false;
+            						}
+HXDLIN( 163)						if (_hx_tmp2) {
+HXLINE( 164)							this->days--;
+            						}
+            					}
+            				}
+            			}
+            		}
+HXLINE( 169)		return this->days;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(DateTimeIntervalCore_obj,getDays,return )
+
+int DateTimeIntervalCore_obj::getTotalDays(){
+            	HX_STACKFRAME(&_hx_pos_83aeac1808ae1ded_178_getTotalDays)
+HXDLIN( 178)		return ::Std_obj::_hx_int((((this->end - ((Float)62135596800.0)) - (this->begin - ((Float)62135596800.0))) / ( (Float)(86400) )));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(DateTimeIntervalCore_obj,getTotalDays,return )
+
+int DateTimeIntervalCore_obj::getHours(){
+            	HX_STACKFRAME(&_hx_pos_83aeac1808ae1ded_186_getHours)
+HXLINE( 187)		if ((this->hours < 0)) {
+HXLINE( 188)			Float this1 = this->begin;
+HXDLIN( 188)			int hourBegin = ::Std_obj::_hx_int(((this1 - (::Math_obj::ffloor((this1 / ( (Float)(86400) ))) * ( (Float)(86400) ))) / ( (Float)(3600) )));
+HXLINE( 189)			Float this2 = this->end;
+HXDLIN( 189)			int hourEnd = ::Std_obj::_hx_int(((this2 - (::Math_obj::ffloor((this2 / ( (Float)(86400) ))) * ( (Float)(86400) ))) / ( (Float)(3600) )));
+HXLINE( 191)			int _hx_tmp;
+HXDLIN( 191)			if ((hourBegin <= hourEnd)) {
+HXLINE( 191)				_hx_tmp = (hourEnd - hourBegin);
+            			}
+            			else {
+HXLINE( 191)				_hx_tmp = ((24 - hourBegin) + hourEnd);
+            			}
+HXDLIN( 191)			this->hours = _hx_tmp;
+HXLINE( 197)			Float this3 = this->begin;
+HXDLIN( 197)			int m1 = ::Std_obj::_hx_int(((this3 - (::Math_obj::ffloor((this3 / ( (Float)(3600) ))) * ( (Float)(3600) ))) / ( (Float)(60) )));
+HXLINE( 198)			Float this4 = this->end;
+HXDLIN( 198)			int m2 = ::Std_obj::_hx_int(((this4 - (::Math_obj::ffloor((this4 / ( (Float)(3600) ))) * ( (Float)(3600) ))) / ( (Float)(60) )));
+HXLINE( 199)			if ((m2 < m1)) {
+HXLINE( 200)				this->hours--;
+            			}
+            			else {
+HXLINE( 201)				bool _hx_tmp1;
+HXDLIN( 201)				if ((m2 == m1)) {
+HXLINE( 201)					Float this5 = this->end;
+HXDLIN( 201)					int _hx_tmp2 = ::Std_obj::_hx_int((this5 - (::Math_obj::ffloor((this5 / ( (Float)(60) ))) * ( (Float)(60) ))));
+HXDLIN( 201)					Float this6 = this->begin;
+HXDLIN( 201)					_hx_tmp1 = (_hx_tmp2 < ::Std_obj::_hx_int((this6 - (::Math_obj::ffloor((this6 / ( (Float)(60) ))) * ( (Float)(60) )))));
+            				}
+            				else {
+HXLINE( 201)					_hx_tmp1 = false;
+            				}
+HXDLIN( 201)				if (_hx_tmp1) {
+HXLINE( 202)					this->hours--;
+            				}
+            			}
+            		}
+HXLINE( 206)		return this->hours;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(DateTimeIntervalCore_obj,getHours,return )
+
+int DateTimeIntervalCore_obj::getTotalHours(){
+            	HX_STACKFRAME(&_hx_pos_83aeac1808ae1ded_215_getTotalHours)
+HXDLIN( 215)		return ::Std_obj::_hx_int((((this->end - ((Float)62135596800.0)) - (this->begin - ((Float)62135596800.0))) / ( (Float)(3600) )));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(DateTimeIntervalCore_obj,getTotalHours,return )
+
+int DateTimeIntervalCore_obj::getMinutes(){
+            	HX_STACKFRAME(&_hx_pos_83aeac1808ae1ded_223_getMinutes)
+HXLINE( 224)		if ((this->minutes < 0)) {
+HXLINE( 225)			Float this1 = this->begin;
+HXDLIN( 225)			int minuteBegin = ::Std_obj::_hx_int(((this1 - (::Math_obj::ffloor((this1 / ( (Float)(3600) ))) * ( (Float)(3600) ))) / ( (Float)(60) )));
+HXLINE( 226)			Float this2 = this->end;
+HXDLIN( 226)			int minuteEnd = ::Std_obj::_hx_int(((this2 - (::Math_obj::ffloor((this2 / ( (Float)(3600) ))) * ( (Float)(3600) ))) / ( (Float)(60) )));
+HXLINE( 228)			int _hx_tmp;
+HXDLIN( 228)			if ((minuteBegin <= minuteEnd)) {
+HXLINE( 228)				_hx_tmp = (minuteEnd - minuteBegin);
+            			}
+            			else {
+HXLINE( 228)				_hx_tmp = ((60 - minuteBegin) + minuteEnd);
+            			}
+HXDLIN( 228)			this->minutes = _hx_tmp;
+HXLINE( 234)			Float this3 = this->end;
+HXDLIN( 234)			int _hx_tmp1 = ::Std_obj::_hx_int((this3 - (::Math_obj::ffloor((this3 / ( (Float)(60) ))) * ( (Float)(60) ))));
+HXDLIN( 234)			Float this4 = this->begin;
+HXDLIN( 234)			if ((_hx_tmp1 < ::Std_obj::_hx_int((this4 - (::Math_obj::ffloor((this4 / ( (Float)(60) ))) * ( (Float)(60) )))))) {
+HXLINE( 235)				this->minutes--;
+            			}
+            		}
+HXLINE( 239)		return this->minutes;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(DateTimeIntervalCore_obj,getMinutes,return )
+
+int DateTimeIntervalCore_obj::getTotalMinutes(){
+            	HX_STACKFRAME(&_hx_pos_83aeac1808ae1ded_248_getTotalMinutes)
+HXDLIN( 248)		return ::Std_obj::_hx_int((((this->end - ((Float)62135596800.0)) - (this->begin - ((Float)62135596800.0))) / ( (Float)(60) )));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(DateTimeIntervalCore_obj,getTotalMinutes,return )
+
+int DateTimeIntervalCore_obj::getSeconds(){
+            	HX_STACKFRAME(&_hx_pos_83aeac1808ae1ded_256_getSeconds)
+HXLINE( 257)		if ((this->seconds < 0)) {
+HXLINE( 258)			Float this1 = this->begin;
+HXDLIN( 258)			int secondBegin = ::Std_obj::_hx_int((this1 - (::Math_obj::ffloor((this1 / ( (Float)(60) ))) * ( (Float)(60) ))));
+HXLINE( 259)			Float this2 = this->end;
+HXDLIN( 259)			int secondEnd = ::Std_obj::_hx_int((this2 - (::Math_obj::ffloor((this2 / ( (Float)(60) ))) * ( (Float)(60) ))));
+HXLINE( 261)			int _hx_tmp;
+HXDLIN( 261)			if ((secondBegin <= secondEnd)) {
+HXLINE( 261)				_hx_tmp = (secondEnd - secondBegin);
+            			}
+            			else {
+HXLINE( 261)				_hx_tmp = ((60 - secondBegin) + secondEnd);
+            			}
+HXDLIN( 261)			this->seconds = _hx_tmp;
+            		}
+HXLINE( 268)		return this->seconds;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(DateTimeIntervalCore_obj,getSeconds,return )
+
+Float DateTimeIntervalCore_obj::getTotalSeconds(){
+            	HX_STACKFRAME(&_hx_pos_83aeac1808ae1ded_277_getTotalSeconds)
+HXDLIN( 277)		return ((this->end - ((Float)62135596800.0)) - (this->begin - ((Float)62135596800.0)));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(DateTimeIntervalCore_obj,getTotalSeconds,return )
+
+
+::hx::ObjectPtr< DateTimeIntervalCore_obj > DateTimeIntervalCore_obj::__new() {
+	::hx::ObjectPtr< DateTimeIntervalCore_obj > __this = new DateTimeIntervalCore_obj();
+	__this->__construct();
+	return __this;
+}
+
+::hx::ObjectPtr< DateTimeIntervalCore_obj > DateTimeIntervalCore_obj::__alloc(::hx::Ctx *_hx_ctx) {
+	DateTimeIntervalCore_obj *__this = (DateTimeIntervalCore_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(DateTimeIntervalCore_obj), false, "datetime.cores.DateTimeIntervalCore"));
+	*(void **)__this = DateTimeIntervalCore_obj::_hx_vtable;
+	__this->__construct();
+	return __this;
+}
+
+DateTimeIntervalCore_obj::DateTimeIntervalCore_obj()
+{
+}
+
+::hx::Val DateTimeIntervalCore_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"end") ) { return ::hx::Val( end ); }
+		break;
+	case 4:
+		if (HX_FIELD_EQ(inName,"days") ) { return ::hx::Val( days ); }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"begin") ) { return ::hx::Val( begin ); }
+		if (HX_FIELD_EQ(inName,"years") ) { return ::hx::Val( years ); }
+		if (HX_FIELD_EQ(inName,"hours") ) { return ::hx::Val( hours ); }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"months") ) { return ::hx::Val( months ); }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"minutes") ) { return ::hx::Val( minutes ); }
+		if (HX_FIELD_EQ(inName,"seconds") ) { return ::hx::Val( seconds ); }
+		if (HX_FIELD_EQ(inName,"getDays") ) { return ::hx::Val( getDays_dyn() ); }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"negative") ) { return ::hx::Val( negative ); }
+		if (HX_FIELD_EQ(inName,"getYears") ) { return ::hx::Val( getYears_dyn() ); }
+		if (HX_FIELD_EQ(inName,"getHours") ) { return ::hx::Val( getHours_dyn() ); }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"getMonths") ) { return ::hx::Val( getMonths_dyn() ); }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"getMinutes") ) { return ::hx::Val( getMinutes_dyn() ); }
+		if (HX_FIELD_EQ(inName,"getSeconds") ) { return ::hx::Val( getSeconds_dyn() ); }
+		break;
+	case 12:
+		if (HX_FIELD_EQ(inName,"getTotalDays") ) { return ::hx::Val( getTotalDays_dyn() ); }
+		break;
+	case 13:
+		if (HX_FIELD_EQ(inName,"getTotalHours") ) { return ::hx::Val( getTotalHours_dyn() ); }
+		break;
+	case 14:
+		if (HX_FIELD_EQ(inName,"getTotalMonths") ) { return ::hx::Val( getTotalMonths_dyn() ); }
+		break;
+	case 15:
+		if (HX_FIELD_EQ(inName,"getTotalMinutes") ) { return ::hx::Val( getTotalMinutes_dyn() ); }
+		if (HX_FIELD_EQ(inName,"getTotalSeconds") ) { return ::hx::Val( getTotalSeconds_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val DateTimeIntervalCore_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"end") ) { end=inValue.Cast< Float >(); return inValue; }
+		break;
+	case 4:
+		if (HX_FIELD_EQ(inName,"days") ) { days=inValue.Cast< int >(); return inValue; }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"begin") ) { begin=inValue.Cast< Float >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"years") ) { years=inValue.Cast< int >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"hours") ) { hours=inValue.Cast< int >(); return inValue; }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"months") ) { months=inValue.Cast< int >(); return inValue; }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"minutes") ) { minutes=inValue.Cast< int >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"seconds") ) { seconds=inValue.Cast< int >(); return inValue; }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"negative") ) { negative=inValue.Cast< bool >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void DateTimeIntervalCore_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("negative",75,26,42,51));
+	outFields->push(HX_("begin",29,ea,55,b0));
+	outFields->push(HX_("end",db,03,4d,00));
+	outFields->push(HX_("years",16,bc,88,ee));
+	outFields->push(HX_("months",33,91,6e,c7));
+	outFields->push(HX_("days",97,5a,63,42));
+	outFields->push(HX_("hours",cf,2e,64,2b));
+	outFields->push(HX_("minutes",1f,97,de,53));
+	outFields->push(HX_("seconds",7f,b6,8d,5a));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo DateTimeIntervalCore_obj_sMemberStorageInfo[] = {
+	{::hx::fsBool,(int)offsetof(DateTimeIntervalCore_obj,negative),HX_("negative",75,26,42,51)},
+	{::hx::fsFloat,(int)offsetof(DateTimeIntervalCore_obj,begin),HX_("begin",29,ea,55,b0)},
+	{::hx::fsFloat,(int)offsetof(DateTimeIntervalCore_obj,end),HX_("end",db,03,4d,00)},
+	{::hx::fsInt,(int)offsetof(DateTimeIntervalCore_obj,years),HX_("years",16,bc,88,ee)},
+	{::hx::fsInt,(int)offsetof(DateTimeIntervalCore_obj,months),HX_("months",33,91,6e,c7)},
+	{::hx::fsInt,(int)offsetof(DateTimeIntervalCore_obj,days),HX_("days",97,5a,63,42)},
+	{::hx::fsInt,(int)offsetof(DateTimeIntervalCore_obj,hours),HX_("hours",cf,2e,64,2b)},
+	{::hx::fsInt,(int)offsetof(DateTimeIntervalCore_obj,minutes),HX_("minutes",1f,97,de,53)},
+	{::hx::fsInt,(int)offsetof(DateTimeIntervalCore_obj,seconds),HX_("seconds",7f,b6,8d,5a)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *DateTimeIntervalCore_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String DateTimeIntervalCore_obj_sMemberFields[] = {
+	HX_("negative",75,26,42,51),
+	HX_("begin",29,ea,55,b0),
+	HX_("end",db,03,4d,00),
+	HX_("years",16,bc,88,ee),
+	HX_("months",33,91,6e,c7),
+	HX_("days",97,5a,63,42),
+	HX_("hours",cf,2e,64,2b),
+	HX_("minutes",1f,97,de,53),
+	HX_("seconds",7f,b6,8d,5a),
+	HX_("getYears",a0,cb,5f,4e),
+	HX_("getMonths",69,1a,c5,43),
+	HX_("getTotalMonths",21,d7,42,15),
+	HX_("getDays",4d,0a,e6,14),
+	HX_("getTotalDays",05,a9,74,6e),
+	HX_("getHours",59,3e,3b,8b),
+	HX_("getTotalHours",a1,80,77,8e),
+	HX_("getMinutes",29,1d,40,a3),
+	HX_("getTotalMinutes",71,81,c7,1f),
+	HX_("getSeconds",89,3c,ef,a9),
+	HX_("getTotalSeconds",d1,a0,76,26),
+	::String(null()) };
+
+::hx::Class DateTimeIntervalCore_obj::__mClass;
+
+void DateTimeIntervalCore_obj::__register()
+{
+	DateTimeIntervalCore_obj _hx_dummy;
+	DateTimeIntervalCore_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("datetime.cores.DateTimeIntervalCore",2c,fa,f8,5e);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(DateTimeIntervalCore_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< DateTimeIntervalCore_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = DateTimeIntervalCore_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = DateTimeIntervalCore_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace datetime
+} // end namespace cores
diff --git a/Sources/c_snikket/src/datetime/utils/DateTimeIntervalUtils.cpp b/Sources/c_snikket/src/datetime/utils/DateTimeIntervalUtils.cpp
new file mode 100644
index 0000000..15df9da
--- /dev/null
+++ b/Sources/c_snikket/src/datetime/utils/DateTimeIntervalUtils.cpp
@@ -0,0 +1,199 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_StringTools
+#include <StringTools.h>
+#endif
+#ifndef INCLUDED_datetime_cores_DateTimeIntervalCore
+#include <datetime/cores/DateTimeIntervalCore.h>
+#endif
+#ifndef INCLUDED_datetime_utils_DateTimeIntervalUtils
+#include <datetime/utils/DateTimeIntervalUtils.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_a0b77070014f1410_21_strftime,"datetime.utils.DateTimeIntervalUtils","strftime",0x585a38af,"datetime.utils.DateTimeIntervalUtils.strftime","datetime/utils/DateTimeIntervalUtils.hx",21,0x78b63b9f)
+namespace datetime{
+namespace utils{
+
+void DateTimeIntervalUtils_obj::__construct() { }
+
+Dynamic DateTimeIntervalUtils_obj::__CreateEmpty() { return new DateTimeIntervalUtils_obj; }
+
+void *DateTimeIntervalUtils_obj::_hx_vtable = 0;
+
+Dynamic DateTimeIntervalUtils_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< DateTimeIntervalUtils_obj > _hx_result = new DateTimeIntervalUtils_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool DateTimeIntervalUtils_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x144eafbf;
+}
+
+::String DateTimeIntervalUtils_obj::strftime( ::datetime::cores::DateTimeIntervalCore dti,::String format){
+            	HX_STACKFRAME(&_hx_pos_a0b77070014f1410_21_strftime)
+HXLINE(  22)		int prevPos = 0;
+HXLINE(  23)		int pos = format.indexOf(HX_("%",25,00,00,00),null());
+HXLINE(  24)		::String str = HX_("",00,00,00,00);
+HXLINE(  26)		while((pos >= 0)){
+HXLINE(  27)			str = (str + format.substring(prevPos,pos));
+HXLINE(  28)			pos = (pos + 1);
+HXLINE(  30)			switch((int)(format.cca(pos))){
+            				case (int)37: {
+HXLINE(  90)					str = (str + HX_("%",25,00,00,00));
+            				}
+            				break;
+            				case (int)68: {
+HXLINE(  48)					str = (str + ::StringTools_obj::lpad((dti->getDays() + HX_("",00,00,00,00)),HX_("0",30,00,00,00),2));
+            				}
+            				break;
+            				case (int)72: {
+HXLINE(  57)					str = (str + ::StringTools_obj::lpad((dti->getHours() + HX_("",00,00,00,00)),HX_("0",30,00,00,00),2));
+            				}
+            				break;
+            				case (int)73: {
+HXLINE(  66)					str = (str + ::StringTools_obj::lpad((dti->getMinutes() + HX_("",00,00,00,00)),HX_("0",30,00,00,00),2));
+            				}
+            				break;
+            				case (int)77: {
+HXLINE(  39)					str = (str + ::StringTools_obj::lpad((dti->getMonths() + HX_("",00,00,00,00)),HX_("0",30,00,00,00),2));
+            				}
+            				break;
+            				case (int)82: {
+HXLINE(  84)					::String str1;
+HXDLIN(  84)					if (dti->negative) {
+HXLINE(  84)						str1 = HX_("-",2d,00,00,00);
+            					}
+            					else {
+HXLINE(  84)						str1 = HX_("+",2b,00,00,00);
+            					}
+HXDLIN(  84)					str = (str + str1);
+            				}
+            				break;
+            				case (int)83: {
+HXLINE(  75)					str = (str + ::StringTools_obj::lpad((dti->getSeconds() + HX_("",00,00,00,00)),HX_("0",30,00,00,00),2));
+            				}
+            				break;
+            				case (int)89: {
+HXLINE(  33)					str = (str + ::StringTools_obj::lpad((dti->getYears() + HX_("",00,00,00,00)),HX_("0",30,00,00,00),2));
+            				}
+            				break;
+            				case (int)97: {
+HXLINE(  54)					str = (str + (dti->getTotalDays() + HX_("",00,00,00,00)));
+            				}
+            				break;
+            				case (int)98: {
+HXLINE(  45)					str = (str + (dti->getTotalMonths() + HX_("",00,00,00,00)));
+            				}
+            				break;
+            				case (int)99: {
+HXLINE(  63)					str = (str + (dti->getTotalHours() + HX_("",00,00,00,00)));
+            				}
+            				break;
+            				case (int)100: {
+HXLINE(  51)					str = (str + (dti->getDays() + HX_("",00,00,00,00)));
+            				}
+            				break;
+            				case (int)101: {
+HXLINE(  72)					str = (str + (dti->getTotalMinutes() + HX_("",00,00,00,00)));
+            				}
+            				break;
+            				case (int)102: {
+HXLINE(  81)					str = (str + (dti->getTotalSeconds() + HX_("",00,00,00,00)));
+            				}
+            				break;
+            				case (int)104: {
+HXLINE(  60)					str = (str + (dti->getHours() + HX_("",00,00,00,00)));
+            				}
+            				break;
+            				case (int)105: {
+HXLINE(  69)					str = (str + (dti->getMinutes() + HX_("",00,00,00,00)));
+            				}
+            				break;
+            				case (int)109: {
+HXLINE(  42)					str = (str + (dti->getMonths() + HX_("",00,00,00,00)));
+            				}
+            				break;
+            				case (int)114: {
+HXLINE(  87)					::String str2;
+HXDLIN(  87)					if (dti->negative) {
+HXLINE(  87)						str2 = HX_("-",2d,00,00,00);
+            					}
+            					else {
+HXLINE(  87)						str2 = HX_("",00,00,00,00);
+            					}
+HXDLIN(  87)					str = (str + str2);
+            				}
+            				break;
+            				case (int)115: {
+HXLINE(  78)					str = (str + (dti->getSeconds() + HX_("",00,00,00,00)));
+            				}
+            				break;
+            				case (int)121: {
+HXLINE(  36)					str = (str + (dti->getYears() + HX_("",00,00,00,00)));
+            				}
+            				break;
+            			}
+HXLINE(  93)			prevPos = (pos + 1);
+HXLINE(  94)			pos = format.indexOf(HX_("%",25,00,00,00),(pos + 1));
+            		}
+HXLINE(  96)		str = (str + format.substring(prevPos,null()));
+HXLINE(  98)		return str;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(DateTimeIntervalUtils_obj,strftime,return )
+
+
+DateTimeIntervalUtils_obj::DateTimeIntervalUtils_obj()
+{
+}
+
+bool DateTimeIntervalUtils_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 8:
+		if (HX_FIELD_EQ(inName,"strftime") ) { outValue = strftime_dyn(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *DateTimeIntervalUtils_obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo *DateTimeIntervalUtils_obj_sStaticStorageInfo = 0;
+#endif
+
+::hx::Class DateTimeIntervalUtils_obj::__mClass;
+
+static ::String DateTimeIntervalUtils_obj_sStaticFields[] = {
+	HX_("strftime",22,2d,ee,25),
+	::String(null())
+};
+
+void DateTimeIntervalUtils_obj::__register()
+{
+	DateTimeIntervalUtils_obj _hx_dummy;
+	DateTimeIntervalUtils_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("datetime.utils.DateTimeIntervalUtils",81,fa,2b,b6);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &DateTimeIntervalUtils_obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(DateTimeIntervalUtils_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< DateTimeIntervalUtils_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = DateTimeIntervalUtils_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = DateTimeIntervalUtils_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace datetime
+} // end namespace utils
diff --git a/Sources/c_snikket/src/datetime/utils/DateTimeMonthUtils.cpp b/Sources/c_snikket/src/datetime/utils/DateTimeMonthUtils.cpp
new file mode 100644
index 0000000..dbe2b90
--- /dev/null
+++ b/Sources/c_snikket/src/datetime/utils/DateTimeMonthUtils.cpp
@@ -0,0 +1,532 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_datetime_utils_DateTimeMonthUtils
+#include <datetime/utils/DateTimeMonthUtils.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_ab169acce21f9458_20_days,"datetime.utils.DateTimeMonthUtils","days",0x65719c69,"datetime.utils.DateTimeMonthUtils.days","datetime/utils/DateTimeMonthUtils.hx",20,0x2b734a60)
+HX_LOCAL_STACK_FRAME(_hx_pos_ab169acce21f9458_42_getMonth,"datetime.utils.DateTimeMonthUtils","getMonth",0x241f699c,"datetime.utils.DateTimeMonthUtils.getMonth","datetime/utils/DateTimeMonthUtils.hx",42,0x2b734a60)
+HX_LOCAL_STACK_FRAME(_hx_pos_ab169acce21f9458_76_getMonthDay,"datetime.utils.DateTimeMonthUtils","getMonthDay",0xc7f96e20,"datetime.utils.DateTimeMonthUtils.getMonthDay","datetime/utils/DateTimeMonthUtils.hx",76,0x2b734a60)
+HX_LOCAL_STACK_FRAME(_hx_pos_ab169acce21f9458_110_toSeconds,"datetime.utils.DateTimeMonthUtils","toSeconds",0xbdb9d332,"datetime.utils.DateTimeMonthUtils.toSeconds","datetime/utils/DateTimeMonthUtils.hx",110,0x2b734a60)
+namespace datetime{
+namespace utils{
+
+void DateTimeMonthUtils_obj::__construct() { }
+
+Dynamic DateTimeMonthUtils_obj::__CreateEmpty() { return new DateTimeMonthUtils_obj; }
+
+void *DateTimeMonthUtils_obj::_hx_vtable = 0;
+
+Dynamic DateTimeMonthUtils_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< DateTimeMonthUtils_obj > _hx_result = new DateTimeMonthUtils_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool DateTimeMonthUtils_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x250427de;
+}
+
+int DateTimeMonthUtils_obj::days(int month,::hx::Null< bool >  __o_isLeapYear){
+            		bool isLeapYear = __o_isLeapYear.Default(false);
+            	HX_STACKFRAME(&_hx_pos_ab169acce21f9458_20_days)
+HXDLIN(  20)		if ((month == 1)) {
+HXDLIN(  20)			return 31;
+            		}
+            		else {
+HXLINE(  21)			bool _hx_tmp;
+HXDLIN(  21)			if ((month == 2)) {
+HXLINE(  21)				_hx_tmp = isLeapYear;
+            			}
+            			else {
+HXLINE(  21)				_hx_tmp = false;
+            			}
+HXDLIN(  21)			if (_hx_tmp) {
+HXLINE(  21)				return 29;
+            			}
+            			else {
+HXLINE(  22)				if ((month == 2)) {
+HXLINE(  22)					return 28;
+            				}
+            				else {
+HXLINE(  23)					if ((month == 3)) {
+HXLINE(  23)						return 31;
+            					}
+            					else {
+HXLINE(  24)						if ((month == 4)) {
+HXLINE(  24)							return 30;
+            						}
+            						else {
+HXLINE(  25)							if ((month == 5)) {
+HXLINE(  25)								return 31;
+            							}
+            							else {
+HXLINE(  26)								if ((month == 6)) {
+HXLINE(  26)									return 30;
+            								}
+            								else {
+HXLINE(  27)									if ((month == 7)) {
+HXLINE(  27)										return 31;
+            									}
+            									else {
+HXLINE(  28)										if ((month == 8)) {
+HXLINE(  28)											return 31;
+            										}
+            										else {
+HXLINE(  29)											if ((month == 9)) {
+HXLINE(  29)												return 30;
+            											}
+            											else {
+HXLINE(  30)												if ((month == 10)) {
+HXLINE(  30)													return 31;
+            												}
+            												else {
+HXLINE(  31)													if ((month == 11)) {
+HXLINE(  31)														return 30;
+            													}
+            													else {
+HXLINE(  32)														return 31;
+            													}
+            												}
+            											}
+            										}
+            									}
+            								}
+            							}
+            						}
+            					}
+            				}
+            			}
+            		}
+HXLINE(  20)		return 0;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(DateTimeMonthUtils_obj,days,return )
+
+int DateTimeMonthUtils_obj::getMonth(int days,::hx::Null< bool >  __o_isLeapYear){
+            		bool isLeapYear = __o_isLeapYear.Default(false);
+            	HX_STACKFRAME(&_hx_pos_ab169acce21f9458_42_getMonth)
+HXDLIN(  42)		if ((days < 32)) {
+HXDLIN(  42)			return 1;
+            		}
+            		else {
+HXLINE(  43)			if (isLeapYear) {
+HXLINE(  44)				if ((days < 61)) {
+HXLINE(  44)					return 2;
+            				}
+            				else {
+HXLINE(  45)					if ((days < 92)) {
+HXLINE(  45)						return 3;
+            					}
+            					else {
+HXLINE(  46)						if ((days < 122)) {
+HXLINE(  46)							return 4;
+            						}
+            						else {
+HXLINE(  47)							if ((days < 153)) {
+HXLINE(  47)								return 5;
+            							}
+            							else {
+HXLINE(  48)								if ((days < 183)) {
+HXLINE(  48)									return 6;
+            								}
+            								else {
+HXLINE(  49)									if ((days < 214)) {
+HXLINE(  49)										return 7;
+            									}
+            									else {
+HXLINE(  50)										if ((days < 245)) {
+HXLINE(  50)											return 8;
+            										}
+            										else {
+HXLINE(  51)											if ((days < 275)) {
+HXLINE(  51)												return 9;
+            											}
+            											else {
+HXLINE(  52)												if ((days < 306)) {
+HXLINE(  52)													return 10;
+            												}
+            												else {
+HXLINE(  53)													if ((days < 336)) {
+HXLINE(  53)														return 11;
+            													}
+            													else {
+HXLINE(  54)														return 12;
+            													}
+            												}
+            											}
+            										}
+            									}
+            								}
+            							}
+            						}
+            					}
+            				}
+            			}
+            			else {
+HXLINE(  56)				if ((days < 60)) {
+HXLINE(  56)					return 2;
+            				}
+            				else {
+HXLINE(  57)					if ((days < 91)) {
+HXLINE(  57)						return 3;
+            					}
+            					else {
+HXLINE(  58)						if ((days < 121)) {
+HXLINE(  58)							return 4;
+            						}
+            						else {
+HXLINE(  59)							if ((days < 152)) {
+HXLINE(  59)								return 5;
+            							}
+            							else {
+HXLINE(  60)								if ((days < 182)) {
+HXLINE(  60)									return 6;
+            								}
+            								else {
+HXLINE(  61)									if ((days < 213)) {
+HXLINE(  61)										return 7;
+            									}
+            									else {
+HXLINE(  62)										if ((days < 244)) {
+HXLINE(  62)											return 8;
+            										}
+            										else {
+HXLINE(  63)											if ((days < 274)) {
+HXLINE(  63)												return 9;
+            											}
+            											else {
+HXLINE(  64)												if ((days < 305)) {
+HXLINE(  64)													return 10;
+            												}
+            												else {
+HXLINE(  65)													if ((days < 335)) {
+HXLINE(  65)														return 11;
+            													}
+            													else {
+HXLINE(  66)														return 12;
+            													}
+            												}
+            											}
+            										}
+            									}
+            								}
+            							}
+            						}
+            					}
+            				}
+            			}
+            		}
+HXLINE(  42)		return 0;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(DateTimeMonthUtils_obj,getMonth,return )
+
+int DateTimeMonthUtils_obj::getMonthDay(int days,::hx::Null< bool >  __o_isLeapYear){
+            		bool isLeapYear = __o_isLeapYear.Default(false);
+            	HX_STACKFRAME(&_hx_pos_ab169acce21f9458_76_getMonthDay)
+HXDLIN(  76)		if ((days < 32)) {
+HXDLIN(  76)			return days;
+            		}
+            		else {
+HXLINE(  77)			if (isLeapYear) {
+HXLINE(  78)				if ((days < 61)) {
+HXLINE(  78)					return (days - 31);
+            				}
+            				else {
+HXLINE(  79)					if ((days < 92)) {
+HXLINE(  79)						return (days - 60);
+            					}
+            					else {
+HXLINE(  80)						if ((days < 122)) {
+HXLINE(  80)							return (days - 91);
+            						}
+            						else {
+HXLINE(  81)							if ((days < 153)) {
+HXLINE(  81)								return (days - 121);
+            							}
+            							else {
+HXLINE(  82)								if ((days < 183)) {
+HXLINE(  82)									return (days - 152);
+            								}
+            								else {
+HXLINE(  83)									if ((days < 214)) {
+HXLINE(  83)										return (days - 182);
+            									}
+            									else {
+HXLINE(  84)										if ((days < 245)) {
+HXLINE(  84)											return (days - 213);
+            										}
+            										else {
+HXLINE(  85)											if ((days < 275)) {
+HXLINE(  85)												return (days - 244);
+            											}
+            											else {
+HXLINE(  86)												if ((days < 306)) {
+HXLINE(  86)													return (days - 274);
+            												}
+            												else {
+HXLINE(  87)													if ((days < 336)) {
+HXLINE(  87)														return (days - 305);
+            													}
+            													else {
+HXLINE(  88)														return (days - 335);
+            													}
+            												}
+            											}
+            										}
+            									}
+            								}
+            							}
+            						}
+            					}
+            				}
+            			}
+            			else {
+HXLINE(  90)				if ((days < 60)) {
+HXLINE(  90)					return (days - 31);
+            				}
+            				else {
+HXLINE(  91)					if ((days < 91)) {
+HXLINE(  91)						return (days - 59);
+            					}
+            					else {
+HXLINE(  92)						if ((days < 121)) {
+HXLINE(  92)							return (days - 90);
+            						}
+            						else {
+HXLINE(  93)							if ((days < 152)) {
+HXLINE(  93)								return (days - 120);
+            							}
+            							else {
+HXLINE(  94)								if ((days < 182)) {
+HXLINE(  94)									return (days - 151);
+            								}
+            								else {
+HXLINE(  95)									if ((days < 213)) {
+HXLINE(  95)										return (days - 181);
+            									}
+            									else {
+HXLINE(  96)										if ((days < 244)) {
+HXLINE(  96)											return (days - 212);
+            										}
+            										else {
+HXLINE(  97)											if ((days < 274)) {
+HXLINE(  97)												return (days - 243);
+            											}
+            											else {
+HXLINE(  98)												if ((days < 305)) {
+HXLINE(  98)													return (days - 273);
+            												}
+            												else {
+HXLINE(  99)													if ((days < 335)) {
+HXLINE(  99)														return (days - 304);
+            													}
+            													else {
+HXLINE( 100)														return (days - 334);
+            													}
+            												}
+            											}
+            										}
+            									}
+            								}
+            							}
+            						}
+            					}
+            				}
+            			}
+            		}
+HXLINE(  76)		return 0;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(DateTimeMonthUtils_obj,getMonthDay,return )
+
+int DateTimeMonthUtils_obj::toSeconds(int month,::hx::Null< bool >  __o_isLeapYear){
+            		bool isLeapYear = __o_isLeapYear.Default(false);
+            	HX_STACKFRAME(&_hx_pos_ab169acce21f9458_110_toSeconds)
+HXDLIN( 110)		int _hx_tmp;
+HXDLIN( 110)		if ((month == 1)) {
+HXDLIN( 110)			_hx_tmp = 0;
+            		}
+            		else {
+HXLINE( 111)			if (isLeapYear) {
+HXLINE( 112)				if ((month == 2)) {
+HXDLIN( 110)					_hx_tmp = 31;
+            				}
+            				else {
+HXLINE( 113)					if ((month == 3)) {
+HXDLIN( 110)						_hx_tmp = 60;
+            					}
+            					else {
+HXLINE( 114)						if ((month == 4)) {
+HXDLIN( 110)							_hx_tmp = 91;
+            						}
+            						else {
+HXLINE( 115)							if ((month == 5)) {
+HXDLIN( 110)								_hx_tmp = 121;
+            							}
+            							else {
+HXLINE( 116)								if ((month == 6)) {
+HXDLIN( 110)									_hx_tmp = 152;
+            								}
+            								else {
+HXLINE( 117)									if ((month == 7)) {
+HXDLIN( 110)										_hx_tmp = 182;
+            									}
+            									else {
+HXLINE( 118)										if ((month == 8)) {
+HXDLIN( 110)											_hx_tmp = 213;
+            										}
+            										else {
+HXLINE( 119)											if ((month == 9)) {
+HXDLIN( 110)												_hx_tmp = 244;
+            											}
+            											else {
+HXLINE( 120)												if ((month == 10)) {
+HXDLIN( 110)													_hx_tmp = 274;
+            												}
+            												else {
+HXLINE( 121)													if ((month == 11)) {
+HXDLIN( 110)														_hx_tmp = 305;
+            													}
+            													else {
+HXDLIN( 110)														_hx_tmp = 335;
+            													}
+            												}
+            											}
+            										}
+            									}
+            								}
+            							}
+            						}
+            					}
+            				}
+            			}
+            			else {
+HXLINE( 124)				if ((month == 2)) {
+HXDLIN( 110)					_hx_tmp = 31;
+            				}
+            				else {
+HXLINE( 125)					if ((month == 3)) {
+HXDLIN( 110)						_hx_tmp = 59;
+            					}
+            					else {
+HXLINE( 126)						if ((month == 4)) {
+HXDLIN( 110)							_hx_tmp = 90;
+            						}
+            						else {
+HXLINE( 127)							if ((month == 5)) {
+HXDLIN( 110)								_hx_tmp = 120;
+            							}
+            							else {
+HXLINE( 128)								if ((month == 6)) {
+HXDLIN( 110)									_hx_tmp = 151;
+            								}
+            								else {
+HXLINE( 129)									if ((month == 7)) {
+HXDLIN( 110)										_hx_tmp = 181;
+            									}
+            									else {
+HXLINE( 130)										if ((month == 8)) {
+HXDLIN( 110)											_hx_tmp = 212;
+            										}
+            										else {
+HXLINE( 131)											if ((month == 9)) {
+HXDLIN( 110)												_hx_tmp = 243;
+            											}
+            											else {
+HXLINE( 132)												if ((month == 10)) {
+HXDLIN( 110)													_hx_tmp = 273;
+            												}
+            												else {
+HXLINE( 133)													if ((month == 11)) {
+HXDLIN( 110)														_hx_tmp = 304;
+            													}
+            													else {
+HXDLIN( 110)														_hx_tmp = 334;
+            													}
+            												}
+            											}
+            										}
+            									}
+            								}
+            							}
+            						}
+            					}
+            				}
+            			}
+            		}
+HXDLIN( 110)		return (86400 * _hx_tmp);
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(DateTimeMonthUtils_obj,toSeconds,return )
+
+
+DateTimeMonthUtils_obj::DateTimeMonthUtils_obj()
+{
+}
+
+bool DateTimeMonthUtils_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"days") ) { outValue = days_dyn(); return true; }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"getMonth") ) { outValue = getMonth_dyn(); return true; }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"toSeconds") ) { outValue = toSeconds_dyn(); return true; }
+		break;
+	case 11:
+		if (HX_FIELD_EQ(inName,"getMonthDay") ) { outValue = getMonthDay_dyn(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *DateTimeMonthUtils_obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo *DateTimeMonthUtils_obj_sStaticStorageInfo = 0;
+#endif
+
+::hx::Class DateTimeMonthUtils_obj::__mClass;
+
+static ::String DateTimeMonthUtils_obj_sStaticFields[] = {
+	HX_("days",97,5a,63,42),
+	HX_("getMonth",ca,d6,36,6c),
+	HX_("getMonthDay",b2,f1,eb,92),
+	HX_("toSeconds",44,ee,21,8a),
+	::String(null())
+};
+
+void DateTimeMonthUtils_obj::__register()
+{
+	DateTimeMonthUtils_obj _hx_dummy;
+	DateTimeMonthUtils_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("datetime.utils.DateTimeMonthUtils",dc,6f,51,c7);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &DateTimeMonthUtils_obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(DateTimeMonthUtils_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< DateTimeMonthUtils_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = DateTimeMonthUtils_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = DateTimeMonthUtils_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace datetime
+} // end namespace utils
diff --git a/Sources/c_snikket/src/datetime/utils/DateTimeUtils.cpp b/Sources/c_snikket/src/datetime/utils/DateTimeUtils.cpp
new file mode 100644
index 0000000..27bf218
--- /dev/null
+++ b/Sources/c_snikket/src/datetime/utils/DateTimeUtils.cpp
@@ -0,0 +1,245 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Std
+#include <Std.h>
+#endif
+#ifndef INCLUDED_datetime_utils_DateTimeMonthUtils
+#include <datetime/utils/DateTimeMonthUtils.h>
+#endif
+#ifndef INCLUDED_datetime_utils_DateTimeUtils
+#include <datetime/utils/DateTimeUtils.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_3ecdb3441ed93307_24_fromString,"datetime.utils.DateTimeUtils","fromString",0x5ba24443,"datetime.utils.DateTimeUtils.fromString","datetime/utils/DateTimeUtils.hx",24,0xd824643a)
+HX_LOCAL_STACK_FRAME(_hx_pos_3ecdb3441ed93307_42_parse,"datetime.utils.DateTimeUtils","parse",0x5eaf12cb,"datetime.utils.DateTimeUtils.parse","datetime/utils/DateTimeUtils.hx",42,0xd824643a)
+HX_LOCAL_STACK_FRAME(_hx_pos_3ecdb3441ed93307_73_fromIsoString,"datetime.utils.DateTimeUtils","fromIsoString",0xf12b87c4,"datetime.utils.DateTimeUtils.fromIsoString","datetime/utils/DateTimeUtils.hx",73,0xd824643a)
+HX_LOCAL_STACK_FRAME(_hx_pos_3ecdb3441ed93307_107_yearToStamp,"datetime.utils.DateTimeUtils","yearToStamp",0x8b7800e3,"datetime.utils.DateTimeUtils.yearToStamp","datetime/utils/DateTimeUtils.hx",107,0xd824643a)
+namespace datetime{
+namespace utils{
+
+void DateTimeUtils_obj::__construct() { }
+
+Dynamic DateTimeUtils_obj::__CreateEmpty() { return new DateTimeUtils_obj; }
+
+void *DateTimeUtils_obj::_hx_vtable = 0;
+
+Dynamic DateTimeUtils_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< DateTimeUtils_obj > _hx_result = new DateTimeUtils_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool DateTimeUtils_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x4dd3c90c;
+}
+
+Float DateTimeUtils_obj::fromString(::String str){
+            	HX_STACKFRAME(&_hx_pos_3ecdb3441ed93307_24_fromString)
+HXDLIN(  24)		bool _hx_tmp;
+HXDLIN(  24)		if ((str.length != 10)) {
+HXDLIN(  24)			_hx_tmp = (str.cca(10) == 32);
+            		}
+            		else {
+HXDLIN(  24)			_hx_tmp = true;
+            		}
+HXDLIN(  24)		if (_hx_tmp) {
+HXLINE(  25)			return ::datetime::utils::DateTimeUtils_obj::parse(str);
+            		}
+            		else {
+HXLINE(  28)			if ((str.cca(10) == 84)) {
+HXLINE(  29)				return ::datetime::utils::DateTimeUtils_obj::fromIsoString(str);
+            			}
+            			else {
+HXLINE(  33)				HX_STACK_DO_THROW(((HX_("`",60,00,00,00) + str) + HX_("` - incorrect date/time format. Should be either `YYYY-MM-DD hh:mm:ss` or `YYYY-MM-DD` or `YYYY-MM-DDThh:mm:ss[.SSS]Z`",8f,45,0a,94)));
+            			}
+            		}
+HXLINE(  24)		return null();
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(DateTimeUtils_obj,fromString,return )
+
+Float DateTimeUtils_obj::parse(::String str){
+            	HX_STACKFRAME(&_hx_pos_3ecdb3441ed93307_42_parse)
+HXLINE(  43)		int ylength = str.indexOf(HX_("-",2d,00,00,00),null());
+HXLINE(  45)		bool _hx_tmp;
+HXDLIN(  45)		if ((ylength >= 1)) {
+HXLINE(  45)			if (((str.length - ylength) != 6)) {
+HXLINE(  45)				_hx_tmp = ((str.length - ylength) != 15);
+            			}
+            			else {
+HXLINE(  45)				_hx_tmp = false;
+            			}
+            		}
+            		else {
+HXLINE(  45)			_hx_tmp = true;
+            		}
+HXDLIN(  45)		if (_hx_tmp) {
+HXLINE(  46)			HX_STACK_DO_THROW(((HX_("`",60,00,00,00) + str) + HX_("` - incorrect date/time format. Should be either `YYYY-MM-DD hh:mm:ss` or `YYYY-MM-DD`",db,89,d2,d6)));
+            		}
+HXLINE(  49)		if (((str.length - ylength) == 6)) {
+HXLINE(  50)			str = (str + HX_(" 00:00:00",60,fa,7d,d7));
+            		}
+HXLINE(  54)		 ::Dynamic year = ::Std_obj::parseInt(str.substr(0,ylength));
+HXLINE(  55)		 ::Dynamic month = ::Std_obj::parseInt(str.substr((ylength + 1),2));
+HXLINE(  56)		 ::Dynamic day = ::Std_obj::parseInt(str.substr((ylength + 4),2));
+HXLINE(  57)		 ::Dynamic hour = ::Std_obj::parseInt(str.substr((ylength + 7),2));
+HXLINE(  58)		 ::Dynamic minute = ::Std_obj::parseInt(str.substr((ylength + 10),2));
+HXLINE(  59)		 ::Dynamic second = ::Std_obj::parseInt(str.substr((ylength + 13),2));
+HXLINE(  61)		bool _hx_tmp1;
+HXDLIN(  61)		bool _hx_tmp2;
+HXDLIN(  61)		bool _hx_tmp3;
+HXDLIN(  61)		bool _hx_tmp4;
+HXDLIN(  61)		bool _hx_tmp5;
+HXDLIN(  61)		if (::hx::IsNotNull( year )) {
+HXLINE(  61)			_hx_tmp5 = ::hx::IsNull( month );
+            		}
+            		else {
+HXLINE(  61)			_hx_tmp5 = true;
+            		}
+HXDLIN(  61)		if (!(_hx_tmp5)) {
+HXLINE(  61)			_hx_tmp4 = ::hx::IsNull( day );
+            		}
+            		else {
+HXLINE(  61)			_hx_tmp4 = true;
+            		}
+HXDLIN(  61)		if (!(_hx_tmp4)) {
+HXLINE(  61)			_hx_tmp3 = ::hx::IsNull( hour );
+            		}
+            		else {
+HXLINE(  61)			_hx_tmp3 = true;
+            		}
+HXDLIN(  61)		if (!(_hx_tmp3)) {
+HXLINE(  61)			_hx_tmp2 = ::hx::IsNull( minute );
+            		}
+            		else {
+HXLINE(  61)			_hx_tmp2 = true;
+            		}
+HXDLIN(  61)		if (!(_hx_tmp2)) {
+HXLINE(  61)			_hx_tmp1 = ::hx::IsNull( second );
+            		}
+            		else {
+HXLINE(  61)			_hx_tmp1 = true;
+            		}
+HXDLIN(  61)		if (_hx_tmp1) {
+HXLINE(  62)			HX_STACK_DO_THROW(((HX_("`",60,00,00,00) + str) + HX_("` - incorrect date/time format. Should be either `YYYY-MM-DD hh:mm:ss` or `YYYY-MM-DD`",db,89,d2,d6)));
+            		}
+HXLINE(  65)		int year1 = ( (int)(year) );
+HXDLIN(  65)		Float time = ::datetime::utils::DateTimeUtils_obj::yearToStamp(year1);
+HXDLIN(  65)		bool time1;
+HXDLIN(  65)		if ((::hx::Mod(year1,4) == 0)) {
+HXLINE(  65)			if ((::hx::Mod(year1,100) == 0)) {
+HXLINE(  65)				time1 = (::hx::Mod(year1,400) == 0);
+            			}
+            			else {
+HXLINE(  65)				time1 = true;
+            			}
+            		}
+            		else {
+HXLINE(  65)			time1 = false;
+            		}
+HXDLIN(  65)		return (((((((time + ::datetime::utils::DateTimeMonthUtils_obj::toSeconds(( (int)(month) ),time1)) + ((( (int)(day) ) - 1) * 86400)) + (( (int)(hour) ) * 3600)) + (( (int)(minute) ) * 60)) + ( (int)(second) )) - ((Float)62135596800.0)) + ((Float)62135596800.0));
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(DateTimeUtils_obj,parse,return )
+
+Float DateTimeUtils_obj::fromIsoString(::String str){
+            	HX_STACKFRAME(&_hx_pos_3ecdb3441ed93307_73_fromIsoString)
+HXLINE(  74)		int dotPos = str.indexOf(HX_(".",2e,00,00,00),null());
+HXLINE(  75)		int zPos = str.indexOf(HX_("Z",5a,00,00,00),null());
+HXLINE(  77)		if ((str.cca((str.length - 1)) != 90)) {
+HXLINE(  78)			HX_STACK_DO_THROW(((HX_("`",60,00,00,00) + str) + HX_("` - incorrect date/time format. Not an ISO 8601 UTC/Zulu string: Z not found.",de,76,4f,0c)));
+            		}
+HXLINE(  81)		if ((str.length > 20)) {
+HXLINE(  82)			if ((str.cca(19) != 46)) {
+HXLINE(  83)				HX_STACK_DO_THROW(((HX_("`",60,00,00,00) + str) + HX_("` - incorrect date/time format. Not an ISO 8601 string: Millisecond specification erroneous.",be,b1,fd,65)));
+            			}
+HXLINE(  85)			if ((str.cca(23) != 90)) {
+HXLINE(  86)				HX_STACK_DO_THROW(((HX_("`",60,00,00,00) + str) + HX_("` - incorrect date/time format. Not an ISO 8601 string: Timezone specification erroneous.",06,eb,8a,5d)));
+            			}
+            		}
+HXLINE(  90)		::String _hx_tmp = (str.substr(0,10) + HX_(" ",20,00,00,00));
+HXDLIN(  90)		return ::datetime::utils::DateTimeUtils_obj::parse((_hx_tmp + str.substr(11,8)));
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(DateTimeUtils_obj,fromIsoString,return )
+
+Float DateTimeUtils_obj::yearToStamp(int year){
+            	HX_STACKFRAME(&_hx_pos_3ecdb3441ed93307_107_yearToStamp)
+HXLINE( 108)		year = (year - 1);
+HXLINE( 109)		int cquads = ::Std_obj::_hx_int((( (Float)(year) ) / ( (Float)(400) )));
+HXLINE( 110)		int quads = ::Std_obj::_hx_int((( (Float)((year - (cquads * 400))) ) / ( (Float)(4) )));
+HXLINE( 111)		int excessDays = ::Std_obj::_hx_int((( (Float)(quads) ) / ( (Float)(25) )));
+HXLINE( 114)		return ((((( (Float)(cquads) ) * ((Float)12622780800.0)) + (( (Float)(quads) ) * ((Float)126230400.0))) - ( (Float)((excessDays * 86400)) )) + (((year - (cquads * 400)) - (quads * 4)) * 31536000));
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(DateTimeUtils_obj,yearToStamp,return )
+
+
+DateTimeUtils_obj::DateTimeUtils_obj()
+{
+}
+
+bool DateTimeUtils_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 5:
+		if (HX_FIELD_EQ(inName,"parse") ) { outValue = parse_dyn(); return true; }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"fromString") ) { outValue = fromString_dyn(); return true; }
+		break;
+	case 11:
+		if (HX_FIELD_EQ(inName,"yearToStamp") ) { outValue = yearToStamp_dyn(); return true; }
+		break;
+	case 13:
+		if (HX_FIELD_EQ(inName,"fromIsoString") ) { outValue = fromIsoString_dyn(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *DateTimeUtils_obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo *DateTimeUtils_obj_sStaticStorageInfo = 0;
+#endif
+
+::hx::Class DateTimeUtils_obj::__mClass;
+
+static ::String DateTimeUtils_obj_sStaticFields[] = {
+	HX_("fromString",db,2d,74,54),
+	HX_("parse",33,90,55,bd),
+	HX_("fromIsoString",2c,ad,29,f8),
+	HX_("yearToStamp",4b,7c,52,4a),
+	::String(null())
+};
+
+void DateTimeUtils_obj::__register()
+{
+	DateTimeUtils_obj _hx_dummy;
+	DateTimeUtils_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("datetime.utils.DateTimeUtils",06,61,2f,d4);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &DateTimeUtils_obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(DateTimeUtils_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< DateTimeUtils_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = DateTimeUtils_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = DateTimeUtils_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace datetime
+} // end namespace utils
diff --git a/Sources/c_snikket/src/haxe/EntryPoint.cpp b/Sources/c_snikket/src/haxe/EntryPoint.cpp
new file mode 100644
index 0000000..e60e8b5
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/EntryPoint.cpp
@@ -0,0 +1,84 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_EntryPoint
+#include <haxe/EntryPoint.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_ca838965b09ef212_126_run,"haxe.EntryPoint","run",0xf0324cc3,"haxe.EntryPoint.run","/usr/local/lib/haxe/std/haxe/EntryPoint.hx",126,0x029442f4)
+namespace haxe{
+
+void EntryPoint_obj::__construct() { }
+
+Dynamic EntryPoint_obj::__CreateEmpty() { return new EntryPoint_obj; }
+
+void *EntryPoint_obj::_hx_vtable = 0;
+
+Dynamic EntryPoint_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< EntryPoint_obj > _hx_result = new EntryPoint_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool EntryPoint_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x7dc0c864;
+}
+
+void EntryPoint_obj::run(){
+            	HX_STACKFRAME(&_hx_pos_ca838965b09ef212_126_run)
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC0(EntryPoint_obj,run,(void))
+
+
+EntryPoint_obj::EntryPoint_obj()
+{
+}
+
+bool EntryPoint_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"run") ) { outValue = run_dyn(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *EntryPoint_obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo *EntryPoint_obj_sStaticStorageInfo = 0;
+#endif
+
+::hx::Class EntryPoint_obj::__mClass;
+
+static ::String EntryPoint_obj_sStaticFields[] = {
+	HX_("run",4b,e7,56,00),
+	::String(null())
+};
+
+void EntryPoint_obj::__register()
+{
+	EntryPoint_obj _hx_dummy;
+	EntryPoint_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.EntryPoint",e6,a9,c1,b6);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &EntryPoint_obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(EntryPoint_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< EntryPoint_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = EntryPoint_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = EntryPoint_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
diff --git a/Sources/c_snikket/src/haxe/Exception.cpp b/Sources/c_snikket/src/haxe/Exception.cpp
new file mode 100644
index 0000000..6925fe8
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/Exception.cpp
@@ -0,0 +1,244 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Std
+#include <Std.h>
+#endif
+#ifndef INCLUDED_haxe_Exception
+#include <haxe/Exception.h>
+#endif
+#ifndef INCLUDED_haxe_NativeStackTrace
+#include <haxe/NativeStackTrace.h>
+#endif
+#ifndef INCLUDED_haxe_ValueException
+#include <haxe/ValueException.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_7c0836163b1ec49e_5_new,"haxe.Exception","new",0xa32fba59,"haxe.Exception.new","/usr/local/lib/haxe/std/cpp/_std/haxe/Exception.hx",5,0x2b1198f6)
+HX_LOCAL_STACK_FRAME(_hx_pos_7c0836163b1ec49e_56_toString,"haxe.Exception","toString",0x11a32013,"haxe.Exception.toString","/usr/local/lib/haxe/std/cpp/_std/haxe/Exception.hx",56,0x2b1198f6)
+HX_LOCAL_STACK_FRAME(_hx_pos_7c0836163b1ec49e_76_get_message,"haxe.Exception","get_message",0x7b47a0d7,"haxe.Exception.get_message","/usr/local/lib/haxe/std/cpp/_std/haxe/Exception.hx",76,0x2b1198f6)
+HX_LOCAL_STACK_FRAME(_hx_pos_7c0836163b1ec49e_19_caught,"haxe.Exception","caught",0xbc294f23,"haxe.Exception.caught","/usr/local/lib/haxe/std/cpp/_std/haxe/Exception.hx",19,0x2b1198f6)
+namespace haxe{
+
+void Exception_obj::__construct(::String message, ::haxe::Exception previous, ::Dynamic native){
+            	HX_STACKFRAME(&_hx_pos_7c0836163b1ec49e_5_new)
+HXLINE(  14)		this->_hx___skipStack = 0;
+HXLINE(  40)		this->_hx___exceptionMessage = message;
+HXLINE(  41)		this->_hx___previousException = previous;
+HXLINE(  42)		if (::hx::IsNotNull( native )) {
+HXLINE(  43)			this->_hx___nativeStack = ::haxe::NativeStackTrace_obj::exceptionStack();
+HXLINE(  44)			this->_hx___nativeException = native;
+            		}
+            		else {
+HXLINE(  46)			this->_hx___nativeStack = ::haxe::NativeStackTrace_obj::callStack();
+HXLINE(  47)			this->_hx___nativeException = ::hx::ObjectPtr<OBJ_>(this);
+            		}
+            	}
+
+Dynamic Exception_obj::__CreateEmpty() { return new Exception_obj; }
+
+void *Exception_obj::_hx_vtable = 0;
+
+Dynamic Exception_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Exception_obj > _hx_result = new Exception_obj();
+	_hx_result->__construct(inArgs[0],inArgs[1],inArgs[2]);
+	return _hx_result;
+}
+
+bool Exception_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x677ddc49;
+}
+
+::String Exception_obj::toString(){
+            	HX_STACKFRAME(&_hx_pos_7c0836163b1ec49e_56_toString)
+HXDLIN(  56)		return this->get_message();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Exception_obj,toString,return )
+
+::String Exception_obj::get_message(){
+            	HX_STACKFRAME(&_hx_pos_7c0836163b1ec49e_76_get_message)
+HXDLIN(  76)		return this->_hx___exceptionMessage;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Exception_obj,get_message,return )
+
+ ::haxe::Exception Exception_obj::caught( ::Dynamic value){
+            	HX_GC_STACKFRAME(&_hx_pos_7c0836163b1ec49e_19_caught)
+HXDLIN(  19)		if (::Std_obj::isOfType(value,::hx::ClassOf< ::haxe::Exception >())) {
+HXLINE(  20)			return ( ( ::haxe::Exception)(value) );
+            		}
+            		else {
+HXLINE(  22)			 ::haxe::ValueException e =  ::haxe::ValueException_obj::__alloc( HX_CTX ,value,null(),value);
+HXLINE(  24)			e->_hx___skipStack--;
+HXLINE(  25)			return e;
+            		}
+HXLINE(  19)		return null();
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Exception_obj,caught,return )
+
+
+::hx::ObjectPtr< Exception_obj > Exception_obj::__new(::String message, ::haxe::Exception previous, ::Dynamic native) {
+	::hx::ObjectPtr< Exception_obj > __this = new Exception_obj();
+	__this->__construct(message,previous,native);
+	return __this;
+}
+
+::hx::ObjectPtr< Exception_obj > Exception_obj::__alloc(::hx::Ctx *_hx_ctx,::String message, ::haxe::Exception previous, ::Dynamic native) {
+	Exception_obj *__this = (Exception_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Exception_obj), true, "haxe.Exception"));
+	*(void **)__this = Exception_obj::_hx_vtable;
+	__this->__construct(message,previous,native);
+	return __this;
+}
+
+Exception_obj::Exception_obj()
+{
+}
+
+void Exception_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(Exception);
+	HX_MARK_MEMBER_NAME(_hx___exceptionMessage,"__exceptionMessage");
+	HX_MARK_MEMBER_NAME(_hx___nativeStack,"__nativeStack");
+	HX_MARK_MEMBER_NAME(_hx___skipStack,"__skipStack");
+	HX_MARK_MEMBER_NAME(_hx___nativeException,"__nativeException");
+	HX_MARK_MEMBER_NAME(_hx___previousException,"__previousException");
+	HX_MARK_END_CLASS();
+}
+
+void Exception_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(_hx___exceptionMessage,"__exceptionMessage");
+	HX_VISIT_MEMBER_NAME(_hx___nativeStack,"__nativeStack");
+	HX_VISIT_MEMBER_NAME(_hx___skipStack,"__skipStack");
+	HX_VISIT_MEMBER_NAME(_hx___nativeException,"__nativeException");
+	HX_VISIT_MEMBER_NAME(_hx___previousException,"__previousException");
+}
+
+::hx::Val Exception_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 7:
+		if (HX_FIELD_EQ(inName,"message") ) { if (inCallProp == ::hx::paccAlways) return ::hx::Val( get_message() ); }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"toString") ) { return ::hx::Val( toString_dyn() ); }
+		break;
+	case 11:
+		if (HX_FIELD_EQ(inName,"__skipStack") ) { return ::hx::Val( _hx___skipStack ); }
+		if (HX_FIELD_EQ(inName,"get_message") ) { return ::hx::Val( get_message_dyn() ); }
+		break;
+	case 13:
+		if (HX_FIELD_EQ(inName,"__nativeStack") ) { return ::hx::Val( _hx___nativeStack ); }
+		break;
+	case 17:
+		if (HX_FIELD_EQ(inName,"__nativeException") ) { return ::hx::Val( _hx___nativeException ); }
+		break;
+	case 18:
+		if (HX_FIELD_EQ(inName,"__exceptionMessage") ) { return ::hx::Val( _hx___exceptionMessage ); }
+		break;
+	case 19:
+		if (HX_FIELD_EQ(inName,"__previousException") ) { return ::hx::Val( _hx___previousException ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+bool Exception_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 6:
+		if (HX_FIELD_EQ(inName,"caught") ) { outValue = caught_dyn(); return true; }
+	}
+	return false;
+}
+
+::hx::Val Exception_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 11:
+		if (HX_FIELD_EQ(inName,"__skipStack") ) { _hx___skipStack=inValue.Cast< int >(); return inValue; }
+		break;
+	case 13:
+		if (HX_FIELD_EQ(inName,"__nativeStack") ) { _hx___nativeStack=inValue.Cast< ::Array< ::String > >(); return inValue; }
+		break;
+	case 17:
+		if (HX_FIELD_EQ(inName,"__nativeException") ) { _hx___nativeException=inValue.Cast<  ::Dynamic >(); return inValue; }
+		break;
+	case 18:
+		if (HX_FIELD_EQ(inName,"__exceptionMessage") ) { _hx___exceptionMessage=inValue.Cast< ::String >(); return inValue; }
+		break;
+	case 19:
+		if (HX_FIELD_EQ(inName,"__previousException") ) { _hx___previousException=inValue.Cast<  ::haxe::Exception >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void Exception_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("message",c7,35,11,9a));
+	outFields->push(HX_("__exceptionMessage",58,18,4c,1e));
+	outFields->push(HX_("__nativeStack",11,2b,7f,33));
+	outFields->push(HX_("__skipStack",29,1d,33,c6));
+	outFields->push(HX_("__nativeException",98,ec,35,0d));
+	outFields->push(HX_("__previousException",f8,9d,b4,84));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo Exception_obj_sMemberStorageInfo[] = {
+	{::hx::fsString,(int)offsetof(Exception_obj,_hx___exceptionMessage),HX_("__exceptionMessage",58,18,4c,1e)},
+	{::hx::fsObject /* ::Array< ::String > */ ,(int)offsetof(Exception_obj,_hx___nativeStack),HX_("__nativeStack",11,2b,7f,33)},
+	{::hx::fsInt,(int)offsetof(Exception_obj,_hx___skipStack),HX_("__skipStack",29,1d,33,c6)},
+	{::hx::fsObject /*  ::Dynamic */ ,(int)offsetof(Exception_obj,_hx___nativeException),HX_("__nativeException",98,ec,35,0d)},
+	{::hx::fsObject /*  ::haxe::Exception */ ,(int)offsetof(Exception_obj,_hx___previousException),HX_("__previousException",f8,9d,b4,84)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *Exception_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String Exception_obj_sMemberFields[] = {
+	HX_("__exceptionMessage",58,18,4c,1e),
+	HX_("__nativeStack",11,2b,7f,33),
+	HX_("__skipStack",29,1d,33,c6),
+	HX_("__nativeException",98,ec,35,0d),
+	HX_("__previousException",f8,9d,b4,84),
+	HX_("toString",ac,d0,6e,38),
+	HX_("get_message",de,95,0b,20),
+	::String(null()) };
+
+::hx::Class Exception_obj::__mClass;
+
+static ::String Exception_obj_sStaticFields[] = {
+	HX_("caught",7c,77,d7,bc),
+	::String(null())
+};
+
+void Exception_obj::__register()
+{
+	Exception_obj _hx_dummy;
+	Exception_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.Exception",e7,99,a3,a6);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &Exception_obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(Exception_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(Exception_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< Exception_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Exception_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Exception_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
diff --git a/Sources/c_snikket/src/haxe/IMap.cpp b/Sources/c_snikket/src/haxe/IMap.cpp
new file mode 100644
index 0000000..ba12ab3
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/IMap.cpp
@@ -0,0 +1,28 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+
+namespace haxe{
+
+
+static ::String IMap_obj_sMemberFields[] = {
+	HX_("get",96,80,4e,00),
+	HX_("keys",f4,e1,06,47),
+	::String(null()) };
+
+::hx::Class IMap_obj::__mClass;
+
+void IMap_obj::__register()
+{
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.IMap",1b,07,35,eb);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(IMap_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TIsInterface< (int)0x09c2bd39 >;
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
diff --git a/Sources/c_snikket/src/haxe/Log.cpp b/Sources/c_snikket/src/haxe/Log.cpp
new file mode 100644
index 0000000..97f3ef5
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/Log.cpp
@@ -0,0 +1,145 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Std
+#include <Std.h>
+#endif
+#ifndef INCLUDED_haxe_Log
+#include <haxe/Log.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_5d4e2478c442a18b_30___default_trace,"haxe.Log","__default_trace",0xe2f5e5d5,"haxe.Log.__default_trace","/usr/local/lib/haxe/std/cpp/_std/haxe/Log.hx",30,0x26c9bca1)
+namespace haxe{
+
+void Log_obj::__construct() { }
+
+Dynamic Log_obj::__CreateEmpty() { return new Log_obj; }
+
+void *Log_obj::_hx_vtable = 0;
+
+Dynamic Log_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Log_obj > _hx_result = new Log_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool Log_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x3c235b1a;
+}
+
+HX_BEGIN_DEFAULT_FUNC(__default_trace,Log_obj)
+void _hx_run( ::Dynamic v, ::Dynamic infos){
+            	HX_STACKFRAME(&_hx_pos_5d4e2478c442a18b_30___default_trace)
+HXDLIN(  30)		bool _hx_tmp;
+HXDLIN(  30)		if (::hx::IsNotNull( infos )) {
+HXDLIN(  30)			_hx_tmp = ::hx::IsNotNull( infos->__Field(HX_("customParams",d7,51,18,ed),::hx::paccDynamic) );
+            		}
+            		else {
+HXDLIN(  30)			_hx_tmp = false;
+            		}
+HXDLIN(  30)		if (_hx_tmp) {
+HXLINE(  31)			::String extra = HX_("",00,00,00,00);
+HXLINE(  32)			{
+HXLINE(  32)				int _g = 0;
+HXDLIN(  32)				::cpp::VirtualArray _g1 = ( (::cpp::VirtualArray)(infos->__Field(HX_("customParams",d7,51,18,ed),::hx::paccDynamic)) );
+HXDLIN(  32)				while((_g < _g1->get_length())){
+HXLINE(  32)					 ::Dynamic v1 = _g1->__get(_g);
+HXDLIN(  32)					_g = (_g + 1);
+HXLINE(  33)					extra = (extra + (HX_(",",2c,00,00,00) + ::Std_obj::string(v1)));
+            				}
+            			}
+HXLINE(  34)			__trace((::Std_obj::string(v) + extra),infos);
+            		}
+            		else {
+HXLINE(  36)			__trace(( (::String)(v) ),infos);
+            		}
+            	}
+HX_END_LOCAL_FUNC2((void))
+HX_END_DEFAULT_FUNC
+
+::Dynamic Log_obj::trace;
+
+
+Log_obj::Log_obj()
+{
+}
+
+bool Log_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 5:
+		if (HX_FIELD_EQ(inName,"trace") ) { outValue = ( trace ); return true; }
+	}
+	return false;
+}
+
+bool Log_obj::__SetStatic(const ::String &inName,Dynamic &ioValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 5:
+		if (HX_FIELD_EQ(inName,"trace") ) { trace=ioValue.Cast<  ::Dynamic >(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *Log_obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo Log_obj_sStaticStorageInfo[] = {
+	{::hx::fsObject /*  ::Dynamic */ ,(void *) &Log_obj::trace,HX_("trace",85,8e,1f,16)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+#endif
+
+static void Log_obj_sMarkStatics(HX_MARK_PARAMS) {
+	HX_MARK_MEMBER_NAME(Log_obj::trace,"trace");
+};
+
+#ifdef HXCPP_VISIT_ALLOCS
+static void Log_obj_sVisitStatics(HX_VISIT_PARAMS) {
+	HX_VISIT_MEMBER_NAME(Log_obj::trace,"trace");
+};
+
+#endif
+
+::hx::Class Log_obj::__mClass;
+
+static ::String Log_obj_sStaticFields[] = {
+	HX_("trace",85,8e,1f,16),
+	::String(null())
+};
+
+void Log_obj::__register()
+{
+	Log_obj _hx_dummy;
+	Log_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.Log",1c,1c,0e,3f);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &Log_obj::__GetStatic;
+	__mClass->mSetStaticField = &Log_obj::__SetStatic;
+	__mClass->mMarkFunc = Log_obj_sMarkStatics;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(Log_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< Log_obj >;
+#ifdef HXCPP_VISIT_ALLOCS
+	__mClass->mVisitFunc = Log_obj_sVisitStatics;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Log_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Log_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+void Log_obj::__boot()
+{
+	trace = new __default_trace;
+
+}
+
+} // end namespace haxe
diff --git a/Sources/c_snikket/src/haxe/MainEvent.cpp b/Sources/c_snikket/src/haxe/MainEvent.cpp
new file mode 100644
index 0000000..28dfe72
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/MainEvent.cpp
@@ -0,0 +1,179 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_95f339a1d026d52c
+#define INCLUDED_95f339a1d026d52c
+#include "hxMath.h"
+#endif
+#ifndef INCLUDED_haxe_MainEvent
+#include <haxe/MainEvent.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_593a9917e735e8fd_9_new,"haxe.MainEvent","new",0x1c640c2b,"haxe.MainEvent.new","/usr/local/lib/haxe/std/haxe/MainLoop.hx",9,0x4a7d9295)
+namespace haxe{
+
+void MainEvent_obj::__construct( ::Dynamic f,int p){
+            	HX_STACKFRAME(&_hx_pos_593a9917e735e8fd_9_new)
+HXLINE(  17)		this->isBlocking = true;
+HXLINE(  23)		this->f = f;
+HXLINE(  24)		this->priority = p;
+HXLINE(  25)		this->nextRun = ::Math_obj::NEGATIVE_INFINITY;
+            	}
+
+Dynamic MainEvent_obj::__CreateEmpty() { return new MainEvent_obj; }
+
+void *MainEvent_obj::_hx_vtable = 0;
+
+Dynamic MainEvent_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< MainEvent_obj > _hx_result = new MainEvent_obj();
+	_hx_result->__construct(inArgs[0],inArgs[1]);
+	return _hx_result;
+}
+
+bool MainEvent_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x0b5efb53;
+}
+
+
+::hx::ObjectPtr< MainEvent_obj > MainEvent_obj::__new( ::Dynamic f,int p) {
+	::hx::ObjectPtr< MainEvent_obj > __this = new MainEvent_obj();
+	__this->__construct(f,p);
+	return __this;
+}
+
+::hx::ObjectPtr< MainEvent_obj > MainEvent_obj::__alloc(::hx::Ctx *_hx_ctx, ::Dynamic f,int p) {
+	MainEvent_obj *__this = (MainEvent_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(MainEvent_obj), true, "haxe.MainEvent"));
+	*(void **)__this = MainEvent_obj::_hx_vtable;
+	__this->__construct(f,p);
+	return __this;
+}
+
+MainEvent_obj::MainEvent_obj()
+{
+}
+
+void MainEvent_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(MainEvent);
+	HX_MARK_MEMBER_NAME(f,"f");
+	HX_MARK_MEMBER_NAME(prev,"prev");
+	HX_MARK_MEMBER_NAME(next,"next");
+	HX_MARK_MEMBER_NAME(isBlocking,"isBlocking");
+	HX_MARK_MEMBER_NAME(nextRun,"nextRun");
+	HX_MARK_MEMBER_NAME(priority,"priority");
+	HX_MARK_END_CLASS();
+}
+
+void MainEvent_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(f,"f");
+	HX_VISIT_MEMBER_NAME(prev,"prev");
+	HX_VISIT_MEMBER_NAME(next,"next");
+	HX_VISIT_MEMBER_NAME(isBlocking,"isBlocking");
+	HX_VISIT_MEMBER_NAME(nextRun,"nextRun");
+	HX_VISIT_MEMBER_NAME(priority,"priority");
+}
+
+::hx::Val MainEvent_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 1:
+		if (HX_FIELD_EQ(inName,"f") ) { return ::hx::Val( f ); }
+		break;
+	case 4:
+		if (HX_FIELD_EQ(inName,"prev") ) { return ::hx::Val( prev ); }
+		if (HX_FIELD_EQ(inName,"next") ) { return ::hx::Val( next ); }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"nextRun") ) { return ::hx::Val( nextRun ); }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"priority") ) { return ::hx::Val( priority ); }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"isBlocking") ) { return ::hx::Val( isBlocking ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val MainEvent_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 1:
+		if (HX_FIELD_EQ(inName,"f") ) { f=inValue.Cast<  ::Dynamic >(); return inValue; }
+		break;
+	case 4:
+		if (HX_FIELD_EQ(inName,"prev") ) { prev=inValue.Cast<  ::haxe::MainEvent >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"next") ) { next=inValue.Cast<  ::haxe::MainEvent >(); return inValue; }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"nextRun") ) { nextRun=inValue.Cast< Float >(); return inValue; }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"priority") ) { priority=inValue.Cast< int >(); return inValue; }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"isBlocking") ) { isBlocking=inValue.Cast< bool >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void MainEvent_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("prev",f3,be,5e,4a));
+	outFields->push(HX_("next",f3,84,02,49));
+	outFields->push(HX_("isBlocking",bf,37,5f,94));
+	outFields->push(HX_("nextRun",18,74,45,a5));
+	outFields->push(HX_("priority",64,7b,3e,bb));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo MainEvent_obj_sMemberStorageInfo[] = {
+	{::hx::fsObject /*  ::Dynamic */ ,(int)offsetof(MainEvent_obj,f),HX_("f",66,00,00,00)},
+	{::hx::fsObject /*  ::haxe::MainEvent */ ,(int)offsetof(MainEvent_obj,prev),HX_("prev",f3,be,5e,4a)},
+	{::hx::fsObject /*  ::haxe::MainEvent */ ,(int)offsetof(MainEvent_obj,next),HX_("next",f3,84,02,49)},
+	{::hx::fsBool,(int)offsetof(MainEvent_obj,isBlocking),HX_("isBlocking",bf,37,5f,94)},
+	{::hx::fsFloat,(int)offsetof(MainEvent_obj,nextRun),HX_("nextRun",18,74,45,a5)},
+	{::hx::fsInt,(int)offsetof(MainEvent_obj,priority),HX_("priority",64,7b,3e,bb)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *MainEvent_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String MainEvent_obj_sMemberFields[] = {
+	HX_("f",66,00,00,00),
+	HX_("prev",f3,be,5e,4a),
+	HX_("next",f3,84,02,49),
+	HX_("isBlocking",bf,37,5f,94),
+	HX_("nextRun",18,74,45,a5),
+	HX_("priority",64,7b,3e,bb),
+	::String(null()) };
+
+::hx::Class MainEvent_obj::__mClass;
+
+void MainEvent_obj::__register()
+{
+	MainEvent_obj _hx_dummy;
+	MainEvent_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.MainEvent",b9,1a,72,ec);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(MainEvent_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< MainEvent_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = MainEvent_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = MainEvent_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
diff --git a/Sources/c_snikket/src/haxe/MainLoop.cpp b/Sources/c_snikket/src/haxe/MainLoop.cpp
new file mode 100644
index 0000000..444ec9c
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/MainLoop.cpp
@@ -0,0 +1,287 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_MainEvent
+#include <haxe/MainEvent.h>
+#endif
+#ifndef INCLUDED_haxe_MainLoop
+#include <haxe/MainLoop.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_c09dd4c76a148f98_71_hasEvents,"haxe.MainLoop","hasEvents",0xbbf2790a,"haxe.MainLoop.hasEvents","/usr/local/lib/haxe/std/haxe/MainLoop.hx",71,0x4a7d9295)
+HX_LOCAL_STACK_FRAME(_hx_pos_c09dd4c76a148f98_104_sortEvents,"haxe.MainLoop","sortEvents",0x1a386640,"haxe.MainLoop.sortEvents","/usr/local/lib/haxe/std/haxe/MainLoop.hx",104,0x4a7d9295)
+HX_LOCAL_STACK_FRAME(_hx_pos_c09dd4c76a148f98_169_tick,"haxe.MainLoop","tick",0x9d5eafc6,"haxe.MainLoop.tick","/usr/local/lib/haxe/std/haxe/MainLoop.hx",169,0x4a7d9295)
+namespace haxe{
+
+void MainLoop_obj::__construct() { }
+
+Dynamic MainLoop_obj::__CreateEmpty() { return new MainLoop_obj; }
+
+void *MainLoop_obj::_hx_vtable = 0;
+
+Dynamic MainLoop_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< MainLoop_obj > _hx_result = new MainLoop_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool MainLoop_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x0c7b74e7;
+}
+
+ ::haxe::MainEvent MainLoop_obj::pending;
+
+bool MainLoop_obj::hasEvents(){
+            	HX_STACKFRAME(&_hx_pos_c09dd4c76a148f98_71_hasEvents)
+HXLINE(  72)		 ::haxe::MainEvent p = ::haxe::MainLoop_obj::pending;
+HXLINE(  73)		while(::hx::IsNotNull( p )){
+HXLINE(  74)			if (p->isBlocking) {
+HXLINE(  75)				return true;
+            			}
+HXLINE(  76)			p = p->next;
+            		}
+HXLINE(  78)		return false;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC0(MainLoop_obj,hasEvents,return )
+
+void MainLoop_obj::sortEvents(){
+            	HX_STACKFRAME(&_hx_pos_c09dd4c76a148f98_104_sortEvents)
+HXLINE( 108)		 ::haxe::MainEvent list = ::haxe::MainLoop_obj::pending;
+HXLINE( 110)		if (::hx::IsNull( list )) {
+HXLINE( 111)			return;
+            		}
+HXLINE( 113)		int insize = 1;
+HXDLIN( 113)		int nmerges;
+HXDLIN( 113)		int psize = 0;
+HXDLIN( 113)		int qsize = 0;
+HXLINE( 114)		 ::haxe::MainEvent p;
+HXDLIN( 114)		 ::haxe::MainEvent q;
+HXDLIN( 114)		 ::haxe::MainEvent e;
+HXDLIN( 114)		 ::haxe::MainEvent tail;
+HXLINE( 116)		while(true){
+HXLINE( 117)			p = list;
+HXLINE( 118)			list = null();
+HXLINE( 119)			tail = null();
+HXLINE( 120)			nmerges = 0;
+HXLINE( 121)			while(::hx::IsNotNull( p )){
+HXLINE( 122)				nmerges = (nmerges + 1);
+HXLINE( 123)				q = p;
+HXLINE( 124)				psize = 0;
+HXLINE( 125)				{
+HXLINE( 125)					int _g = 0;
+HXDLIN( 125)					int _g1 = insize;
+HXDLIN( 125)					while((_g < _g1)){
+HXLINE( 125)						_g = (_g + 1);
+HXDLIN( 125)						int i = (_g - 1);
+HXLINE( 126)						psize = (psize + 1);
+HXLINE( 127)						q = q->next;
+HXLINE( 128)						if (::hx::IsNull( q )) {
+HXLINE( 129)							goto _hx_goto_4;
+            						}
+            					}
+            					_hx_goto_4:;
+            				}
+HXLINE( 131)				qsize = insize;
+HXLINE( 132)				while(true){
+HXLINE( 132)					bool _hx_tmp;
+HXDLIN( 132)					if ((psize <= 0)) {
+HXLINE( 132)						if ((qsize > 0)) {
+HXLINE( 132)							_hx_tmp = ::hx::IsNotNull( q );
+            						}
+            						else {
+HXLINE( 132)							_hx_tmp = false;
+            						}
+            					}
+            					else {
+HXLINE( 132)						_hx_tmp = true;
+            					}
+HXDLIN( 132)					if (!(_hx_tmp)) {
+HXLINE( 132)						goto _hx_goto_5;
+            					}
+HXLINE( 133)					if ((psize == 0)) {
+HXLINE( 134)						e = q;
+HXLINE( 135)						q = q->next;
+HXLINE( 136)						qsize = (qsize - 1);
+            					}
+            					else {
+HXLINE( 137)						bool _hx_tmp1;
+HXDLIN( 137)						bool _hx_tmp2;
+HXDLIN( 137)						if ((qsize != 0)) {
+HXLINE( 137)							_hx_tmp2 = ::hx::IsNull( q );
+            						}
+            						else {
+HXLINE( 137)							_hx_tmp2 = true;
+            						}
+HXDLIN( 137)						if (!(_hx_tmp2)) {
+HXLINE( 139)							if ((p->priority <= q->priority)) {
+HXLINE( 139)								if ((p->priority == q->priority)) {
+HXLINE( 137)									_hx_tmp1 = (p->nextRun <= q->nextRun);
+            								}
+            								else {
+HXLINE( 137)									_hx_tmp1 = false;
+            								}
+            							}
+            							else {
+HXLINE( 137)								_hx_tmp1 = true;
+            							}
+            						}
+            						else {
+HXLINE( 137)							_hx_tmp1 = true;
+            						}
+HXDLIN( 137)						if (_hx_tmp1) {
+HXLINE( 140)							e = p;
+HXLINE( 141)							p = p->next;
+HXLINE( 142)							psize = (psize - 1);
+            						}
+            						else {
+HXLINE( 144)							e = q;
+HXLINE( 145)							q = q->next;
+HXLINE( 146)							qsize = (qsize - 1);
+            						}
+            					}
+HXLINE( 148)					if (::hx::IsNotNull( tail )) {
+HXLINE( 149)						tail->next = e;
+            					}
+            					else {
+HXLINE( 151)						list = e;
+            					}
+HXLINE( 152)					e->prev = tail;
+HXLINE( 153)					tail = e;
+            				}
+            				_hx_goto_5:;
+HXLINE( 155)				p = q;
+            			}
+HXLINE( 157)			tail->next = null();
+HXLINE( 158)			if ((nmerges <= 1)) {
+HXLINE( 159)				goto _hx_goto_2;
+            			}
+HXLINE( 160)			insize = (insize * 2);
+            		}
+            		_hx_goto_2:;
+HXLINE( 162)		list->prev = null();
+HXLINE( 163)		::haxe::MainLoop_obj::pending = list;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC0(MainLoop_obj,sortEvents,(void))
+
+Float MainLoop_obj::tick(){
+            	HX_STACKFRAME(&_hx_pos_c09dd4c76a148f98_169_tick)
+HXLINE( 170)		::haxe::MainLoop_obj::sortEvents();
+HXLINE( 171)		 ::haxe::MainEvent e = ::haxe::MainLoop_obj::pending;
+HXLINE( 172)		Float now =  ::__time_stamp();
+HXLINE( 173)		Float wait = ((Float)1e9);
+HXLINE( 174)		while(::hx::IsNotNull( e )){
+HXLINE( 175)			 ::haxe::MainEvent next = e->next;
+HXLINE( 176)			Float wt = (e->nextRun - now);
+HXLINE( 177)			if ((wt <= 0)) {
+HXLINE( 178)				wait = ( (Float)(0) );
+HXLINE( 179)				if (::hx::IsNotNull( e->f )) {
+HXLINE( 179)					e->f();
+            				}
+            			}
+            			else {
+HXLINE( 180)				if ((wait > wt)) {
+HXLINE( 181)					wait = wt;
+            				}
+            			}
+HXLINE( 182)			e = next;
+            		}
+HXLINE( 184)		return wait;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC0(MainLoop_obj,tick,return )
+
+
+MainLoop_obj::MainLoop_obj()
+{
+}
+
+bool MainLoop_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"tick") ) { outValue = tick_dyn(); return true; }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"pending") ) { outValue = ( pending ); return true; }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"hasEvents") ) { outValue = hasEvents_dyn(); return true; }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"sortEvents") ) { outValue = sortEvents_dyn(); return true; }
+	}
+	return false;
+}
+
+bool MainLoop_obj::__SetStatic(const ::String &inName,Dynamic &ioValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 7:
+		if (HX_FIELD_EQ(inName,"pending") ) { pending=ioValue.Cast<  ::haxe::MainEvent >(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *MainLoop_obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo MainLoop_obj_sStaticStorageInfo[] = {
+	{::hx::fsObject /*  ::haxe::MainEvent */ ,(void *) &MainLoop_obj::pending,HX_("pending",57,98,ec,2b)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+#endif
+
+static void MainLoop_obj_sMarkStatics(HX_MARK_PARAMS) {
+	HX_MARK_MEMBER_NAME(MainLoop_obj::pending,"pending");
+};
+
+#ifdef HXCPP_VISIT_ALLOCS
+static void MainLoop_obj_sVisitStatics(HX_VISIT_PARAMS) {
+	HX_VISIT_MEMBER_NAME(MainLoop_obj::pending,"pending");
+};
+
+#endif
+
+::hx::Class MainLoop_obj::__mClass;
+
+static ::String MainLoop_obj_sStaticFields[] = {
+	HX_("pending",57,98,ec,2b),
+	HX_("hasEvents",13,02,53,d7),
+	HX_("sortEvents",17,c5,4f,f3),
+	HX_("tick",5d,c3,fc,4c),
+	::String(null())
+};
+
+void MainLoop_obj::__register()
+{
+	MainLoop_obj _hx_dummy;
+	MainLoop_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.MainLoop",a5,cc,ab,e6);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &MainLoop_obj::__GetStatic;
+	__mClass->mSetStaticField = &MainLoop_obj::__SetStatic;
+	__mClass->mMarkFunc = MainLoop_obj_sMarkStatics;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(MainLoop_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< MainLoop_obj >;
+#ifdef HXCPP_VISIT_ALLOCS
+	__mClass->mVisitFunc = MainLoop_obj_sVisitStatics;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = MainLoop_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = MainLoop_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
diff --git a/Sources/c_snikket/src/haxe/NativeStackTrace.cpp b/Sources/c_snikket/src/haxe/NativeStackTrace.cpp
new file mode 100644
index 0000000..654bc33
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/NativeStackTrace.cpp
@@ -0,0 +1,104 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_NativeStackTrace
+#include <haxe/NativeStackTrace.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_0eaca57ef1f373a1_12_saveStack,"haxe.NativeStackTrace","saveStack",0x471b27d9,"haxe.NativeStackTrace.saveStack","/usr/local/lib/haxe/std/cpp/_std/haxe/NativeStackTrace.hx",12,0xab41cc63)
+namespace haxe{
+
+void NativeStackTrace_obj::__construct() { }
+
+Dynamic NativeStackTrace_obj::__CreateEmpty() { return new NativeStackTrace_obj; }
+
+void *NativeStackTrace_obj::_hx_vtable = 0;
+
+Dynamic NativeStackTrace_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< NativeStackTrace_obj > _hx_result = new NativeStackTrace_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool NativeStackTrace_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x3984963e;
+}
+
+void NativeStackTrace_obj::saveStack( ::Dynamic exception){
+            	HX_STACKFRAME(&_hx_pos_0eaca57ef1f373a1_12_saveStack)
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(NativeStackTrace_obj,saveStack,(void))
+
+::Array< ::String > NativeStackTrace_obj::callStack(){
+	return  ::__hxcpp_get_call_stack(true);
+}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC0(NativeStackTrace_obj,callStack,return )
+
+::Array< ::String > NativeStackTrace_obj::exceptionStack(){
+	return  ::__hxcpp_get_exception_stack();
+}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC0(NativeStackTrace_obj,exceptionStack,return )
+
+
+NativeStackTrace_obj::NativeStackTrace_obj()
+{
+}
+
+bool NativeStackTrace_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 9:
+		if (HX_FIELD_EQ(inName,"saveStack") ) { outValue = saveStack_dyn(); return true; }
+		if (HX_FIELD_EQ(inName,"callStack") ) { outValue = callStack_dyn(); return true; }
+		break;
+	case 14:
+		if (HX_FIELD_EQ(inName,"exceptionStack") ) { outValue = exceptionStack_dyn(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *NativeStackTrace_obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo *NativeStackTrace_obj_sStaticStorageInfo = 0;
+#endif
+
+::hx::Class NativeStackTrace_obj::__mClass;
+
+static ::String NativeStackTrace_obj_sStaticFields[] = {
+	HX_("saveStack",cb,6e,b8,12),
+	HX_("callStack",ca,c1,4a,10),
+	HX_("exceptionStack",79,48,56,0b),
+	::String(null())
+};
+
+void NativeStackTrace_obj::__register()
+{
+	NativeStackTrace_obj _hx_dummy;
+	NativeStackTrace_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.NativeStackTrace",fc,db,8f,5d);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &NativeStackTrace_obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(NativeStackTrace_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< NativeStackTrace_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = NativeStackTrace_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = NativeStackTrace_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
diff --git a/Sources/c_snikket/src/haxe/StackItem.cpp b/Sources/c_snikket/src/haxe/StackItem.cpp
new file mode 100644
index 0000000..dd84ddb
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/StackItem.cpp
@@ -0,0 +1,116 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_StackItem
+#include <haxe/StackItem.h>
+#endif
+namespace haxe{
+
+::haxe::StackItem StackItem_obj::CFunction;
+
+::haxe::StackItem StackItem_obj::FilePos( ::haxe::StackItem s,::String file,int line, ::Dynamic column)
+{
+	return ::hx::CreateEnum< StackItem_obj >(HX_("FilePos",58,a4,9d,cc),2,4)->_hx_init(0,s)->_hx_init(1,file)->_hx_init(2,line)->_hx_init(3,column);
+}
+
+::haxe::StackItem StackItem_obj::LocalFunction( ::Dynamic v)
+{
+	return ::hx::CreateEnum< StackItem_obj >(HX_("LocalFunction",83,63,3d,d5),4,1)->_hx_init(0,v);
+}
+
+::haxe::StackItem StackItem_obj::Method(::String classname,::String method)
+{
+	return ::hx::CreateEnum< StackItem_obj >(HX_("Method",01,6b,ef,3d),3,2)->_hx_init(0,classname)->_hx_init(1,method);
+}
+
+::haxe::StackItem StackItem_obj::Module(::String m)
+{
+	return ::hx::CreateEnum< StackItem_obj >(HX_("Module",cc,a8,67,f5),1,1)->_hx_init(0,m);
+}
+
+bool StackItem_obj::__GetStatic(const ::String &inName, ::Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	if (inName==HX_("CFunction",7b,e2,32,23)) { outValue = StackItem_obj::CFunction; return true; }
+	if (inName==HX_("FilePos",58,a4,9d,cc)) { outValue = StackItem_obj::FilePos_dyn(); return true; }
+	if (inName==HX_("LocalFunction",83,63,3d,d5)) { outValue = StackItem_obj::LocalFunction_dyn(); return true; }
+	if (inName==HX_("Method",01,6b,ef,3d)) { outValue = StackItem_obj::Method_dyn(); return true; }
+	if (inName==HX_("Module",cc,a8,67,f5)) { outValue = StackItem_obj::Module_dyn(); return true; }
+	return super::__GetStatic(inName, outValue, inCallProp);
+}
+
+HX_DEFINE_CREATE_ENUM(StackItem_obj)
+
+int StackItem_obj::__FindIndex(::String inName)
+{
+	if (inName==HX_("CFunction",7b,e2,32,23)) return 0;
+	if (inName==HX_("FilePos",58,a4,9d,cc)) return 2;
+	if (inName==HX_("LocalFunction",83,63,3d,d5)) return 4;
+	if (inName==HX_("Method",01,6b,ef,3d)) return 3;
+	if (inName==HX_("Module",cc,a8,67,f5)) return 1;
+	return super::__FindIndex(inName);
+}
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC4(StackItem_obj,FilePos,return)
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(StackItem_obj,LocalFunction,return)
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(StackItem_obj,Method,return)
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(StackItem_obj,Module,return)
+
+int StackItem_obj::__FindArgCount(::String inName)
+{
+	if (inName==HX_("CFunction",7b,e2,32,23)) return 0;
+	if (inName==HX_("FilePos",58,a4,9d,cc)) return 4;
+	if (inName==HX_("LocalFunction",83,63,3d,d5)) return 1;
+	if (inName==HX_("Method",01,6b,ef,3d)) return 2;
+	if (inName==HX_("Module",cc,a8,67,f5)) return 1;
+	return super::__FindArgCount(inName);
+}
+
+::hx::Val StackItem_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	if (inName==HX_("CFunction",7b,e2,32,23)) return CFunction;
+	if (inName==HX_("FilePos",58,a4,9d,cc)) return FilePos_dyn();
+	if (inName==HX_("LocalFunction",83,63,3d,d5)) return LocalFunction_dyn();
+	if (inName==HX_("Method",01,6b,ef,3d)) return Method_dyn();
+	if (inName==HX_("Module",cc,a8,67,f5)) return Module_dyn();
+	return super::__Field(inName,inCallProp);
+}
+
+static ::String StackItem_obj_sStaticFields[] = {
+	HX_("CFunction",7b,e2,32,23),
+	HX_("Module",cc,a8,67,f5),
+	HX_("FilePos",58,a4,9d,cc),
+	HX_("Method",01,6b,ef,3d),
+	HX_("LocalFunction",83,63,3d,d5),
+	::String(null())
+};
+
+::hx::Class StackItem_obj::__mClass;
+
+Dynamic __Create_StackItem_obj() { return new StackItem_obj; }
+
+void StackItem_obj::__register()
+{
+
+::hx::Static(__mClass) = ::hx::_hx_RegisterClass(HX_("haxe.StackItem",13,26,c7,2d), ::hx::TCanCast< StackItem_obj >,StackItem_obj_sStaticFields,0,
+	&__Create_StackItem_obj, &__Create,
+	&super::__SGetClass(), &CreateStackItem_obj, 0
+#ifdef HXCPP_VISIT_ALLOCS
+    , 0
+#endif
+#ifdef HXCPP_SCRIPTABLE
+    , 0
+#endif
+);
+	__mClass->mGetStaticField = &StackItem_obj::__GetStatic;
+}
+
+void StackItem_obj::__boot()
+{
+CFunction = ::hx::CreateConstEnum< StackItem_obj >(HX_("CFunction",7b,e2,32,23),0);
+}
+
+
+} // end namespace haxe
diff --git a/Sources/c_snikket/src/haxe/Timer.cpp b/Sources/c_snikket/src/haxe/Timer.cpp
new file mode 100644
index 0000000..af1c1f6
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/Timer.cpp
@@ -0,0 +1,225 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_Timer
+#include <haxe/Timer.h>
+#endif
+#ifndef INCLUDED_sys_thread_EventLoop
+#include <sys/thread/EventLoop.h>
+#endif
+#ifndef INCLUDED_sys_thread__EventLoop_RegularEvent
+#include <sys/thread/_EventLoop/RegularEvent.h>
+#endif
+#ifndef INCLUDED_sys_thread__Thread_HaxeThread
+#include <sys/thread/_Thread/HaxeThread.h>
+#endif
+#ifndef INCLUDED_sys_thread__Thread_Thread_Impl_
+#include <sys/thread/_Thread/Thread_Impl_.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_62462c654e989831_81_new,"haxe.Timer","new",0x4136b0cf,"haxe.Timer.new","/usr/local/lib/haxe/std/haxe/Timer.hx",81,0x03b744a5)
+HX_DEFINE_STACK_FRAME(_hx_pos_62462c654e989831_70_new,"haxe.Timer","new",0x4136b0cf,"haxe.Timer.new","/usr/local/lib/haxe/std/haxe/Timer.hx",70,0x03b744a5)
+HX_LOCAL_STACK_FRAME(_hx_pos_62462c654e989831_111_stop,"haxe.Timer","stop",0xd1fd70b3,"haxe.Timer.stop","/usr/local/lib/haxe/std/haxe/Timer.hx",111,0x03b744a5)
+HX_LOCAL_STACK_FRAME(_hx_pos_62462c654e989831_134___default_run,"haxe.Timer","__default_run",0xdc2b9b9c,"haxe.Timer.__default_run","/usr/local/lib/haxe/std/haxe/Timer.hx",134,0x03b744a5)
+HX_LOCAL_STACK_FRAME(_hx_pos_62462c654e989831_147_delay,"haxe.Timer","delay",0x3ed5f1b2,"haxe.Timer.delay","/usr/local/lib/haxe/std/haxe/Timer.hx",147,0x03b744a5)
+HX_LOCAL_STACK_FRAME(_hx_pos_62462c654e989831_145_delay,"haxe.Timer","delay",0x3ed5f1b2,"haxe.Timer.delay","/usr/local/lib/haxe/std/haxe/Timer.hx",145,0x03b744a5)
+namespace haxe{
+
+void Timer_obj::__construct(int time_ms){
+            		HX_BEGIN_LOCAL_FUNC_S1(::hx::LocalFunc,_hx_Closure_0, ::haxe::Timer,_gthis) HXARGC(0)
+            		void _hx_run(){
+            			HX_STACKFRAME(&_hx_pos_62462c654e989831_81_new)
+HXLINE(  81)			_gthis->run();
+            		}
+            		HX_END_LOCAL_FUNC0((void))
+
+            	HX_STACKFRAME(&_hx_pos_62462c654e989831_70_new)
+HXDLIN(  70)		 ::haxe::Timer _gthis = ::hx::ObjectPtr<OBJ_>(this);
+HXLINE(  80)		this->thread = ::sys::thread::_Thread::HaxeThread_obj::current();
+HXLINE(  81)		this->eventHandler = ::sys::thread::_Thread::Thread_Impl__obj::get_events(this->thread)->repeat( ::Dynamic(new _hx_Closure_0(_gthis)),time_ms);
+            	}
+
+Dynamic Timer_obj::__CreateEmpty() { return new Timer_obj; }
+
+void *Timer_obj::_hx_vtable = 0;
+
+Dynamic Timer_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Timer_obj > _hx_result = new Timer_obj();
+	_hx_result->__construct(inArgs[0]);
+	return _hx_result;
+}
+
+bool Timer_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x04eaa0bb;
+}
+
+void Timer_obj::stop(){
+            	HX_STACKFRAME(&_hx_pos_62462c654e989831_111_stop)
+HXDLIN( 111)		::sys::thread::_Thread::Thread_Impl__obj::get_events(this->thread)->cancel(this->eventHandler);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Timer_obj,stop,(void))
+
+HX_BEGIN_DEFAULT_FUNC(__default_run,Timer_obj)
+void _hx_run(){
+            	HX_STACKFRAME(&_hx_pos_62462c654e989831_134___default_run)
+            	}
+HX_END_LOCAL_FUNC0((void))
+HX_END_DEFAULT_FUNC
+
+ ::haxe::Timer Timer_obj::delay( ::Dynamic f,int time_ms){
+            		HX_BEGIN_LOCAL_FUNC_S2(::hx::LocalFunc,_hx_Closure_0, ::Dynamic,f, ::haxe::Timer,t) HXARGC(0)
+            		void _hx_run(){
+            			HX_GC_STACKFRAME(&_hx_pos_62462c654e989831_147_delay)
+HXLINE( 148)			t->stop();
+HXLINE( 149)			f();
+            		}
+            		HX_END_LOCAL_FUNC0((void))
+
+            	HX_GC_STACKFRAME(&_hx_pos_62462c654e989831_145_delay)
+HXLINE( 146)		 ::haxe::Timer t =  ::haxe::Timer_obj::__alloc( HX_CTX ,time_ms);
+HXLINE( 147)		t->run =  ::Dynamic(new _hx_Closure_0(f,t));
+HXLINE( 151)		return t;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(Timer_obj,delay,return )
+
+
+void Timer_obj::__alloc_dynamic_functions(::hx::Ctx *_hx_ctx,Timer_obj *_hx_obj) {
+	if (!_hx_obj->run.mPtr) _hx_obj->run = new __default_run(_hx_obj);
+}
+::hx::ObjectPtr< Timer_obj > Timer_obj::__new(int time_ms) {
+	::hx::ObjectPtr< Timer_obj > __this = new Timer_obj();
+	__this->__construct(time_ms);
+	return __this;
+}
+
+::hx::ObjectPtr< Timer_obj > Timer_obj::__alloc(::hx::Ctx *_hx_ctx,int time_ms) {
+	Timer_obj *__this = (Timer_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Timer_obj), true, "haxe.Timer"));
+	*(void **)__this = Timer_obj::_hx_vtable;
+	haxe::Timer_obj::__alloc_dynamic_functions(_hx_ctx,__this);
+	__this->__construct(time_ms);
+	return __this;
+}
+
+Timer_obj::Timer_obj()
+{
+	run = new __default_run(this);
+}
+
+void Timer_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(Timer);
+	HX_MARK_MEMBER_NAME(thread,"thread");
+	HX_MARK_MEMBER_NAME(eventHandler,"eventHandler");
+	HX_MARK_MEMBER_NAME(run,"run");
+	HX_MARK_END_CLASS();
+}
+
+void Timer_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(thread,"thread");
+	HX_VISIT_MEMBER_NAME(eventHandler,"eventHandler");
+	HX_VISIT_MEMBER_NAME(run,"run");
+}
+
+::hx::Val Timer_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"run") ) { return ::hx::Val( run ); }
+		break;
+	case 4:
+		if (HX_FIELD_EQ(inName,"stop") ) { return ::hx::Val( stop_dyn() ); }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"thread") ) { return ::hx::Val( thread ); }
+		break;
+	case 12:
+		if (HX_FIELD_EQ(inName,"eventHandler") ) { return ::hx::Val( eventHandler ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+bool Timer_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 5:
+		if (HX_FIELD_EQ(inName,"delay") ) { outValue = delay_dyn(); return true; }
+	}
+	return false;
+}
+
+::hx::Val Timer_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"run") ) { run=inValue.Cast<  ::Dynamic >(); return inValue; }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"thread") ) { thread=inValue.Cast<  ::sys::thread::_Thread::HaxeThread >(); return inValue; }
+		break;
+	case 12:
+		if (HX_FIELD_EQ(inName,"eventHandler") ) { eventHandler=inValue.Cast<  ::sys::thread::_EventLoop::RegularEvent >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void Timer_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("thread",ca,7a,b9,8e));
+	outFields->push(HX_("eventHandler",d0,a6,2a,d6));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo Timer_obj_sMemberStorageInfo[] = {
+	{::hx::fsObject /*  ::sys::thread::_Thread::HaxeThread */ ,(int)offsetof(Timer_obj,thread),HX_("thread",ca,7a,b9,8e)},
+	{::hx::fsObject /*  ::sys::thread::_EventLoop::RegularEvent */ ,(int)offsetof(Timer_obj,eventHandler),HX_("eventHandler",d0,a6,2a,d6)},
+	{::hx::fsObject /*  ::Dynamic */ ,(int)offsetof(Timer_obj,run),HX_("run",4b,e7,56,00)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *Timer_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String Timer_obj_sMemberFields[] = {
+	HX_("thread",ca,7a,b9,8e),
+	HX_("eventHandler",d0,a6,2a,d6),
+	HX_("stop",02,f0,5b,4c),
+	HX_("run",4b,e7,56,00),
+	::String(null()) };
+
+::hx::Class Timer_obj::__mClass;
+
+static ::String Timer_obj_sStaticFields[] = {
+	HX_("delay",83,d7,26,d7),
+	::String(null())
+};
+
+void Timer_obj::__register()
+{
+	Timer_obj _hx_dummy;
+	Timer_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.Timer",5d,9d,24,4b);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &Timer_obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(Timer_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(Timer_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< Timer_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Timer_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Timer_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
diff --git a/Sources/c_snikket/src/haxe/ValueException.cpp b/Sources/c_snikket/src/haxe/ValueException.cpp
new file mode 100644
index 0000000..94292f4
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/ValueException.cpp
@@ -0,0 +1,142 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Std
+#include <Std.h>
+#endif
+#ifndef INCLUDED_haxe_Exception
+#include <haxe/Exception.h>
+#endif
+#ifndef INCLUDED_haxe_ValueException
+#include <haxe/ValueException.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_aef49c9161dcd373_23_new,"haxe.ValueException","new",0xb19045f8,"haxe.ValueException.new","/usr/local/lib/haxe/std/haxe/ValueException.hx",23,0x518cf4d4)
+namespace haxe{
+
+void ValueException_obj::__construct( ::Dynamic value, ::haxe::Exception previous, ::Dynamic native){
+            	HX_STACKFRAME(&_hx_pos_aef49c9161dcd373_23_new)
+HXLINE(  24)		::String _hx_tmp;
+HXDLIN(  24)		if (::hx::IsNull( value )) {
+HXLINE(  24)			_hx_tmp = HX_("null",87,9e,0e,49);
+            		}
+            		else {
+HXLINE(  24)			_hx_tmp = ::Std_obj::string(value);
+            		}
+HXDLIN(  24)		super::__construct(_hx_tmp,previous,native);
+HXLINE(  25)		this->value = value;
+            	}
+
+Dynamic ValueException_obj::__CreateEmpty() { return new ValueException_obj; }
+
+void *ValueException_obj::_hx_vtable = 0;
+
+Dynamic ValueException_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< ValueException_obj > _hx_result = new ValueException_obj();
+	_hx_result->__construct(inArgs[0],inArgs[1],inArgs[2]);
+	return _hx_result;
+}
+
+bool ValueException_obj::_hx_isInstanceOf(int inClassId) {
+	if (inClassId<=(int)0x0af01d58) {
+		return inClassId==(int)0x00000001 || inClassId==(int)0x0af01d58;
+	} else {
+		return inClassId==(int)0x677ddc49;
+	}
+}
+
+
+::hx::ObjectPtr< ValueException_obj > ValueException_obj::__new( ::Dynamic value, ::haxe::Exception previous, ::Dynamic native) {
+	::hx::ObjectPtr< ValueException_obj > __this = new ValueException_obj();
+	__this->__construct(value,previous,native);
+	return __this;
+}
+
+::hx::ObjectPtr< ValueException_obj > ValueException_obj::__alloc(::hx::Ctx *_hx_ctx, ::Dynamic value, ::haxe::Exception previous, ::Dynamic native) {
+	ValueException_obj *__this = (ValueException_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(ValueException_obj), true, "haxe.ValueException"));
+	*(void **)__this = ValueException_obj::_hx_vtable;
+	__this->__construct(value,previous,native);
+	return __this;
+}
+
+ValueException_obj::ValueException_obj()
+{
+}
+
+void ValueException_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(ValueException);
+	HX_MARK_MEMBER_NAME(value,"value");
+	 ::haxe::Exception_obj::__Mark(HX_MARK_ARG);
+	HX_MARK_END_CLASS();
+}
+
+void ValueException_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(value,"value");
+	 ::haxe::Exception_obj::__Visit(HX_VISIT_ARG);
+}
+
+::hx::Val ValueException_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 5:
+		if (HX_FIELD_EQ(inName,"value") ) { return ::hx::Val( value ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val ValueException_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 5:
+		if (HX_FIELD_EQ(inName,"value") ) { value=inValue.Cast<  ::Dynamic >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void ValueException_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("value",71,7f,b8,31));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo ValueException_obj_sMemberStorageInfo[] = {
+	{::hx::fsObject /*  ::Dynamic */ ,(int)offsetof(ValueException_obj,value),HX_("value",71,7f,b8,31)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *ValueException_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String ValueException_obj_sMemberFields[] = {
+	HX_("value",71,7f,b8,31),
+	::String(null()) };
+
+::hx::Class ValueException_obj::__mClass;
+
+void ValueException_obj::__register()
+{
+	ValueException_obj _hx_dummy;
+	ValueException_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.ValueException",06,2a,10,02);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(ValueException_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< ValueException_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = ValueException_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = ValueException_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
diff --git a/Sources/c_snikket/src/haxe/crypto/Base64.cpp b/Sources/c_snikket/src/haxe/crypto/Base64.cpp
new file mode 100644
index 0000000..2185a75
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/crypto/Base64.cpp
@@ -0,0 +1,260 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_crypto_Base64
+#include <haxe/crypto/Base64.h>
+#endif
+#ifndef INCLUDED_haxe_crypto_BaseCode
+#include <haxe/crypto/BaseCode.h>
+#endif
+#ifndef INCLUDED_haxe_io_Bytes
+#include <haxe/io/Bytes.h>
+#endif
+#ifndef INCLUDED_haxe_io_Encoding
+#include <haxe/io/Encoding.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_160cc64a37c5b236_35_encode,"haxe.crypto.Base64","encode",0xc6961450,"haxe.crypto.Base64.encode","/usr/local/lib/haxe/std/haxe/crypto/Base64.hx",35,0x132e3b4d)
+HX_LOCAL_STACK_FRAME(_hx_pos_160cc64a37c5b236_48_decode,"haxe.crypto.Base64","decode",0x319f7f68,"haxe.crypto.Base64.decode","/usr/local/lib/haxe/std/haxe/crypto/Base64.hx",48,0x132e3b4d)
+HX_LOCAL_STACK_FRAME(_hx_pos_160cc64a37c5b236_55_urlEncode,"haxe.crypto.Base64","urlEncode",0xe877cceb,"haxe.crypto.Base64.urlEncode","/usr/local/lib/haxe/std/haxe/crypto/Base64.hx",55,0x132e3b4d)
+HX_LOCAL_STACK_FRAME(_hx_pos_160cc64a37c5b236_68_urlDecode,"haxe.crypto.Base64","urlDecode",0x53813803,"haxe.crypto.Base64.urlDecode","/usr/local/lib/haxe/std/haxe/crypto/Base64.hx",68,0x132e3b4d)
+HX_LOCAL_STACK_FRAME(_hx_pos_160cc64a37c5b236_29_boot,"haxe.crypto.Base64","boot",0x49b2c3ec,"haxe.crypto.Base64.boot","/usr/local/lib/haxe/std/haxe/crypto/Base64.hx",29,0x132e3b4d)
+HX_LOCAL_STACK_FRAME(_hx_pos_160cc64a37c5b236_30_boot,"haxe.crypto.Base64","boot",0x49b2c3ec,"haxe.crypto.Base64.boot","/usr/local/lib/haxe/std/haxe/crypto/Base64.hx",30,0x132e3b4d)
+HX_LOCAL_STACK_FRAME(_hx_pos_160cc64a37c5b236_32_boot,"haxe.crypto.Base64","boot",0x49b2c3ec,"haxe.crypto.Base64.boot","/usr/local/lib/haxe/std/haxe/crypto/Base64.hx",32,0x132e3b4d)
+HX_LOCAL_STACK_FRAME(_hx_pos_160cc64a37c5b236_33_boot,"haxe.crypto.Base64","boot",0x49b2c3ec,"haxe.crypto.Base64.boot","/usr/local/lib/haxe/std/haxe/crypto/Base64.hx",33,0x132e3b4d)
+namespace haxe{
+namespace crypto{
+
+void Base64_obj::__construct() { }
+
+Dynamic Base64_obj::__CreateEmpty() { return new Base64_obj; }
+
+void *Base64_obj::_hx_vtable = 0;
+
+Dynamic Base64_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Base64_obj > _hx_result = new Base64_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool Base64_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x08b38de6;
+}
+
+::String Base64_obj::CHARS;
+
+ ::haxe::io::Bytes Base64_obj::BYTES;
+
+::String Base64_obj::URL_CHARS;
+
+ ::haxe::io::Bytes Base64_obj::URL_BYTES;
+
+::String Base64_obj::encode( ::haxe::io::Bytes bytes,::hx::Null< bool >  __o_complement){
+            		bool complement = __o_complement.Default(true);
+            	HX_GC_STACKFRAME(&_hx_pos_160cc64a37c5b236_35_encode)
+HXLINE(  36)		::String str =  ::haxe::crypto::BaseCode_obj::__alloc( HX_CTX ,::haxe::crypto::Base64_obj::BYTES)->encodeBytes(bytes)->toString();
+HXLINE(  37)		if (complement) {
+HXLINE(  38)			switch((int)(::hx::Mod(bytes->length,3))){
+            				case (int)1: {
+HXLINE(  40)					str = (str + HX_("==",60,35,00,00));
+            				}
+            				break;
+            				case (int)2: {
+HXLINE(  42)					str = (str + HX_("=",3d,00,00,00));
+            				}
+            				break;
+            				default:{
+            				}
+            			}
+            		}
+HXLINE(  45)		return str;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(Base64_obj,encode,return )
+
+ ::haxe::io::Bytes Base64_obj::decode(::String str,::hx::Null< bool >  __o_complement){
+            		bool complement = __o_complement.Default(true);
+            	HX_GC_STACKFRAME(&_hx_pos_160cc64a37c5b236_48_decode)
+HXLINE(  49)		if (complement) {
+HXLINE(  50)			while(::hx::IsEq( str.charCodeAt((str.length - 1)),61 )){
+HXLINE(  51)				str = str.substr(0,-1);
+            			}
+            		}
+HXLINE(  52)		 ::haxe::crypto::BaseCode _hx_tmp =  ::haxe::crypto::BaseCode_obj::__alloc( HX_CTX ,::haxe::crypto::Base64_obj::BYTES);
+HXDLIN(  52)		return _hx_tmp->decodeBytes(::haxe::io::Bytes_obj::ofString(str,null()));
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(Base64_obj,decode,return )
+
+::String Base64_obj::urlEncode( ::haxe::io::Bytes bytes,::hx::Null< bool >  __o_complement){
+            		bool complement = __o_complement.Default(false);
+            	HX_GC_STACKFRAME(&_hx_pos_160cc64a37c5b236_55_urlEncode)
+HXLINE(  56)		::String str =  ::haxe::crypto::BaseCode_obj::__alloc( HX_CTX ,::haxe::crypto::Base64_obj::URL_BYTES)->encodeBytes(bytes)->toString();
+HXLINE(  57)		if (complement) {
+HXLINE(  58)			switch((int)(::hx::Mod(bytes->length,3))){
+            				case (int)1: {
+HXLINE(  60)					str = (str + HX_("==",60,35,00,00));
+            				}
+            				break;
+            				case (int)2: {
+HXLINE(  62)					str = (str + HX_("=",3d,00,00,00));
+            				}
+            				break;
+            				default:{
+            				}
+            			}
+            		}
+HXLINE(  65)		return str;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(Base64_obj,urlEncode,return )
+
+ ::haxe::io::Bytes Base64_obj::urlDecode(::String str,::hx::Null< bool >  __o_complement){
+            		bool complement = __o_complement.Default(false);
+            	HX_GC_STACKFRAME(&_hx_pos_160cc64a37c5b236_68_urlDecode)
+HXLINE(  69)		if (complement) {
+HXLINE(  70)			while(::hx::IsEq( str.charCodeAt((str.length - 1)),61 )){
+HXLINE(  71)				str = str.substr(0,-1);
+            			}
+            		}
+HXLINE(  72)		 ::haxe::crypto::BaseCode _hx_tmp =  ::haxe::crypto::BaseCode_obj::__alloc( HX_CTX ,::haxe::crypto::Base64_obj::URL_BYTES);
+HXDLIN(  72)		return _hx_tmp->decodeBytes(::haxe::io::Bytes_obj::ofString(str,null()));
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(Base64_obj,urlDecode,return )
+
+
+Base64_obj::Base64_obj()
+{
+}
+
+bool Base64_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 5:
+		if (HX_FIELD_EQ(inName,"CHARS") ) { outValue = ( CHARS ); return true; }
+		if (HX_FIELD_EQ(inName,"BYTES") ) { outValue = ( BYTES ); return true; }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"encode") ) { outValue = encode_dyn(); return true; }
+		if (HX_FIELD_EQ(inName,"decode") ) { outValue = decode_dyn(); return true; }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"URL_CHARS") ) { outValue = ( URL_CHARS ); return true; }
+		if (HX_FIELD_EQ(inName,"URL_BYTES") ) { outValue = ( URL_BYTES ); return true; }
+		if (HX_FIELD_EQ(inName,"urlEncode") ) { outValue = urlEncode_dyn(); return true; }
+		if (HX_FIELD_EQ(inName,"urlDecode") ) { outValue = urlDecode_dyn(); return true; }
+	}
+	return false;
+}
+
+bool Base64_obj::__SetStatic(const ::String &inName,Dynamic &ioValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 5:
+		if (HX_FIELD_EQ(inName,"CHARS") ) { CHARS=ioValue.Cast< ::String >(); return true; }
+		if (HX_FIELD_EQ(inName,"BYTES") ) { BYTES=ioValue.Cast<  ::haxe::io::Bytes >(); return true; }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"URL_CHARS") ) { URL_CHARS=ioValue.Cast< ::String >(); return true; }
+		if (HX_FIELD_EQ(inName,"URL_BYTES") ) { URL_BYTES=ioValue.Cast<  ::haxe::io::Bytes >(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *Base64_obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo Base64_obj_sStaticStorageInfo[] = {
+	{::hx::fsString,(void *) &Base64_obj::CHARS,HX_("CHARS",bd,d4,a1,c3)},
+	{::hx::fsObject /*  ::haxe::io::Bytes */ ,(void *) &Base64_obj::BYTES,HX_("BYTES",4b,40,86,3b)},
+	{::hx::fsString,(void *) &Base64_obj::URL_CHARS,HX_("URL_CHARS",8d,c8,38,74)},
+	{::hx::fsObject /*  ::haxe::io::Bytes */ ,(void *) &Base64_obj::URL_BYTES,HX_("URL_BYTES",1b,34,1d,ec)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+#endif
+
+static void Base64_obj_sMarkStatics(HX_MARK_PARAMS) {
+	HX_MARK_MEMBER_NAME(Base64_obj::CHARS,"CHARS");
+	HX_MARK_MEMBER_NAME(Base64_obj::BYTES,"BYTES");
+	HX_MARK_MEMBER_NAME(Base64_obj::URL_CHARS,"URL_CHARS");
+	HX_MARK_MEMBER_NAME(Base64_obj::URL_BYTES,"URL_BYTES");
+};
+
+#ifdef HXCPP_VISIT_ALLOCS
+static void Base64_obj_sVisitStatics(HX_VISIT_PARAMS) {
+	HX_VISIT_MEMBER_NAME(Base64_obj::CHARS,"CHARS");
+	HX_VISIT_MEMBER_NAME(Base64_obj::BYTES,"BYTES");
+	HX_VISIT_MEMBER_NAME(Base64_obj::URL_CHARS,"URL_CHARS");
+	HX_VISIT_MEMBER_NAME(Base64_obj::URL_BYTES,"URL_BYTES");
+};
+
+#endif
+
+::hx::Class Base64_obj::__mClass;
+
+static ::String Base64_obj_sStaticFields[] = {
+	HX_("CHARS",bd,d4,a1,c3),
+	HX_("BYTES",4b,40,86,3b),
+	HX_("URL_CHARS",8d,c8,38,74),
+	HX_("URL_BYTES",1b,34,1d,ec),
+	HX_("encode",16,f2,e3,f9),
+	HX_("decode",2e,5d,ed,64),
+	HX_("urlEncode",e5,4e,52,9a),
+	HX_("urlDecode",fd,b9,5b,05),
+	::String(null())
+};
+
+void Base64_obj::__register()
+{
+	Base64_obj _hx_dummy;
+	Base64_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.crypto.Base64",f4,3a,39,e7);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &Base64_obj::__GetStatic;
+	__mClass->mSetStaticField = &Base64_obj::__SetStatic;
+	__mClass->mMarkFunc = Base64_obj_sMarkStatics;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(Base64_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< Base64_obj >;
+#ifdef HXCPP_VISIT_ALLOCS
+	__mClass->mVisitFunc = Base64_obj_sVisitStatics;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Base64_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Base64_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+void Base64_obj::__boot()
+{
+{
+            	HX_STACKFRAME(&_hx_pos_160cc64a37c5b236_29_boot)
+HXDLIN(  29)		CHARS = HX_("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",03,41,03,7f);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_160cc64a37c5b236_30_boot)
+HXDLIN(  30)		BYTES = ::haxe::io::Bytes_obj::ofString(::haxe::crypto::Base64_obj::CHARS,null());
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_160cc64a37c5b236_32_boot)
+HXDLIN(  32)		URL_CHARS = HX_("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_",f1,42,03,7f);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_160cc64a37c5b236_33_boot)
+HXDLIN(  33)		URL_BYTES = ::haxe::io::Bytes_obj::ofString(::haxe::crypto::Base64_obj::URL_CHARS,null());
+            	}
+}
+
+} // end namespace haxe
+} // end namespace crypto
diff --git a/Sources/c_snikket/src/haxe/crypto/BaseCode.cpp b/Sources/c_snikket/src/haxe/crypto/BaseCode.cpp
new file mode 100644
index 0000000..c17124b
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/crypto/BaseCode.cpp
@@ -0,0 +1,285 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Std
+#include <Std.h>
+#endif
+#ifndef INCLUDED_haxe_crypto_BaseCode
+#include <haxe/crypto/BaseCode.h>
+#endif
+#ifndef INCLUDED_haxe_io_Bytes
+#include <haxe/io/Bytes.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_b23e417e2bb3f320_33_new,"haxe.crypto.BaseCode","new",0xd63c60f5,"haxe.crypto.BaseCode.new","/usr/local/lib/haxe/std/haxe/crypto/BaseCode.hx",33,0xb0c29dde)
+HX_LOCAL_STACK_FRAME(_hx_pos_b23e417e2bb3f320_44_encodeBytes,"haxe.crypto.BaseCode","encodeBytes",0x58a8e40a,"haxe.crypto.BaseCode.encodeBytes","/usr/local/lib/haxe/std/haxe/crypto/BaseCode.hx",44,0xb0c29dde)
+HX_LOCAL_STACK_FRAME(_hx_pos_b23e417e2bb3f320_72_initTable,"haxe.crypto.BaseCode","initTable",0xa1288133,"haxe.crypto.BaseCode.initTable","/usr/local/lib/haxe/std/haxe/crypto/BaseCode.hx",72,0xb0c29dde)
+HX_LOCAL_STACK_FRAME(_hx_pos_b23e417e2bb3f320_81_decodeBytes,"haxe.crypto.BaseCode","decodeBytes",0x152c41f2,"haxe.crypto.BaseCode.decodeBytes","/usr/local/lib/haxe/std/haxe/crypto/BaseCode.hx",81,0xb0c29dde)
+namespace haxe{
+namespace crypto{
+
+void BaseCode_obj::__construct( ::haxe::io::Bytes base){
+            	HX_STACKFRAME(&_hx_pos_b23e417e2bb3f320_33_new)
+HXLINE(  34)		int len = base->length;
+HXLINE(  35)		int nbits = 1;
+HXLINE(  36)		while((len > (1 << nbits))){
+HXLINE(  37)			nbits = (nbits + 1);
+            		}
+HXLINE(  38)		bool _hx_tmp;
+HXDLIN(  38)		if ((nbits <= 8)) {
+HXLINE(  38)			_hx_tmp = (len != (1 << nbits));
+            		}
+            		else {
+HXLINE(  38)			_hx_tmp = true;
+            		}
+HXDLIN(  38)		if (_hx_tmp) {
+HXLINE(  39)			HX_STACK_DO_THROW(HX_("BaseCode : base length must be a power of two.",78,b6,c8,ca));
+            		}
+HXLINE(  40)		this->base = base;
+HXLINE(  41)		this->nbits = nbits;
+            	}
+
+Dynamic BaseCode_obj::__CreateEmpty() { return new BaseCode_obj; }
+
+void *BaseCode_obj::_hx_vtable = 0;
+
+Dynamic BaseCode_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< BaseCode_obj > _hx_result = new BaseCode_obj();
+	_hx_result->__construct(inArgs[0]);
+	return _hx_result;
+}
+
+bool BaseCode_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x34980465;
+}
+
+ ::haxe::io::Bytes BaseCode_obj::encodeBytes( ::haxe::io::Bytes b){
+            	HX_STACKFRAME(&_hx_pos_b23e417e2bb3f320_44_encodeBytes)
+HXLINE(  48)		int nbits = this->nbits;
+HXLINE(  49)		 ::haxe::io::Bytes base = this->base;
+HXLINE(  50)		int size = ::Std_obj::_hx_int((( (Float)((b->length * 8)) ) / ( (Float)(nbits) )));
+HXLINE(  51)		int out;
+HXDLIN(  51)		if ((::hx::Mod((b->length * 8),nbits) == 0)) {
+HXLINE(  51)			out = 0;
+            		}
+            		else {
+HXLINE(  51)			out = 1;
+            		}
+HXDLIN(  51)		 ::haxe::io::Bytes out1 = ::haxe::io::Bytes_obj::alloc((size + out));
+HXLINE(  52)		int buf = 0;
+HXLINE(  53)		int curbits = 0;
+HXLINE(  54)		int mask = ((1 << nbits) - 1);
+HXLINE(  55)		int pin = 0;
+HXLINE(  56)		int pout = 0;
+HXLINE(  57)		while((pout < size)){
+HXLINE(  58)			while((curbits < nbits)){
+HXLINE(  59)				curbits = (curbits + 8);
+HXLINE(  60)				buf = (buf << 8);
+HXLINE(  61)				pin = (pin + 1);
+HXDLIN(  61)				buf = (buf | ( (int)(b->b->__get((pin - 1))) ));
+            			}
+HXLINE(  63)			curbits = (curbits - nbits);
+HXLINE(  64)			{
+HXLINE(  64)				pout = (pout + 1);
+HXDLIN(  64)				out1->b[(pout - 1)] = base->b->__get(((buf >> curbits) & mask));
+            			}
+            		}
+HXLINE(  66)		if ((curbits > 0)) {
+HXLINE(  67)			pout = (pout + 1);
+HXDLIN(  67)			out1->b[(pout - 1)] = base->b->__get(((buf << (nbits - curbits)) & mask));
+            		}
+HXLINE(  68)		return out1;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(BaseCode_obj,encodeBytes,return )
+
+void BaseCode_obj::initTable(){
+            	HX_STACKFRAME(&_hx_pos_b23e417e2bb3f320_72_initTable)
+HXLINE(  73)		::Array< int > tbl = ::Array_obj< int >::__new();
+HXLINE(  74)		{
+HXLINE(  74)			int _g = 0;
+HXDLIN(  74)			while((_g < 256)){
+HXLINE(  74)				_g = (_g + 1);
+HXDLIN(  74)				int i = (_g - 1);
+HXLINE(  75)				tbl[i] = -1;
+            			}
+            		}
+HXLINE(  76)		{
+HXLINE(  76)			int _g1 = 0;
+HXDLIN(  76)			int _g2 = this->base->length;
+HXDLIN(  76)			while((_g1 < _g2)){
+HXLINE(  76)				_g1 = (_g1 + 1);
+HXDLIN(  76)				int i1 = (_g1 - 1);
+HXLINE(  77)				tbl[( (int)(this->base->b->__get(i1)) )] = i1;
+            			}
+            		}
+HXLINE(  78)		this->tbl = tbl;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(BaseCode_obj,initTable,(void))
+
+ ::haxe::io::Bytes BaseCode_obj::decodeBytes( ::haxe::io::Bytes b){
+            	HX_STACKFRAME(&_hx_pos_b23e417e2bb3f320_81_decodeBytes)
+HXLINE(  85)		int nbits = this->nbits;
+HXLINE(  86)		 ::haxe::io::Bytes base = this->base;
+HXLINE(  87)		if (::hx::IsNull( this->tbl )) {
+HXLINE(  88)			this->initTable();
+            		}
+HXLINE(  89)		::Array< int > tbl = this->tbl;
+HXLINE(  90)		int size = ((b->length * nbits) >> 3);
+HXLINE(  91)		 ::haxe::io::Bytes out = ::haxe::io::Bytes_obj::alloc(size);
+HXLINE(  92)		int buf = 0;
+HXLINE(  93)		int curbits = 0;
+HXLINE(  94)		int pin = 0;
+HXLINE(  95)		int pout = 0;
+HXLINE(  96)		while((pout < size)){
+HXLINE(  97)			while((curbits < 8)){
+HXLINE(  98)				curbits = (curbits + nbits);
+HXLINE(  99)				buf = (buf << nbits);
+HXLINE( 100)				pin = (pin + 1);
+HXDLIN( 100)				int i = tbl->__get(( (int)(b->b->__get((pin - 1))) ));
+HXLINE( 101)				if ((i == -1)) {
+HXLINE( 102)					HX_STACK_DO_THROW(HX_("BaseCode : invalid encoded char",f9,14,33,18));
+            				}
+HXLINE( 103)				buf = (buf | i);
+            			}
+HXLINE( 105)			curbits = (curbits - 8);
+HXLINE( 106)			{
+HXLINE( 106)				pout = (pout + 1);
+HXDLIN( 106)				out->b[(pout - 1)] = ( (unsigned char)(((buf >> curbits) & 255)) );
+            			}
+            		}
+HXLINE( 108)		return out;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(BaseCode_obj,decodeBytes,return )
+
+
+::hx::ObjectPtr< BaseCode_obj > BaseCode_obj::__new( ::haxe::io::Bytes base) {
+	::hx::ObjectPtr< BaseCode_obj > __this = new BaseCode_obj();
+	__this->__construct(base);
+	return __this;
+}
+
+::hx::ObjectPtr< BaseCode_obj > BaseCode_obj::__alloc(::hx::Ctx *_hx_ctx, ::haxe::io::Bytes base) {
+	BaseCode_obj *__this = (BaseCode_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(BaseCode_obj), true, "haxe.crypto.BaseCode"));
+	*(void **)__this = BaseCode_obj::_hx_vtable;
+	__this->__construct(base);
+	return __this;
+}
+
+BaseCode_obj::BaseCode_obj()
+{
+}
+
+void BaseCode_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(BaseCode);
+	HX_MARK_MEMBER_NAME(base,"base");
+	HX_MARK_MEMBER_NAME(nbits,"nbits");
+	HX_MARK_MEMBER_NAME(tbl,"tbl");
+	HX_MARK_END_CLASS();
+}
+
+void BaseCode_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(base,"base");
+	HX_VISIT_MEMBER_NAME(nbits,"nbits");
+	HX_VISIT_MEMBER_NAME(tbl,"tbl");
+}
+
+::hx::Val BaseCode_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"tbl") ) { return ::hx::Val( tbl ); }
+		break;
+	case 4:
+		if (HX_FIELD_EQ(inName,"base") ) { return ::hx::Val( base ); }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"nbits") ) { return ::hx::Val( nbits ); }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"initTable") ) { return ::hx::Val( initTable_dyn() ); }
+		break;
+	case 11:
+		if (HX_FIELD_EQ(inName,"encodeBytes") ) { return ::hx::Val( encodeBytes_dyn() ); }
+		if (HX_FIELD_EQ(inName,"decodeBytes") ) { return ::hx::Val( decodeBytes_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val BaseCode_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"tbl") ) { tbl=inValue.Cast< ::Array< int > >(); return inValue; }
+		break;
+	case 4:
+		if (HX_FIELD_EQ(inName,"base") ) { base=inValue.Cast<  ::haxe::io::Bytes >(); return inValue; }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"nbits") ) { nbits=inValue.Cast< int >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void BaseCode_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("base",11,e8,10,41));
+	outFields->push(HX_("nbits",74,ca,2a,97));
+	outFields->push(HX_("tbl",3e,5b,58,00));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo BaseCode_obj_sMemberStorageInfo[] = {
+	{::hx::fsObject /*  ::haxe::io::Bytes */ ,(int)offsetof(BaseCode_obj,base),HX_("base",11,e8,10,41)},
+	{::hx::fsInt,(int)offsetof(BaseCode_obj,nbits),HX_("nbits",74,ca,2a,97)},
+	{::hx::fsObject /* ::Array< int > */ ,(int)offsetof(BaseCode_obj,tbl),HX_("tbl",3e,5b,58,00)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *BaseCode_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String BaseCode_obj_sMemberFields[] = {
+	HX_("base",11,e8,10,41),
+	HX_("nbits",74,ca,2a,97),
+	HX_("tbl",3e,5b,58,00),
+	HX_("encodeBytes",75,36,2e,c9),
+	HX_("initTable",de,d2,75,26),
+	HX_("decodeBytes",5d,94,b1,85),
+	::String(null()) };
+
+::hx::Class BaseCode_obj::__mClass;
+
+void BaseCode_obj::__register()
+{
+	BaseCode_obj _hx_dummy;
+	BaseCode_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.crypto.BaseCode",83,c2,f9,1c);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(BaseCode_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< BaseCode_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = BaseCode_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = BaseCode_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace crypto
diff --git a/Sources/c_snikket/src/haxe/crypto/Sha1.cpp b/Sources/c_snikket/src/haxe/crypto/Sha1.cpp
new file mode 100644
index 0000000..3ab767b
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/crypto/Sha1.cpp
@@ -0,0 +1,334 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_crypto_Sha1
+#include <haxe/crypto/Sha1.h>
+#endif
+#ifndef INCLUDED_haxe_io_Bytes
+#include <haxe/io/Bytes.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_b388adc1457cbfc2_48_new,"haxe.crypto.Sha1","new",0xdb44b09c,"haxe.crypto.Sha1.new","/usr/local/lib/haxe/std/haxe/crypto/Sha1.hx",48,0x02d96297)
+HX_LOCAL_STACK_FRAME(_hx_pos_b388adc1457cbfc2_50_doEncode,"haxe.crypto.Sha1","doEncode",0xfb483e45,"haxe.crypto.Sha1.doEncode","/usr/local/lib/haxe/std/haxe/crypto/Sha1.hx",50,0x02d96297)
+HX_LOCAL_STACK_FRAME(_hx_pos_b388adc1457cbfc2_142_ft,"haxe.crypto.Sha1","ft",0x7aab5492,"haxe.crypto.Sha1.ft","/usr/local/lib/haxe/std/haxe/crypto/Sha1.hx",142,0x02d96297)
+HX_LOCAL_STACK_FRAME(_hx_pos_b388adc1457cbfc2_155_kt,"haxe.crypto.Sha1","kt",0x7aab58ed,"haxe.crypto.Sha1.kt","/usr/local/lib/haxe/std/haxe/crypto/Sha1.hx",155,0x02d96297)
+HX_LOCAL_STACK_FRAME(_hx_pos_b388adc1457cbfc2_35_make,"haxe.crypto.Sha1","make",0x00298e32,"haxe.crypto.Sha1.make","/usr/local/lib/haxe/std/haxe/crypto/Sha1.hx",35,0x02d96297)
+HX_LOCAL_STACK_FRAME(_hx_pos_b388adc1457cbfc2_115_bytes2blks,"haxe.crypto.Sha1","bytes2blks",0x985aae1d,"haxe.crypto.Sha1.bytes2blks","/usr/local/lib/haxe/std/haxe/crypto/Sha1.hx",115,0x02d96297)
+namespace haxe{
+namespace crypto{
+
+void Sha1_obj::__construct(){
+            	HX_STACKFRAME(&_hx_pos_b388adc1457cbfc2_48_new)
+            	}
+
+Dynamic Sha1_obj::__CreateEmpty() { return new Sha1_obj; }
+
+void *Sha1_obj::_hx_vtable = 0;
+
+Dynamic Sha1_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Sha1_obj > _hx_result = new Sha1_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool Sha1_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x3a249b8c;
+}
+
+::Array< int > Sha1_obj::doEncode(::Array< int > x){
+            	HX_STACKFRAME(&_hx_pos_b388adc1457cbfc2_50_doEncode)
+HXLINE(  51)		::Array< int > w = ::Array_obj< int >::__new();
+HXLINE(  53)		int a = (int)1732584193;
+HXLINE(  54)		int b = -271733879;
+HXLINE(  55)		int c = (int)-1732584194;
+HXLINE(  56)		int d = 271733878;
+HXLINE(  57)		int e = (int)-1009589776;
+HXLINE(  59)		int i = 0;
+HXLINE(  60)		while((i < x->length)){
+HXLINE(  61)			int olda = a;
+HXLINE(  62)			int oldb = b;
+HXLINE(  63)			int oldc = c;
+HXLINE(  64)			int oldd = d;
+HXLINE(  65)			int olde = e;
+HXLINE(  67)			int j = 0;
+HXLINE(  68)			while((j < 80)){
+HXLINE(  69)				if ((j < 16)) {
+HXLINE(  70)					w[j] = x->__get((i + j));
+            				}
+            				else {
+HXLINE(  72)					int num = (((w->__get((j - 3)) ^ w->__get((j - 8))) ^ w->__get((j - 14))) ^ w->__get((j - 16)));
+HXDLIN(  72)					w[j] = ((num << 1) | ::hx::UShr(num,31));
+            				}
+HXLINE(  73)				int t = ((((a << 5) | ::hx::UShr(a,27)) + this->ft(j,b,c,d)) + e);
+HXDLIN(  73)				int t1 = (t + w->__get(j));
+HXDLIN(  73)				int t2 = (t1 + this->kt(j));
+HXLINE(  74)				e = d;
+HXLINE(  75)				d = c;
+HXLINE(  76)				c = ((b << 30) | ::hx::UShr(b,2));
+HXLINE(  77)				b = a;
+HXLINE(  78)				a = t2;
+HXLINE(  79)				j = (j + 1);
+            			}
+HXLINE(  81)			a = (a + olda);
+HXLINE(  82)			b = (b + oldb);
+HXLINE(  83)			c = (c + oldc);
+HXLINE(  84)			d = (d + oldd);
+HXLINE(  85)			e = (e + olde);
+HXLINE(  86)			i = (i + 16);
+            		}
+HXLINE(  88)		return ::Array_obj< int >::__new(5)->init(0,a)->init(1,b)->init(2,c)->init(3,d)->init(4,e);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Sha1_obj,doEncode,return )
+
+int Sha1_obj::ft(int t,int b,int c,int d){
+            	HX_STACKFRAME(&_hx_pos_b388adc1457cbfc2_142_ft)
+HXLINE( 143)		if ((t < 20)) {
+HXLINE( 144)			return ((b & c) | (~(b) & d));
+            		}
+HXLINE( 145)		if ((t < 40)) {
+HXLINE( 146)			return ((b ^ c) ^ d);
+            		}
+HXLINE( 147)		if ((t < 60)) {
+HXLINE( 148)			return (((b & c) | (b & d)) | (c & d));
+            		}
+HXLINE( 149)		return ((b ^ c) ^ d);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC4(Sha1_obj,ft,return )
+
+int Sha1_obj::kt(int t){
+            	HX_STACKFRAME(&_hx_pos_b388adc1457cbfc2_155_kt)
+HXLINE( 156)		if ((t < 20)) {
+HXLINE( 157)			return (int)1518500249;
+            		}
+HXLINE( 158)		if ((t < 40)) {
+HXLINE( 159)			return (int)1859775393;
+            		}
+HXLINE( 160)		if ((t < 60)) {
+HXLINE( 161)			return (int)-1894007588;
+            		}
+HXLINE( 162)		return -899497514;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Sha1_obj,kt,return )
+
+ ::haxe::io::Bytes Sha1_obj::make( ::haxe::io::Bytes b){
+            	HX_GC_STACKFRAME(&_hx_pos_b388adc1457cbfc2_35_make)
+HXLINE(  36)		 ::haxe::crypto::Sha1 h =  ::haxe::crypto::Sha1_obj::__alloc( HX_CTX );
+HXDLIN(  36)		::Array< int > h1 = h->doEncode(::haxe::crypto::Sha1_obj::bytes2blks(b));
+HXLINE(  37)		 ::haxe::io::Bytes out = ::haxe::io::Bytes_obj::alloc(20);
+HXLINE(  38)		int p = 0;
+HXLINE(  39)		{
+HXLINE(  39)			{
+HXLINE(  40)				{
+HXLINE(  40)					p = (p + 1);
+HXDLIN(  40)					out->b[(p - 1)] = ( (unsigned char)(::hx::UShr(h1->__get(0),24)) );
+            				}
+HXLINE(  41)				{
+HXLINE(  41)					p = (p + 1);
+HXDLIN(  41)					out->b[(p - 1)] = ( (unsigned char)(((h1->__get(0) >> 16) & 255)) );
+            				}
+HXLINE(  42)				{
+HXLINE(  42)					p = (p + 1);
+HXDLIN(  42)					out->b[(p - 1)] = ( (unsigned char)(((h1->__get(0) >> 8) & 255)) );
+            				}
+HXLINE(  43)				{
+HXLINE(  43)					p = (p + 1);
+HXDLIN(  43)					out->b[(p - 1)] = ( (unsigned char)((h1->__get(0) & 255)) );
+            				}
+            			}
+HXLINE(  39)			{
+HXLINE(  40)				{
+HXLINE(  40)					p = (p + 1);
+HXDLIN(  40)					out->b[(p - 1)] = ( (unsigned char)(::hx::UShr(h1->__get(1),24)) );
+            				}
+HXLINE(  41)				{
+HXLINE(  41)					p = (p + 1);
+HXDLIN(  41)					out->b[(p - 1)] = ( (unsigned char)(((h1->__get(1) >> 16) & 255)) );
+            				}
+HXLINE(  42)				{
+HXLINE(  42)					p = (p + 1);
+HXDLIN(  42)					out->b[(p - 1)] = ( (unsigned char)(((h1->__get(1) >> 8) & 255)) );
+            				}
+HXLINE(  43)				{
+HXLINE(  43)					p = (p + 1);
+HXDLIN(  43)					out->b[(p - 1)] = ( (unsigned char)((h1->__get(1) & 255)) );
+            				}
+            			}
+HXLINE(  39)			{
+HXLINE(  40)				{
+HXLINE(  40)					p = (p + 1);
+HXDLIN(  40)					out->b[(p - 1)] = ( (unsigned char)(::hx::UShr(h1->__get(2),24)) );
+            				}
+HXLINE(  41)				{
+HXLINE(  41)					p = (p + 1);
+HXDLIN(  41)					out->b[(p - 1)] = ( (unsigned char)(((h1->__get(2) >> 16) & 255)) );
+            				}
+HXLINE(  42)				{
+HXLINE(  42)					p = (p + 1);
+HXDLIN(  42)					out->b[(p - 1)] = ( (unsigned char)(((h1->__get(2) >> 8) & 255)) );
+            				}
+HXLINE(  43)				{
+HXLINE(  43)					p = (p + 1);
+HXDLIN(  43)					out->b[(p - 1)] = ( (unsigned char)((h1->__get(2) & 255)) );
+            				}
+            			}
+HXLINE(  39)			{
+HXLINE(  40)				{
+HXLINE(  40)					p = (p + 1);
+HXDLIN(  40)					out->b[(p - 1)] = ( (unsigned char)(::hx::UShr(h1->__get(3),24)) );
+            				}
+HXLINE(  41)				{
+HXLINE(  41)					p = (p + 1);
+HXDLIN(  41)					out->b[(p - 1)] = ( (unsigned char)(((h1->__get(3) >> 16) & 255)) );
+            				}
+HXLINE(  42)				{
+HXLINE(  42)					p = (p + 1);
+HXDLIN(  42)					out->b[(p - 1)] = ( (unsigned char)(((h1->__get(3) >> 8) & 255)) );
+            				}
+HXLINE(  43)				{
+HXLINE(  43)					p = (p + 1);
+HXDLIN(  43)					out->b[(p - 1)] = ( (unsigned char)((h1->__get(3) & 255)) );
+            				}
+            			}
+HXLINE(  39)			{
+HXLINE(  40)				{
+HXLINE(  40)					p = (p + 1);
+HXDLIN(  40)					out->b[(p - 1)] = ( (unsigned char)(::hx::UShr(h1->__get(4),24)) );
+            				}
+HXLINE(  41)				{
+HXLINE(  41)					p = (p + 1);
+HXDLIN(  41)					out->b[(p - 1)] = ( (unsigned char)(((h1->__get(4) >> 16) & 255)) );
+            				}
+HXLINE(  42)				{
+HXLINE(  42)					p = (p + 1);
+HXDLIN(  42)					out->b[(p - 1)] = ( (unsigned char)(((h1->__get(4) >> 8) & 255)) );
+            				}
+HXLINE(  43)				{
+HXLINE(  43)					p = (p + 1);
+HXDLIN(  43)					out->b[(p - 1)] = ( (unsigned char)((h1->__get(4) & 255)) );
+            				}
+            			}
+            		}
+HXLINE(  45)		return out;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Sha1_obj,make,return )
+
+::Array< int > Sha1_obj::bytes2blks( ::haxe::io::Bytes b){
+            	HX_STACKFRAME(&_hx_pos_b388adc1457cbfc2_115_bytes2blks)
+HXLINE( 116)		int nblk = (((b->length + 8) >> 6) + 1);
+HXLINE( 117)		::Array< int > blks = ::Array_obj< int >::__new();
+HXLINE( 119)		{
+HXLINE( 119)			int _g = 0;
+HXDLIN( 119)			int _g1 = (nblk * 16);
+HXDLIN( 119)			while((_g < _g1)){
+HXLINE( 119)				_g = (_g + 1);
+HXDLIN( 119)				int i = (_g - 1);
+HXLINE( 120)				blks[i] = 0;
+            			}
+            		}
+HXLINE( 121)		{
+HXLINE( 121)			int _g2 = 0;
+HXDLIN( 121)			int _g3 = b->length;
+HXDLIN( 121)			while((_g2 < _g3)){
+HXLINE( 121)				_g2 = (_g2 + 1);
+HXDLIN( 121)				int i1 = (_g2 - 1);
+HXLINE( 122)				int p = (i1 >> 2);
+HXLINE( 123)				::Array< int > blks1 = blks;
+HXDLIN( 123)				int p1 = p;
+HXDLIN( 123)				blks1[p1] = (blks1->__get(p1) | (( (int)(b->b->__get(i1)) ) << (24 - ((i1 & 3) << 3))));
+            			}
+            		}
+HXLINE( 125)		int i2 = b->length;
+HXLINE( 126)		int p2 = (i2 >> 2);
+HXLINE( 127)		::Array< int > blks2 = blks;
+HXDLIN( 127)		int p3 = p2;
+HXDLIN( 127)		blks2[p3] = (blks2->__get(p3) | (128 << (24 - ((i2 & 3) << 3))));
+HXLINE( 128)		blks[((nblk * 16) - 1)] = (b->length * 8);
+HXLINE( 129)		return blks;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Sha1_obj,bytes2blks,return )
+
+
+Sha1_obj::Sha1_obj()
+{
+}
+
+::hx::Val Sha1_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 2:
+		if (HX_FIELD_EQ(inName,"ft") ) { return ::hx::Val( ft_dyn() ); }
+		if (HX_FIELD_EQ(inName,"kt") ) { return ::hx::Val( kt_dyn() ); }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"doEncode") ) { return ::hx::Val( doEncode_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+bool Sha1_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"make") ) { outValue = make_dyn(); return true; }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"bytes2blks") ) { outValue = bytes2blks_dyn(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *Sha1_obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo *Sha1_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String Sha1_obj_sMemberFields[] = {
+	HX_("doEncode",01,78,fb,8d),
+	HX_("ft",4e,59,00,00),
+	HX_("kt",a9,5d,00,00),
+	::String(null()) };
+
+::hx::Class Sha1_obj::__mClass;
+
+static ::String Sha1_obj_sStaticFields[] = {
+	HX_("make",ee,39,56,48),
+	HX_("bytes2blks",d9,ce,9c,a9),
+	::String(null())
+};
+
+void Sha1_obj::__register()
+{
+	Sha1_obj _hx_dummy;
+	Sha1_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.crypto.Sha1",aa,72,c9,13);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &Sha1_obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(Sha1_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(Sha1_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< Sha1_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Sha1_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Sha1_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace crypto
diff --git a/Sources/c_snikket/src/haxe/crypto/Sha256.cpp b/Sources/c_snikket/src/haxe/crypto/Sha256.cpp
new file mode 100644
index 0000000..fc04c02
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/crypto/Sha256.cpp
@@ -0,0 +1,313 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_crypto_Sha256
+#include <haxe/crypto/Sha256.h>
+#endif
+#ifndef INCLUDED_haxe_io_Bytes
+#include <haxe/io/Bytes.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_0a4e95b4276e5057_48_new,"haxe.crypto.Sha256","new",0x4d8a58be,"haxe.crypto.Sha256.new","/usr/local/lib/haxe/std/haxe/crypto/Sha256.hx",48,0xc2cd6b75)
+HX_LOCAL_STACK_FRAME(_hx_pos_0a4e95b4276e5057_50_doEncode,"haxe.crypto.Sha256","doEncode",0xbba3dae3,"haxe.crypto.Sha256.doEncode","/usr/local/lib/haxe/std/haxe/crypto/Sha256.hx",50,0xc2cd6b75)
+static const int _hx_array_data_af0be1cc_4[] = {
+	(int)1116352408,(int)1899447441,(int)-1245643825,(int)-373957723,(int)961987163,(int)1508970993,(int)-1841331548,(int)-1424204075,(int)-670586216,(int)310598401,(int)607225278,(int)1426881987,(int)1925078388,(int)-2132889090,(int)-1680079193,(int)-1046744716,(int)-459576895,(int)-272742522,(int)264347078,(int)604807628,(int)770255983,(int)1249150122,(int)1555081692,(int)1996064986,(int)-1740746414,(int)-1473132947,(int)-1341970488,(int)-1084653625,(int)-958395405,(int)-710438585,(int)113926993,(int)338241895,(int)666307205,(int)773529912,(int)1294757372,(int)1396182291,(int)1695183700,(int)1986661051,(int)-2117940946,(int)-1838011259,(int)-1564481375,(int)-1474664885,(int)-1035236496,(int)-949202525,(int)-778901479,(int)-694614492,(int)-200395387,(int)275423344,(int)430227734,(int)506948616,(int)659060556,(int)883997877,(int)958139571,(int)1322822218,(int)1537002063,(int)1747873779,(int)1955562222,(int)2024104815,(int)-2067236844,(int)-1933114872,(int)-1866530822,(int)-1538233109,(int)-1090935817,(int)-965641998,
+};
+static const int _hx_array_data_af0be1cc_5[] = {
+	(int)1779033703,(int)-1150833019,(int)1013904242,(int)-1521486534,(int)1359893119,(int)-1694144372,(int)528734635,(int)1541459225,
+};
+HX_LOCAL_STACK_FRAME(_hx_pos_0a4e95b4276e5057_35_make,"haxe.crypto.Sha256","make",0x8ad703d0,"haxe.crypto.Sha256.make","/usr/local/lib/haxe/std/haxe/crypto/Sha256.hx",35,0xc2cd6b75)
+HX_LOCAL_STACK_FRAME(_hx_pos_0a4e95b4276e5057_133_bytes2blks,"haxe.crypto.Sha256","bytes2blks",0xdc4d2e3b,"haxe.crypto.Sha256.bytes2blks","/usr/local/lib/haxe/std/haxe/crypto/Sha256.hx",133,0xc2cd6b75)
+namespace haxe{
+namespace crypto{
+
+void Sha256_obj::__construct(){
+            	HX_STACKFRAME(&_hx_pos_0a4e95b4276e5057_48_new)
+            	}
+
+Dynamic Sha256_obj::__CreateEmpty() { return new Sha256_obj; }
+
+void *Sha256_obj::_hx_vtable = 0;
+
+Dynamic Sha256_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Sha256_obj > _hx_result = new Sha256_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool Sha256_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x0c0976ea;
+}
+
+::Array< int > Sha256_obj::doEncode(::Array< int > m,int l){
+            	HX_STACKFRAME(&_hx_pos_0a4e95b4276e5057_50_doEncode)
+HXLINE(  51)		::Array< int > K = ::Array_obj< int >::fromData( _hx_array_data_af0be1cc_4,64);
+HXLINE(  59)		::Array< int > HASH = ::Array_obj< int >::fromData( _hx_array_data_af0be1cc_5,8);
+HXLINE(  64)		::Array< int > W = ::Array_obj< int >::__new();
+HXLINE(  65)		W[64] = 0;
+HXLINE(  66)		int a;
+HXDLIN(  66)		int b;
+HXDLIN(  66)		int c;
+HXDLIN(  66)		int d;
+HXDLIN(  66)		int e;
+HXDLIN(  66)		int f;
+HXDLIN(  66)		int g;
+HXDLIN(  66)		int h;
+HXLINE(  67)		int T1;
+HXDLIN(  67)		int T2;
+HXLINE(  68)		::Array< int > m1 = m;
+HXDLIN(  68)		int index = (l >> 5);
+HXDLIN(  68)		m1[index] = (m1->__get(index) | (128 << (24 - ::hx::Mod(l,32))));
+HXLINE(  69)		m[((((l + 64) >> 9) << 4) + 15)] = l;
+HXLINE(  70)		int i = 0;
+HXLINE(  71)		while((i < m->length)){
+HXLINE(  72)			a = HASH->__get(0);
+HXLINE(  73)			b = HASH->__get(1);
+HXLINE(  74)			c = HASH->__get(2);
+HXLINE(  75)			d = HASH->__get(3);
+HXLINE(  76)			e = HASH->__get(4);
+HXLINE(  77)			f = HASH->__get(5);
+HXLINE(  78)			g = HASH->__get(6);
+HXLINE(  79)			h = HASH->__get(7);
+HXLINE(  80)			{
+HXLINE(  80)				int _g = 0;
+HXDLIN(  80)				while((_g < 64)){
+HXLINE(  80)					_g = (_g + 1);
+HXDLIN(  80)					int j = (_g - 1);
+HXLINE(  81)					if ((j < 16)) {
+HXLINE(  82)						W[j] = m->__get((j + i));
+            					}
+            					else {
+HXLINE(  84)						int x = W->__get((j - 2));
+HXDLIN(  84)						int x1 = (((::hx::UShr(x,17) | (x << 15)) ^ (::hx::UShr(x,19) | (x << 13))) ^ ::hx::UShr(x,10));
+HXDLIN(  84)						int y = W->__get((j - 7));
+HXDLIN(  84)						int lsw = ((x1 & 65535) + (y & 65535));
+HXDLIN(  84)						int msw = (((x1 >> 16) + (y >> 16)) + (lsw >> 16));
+HXDLIN(  84)						int x2 = ((msw << 16) | (lsw & 65535));
+HXDLIN(  84)						int x3 = W->__get((j - 15));
+HXDLIN(  84)						int y1 = (((::hx::UShr(x3,7) | (x3 << 25)) ^ (::hx::UShr(x3,18) | (x3 << 14))) ^ ::hx::UShr(x3,3));
+HXDLIN(  84)						int lsw1 = ((x2 & 65535) + (y1 & 65535));
+HXDLIN(  84)						int msw1 = (((x2 >> 16) + (y1 >> 16)) + (lsw1 >> 16));
+HXDLIN(  84)						int x4 = ((msw1 << 16) | (lsw1 & 65535));
+HXDLIN(  84)						int y2 = W->__get((j - 16));
+HXDLIN(  84)						int lsw2 = ((x4 & 65535) + (y2 & 65535));
+HXDLIN(  84)						int msw2 = (((x4 >> 16) + (y2 >> 16)) + (lsw2 >> 16));
+HXDLIN(  84)						W[j] = ((msw2 << 16) | (lsw2 & 65535));
+            					}
+HXLINE(  85)					int y3 = (((::hx::UShr(e,6) | (e << 26)) ^ (::hx::UShr(e,11) | (e << 21))) ^ (::hx::UShr(e,25) | (e << 7)));
+HXDLIN(  85)					int lsw3 = ((h & 65535) + (y3 & 65535));
+HXDLIN(  85)					int msw3 = (((h >> 16) + (y3 >> 16)) + (lsw3 >> 16));
+HXDLIN(  85)					int x5 = ((msw3 << 16) | (lsw3 & 65535));
+HXDLIN(  85)					int y4 = ((e & f) ^ (~(e) & g));
+HXDLIN(  85)					int lsw4 = ((x5 & 65535) + (y4 & 65535));
+HXDLIN(  85)					int msw4 = (((x5 >> 16) + (y4 >> 16)) + (lsw4 >> 16));
+HXDLIN(  85)					int x6 = ((msw4 << 16) | (lsw4 & 65535));
+HXDLIN(  85)					int y5 = K->__get(j);
+HXDLIN(  85)					int lsw5 = ((x6 & 65535) + (y5 & 65535));
+HXDLIN(  85)					int msw5 = (((x6 >> 16) + (y5 >> 16)) + (lsw5 >> 16));
+HXDLIN(  85)					int x7 = ((msw5 << 16) | (lsw5 & 65535));
+HXDLIN(  85)					int y6 = W->__get(j);
+HXDLIN(  85)					int lsw6 = ((x7 & 65535) + (y6 & 65535));
+HXDLIN(  85)					int msw6 = (((x7 >> 16) + (y6 >> 16)) + (lsw6 >> 16));
+HXDLIN(  85)					T1 = ((msw6 << 16) | (lsw6 & 65535));
+HXLINE(  86)					int x8 = (((::hx::UShr(a,2) | (a << 30)) ^ (::hx::UShr(a,13) | (a << 19))) ^ (::hx::UShr(a,22) | (a << 10)));
+HXDLIN(  86)					int y7 = (((a & b) ^ (a & c)) ^ (b & c));
+HXDLIN(  86)					int lsw7 = ((x8 & 65535) + (y7 & 65535));
+HXDLIN(  86)					int msw7 = (((x8 >> 16) + (y7 >> 16)) + (lsw7 >> 16));
+HXDLIN(  86)					T2 = ((msw7 << 16) | (lsw7 & 65535));
+HXLINE(  87)					h = g;
+HXLINE(  88)					g = f;
+HXLINE(  89)					f = e;
+HXLINE(  90)					int lsw8 = ((d & 65535) + (T1 & 65535));
+HXDLIN(  90)					int msw8 = (((d >> 16) + (T1 >> 16)) + (lsw8 >> 16));
+HXDLIN(  90)					e = ((msw8 << 16) | (lsw8 & 65535));
+HXLINE(  91)					d = c;
+HXLINE(  92)					c = b;
+HXLINE(  93)					b = a;
+HXLINE(  94)					int lsw9 = ((T1 & 65535) + (T2 & 65535));
+HXDLIN(  94)					int msw9 = (((T1 >> 16) + (T2 >> 16)) + (lsw9 >> 16));
+HXDLIN(  94)					a = ((msw9 << 16) | (lsw9 & 65535));
+            				}
+            			}
+HXLINE(  96)			int y8 = HASH->__get(0);
+HXDLIN(  96)			int lsw10 = ((a & 65535) + (y8 & 65535));
+HXDLIN(  96)			int msw10 = (((a >> 16) + (y8 >> 16)) + (lsw10 >> 16));
+HXDLIN(  96)			HASH[0] = ((msw10 << 16) | (lsw10 & 65535));
+HXLINE(  97)			int y9 = HASH->__get(1);
+HXDLIN(  97)			int lsw11 = ((b & 65535) + (y9 & 65535));
+HXDLIN(  97)			int msw11 = (((b >> 16) + (y9 >> 16)) + (lsw11 >> 16));
+HXDLIN(  97)			HASH[1] = ((msw11 << 16) | (lsw11 & 65535));
+HXLINE(  98)			int y10 = HASH->__get(2);
+HXDLIN(  98)			int lsw12 = ((c & 65535) + (y10 & 65535));
+HXDLIN(  98)			int msw12 = (((c >> 16) + (y10 >> 16)) + (lsw12 >> 16));
+HXDLIN(  98)			HASH[2] = ((msw12 << 16) | (lsw12 & 65535));
+HXLINE(  99)			int y11 = HASH->__get(3);
+HXDLIN(  99)			int lsw13 = ((d & 65535) + (y11 & 65535));
+HXDLIN(  99)			int msw13 = (((d >> 16) + (y11 >> 16)) + (lsw13 >> 16));
+HXDLIN(  99)			HASH[3] = ((msw13 << 16) | (lsw13 & 65535));
+HXLINE( 100)			int y12 = HASH->__get(4);
+HXDLIN( 100)			int lsw14 = ((e & 65535) + (y12 & 65535));
+HXDLIN( 100)			int msw14 = (((e >> 16) + (y12 >> 16)) + (lsw14 >> 16));
+HXDLIN( 100)			HASH[4] = ((msw14 << 16) | (lsw14 & 65535));
+HXLINE( 101)			int y13 = HASH->__get(5);
+HXDLIN( 101)			int lsw15 = ((f & 65535) + (y13 & 65535));
+HXDLIN( 101)			int msw15 = (((f >> 16) + (y13 >> 16)) + (lsw15 >> 16));
+HXDLIN( 101)			HASH[5] = ((msw15 << 16) | (lsw15 & 65535));
+HXLINE( 102)			int y14 = HASH->__get(6);
+HXDLIN( 102)			int lsw16 = ((g & 65535) + (y14 & 65535));
+HXDLIN( 102)			int msw16 = (((g >> 16) + (y14 >> 16)) + (lsw16 >> 16));
+HXDLIN( 102)			HASH[6] = ((msw16 << 16) | (lsw16 & 65535));
+HXLINE( 103)			int y15 = HASH->__get(7);
+HXDLIN( 103)			int lsw17 = ((h & 65535) + (y15 & 65535));
+HXDLIN( 103)			int msw17 = (((h >> 16) + (y15 >> 16)) + (lsw17 >> 16));
+HXDLIN( 103)			HASH[7] = ((msw17 << 16) | (lsw17 & 65535));
+HXLINE( 104)			i = (i + 16);
+            		}
+HXLINE( 106)		return HASH;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(Sha256_obj,doEncode,return )
+
+ ::haxe::io::Bytes Sha256_obj::make( ::haxe::io::Bytes b){
+            	HX_GC_STACKFRAME(&_hx_pos_0a4e95b4276e5057_35_make)
+HXLINE(  36)		 ::haxe::crypto::Sha256 h =  ::haxe::crypto::Sha256_obj::__alloc( HX_CTX );
+HXDLIN(  36)		::Array< int > h1 = ::haxe::crypto::Sha256_obj::bytes2blks(b);
+HXDLIN(  36)		::Array< int > h2 = h->doEncode(h1,(b->length * 8));
+HXLINE(  37)		 ::haxe::io::Bytes out = ::haxe::io::Bytes_obj::alloc(32);
+HXLINE(  38)		int p = 0;
+HXLINE(  39)		{
+HXLINE(  39)			int _g = 0;
+HXDLIN(  39)			while((_g < 8)){
+HXLINE(  39)				_g = (_g + 1);
+HXDLIN(  39)				int i = (_g - 1);
+HXLINE(  40)				{
+HXLINE(  40)					p = (p + 1);
+HXDLIN(  40)					out->b[(p - 1)] = ( (unsigned char)(::hx::UShr(h2->__get(i),24)) );
+            				}
+HXLINE(  41)				{
+HXLINE(  41)					p = (p + 1);
+HXDLIN(  41)					out->b[(p - 1)] = ( (unsigned char)(((h2->__get(i) >> 16) & 255)) );
+            				}
+HXLINE(  42)				{
+HXLINE(  42)					p = (p + 1);
+HXDLIN(  42)					out->b[(p - 1)] = ( (unsigned char)(((h2->__get(i) >> 8) & 255)) );
+            				}
+HXLINE(  43)				{
+HXLINE(  43)					p = (p + 1);
+HXDLIN(  43)					out->b[(p - 1)] = ( (unsigned char)((h2->__get(i) & 255)) );
+            				}
+            			}
+            		}
+HXLINE(  45)		return out;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Sha256_obj,make,return )
+
+::Array< int > Sha256_obj::bytes2blks( ::haxe::io::Bytes b){
+            	HX_STACKFRAME(&_hx_pos_0a4e95b4276e5057_133_bytes2blks)
+HXLINE( 134)		int nblk = (((b->length + 8) >> 6) + 1);
+HXLINE( 135)		::Array< int > blks = ::Array_obj< int >::__new();
+HXLINE( 137)		{
+HXLINE( 137)			int _g = 0;
+HXDLIN( 137)			int _g1 = (nblk * 16);
+HXDLIN( 137)			while((_g < _g1)){
+HXLINE( 137)				_g = (_g + 1);
+HXDLIN( 137)				int i = (_g - 1);
+HXLINE( 138)				blks[i] = 0;
+            			}
+            		}
+HXLINE( 139)		{
+HXLINE( 139)			int _g2 = 0;
+HXDLIN( 139)			int _g3 = b->length;
+HXDLIN( 139)			while((_g2 < _g3)){
+HXLINE( 139)				_g2 = (_g2 + 1);
+HXDLIN( 139)				int i1 = (_g2 - 1);
+HXLINE( 140)				int p = (i1 >> 2);
+HXLINE( 141)				::Array< int > blks1 = blks;
+HXDLIN( 141)				int p1 = p;
+HXDLIN( 141)				blks1[p1] = (blks1->__get(p1) | (( (int)(b->b->__get(i1)) ) << (24 - ((i1 & 3) << 3))));
+            			}
+            		}
+HXLINE( 143)		int i2 = b->length;
+HXLINE( 144)		int p2 = (i2 >> 2);
+HXLINE( 145)		::Array< int > blks2 = blks;
+HXDLIN( 145)		int p3 = p2;
+HXDLIN( 145)		blks2[p3] = (blks2->__get(p3) | (128 << (24 - ((i2 & 3) << 3))));
+HXLINE( 146)		blks[((nblk * 16) - 1)] = (b->length * 8);
+HXLINE( 147)		return blks;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Sha256_obj,bytes2blks,return )
+
+
+Sha256_obj::Sha256_obj()
+{
+}
+
+::hx::Val Sha256_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 8:
+		if (HX_FIELD_EQ(inName,"doEncode") ) { return ::hx::Val( doEncode_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+bool Sha256_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"make") ) { outValue = make_dyn(); return true; }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"bytes2blks") ) { outValue = bytes2blks_dyn(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *Sha256_obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo *Sha256_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String Sha256_obj_sMemberFields[] = {
+	HX_("doEncode",01,78,fb,8d),
+	::String(null()) };
+
+::hx::Class Sha256_obj::__mClass;
+
+static ::String Sha256_obj_sStaticFields[] = {
+	HX_("make",ee,39,56,48),
+	HX_("bytes2blks",d9,ce,9c,a9),
+	::String(null())
+};
+
+void Sha256_obj::__register()
+{
+	Sha256_obj _hx_dummy;
+	Sha256_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.crypto.Sha256",cc,e1,0b,af);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &Sha256_obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(Sha256_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(Sha256_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< Sha256_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Sha256_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Sha256_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace crypto
diff --git a/Sources/c_snikket/src/haxe/ds/BalancedTree.cpp b/Sources/c_snikket/src/haxe/ds/BalancedTree.cpp
new file mode 100644
index 0000000..03e7628
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/ds/BalancedTree.cpp
@@ -0,0 +1,388 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Reflect
+#include <Reflect.h>
+#endif
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+#ifndef INCLUDED_haxe_ds_BalancedTree
+#include <haxe/ds/BalancedTree.h>
+#endif
+#ifndef INCLUDED_haxe_ds_TreeNode
+#include <haxe/ds/TreeNode.h>
+#endif
+#ifndef INCLUDED_haxe_iterators_ArrayIterator
+#include <haxe/iterators/ArrayIterator.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_84f0fad7b22fcaf3_41_new,"haxe.ds.BalancedTree","new",0xfb50b0cf,"haxe.ds.BalancedTree.new","/usr/local/lib/haxe/std/haxe/ds/BalancedTree.hx",41,0xee0b42c4)
+HX_LOCAL_STACK_FRAME(_hx_pos_84f0fad7b22fcaf3_51_set,"haxe.ds.BalancedTree","set",0xfb547c11,"haxe.ds.BalancedTree.set","/usr/local/lib/haxe/std/haxe/ds/BalancedTree.hx",51,0xee0b42c4)
+HX_LOCAL_STACK_FRAME(_hx_pos_84f0fad7b22fcaf3_61_get,"haxe.ds.BalancedTree","get",0xfb4b6105,"haxe.ds.BalancedTree.get","/usr/local/lib/haxe/std/haxe/ds/BalancedTree.hx",61,0xee0b42c4)
+HX_LOCAL_STACK_FRAME(_hx_pos_84f0fad7b22fcaf3_101_exists,"haxe.ds.BalancedTree","exists",0x238deccd,"haxe.ds.BalancedTree.exists","/usr/local/lib/haxe/std/haxe/ds/BalancedTree.hx",101,0xee0b42c4)
+HX_LOCAL_STACK_FRAME(_hx_pos_84f0fad7b22fcaf3_138_keys,"haxe.ds.BalancedTree","keys",0xe94e62a5,"haxe.ds.BalancedTree.keys","/usr/local/lib/haxe/std/haxe/ds/BalancedTree.hx",138,0xee0b42c4)
+HX_LOCAL_STACK_FRAME(_hx_pos_84f0fad7b22fcaf3_150_setLoop,"haxe.ds.BalancedTree","setLoop",0xe1a32b15,"haxe.ds.BalancedTree.setLoop","/usr/local/lib/haxe/std/haxe/ds/BalancedTree.hx",150,0xee0b42c4)
+HX_LOCAL_STACK_FRAME(_hx_pos_84f0fad7b22fcaf3_181_keysLoop,"haxe.ds.BalancedTree","keysLoop",0x20d5eba9,"haxe.ds.BalancedTree.keysLoop","/usr/local/lib/haxe/std/haxe/ds/BalancedTree.hx",181,0xee0b42c4)
+HX_LOCAL_STACK_FRAME(_hx_pos_84f0fad7b22fcaf3_205_balance,"haxe.ds.BalancedTree","balance",0xf7f4e10b,"haxe.ds.BalancedTree.balance","/usr/local/lib/haxe/std/haxe/ds/BalancedTree.hx",205,0xee0b42c4)
+HX_LOCAL_STACK_FRAME(_hx_pos_84f0fad7b22fcaf3_226_compare,"haxe.ds.BalancedTree","compare",0x57d05c94,"haxe.ds.BalancedTree.compare","/usr/local/lib/haxe/std/haxe/ds/BalancedTree.hx",226,0xee0b42c4)
+namespace haxe{
+namespace ds{
+
+void BalancedTree_obj::__construct(){
+            	HX_STACKFRAME(&_hx_pos_84f0fad7b22fcaf3_41_new)
+            	}
+
+Dynamic BalancedTree_obj::__CreateEmpty() { return new BalancedTree_obj; }
+
+void *BalancedTree_obj::_hx_vtable = 0;
+
+Dynamic BalancedTree_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< BalancedTree_obj > _hx_result = new BalancedTree_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool BalancedTree_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x4cc9cf7f;
+}
+
+static ::haxe::IMap_obj _hx_haxe_ds_BalancedTree__hx_haxe_IMap= {
+	(  ::Dynamic (::hx::Object::*)( ::Dynamic))&::haxe::ds::BalancedTree_obj::get,
+	(  ::Dynamic (::hx::Object::*)())&::haxe::ds::BalancedTree_obj::keys,
+};
+
+void *BalancedTree_obj::_hx_getInterface(int inHash) {
+	switch(inHash) {
+		case (int)0x09c2bd39: return &_hx_haxe_ds_BalancedTree__hx_haxe_IMap;
+	}
+	#ifdef HXCPP_SCRIPTABLE
+	return super::_hx_getInterface(inHash);
+	#else
+	return 0;
+	#endif
+}
+
+void BalancedTree_obj::set( ::Dynamic key, ::Dynamic value){
+            	HX_STACKFRAME(&_hx_pos_84f0fad7b22fcaf3_51_set)
+HXDLIN(  51)		this->root = this->setLoop(key,value,this->root);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(BalancedTree_obj,set,(void))
+
+ ::Dynamic BalancedTree_obj::get( ::Dynamic key){
+            	HX_STACKFRAME(&_hx_pos_84f0fad7b22fcaf3_61_get)
+HXLINE(  62)		 ::haxe::ds::TreeNode node = this->root;
+HXLINE(  63)		while(::hx::IsNotNull( node )){
+HXLINE(  64)			int c = this->compare(key,node->key);
+HXLINE(  65)			if ((c == 0)) {
+HXLINE(  66)				return node->value;
+            			}
+HXLINE(  67)			if ((c < 0)) {
+HXLINE(  68)				node = node->left;
+            			}
+            			else {
+HXLINE(  70)				node = node->right;
+            			}
+            		}
+HXLINE(  72)		return null();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(BalancedTree_obj,get,return )
+
+bool BalancedTree_obj::exists( ::Dynamic key){
+            	HX_STACKFRAME(&_hx_pos_84f0fad7b22fcaf3_101_exists)
+HXLINE( 102)		 ::haxe::ds::TreeNode node = this->root;
+HXLINE( 103)		while(::hx::IsNotNull( node )){
+HXLINE( 104)			int c = this->compare(key,node->key);
+HXLINE( 105)			if ((c == 0)) {
+HXLINE( 106)				return true;
+            			}
+            			else {
+HXLINE( 107)				if ((c < 0)) {
+HXLINE( 108)					node = node->left;
+            				}
+            				else {
+HXLINE( 110)					node = node->right;
+            				}
+            			}
+            		}
+HXLINE( 112)		return false;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(BalancedTree_obj,exists,return )
+
+ ::Dynamic BalancedTree_obj::keys(){
+            	HX_GC_STACKFRAME(&_hx_pos_84f0fad7b22fcaf3_138_keys)
+HXLINE( 139)		::cpp::VirtualArray ret = ::cpp::VirtualArray_obj::__new(0);
+HXLINE( 140)		this->keysLoop(this->root,ret);
+HXLINE( 141)		return  ::haxe::iterators::ArrayIterator_obj::__alloc( HX_CTX ,ret);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(BalancedTree_obj,keys,return )
+
+ ::haxe::ds::TreeNode BalancedTree_obj::setLoop( ::Dynamic k, ::Dynamic v, ::haxe::ds::TreeNode node){
+            	HX_GC_STACKFRAME(&_hx_pos_84f0fad7b22fcaf3_150_setLoop)
+HXLINE( 151)		if (::hx::IsNull( node )) {
+HXLINE( 152)			return  ::haxe::ds::TreeNode_obj::__alloc( HX_CTX ,null(),k,v,null(),null());
+            		}
+HXLINE( 153)		int c = this->compare(k,node->key);
+HXLINE( 154)		if ((c == 0)) {
+HXLINE( 154)			int _hx_tmp;
+HXDLIN( 154)			if (::hx::IsNull( node )) {
+HXLINE( 154)				_hx_tmp = 0;
+            			}
+            			else {
+HXLINE( 154)				_hx_tmp = node->_height;
+            			}
+HXDLIN( 154)			return  ::haxe::ds::TreeNode_obj::__alloc( HX_CTX ,node->left,k,v,node->right,_hx_tmp);
+            		}
+            		else {
+HXLINE( 154)			if ((c < 0)) {
+HXLINE( 155)				 ::haxe::ds::TreeNode nl = this->setLoop(k,v,node->left);
+HXLINE( 156)				return this->balance(nl,node->key,node->value,node->right);
+            			}
+            			else {
+HXLINE( 158)				 ::haxe::ds::TreeNode nr = this->setLoop(k,v,node->right);
+HXLINE( 159)				return this->balance(node->left,node->key,node->value,nr);
+            			}
+            		}
+HXLINE( 154)		return null();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC3(BalancedTree_obj,setLoop,return )
+
+void BalancedTree_obj::keysLoop( ::haxe::ds::TreeNode node,::cpp::VirtualArray acc){
+            	HX_STACKFRAME(&_hx_pos_84f0fad7b22fcaf3_181_keysLoop)
+HXDLIN( 181)		if (::hx::IsNotNull( node )) {
+HXLINE( 182)			this->keysLoop(node->left,acc);
+HXLINE( 183)			acc->push(node->key);
+HXLINE( 184)			this->keysLoop(node->right,acc);
+            		}
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(BalancedTree_obj,keysLoop,(void))
+
+ ::haxe::ds::TreeNode BalancedTree_obj::balance( ::haxe::ds::TreeNode l, ::Dynamic k, ::Dynamic v, ::haxe::ds::TreeNode r){
+            	HX_GC_STACKFRAME(&_hx_pos_84f0fad7b22fcaf3_205_balance)
+HXLINE( 206)		int hl;
+HXDLIN( 206)		if (::hx::IsNull( l )) {
+HXLINE( 206)			hl = 0;
+            		}
+            		else {
+HXLINE( 206)			hl = l->_height;
+            		}
+HXLINE( 207)		int hr;
+HXDLIN( 207)		if (::hx::IsNull( r )) {
+HXLINE( 207)			hr = 0;
+            		}
+            		else {
+HXLINE( 207)			hr = r->_height;
+            		}
+HXLINE( 208)		if ((hl > (hr + 2))) {
+HXLINE( 209)			 ::haxe::ds::TreeNode _this = l->left;
+HXDLIN( 209)			int _hx_tmp;
+HXDLIN( 209)			if (::hx::IsNull( _this )) {
+HXLINE( 209)				_hx_tmp = 0;
+            			}
+            			else {
+HXLINE( 209)				_hx_tmp = _this->_height;
+            			}
+HXDLIN( 209)			 ::haxe::ds::TreeNode _this1 = l->right;
+HXDLIN( 209)			int _hx_tmp1;
+HXDLIN( 209)			if (::hx::IsNull( _this1 )) {
+HXLINE( 209)				_hx_tmp1 = 0;
+            			}
+            			else {
+HXLINE( 209)				_hx_tmp1 = _this1->_height;
+            			}
+HXDLIN( 209)			if ((_hx_tmp >= _hx_tmp1)) {
+HXLINE( 210)				 ::haxe::ds::TreeNode l1 = l->left;
+HXDLIN( 210)				 ::Dynamic l2 = l->key;
+HXDLIN( 210)				 ::Dynamic l3 = l->value;
+HXDLIN( 210)				return  ::haxe::ds::TreeNode_obj::__alloc( HX_CTX ,l1,l2,l3, ::haxe::ds::TreeNode_obj::__alloc( HX_CTX ,l->right,k,v,r,null()),null());
+            			}
+            			else {
+HXLINE( 212)				 ::haxe::ds::TreeNode _hx_tmp2 =  ::haxe::ds::TreeNode_obj::__alloc( HX_CTX ,l->left,l->key,l->value,l->right->left,null());
+HXDLIN( 212)				 ::Dynamic l4 = l->right->key;
+HXDLIN( 212)				 ::Dynamic l5 = l->right->value;
+HXDLIN( 212)				return  ::haxe::ds::TreeNode_obj::__alloc( HX_CTX ,_hx_tmp2,l4,l5, ::haxe::ds::TreeNode_obj::__alloc( HX_CTX ,l->right->right,k,v,r,null()),null());
+            			}
+            		}
+            		else {
+HXLINE( 214)			if ((hr > (hl + 2))) {
+HXLINE( 215)				 ::haxe::ds::TreeNode _this2 = r->right;
+HXDLIN( 215)				int _hx_tmp3;
+HXDLIN( 215)				if (::hx::IsNull( _this2 )) {
+HXLINE( 215)					_hx_tmp3 = 0;
+            				}
+            				else {
+HXLINE( 215)					_hx_tmp3 = _this2->_height;
+            				}
+HXDLIN( 215)				 ::haxe::ds::TreeNode _this3 = r->left;
+HXDLIN( 215)				int _hx_tmp4;
+HXDLIN( 215)				if (::hx::IsNull( _this3 )) {
+HXLINE( 215)					_hx_tmp4 = 0;
+            				}
+            				else {
+HXLINE( 215)					_hx_tmp4 = _this3->_height;
+            				}
+HXDLIN( 215)				if ((_hx_tmp3 > _hx_tmp4)) {
+HXLINE( 216)					return  ::haxe::ds::TreeNode_obj::__alloc( HX_CTX , ::haxe::ds::TreeNode_obj::__alloc( HX_CTX ,l,k,v,r->left,null()),r->key,r->value,r->right,null());
+            				}
+            				else {
+HXLINE( 218)					 ::haxe::ds::TreeNode _hx_tmp5 =  ::haxe::ds::TreeNode_obj::__alloc( HX_CTX ,l,k,v,r->left->left,null());
+HXDLIN( 218)					 ::Dynamic r1 = r->left->key;
+HXDLIN( 218)					 ::Dynamic r2 = r->left->value;
+HXDLIN( 218)					return  ::haxe::ds::TreeNode_obj::__alloc( HX_CTX ,_hx_tmp5,r1,r2, ::haxe::ds::TreeNode_obj::__alloc( HX_CTX ,r->left->right,r->key,r->value,r->right,null()),null());
+            				}
+            			}
+            			else {
+HXLINE( 221)				int _hx_tmp6;
+HXDLIN( 221)				if ((hl > hr)) {
+HXLINE( 221)					_hx_tmp6 = hl;
+            				}
+            				else {
+HXLINE( 221)					_hx_tmp6 = hr;
+            				}
+HXDLIN( 221)				return  ::haxe::ds::TreeNode_obj::__alloc( HX_CTX ,l,k,v,r,(_hx_tmp6 + 1));
+            			}
+            		}
+HXLINE( 208)		return null();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC4(BalancedTree_obj,balance,return )
+
+int BalancedTree_obj::compare( ::Dynamic k1, ::Dynamic k2){
+            	HX_STACKFRAME(&_hx_pos_84f0fad7b22fcaf3_226_compare)
+HXDLIN( 226)		return ::Reflect_obj::compare(k1,k2);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(BalancedTree_obj,compare,return )
+
+
+::hx::ObjectPtr< BalancedTree_obj > BalancedTree_obj::__new() {
+	::hx::ObjectPtr< BalancedTree_obj > __this = new BalancedTree_obj();
+	__this->__construct();
+	return __this;
+}
+
+::hx::ObjectPtr< BalancedTree_obj > BalancedTree_obj::__alloc(::hx::Ctx *_hx_ctx) {
+	BalancedTree_obj *__this = (BalancedTree_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(BalancedTree_obj), true, "haxe.ds.BalancedTree"));
+	*(void **)__this = BalancedTree_obj::_hx_vtable;
+	__this->__construct();
+	return __this;
+}
+
+BalancedTree_obj::BalancedTree_obj()
+{
+}
+
+void BalancedTree_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(BalancedTree);
+	HX_MARK_MEMBER_NAME(root,"root");
+	HX_MARK_END_CLASS();
+}
+
+void BalancedTree_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(root,"root");
+}
+
+::hx::Val BalancedTree_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"set") ) { return ::hx::Val( set_dyn() ); }
+		if (HX_FIELD_EQ(inName,"get") ) { return ::hx::Val( get_dyn() ); }
+		break;
+	case 4:
+		if (HX_FIELD_EQ(inName,"root") ) { return ::hx::Val( root ); }
+		if (HX_FIELD_EQ(inName,"keys") ) { return ::hx::Val( keys_dyn() ); }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"exists") ) { return ::hx::Val( exists_dyn() ); }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"setLoop") ) { return ::hx::Val( setLoop_dyn() ); }
+		if (HX_FIELD_EQ(inName,"balance") ) { return ::hx::Val( balance_dyn() ); }
+		if (HX_FIELD_EQ(inName,"compare") ) { return ::hx::Val( compare_dyn() ); }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"keysLoop") ) { return ::hx::Val( keysLoop_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val BalancedTree_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"root") ) { root=inValue.Cast<  ::haxe::ds::TreeNode >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void BalancedTree_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("root",22,ee,ae,4b));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo BalancedTree_obj_sMemberStorageInfo[] = {
+	{::hx::fsObject /*  ::haxe::ds::TreeNode */ ,(int)offsetof(BalancedTree_obj,root),HX_("root",22,ee,ae,4b)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *BalancedTree_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String BalancedTree_obj_sMemberFields[] = {
+	HX_("root",22,ee,ae,4b),
+	HX_("set",a2,9b,57,00),
+	HX_("get",96,80,4e,00),
+	HX_("exists",dc,1d,e0,bf),
+	HX_("keys",f4,e1,06,47),
+	HX_("setLoop",26,e7,3b,0d),
+	HX_("keysLoop",78,be,e1,1a),
+	HX_("balance",1c,9d,8d,23),
+	HX_("compare",a5,18,69,83),
+	::String(null()) };
+
+::hx::Class BalancedTree_obj::__mClass;
+
+void BalancedTree_obj::__register()
+{
+	BalancedTree_obj _hx_dummy;
+	BalancedTree_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.ds.BalancedTree",5d,9d,3e,70);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(BalancedTree_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< BalancedTree_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = BalancedTree_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = BalancedTree_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace ds
diff --git a/Sources/c_snikket/src/haxe/ds/Either.cpp b/Sources/c_snikket/src/haxe/ds/Either.cpp
new file mode 100644
index 0000000..d94ed1a
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/ds/Either.cpp
@@ -0,0 +1,86 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_ds_Either
+#include <haxe/ds/Either.h>
+#endif
+namespace haxe{
+namespace ds{
+
+::haxe::ds::Either Either_obj::Left( ::Dynamic v)
+{
+	return ::hx::CreateEnum< Either_obj >(HX_("Left",27,34,89,32),0,1)->_hx_init(0,v);
+}
+
+::haxe::ds::Either Either_obj::Right( ::Dynamic v)
+{
+	return ::hx::CreateEnum< Either_obj >(HX_("Right",bc,7b,91,7c),1,1)->_hx_init(0,v);
+}
+
+bool Either_obj::__GetStatic(const ::String &inName, ::Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	if (inName==HX_("Left",27,34,89,32)) { outValue = Either_obj::Left_dyn(); return true; }
+	if (inName==HX_("Right",bc,7b,91,7c)) { outValue = Either_obj::Right_dyn(); return true; }
+	return super::__GetStatic(inName, outValue, inCallProp);
+}
+
+HX_DEFINE_CREATE_ENUM(Either_obj)
+
+int Either_obj::__FindIndex(::String inName)
+{
+	if (inName==HX_("Left",27,34,89,32)) return 0;
+	if (inName==HX_("Right",bc,7b,91,7c)) return 1;
+	return super::__FindIndex(inName);
+}
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Either_obj,Left,return)
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Either_obj,Right,return)
+
+int Either_obj::__FindArgCount(::String inName)
+{
+	if (inName==HX_("Left",27,34,89,32)) return 1;
+	if (inName==HX_("Right",bc,7b,91,7c)) return 1;
+	return super::__FindArgCount(inName);
+}
+
+::hx::Val Either_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	if (inName==HX_("Left",27,34,89,32)) return Left_dyn();
+	if (inName==HX_("Right",bc,7b,91,7c)) return Right_dyn();
+	return super::__Field(inName,inCallProp);
+}
+
+static ::String Either_obj_sStaticFields[] = {
+	HX_("Left",27,34,89,32),
+	HX_("Right",bc,7b,91,7c),
+	::String(null())
+};
+
+::hx::Class Either_obj::__mClass;
+
+Dynamic __Create_Either_obj() { return new Either_obj; }
+
+void Either_obj::__register()
+{
+
+::hx::Static(__mClass) = ::hx::_hx_RegisterClass(HX_("haxe.ds.Either",1c,1a,b7,a4), ::hx::TCanCast< Either_obj >,Either_obj_sStaticFields,0,
+	&__Create_Either_obj, &__Create,
+	&super::__SGetClass(), &CreateEither_obj, 0
+#ifdef HXCPP_VISIT_ALLOCS
+    , 0
+#endif
+#ifdef HXCPP_SCRIPTABLE
+    , 0
+#endif
+);
+	__mClass->mGetStaticField = &Either_obj::__GetStatic;
+}
+
+void Either_obj::__boot()
+{
+}
+
+
+} // end namespace haxe
+} // end namespace ds
diff --git a/Sources/c_snikket/src/haxe/ds/EnumValueMap.cpp b/Sources/c_snikket/src/haxe/ds/EnumValueMap.cpp
new file mode 100644
index 0000000..a7dc74a
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/ds/EnumValueMap.cpp
@@ -0,0 +1,218 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Reflect
+#include <Reflect.h>
+#endif
+#ifndef INCLUDED_Std
+#include <Std.h>
+#endif
+#ifndef INCLUDED_Type
+#include <Type.h>
+#endif
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+#ifndef INCLUDED_haxe_ds_BalancedTree
+#include <haxe/ds/BalancedTree.h>
+#endif
+#ifndef INCLUDED_haxe_ds_EnumValueMap
+#include <haxe/ds/EnumValueMap.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_2be74ae4095285fe_31_new,"haxe.ds.EnumValueMap","new",0x9ce29655,"haxe.ds.EnumValueMap.new","/usr/local/lib/haxe/std/haxe/ds/EnumValueMap.hx",31,0xc570effe)
+HX_LOCAL_STACK_FRAME(_hx_pos_2be74ae4095285fe_32_compare,"haxe.ds.EnumValueMap","compare",0x806a7d1a,"haxe.ds.EnumValueMap.compare","/usr/local/lib/haxe/std/haxe/ds/EnumValueMap.hx",32,0xc570effe)
+HX_LOCAL_STACK_FRAME(_hx_pos_2be74ae4095285fe_57_compareArgs,"haxe.ds.EnumValueMap","compareArgs",0x37a5cb97,"haxe.ds.EnumValueMap.compareArgs","/usr/local/lib/haxe/std/haxe/ds/EnumValueMap.hx",57,0xc570effe)
+HX_LOCAL_STACK_FRAME(_hx_pos_2be74ae4095285fe_70_compareArg,"haxe.ds.EnumValueMap","compareArg",0xcee2e55c,"haxe.ds.EnumValueMap.compareArg","/usr/local/lib/haxe/std/haxe/ds/EnumValueMap.hx",70,0xc570effe)
+namespace haxe{
+namespace ds{
+
+void EnumValueMap_obj::__construct(){
+            	HX_STACKFRAME(&_hx_pos_2be74ae4095285fe_31_new)
+HXDLIN(  31)		super::__construct();
+            	}
+
+Dynamic EnumValueMap_obj::__CreateEmpty() { return new EnumValueMap_obj; }
+
+void *EnumValueMap_obj::_hx_vtable = 0;
+
+Dynamic EnumValueMap_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< EnumValueMap_obj > _hx_result = new EnumValueMap_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool EnumValueMap_obj::_hx_isInstanceOf(int inClassId) {
+	if (inClassId<=(int)0x34ccfa05) {
+		return inClassId==(int)0x00000001 || inClassId==(int)0x34ccfa05;
+	} else {
+		return inClassId==(int)0x4cc9cf7f;
+	}
+}
+
+static ::haxe::IMap_obj _hx_haxe_ds_EnumValueMap__hx_haxe_IMap= {
+	(  ::Dynamic (::hx::Object::*)( ::Dynamic))&::haxe::ds::EnumValueMap_obj::get,
+	(  ::Dynamic (::hx::Object::*)())&::haxe::ds::EnumValueMap_obj::keys,
+};
+
+void *EnumValueMap_obj::_hx_getInterface(int inHash) {
+	switch(inHash) {
+		case (int)0x09c2bd39: return &_hx_haxe_ds_EnumValueMap__hx_haxe_IMap;
+	}
+	return super::_hx_getInterface(inHash);
+}
+
+int EnumValueMap_obj::compare( ::Dynamic _tmp_k1, ::Dynamic _tmp_k2){
+            	HX_STACKFRAME(&_hx_pos_2be74ae4095285fe_32_compare)
+HXLINE(  33)		 ::Dynamic k1 = _tmp_k1;
+HXDLIN(  33)		 ::Dynamic k2 = _tmp_k2;
+HXDLIN(  33)		int d = _hx_getEnumValueIndex(k1);
+HXDLIN(  33)		int d1 = (d - _hx_getEnumValueIndex(k2));
+HXLINE(  34)		if ((d1 != 0)) {
+HXLINE(  35)			return d1;
+            		}
+HXLINE(  49)		::cpp::VirtualArray p1 = ::Type_obj::enumParameters(k1);
+HXLINE(  50)		::cpp::VirtualArray p2 = ::Type_obj::enumParameters(k2);
+HXLINE(  51)		bool _hx_tmp;
+HXDLIN(  51)		if ((p1->get_length() == 0)) {
+HXLINE(  51)			_hx_tmp = (p2->get_length() == 0);
+            		}
+            		else {
+HXLINE(  51)			_hx_tmp = false;
+            		}
+HXDLIN(  51)		if (_hx_tmp) {
+HXLINE(  52)			return 0;
+            		}
+HXLINE(  53)		return this->compareArgs(p1,p2);
+            	}
+
+
+int EnumValueMap_obj::compareArgs(::cpp::VirtualArray a1,::cpp::VirtualArray a2){
+            	HX_STACKFRAME(&_hx_pos_2be74ae4095285fe_57_compareArgs)
+HXLINE(  58)		int ld = (a1->get_length() - a2->get_length());
+HXLINE(  59)		if ((ld != 0)) {
+HXLINE(  60)			return ld;
+            		}
+HXLINE(  61)		{
+HXLINE(  61)			int _g = 0;
+HXDLIN(  61)			int _g1 = a1->get_length();
+HXDLIN(  61)			while((_g < _g1)){
+HXLINE(  61)				_g = (_g + 1);
+HXDLIN(  61)				int i = (_g - 1);
+HXLINE(  62)				int d = this->compareArg(a1->__get(i),a2->__get(i));
+HXLINE(  63)				if ((d != 0)) {
+HXLINE(  64)					return d;
+            				}
+            			}
+            		}
+HXLINE(  66)		return 0;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(EnumValueMap_obj,compareArgs,return )
+
+int EnumValueMap_obj::compareArg( ::Dynamic v1, ::Dynamic v2){
+            	HX_STACKFRAME(&_hx_pos_2be74ae4095285fe_70_compareArg)
+HXDLIN(  70)		bool _hx_tmp;
+HXDLIN(  70)		if (::Reflect_obj::isEnumValue(v1)) {
+HXDLIN(  70)			_hx_tmp = ::Reflect_obj::isEnumValue(v2);
+            		}
+            		else {
+HXDLIN(  70)			_hx_tmp = false;
+            		}
+HXDLIN(  70)		if (_hx_tmp) {
+HXLINE(  71)			return this->compare(v1,v2);
+            		}
+            		else {
+HXLINE(  72)			bool _hx_tmp1;
+HXDLIN(  72)			if (::Std_obj::isOfType(v1,::hx::ArrayBase::__mClass)) {
+HXLINE(  72)				_hx_tmp1 = ::Std_obj::isOfType(v2,::hx::ArrayBase::__mClass);
+            			}
+            			else {
+HXLINE(  72)				_hx_tmp1 = false;
+            			}
+HXDLIN(  72)			if (_hx_tmp1) {
+HXLINE(  73)				return this->compareArgs(( (::cpp::VirtualArray)(v1) ),( (::cpp::VirtualArray)(v2) ));
+            			}
+            			else {
+HXLINE(  75)				return ::Reflect_obj::compare(v1,v2);
+            			}
+            		}
+HXLINE(  70)		return 0;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(EnumValueMap_obj,compareArg,return )
+
+
+::hx::ObjectPtr< EnumValueMap_obj > EnumValueMap_obj::__new() {
+	::hx::ObjectPtr< EnumValueMap_obj > __this = new EnumValueMap_obj();
+	__this->__construct();
+	return __this;
+}
+
+::hx::ObjectPtr< EnumValueMap_obj > EnumValueMap_obj::__alloc(::hx::Ctx *_hx_ctx) {
+	EnumValueMap_obj *__this = (EnumValueMap_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(EnumValueMap_obj), true, "haxe.ds.EnumValueMap"));
+	*(void **)__this = EnumValueMap_obj::_hx_vtable;
+	__this->__construct();
+	return __this;
+}
+
+EnumValueMap_obj::EnumValueMap_obj()
+{
+}
+
+::hx::Val EnumValueMap_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 7:
+		if (HX_FIELD_EQ(inName,"compare") ) { return ::hx::Val( compare_dyn() ); }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"compareArg") ) { return ::hx::Val( compareArg_dyn() ); }
+		break;
+	case 11:
+		if (HX_FIELD_EQ(inName,"compareArgs") ) { return ::hx::Val( compareArgs_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *EnumValueMap_obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo *EnumValueMap_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String EnumValueMap_obj_sMemberFields[] = {
+	HX_("compare",a5,18,69,83),
+	HX_("compareArgs",a2,88,40,b6),
+	HX_("compareArg",b1,d2,97,0e),
+	::String(null()) };
+
+::hx::Class EnumValueMap_obj::__mClass;
+
+void EnumValueMap_obj::__register()
+{
+	EnumValueMap_obj _hx_dummy;
+	EnumValueMap_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.ds.EnumValueMap",e3,c7,41,58);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(EnumValueMap_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< EnumValueMap_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = EnumValueMap_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = EnumValueMap_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace ds
diff --git a/Sources/c_snikket/src/haxe/ds/IntMap.cpp b/Sources/c_snikket/src/haxe/ds/IntMap.cpp
new file mode 100644
index 0000000..53efbe1
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/ds/IntMap.cpp
@@ -0,0 +1,199 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+#ifndef INCLUDED_haxe_ds_IntMap
+#include <haxe/ds/IntMap.h>
+#endif
+#ifndef INCLUDED_haxe_iterators_ArrayIterator
+#include <haxe/iterators/ArrayIterator.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_51ea85db291dbdd4_60_new,"haxe.ds.IntMap","new",0x7222c4b6,"haxe.ds.IntMap.new","/usr/local/lib/haxe/std/cpp/_std/haxe/ds/IntMap.hx",60,0xc8b34118)
+HX_LOCAL_STACK_FRAME(_hx_pos_51ea85db291dbdd4_63_set,"haxe.ds.IntMap","set",0x72268ff8,"haxe.ds.IntMap.set","/usr/local/lib/haxe/std/cpp/_std/haxe/ds/IntMap.hx",63,0xc8b34118)
+HX_LOCAL_STACK_FRAME(_hx_pos_51ea85db291dbdd4_67_get,"haxe.ds.IntMap","get",0x721d74ec,"haxe.ds.IntMap.get","/usr/local/lib/haxe/std/cpp/_std/haxe/ds/IntMap.hx",67,0xc8b34118)
+HX_LOCAL_STACK_FRAME(_hx_pos_51ea85db291dbdd4_75_remove,"haxe.ds.IntMap","remove",0xa86281ae,"haxe.ds.IntMap.remove","/usr/local/lib/haxe/std/cpp/_std/haxe/ds/IntMap.hx",75,0xc8b34118)
+HX_LOCAL_STACK_FRAME(_hx_pos_51ea85db291dbdd4_78_keys,"haxe.ds.IntMap","keys",0x6a4db8de,"haxe.ds.IntMap.keys","/usr/local/lib/haxe/std/cpp/_std/haxe/ds/IntMap.hx",78,0xc8b34118)
+namespace haxe{
+namespace ds{
+
+void IntMap_obj::__construct(){
+            	HX_STACKFRAME(&_hx_pos_51ea85db291dbdd4_60_new)
+            	}
+
+Dynamic IntMap_obj::__CreateEmpty() { return new IntMap_obj; }
+
+void *IntMap_obj::_hx_vtable = 0;
+
+Dynamic IntMap_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< IntMap_obj > _hx_result = new IntMap_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool IntMap_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x269a1502;
+}
+
+static ::haxe::IMap_obj _hx_haxe_ds_IntMap__hx_haxe_IMap= {
+	(  ::Dynamic (::hx::Object::*)( ::Dynamic))&::haxe::ds::IntMap_obj::get_a7a2487a,
+	(  ::Dynamic (::hx::Object::*)())&::haxe::ds::IntMap_obj::keys,
+};
+
+ ::Dynamic IntMap_obj::get_a7a2487a( ::Dynamic k) {
+			return get(k);
+}
+void *IntMap_obj::_hx_getInterface(int inHash) {
+	switch(inHash) {
+		case (int)0x09c2bd39: return &_hx_haxe_ds_IntMap__hx_haxe_IMap;
+	}
+	#ifdef HXCPP_SCRIPTABLE
+	return super::_hx_getInterface(inHash);
+	#else
+	return 0;
+	#endif
+}
+
+void IntMap_obj::set(int key, ::Dynamic value){
+            	HX_STACKFRAME(&_hx_pos_51ea85db291dbdd4_63_set)
+HXDLIN(  63)		 ::__int_hash_set(HX_MAP_THIS,key,value);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(IntMap_obj,set,(void))
+
+ ::Dynamic IntMap_obj::get(int key){
+            	HX_STACKFRAME(&_hx_pos_51ea85db291dbdd4_67_get)
+HXDLIN(  67)		return  ::__int_hash_get(this->h,key);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(IntMap_obj,get,return )
+
+bool IntMap_obj::remove(int key){
+            	HX_STACKFRAME(&_hx_pos_51ea85db291dbdd4_75_remove)
+HXDLIN(  75)		return  ::__int_hash_remove(this->h,key);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(IntMap_obj,remove,return )
+
+ ::Dynamic IntMap_obj::keys(){
+            	HX_GC_STACKFRAME(&_hx_pos_51ea85db291dbdd4_78_keys)
+HXLINE(  79)		::Array< int > a =  ::__int_hash_keys(this->h);
+HXLINE(  80)		return  ::haxe::iterators::ArrayIterator_obj::__alloc( HX_CTX ,a);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(IntMap_obj,keys,return )
+
+
+::hx::ObjectPtr< IntMap_obj > IntMap_obj::__new() {
+	::hx::ObjectPtr< IntMap_obj > __this = new IntMap_obj();
+	__this->__construct();
+	return __this;
+}
+
+::hx::ObjectPtr< IntMap_obj > IntMap_obj::__alloc(::hx::Ctx *_hx_ctx) {
+	IntMap_obj *__this = (IntMap_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(IntMap_obj), true, "haxe.ds.IntMap"));
+	*(void **)__this = IntMap_obj::_hx_vtable;
+	__this->__construct();
+	return __this;
+}
+
+IntMap_obj::IntMap_obj()
+{
+}
+
+void IntMap_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(IntMap);
+	HX_MARK_MEMBER_NAME(h,"h");
+	HX_MARK_END_CLASS();
+}
+
+void IntMap_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(h,"h");
+}
+
+::hx::Val IntMap_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 1:
+		if (HX_FIELD_EQ(inName,"h") ) { return ::hx::Val( h ); }
+		break;
+	case 3:
+		if (HX_FIELD_EQ(inName,"set") ) { return ::hx::Val( set_dyn() ); }
+		if (HX_FIELD_EQ(inName,"get") ) { return ::hx::Val( get_dyn() ); }
+		break;
+	case 4:
+		if (HX_FIELD_EQ(inName,"keys") ) { return ::hx::Val( keys_dyn() ); }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"remove") ) { return ::hx::Val( remove_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val IntMap_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 1:
+		if (HX_FIELD_EQ(inName,"h") ) { h=inValue.Cast<  ::Dynamic >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void IntMap_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("h",68,00,00,00));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo IntMap_obj_sMemberStorageInfo[] = {
+	{::hx::fsObject /*  ::Dynamic */ ,(int)offsetof(IntMap_obj,h),HX_("h",68,00,00,00)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *IntMap_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String IntMap_obj_sMemberFields[] = {
+	HX_("h",68,00,00,00),
+	HX_("set",a2,9b,57,00),
+	HX_("get",96,80,4e,00),
+	HX_("remove",44,9c,88,04),
+	HX_("keys",f4,e1,06,47),
+	::String(null()) };
+
+::hx::Class IntMap_obj::__mClass;
+
+void IntMap_obj::__register()
+{
+	IntMap_obj _hx_dummy;
+	IntMap_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.ds.IntMap",c4,f1,10,1f);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(IntMap_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< IntMap_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = IntMap_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = IntMap_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace ds
diff --git a/Sources/c_snikket/src/haxe/ds/List.cpp b/Sources/c_snikket/src/haxe/ds/List.cpp
new file mode 100644
index 0000000..a286030
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/ds/List.cpp
@@ -0,0 +1,185 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_ds_List
+#include <haxe/ds/List.h>
+#endif
+#ifndef INCLUDED_haxe_ds__List_ListNode
+#include <haxe/ds/_List/ListNode.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_28668287f4db9634_45_new,"haxe.ds.List","new",0x82be24e7,"haxe.ds.List.new","/usr/local/lib/haxe/std/haxe/ds/List.hx",45,0x54f95eac)
+HX_LOCAL_STACK_FRAME(_hx_pos_28668287f4db9634_68_push,"haxe.ds.List","push",0xe500b373,"haxe.ds.List.push","/usr/local/lib/haxe/std/haxe/ds/List.hx",68,0x54f95eac)
+HX_LOCAL_STACK_FRAME(_hx_pos_28668287f4db9634_99_pop,"haxe.ds.List","pop",0x82bfb218,"haxe.ds.List.pop","/usr/local/lib/haxe/std/haxe/ds/List.hx",99,0x54f95eac)
+namespace haxe{
+namespace ds{
+
+void List_obj::__construct(){
+            	HX_STACKFRAME(&_hx_pos_28668287f4db9634_45_new)
+HXDLIN(  45)		this->length = 0;
+            	}
+
+Dynamic List_obj::__CreateEmpty() { return new List_obj; }
+
+void *List_obj::_hx_vtable = 0;
+
+Dynamic List_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< List_obj > _hx_result = new List_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool List_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x39a75d33;
+}
+
+void List_obj::push( ::Dynamic item){
+            	HX_GC_STACKFRAME(&_hx_pos_28668287f4db9634_68_push)
+HXLINE(  69)		 ::haxe::ds::_List::ListNode x =  ::haxe::ds::_List::ListNode_obj::__alloc( HX_CTX ,item,this->h);
+HXLINE(  70)		this->h = x;
+HXLINE(  71)		if (::hx::IsNull( this->q )) {
+HXLINE(  72)			this->q = x;
+            		}
+HXLINE(  73)		this->length++;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(List_obj,push,(void))
+
+ ::Dynamic List_obj::pop(){
+            	HX_STACKFRAME(&_hx_pos_28668287f4db9634_99_pop)
+HXLINE( 100)		if (::hx::IsNull( this->h )) {
+HXLINE( 101)			return null();
+            		}
+HXLINE( 102)		 ::Dynamic x = this->h->item;
+HXLINE( 103)		this->h = this->h->next;
+HXLINE( 104)		if (::hx::IsNull( this->h )) {
+HXLINE( 105)			this->q = null();
+            		}
+HXLINE( 106)		this->length--;
+HXLINE( 107)		return x;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(List_obj,pop,return )
+
+
+::hx::ObjectPtr< List_obj > List_obj::__new() {
+	::hx::ObjectPtr< List_obj > __this = new List_obj();
+	__this->__construct();
+	return __this;
+}
+
+::hx::ObjectPtr< List_obj > List_obj::__alloc(::hx::Ctx *_hx_ctx) {
+	List_obj *__this = (List_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(List_obj), true, "haxe.ds.List"));
+	*(void **)__this = List_obj::_hx_vtable;
+	__this->__construct();
+	return __this;
+}
+
+List_obj::List_obj()
+{
+}
+
+void List_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(List);
+	HX_MARK_MEMBER_NAME(h,"h");
+	HX_MARK_MEMBER_NAME(q,"q");
+	HX_MARK_MEMBER_NAME(length,"length");
+	HX_MARK_END_CLASS();
+}
+
+void List_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(h,"h");
+	HX_VISIT_MEMBER_NAME(q,"q");
+	HX_VISIT_MEMBER_NAME(length,"length");
+}
+
+::hx::Val List_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 1:
+		if (HX_FIELD_EQ(inName,"h") ) { return ::hx::Val( h ); }
+		if (HX_FIELD_EQ(inName,"q") ) { return ::hx::Val( q ); }
+		break;
+	case 3:
+		if (HX_FIELD_EQ(inName,"pop") ) { return ::hx::Val( pop_dyn() ); }
+		break;
+	case 4:
+		if (HX_FIELD_EQ(inName,"push") ) { return ::hx::Val( push_dyn() ); }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"length") ) { return ::hx::Val( length ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val List_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 1:
+		if (HX_FIELD_EQ(inName,"h") ) { h=inValue.Cast<  ::haxe::ds::_List::ListNode >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"q") ) { q=inValue.Cast<  ::haxe::ds::_List::ListNode >(); return inValue; }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"length") ) { length=inValue.Cast< int >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void List_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("h",68,00,00,00));
+	outFields->push(HX_("q",71,00,00,00));
+	outFields->push(HX_("length",e6,94,07,9f));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo List_obj_sMemberStorageInfo[] = {
+	{::hx::fsObject /*  ::haxe::ds::_List::ListNode */ ,(int)offsetof(List_obj,h),HX_("h",68,00,00,00)},
+	{::hx::fsObject /*  ::haxe::ds::_List::ListNode */ ,(int)offsetof(List_obj,q),HX_("q",71,00,00,00)},
+	{::hx::fsInt,(int)offsetof(List_obj,length),HX_("length",e6,94,07,9f)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *List_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String List_obj_sMemberFields[] = {
+	HX_("h",68,00,00,00),
+	HX_("q",71,00,00,00),
+	HX_("length",e6,94,07,9f),
+	HX_("push",da,11,61,4a),
+	HX_("pop",91,5d,55,00),
+	::String(null()) };
+
+::hx::Class List_obj::__mClass;
+
+void List_obj::__register()
+{
+	List_obj _hx_dummy;
+	List_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.ds.List",75,25,aa,15);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(List_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< List_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = List_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = List_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace ds
diff --git a/Sources/c_snikket/src/haxe/ds/ObjectMap.cpp b/Sources/c_snikket/src/haxe/ds/ObjectMap.cpp
new file mode 100644
index 0000000..0483f59
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/ds/ObjectMap.cpp
@@ -0,0 +1,183 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+#ifndef INCLUDED_haxe_ds_ObjectMap
+#include <haxe/ds/ObjectMap.h>
+#endif
+#ifndef INCLUDED_haxe_iterators_ArrayIterator
+#include <haxe/iterators/ArrayIterator.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_d1a78e92de9dff66_59_new,"haxe.ds.ObjectMap","new",0x27af5498,"haxe.ds.ObjectMap.new","/usr/local/lib/haxe/std/cpp/_std/haxe/ds/ObjectMap.hx",59,0xa4879efa)
+HX_LOCAL_STACK_FRAME(_hx_pos_d1a78e92de9dff66_62_set,"haxe.ds.ObjectMap","set",0x27b31fda,"haxe.ds.ObjectMap.set","/usr/local/lib/haxe/std/cpp/_std/haxe/ds/ObjectMap.hx",62,0xa4879efa)
+HX_LOCAL_STACK_FRAME(_hx_pos_d1a78e92de9dff66_66_get,"haxe.ds.ObjectMap","get",0x27aa04ce,"haxe.ds.ObjectMap.get","/usr/local/lib/haxe/std/cpp/_std/haxe/ds/ObjectMap.hx",66,0xa4879efa)
+HX_LOCAL_STACK_FRAME(_hx_pos_d1a78e92de9dff66_77_keys,"haxe.ds.ObjectMap","keys",0x8fbf0ebc,"haxe.ds.ObjectMap.keys","/usr/local/lib/haxe/std/cpp/_std/haxe/ds/ObjectMap.hx",77,0xa4879efa)
+namespace haxe{
+namespace ds{
+
+void ObjectMap_obj::__construct(){
+            	HX_STACKFRAME(&_hx_pos_d1a78e92de9dff66_59_new)
+            	}
+
+Dynamic ObjectMap_obj::__CreateEmpty() { return new ObjectMap_obj; }
+
+void *ObjectMap_obj::_hx_vtable = 0;
+
+Dynamic ObjectMap_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< ObjectMap_obj > _hx_result = new ObjectMap_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool ObjectMap_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x6cba6d44;
+}
+
+static ::haxe::IMap_obj _hx_haxe_ds_ObjectMap__hx_haxe_IMap= {
+	(  ::Dynamic (::hx::Object::*)( ::Dynamic))&::haxe::ds::ObjectMap_obj::get,
+	(  ::Dynamic (::hx::Object::*)())&::haxe::ds::ObjectMap_obj::keys,
+};
+
+void *ObjectMap_obj::_hx_getInterface(int inHash) {
+	switch(inHash) {
+		case (int)0x09c2bd39: return &_hx_haxe_ds_ObjectMap__hx_haxe_IMap;
+	}
+	#ifdef HXCPP_SCRIPTABLE
+	return super::_hx_getInterface(inHash);
+	#else
+	return 0;
+	#endif
+}
+
+void ObjectMap_obj::set( ::Dynamic key, ::Dynamic value){
+            	HX_STACKFRAME(&_hx_pos_d1a78e92de9dff66_62_set)
+HXDLIN(  62)		 ::__object_hash_set(HX_MAP_THIS,key,value);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(ObjectMap_obj,set,(void))
+
+ ::Dynamic ObjectMap_obj::get( ::Dynamic key){
+            	HX_STACKFRAME(&_hx_pos_d1a78e92de9dff66_66_get)
+HXDLIN(  66)		return  ::__object_hash_get(this->h,key);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(ObjectMap_obj,get,return )
+
+ ::Dynamic ObjectMap_obj::keys(){
+            	HX_GC_STACKFRAME(&_hx_pos_d1a78e92de9dff66_77_keys)
+HXLINE(  78)		::cpp::VirtualArray a =  ::__object_hash_keys(this->h);
+HXLINE(  79)		return  ::haxe::iterators::ArrayIterator_obj::__alloc( HX_CTX ,a);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(ObjectMap_obj,keys,return )
+
+
+::hx::ObjectPtr< ObjectMap_obj > ObjectMap_obj::__new() {
+	::hx::ObjectPtr< ObjectMap_obj > __this = new ObjectMap_obj();
+	__this->__construct();
+	return __this;
+}
+
+::hx::ObjectPtr< ObjectMap_obj > ObjectMap_obj::__alloc(::hx::Ctx *_hx_ctx) {
+	ObjectMap_obj *__this = (ObjectMap_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(ObjectMap_obj), true, "haxe.ds.ObjectMap"));
+	*(void **)__this = ObjectMap_obj::_hx_vtable;
+	__this->__construct();
+	return __this;
+}
+
+ObjectMap_obj::ObjectMap_obj()
+{
+}
+
+void ObjectMap_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(ObjectMap);
+	HX_MARK_MEMBER_NAME(h,"h");
+	HX_MARK_END_CLASS();
+}
+
+void ObjectMap_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(h,"h");
+}
+
+::hx::Val ObjectMap_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 1:
+		if (HX_FIELD_EQ(inName,"h") ) { return ::hx::Val( h ); }
+		break;
+	case 3:
+		if (HX_FIELD_EQ(inName,"set") ) { return ::hx::Val( set_dyn() ); }
+		if (HX_FIELD_EQ(inName,"get") ) { return ::hx::Val( get_dyn() ); }
+		break;
+	case 4:
+		if (HX_FIELD_EQ(inName,"keys") ) { return ::hx::Val( keys_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val ObjectMap_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 1:
+		if (HX_FIELD_EQ(inName,"h") ) { h=inValue.Cast<  ::Dynamic >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void ObjectMap_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("h",68,00,00,00));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo ObjectMap_obj_sMemberStorageInfo[] = {
+	{::hx::fsObject /*  ::Dynamic */ ,(int)offsetof(ObjectMap_obj,h),HX_("h",68,00,00,00)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *ObjectMap_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String ObjectMap_obj_sMemberFields[] = {
+	HX_("h",68,00,00,00),
+	HX_("set",a2,9b,57,00),
+	HX_("get",96,80,4e,00),
+	HX_("keys",f4,e1,06,47),
+	::String(null()) };
+
+::hx::Class ObjectMap_obj::__mClass;
+
+void ObjectMap_obj::__register()
+{
+	ObjectMap_obj _hx_dummy;
+	ObjectMap_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.ds.ObjectMap",a6,68,9b,de);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(ObjectMap_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< ObjectMap_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = ObjectMap_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = ObjectMap_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace ds
diff --git a/Sources/c_snikket/src/haxe/ds/Option.cpp b/Sources/c_snikket/src/haxe/ds/Option.cpp
new file mode 100644
index 0000000..116d140
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/ds/Option.cpp
@@ -0,0 +1,82 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_ds_Option
+#include <haxe/ds/Option.h>
+#endif
+namespace haxe{
+namespace ds{
+
+::haxe::ds::Option Option_obj::None;
+
+::haxe::ds::Option Option_obj::Some( ::Dynamic v)
+{
+	return ::hx::CreateEnum< Option_obj >(HX_("Some",14,4f,31,37),0,1)->_hx_init(0,v);
+}
+
+bool Option_obj::__GetStatic(const ::String &inName, ::Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	if (inName==HX_("None",d8,3e,e3,33)) { outValue = Option_obj::None; return true; }
+	if (inName==HX_("Some",14,4f,31,37)) { outValue = Option_obj::Some_dyn(); return true; }
+	return super::__GetStatic(inName, outValue, inCallProp);
+}
+
+HX_DEFINE_CREATE_ENUM(Option_obj)
+
+int Option_obj::__FindIndex(::String inName)
+{
+	if (inName==HX_("None",d8,3e,e3,33)) return 1;
+	if (inName==HX_("Some",14,4f,31,37)) return 0;
+	return super::__FindIndex(inName);
+}
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Option_obj,Some,return)
+
+int Option_obj::__FindArgCount(::String inName)
+{
+	if (inName==HX_("None",d8,3e,e3,33)) return 0;
+	if (inName==HX_("Some",14,4f,31,37)) return 1;
+	return super::__FindArgCount(inName);
+}
+
+::hx::Val Option_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	if (inName==HX_("None",d8,3e,e3,33)) return None;
+	if (inName==HX_("Some",14,4f,31,37)) return Some_dyn();
+	return super::__Field(inName,inCallProp);
+}
+
+static ::String Option_obj_sStaticFields[] = {
+	HX_("Some",14,4f,31,37),
+	HX_("None",d8,3e,e3,33),
+	::String(null())
+};
+
+::hx::Class Option_obj::__mClass;
+
+Dynamic __Create_Option_obj() { return new Option_obj; }
+
+void Option_obj::__register()
+{
+
+::hx::Static(__mClass) = ::hx::_hx_RegisterClass(HX_("haxe.ds.Option",4c,90,17,ac), ::hx::TCanCast< Option_obj >,Option_obj_sStaticFields,0,
+	&__Create_Option_obj, &__Create,
+	&super::__SGetClass(), &CreateOption_obj, 0
+#ifdef HXCPP_VISIT_ALLOCS
+    , 0
+#endif
+#ifdef HXCPP_SCRIPTABLE
+    , 0
+#endif
+);
+	__mClass->mGetStaticField = &Option_obj::__GetStatic;
+}
+
+void Option_obj::__boot()
+{
+None = ::hx::CreateConstEnum< Option_obj >(HX_("None",d8,3e,e3,33),1);
+}
+
+
+} // end namespace haxe
+} // end namespace ds
diff --git a/Sources/c_snikket/src/haxe/ds/StringMap.cpp b/Sources/c_snikket/src/haxe/ds/StringMap.cpp
new file mode 100644
index 0000000..0a68889
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/ds/StringMap.cpp
@@ -0,0 +1,237 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+#ifndef INCLUDED_haxe_ds_StringMap
+#include <haxe/ds/StringMap.h>
+#endif
+#ifndef INCLUDED_haxe_iterators_ArrayIterator
+#include <haxe/iterators/ArrayIterator.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_8577865ab46301b9_60_new,"haxe.ds.StringMap","new",0x0f13f0c6,"haxe.ds.StringMap.new","/usr/local/lib/haxe/std/cpp/_std/haxe/ds/StringMap.hx",60,0x61d6228c)
+HX_LOCAL_STACK_FRAME(_hx_pos_8577865ab46301b9_63_set,"haxe.ds.StringMap","set",0x0f17bc08,"haxe.ds.StringMap.set","/usr/local/lib/haxe/std/cpp/_std/haxe/ds/StringMap.hx",63,0x61d6228c)
+HX_LOCAL_STACK_FRAME(_hx_pos_8577865ab46301b9_67_get,"haxe.ds.StringMap","get",0x0f0ea0fc,"haxe.ds.StringMap.get","/usr/local/lib/haxe/std/cpp/_std/haxe/ds/StringMap.hx",67,0x61d6228c)
+HX_LOCAL_STACK_FRAME(_hx_pos_8577865ab46301b9_71_exists,"haxe.ds.StringMap","exists",0xd35fc136,"haxe.ds.StringMap.exists","/usr/local/lib/haxe/std/cpp/_std/haxe/ds/StringMap.hx",71,0x61d6228c)
+HX_LOCAL_STACK_FRAME(_hx_pos_8577865ab46301b9_75_remove,"haxe.ds.StringMap","remove",0x18083f9e,"haxe.ds.StringMap.remove","/usr/local/lib/haxe/std/cpp/_std/haxe/ds/StringMap.hx",75,0x61d6228c)
+HX_LOCAL_STACK_FRAME(_hx_pos_8577865ab46301b9_78_keys,"haxe.ds.StringMap","keys",0x20631ace,"haxe.ds.StringMap.keys","/usr/local/lib/haxe/std/cpp/_std/haxe/ds/StringMap.hx",78,0x61d6228c)
+HX_LOCAL_STACK_FRAME(_hx_pos_8577865ab46301b9_83_iterator,"haxe.ds.StringMap","iterator",0x40ccf7c8,"haxe.ds.StringMap.iterator","/usr/local/lib/haxe/std/cpp/_std/haxe/ds/StringMap.hx",83,0x61d6228c)
+HX_LOCAL_STACK_FRAME(_hx_pos_8577865ab46301b9_105_clear,"haxe.ds.StringMap","clear",0x9fb0f773,"haxe.ds.StringMap.clear","/usr/local/lib/haxe/std/cpp/_std/haxe/ds/StringMap.hx",105,0x61d6228c)
+namespace haxe{
+namespace ds{
+
+void StringMap_obj::__construct(){
+            	HX_STACKFRAME(&_hx_pos_8577865ab46301b9_60_new)
+            	}
+
+Dynamic StringMap_obj::__CreateEmpty() { return new StringMap_obj; }
+
+void *StringMap_obj::_hx_vtable = 0;
+
+Dynamic StringMap_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< StringMap_obj > _hx_result = new StringMap_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool StringMap_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x4260cd56;
+}
+
+static ::haxe::IMap_obj _hx_haxe_ds_StringMap__hx_haxe_IMap= {
+	(  ::Dynamic (::hx::Object::*)( ::Dynamic))&::haxe::ds::StringMap_obj::get_a7a2487a,
+	(  ::Dynamic (::hx::Object::*)())&::haxe::ds::StringMap_obj::keys,
+};
+
+ ::Dynamic StringMap_obj::get_a7a2487a( ::Dynamic k) {
+			return get(k);
+}
+void *StringMap_obj::_hx_getInterface(int inHash) {
+	switch(inHash) {
+		case (int)0x09c2bd39: return &_hx_haxe_ds_StringMap__hx_haxe_IMap;
+	}
+	#ifdef HXCPP_SCRIPTABLE
+	return super::_hx_getInterface(inHash);
+	#else
+	return 0;
+	#endif
+}
+
+void StringMap_obj::set(::String key, ::Dynamic value){
+            	HX_STACKFRAME(&_hx_pos_8577865ab46301b9_63_set)
+HXDLIN(  63)		 ::__string_hash_set(HX_MAP_THIS,key,value);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(StringMap_obj,set,(void))
+
+ ::Dynamic StringMap_obj::get(::String key){
+            	HX_STACKFRAME(&_hx_pos_8577865ab46301b9_67_get)
+HXDLIN(  67)		return  ::__string_hash_get(this->h,key);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(StringMap_obj,get,return )
+
+bool StringMap_obj::exists(::String key){
+            	HX_STACKFRAME(&_hx_pos_8577865ab46301b9_71_exists)
+HXDLIN(  71)		return  ::__string_hash_exists(this->h,key);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(StringMap_obj,exists,return )
+
+bool StringMap_obj::remove(::String key){
+            	HX_STACKFRAME(&_hx_pos_8577865ab46301b9_75_remove)
+HXDLIN(  75)		return  ::__string_hash_remove(this->h,key);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(StringMap_obj,remove,return )
+
+ ::Dynamic StringMap_obj::keys(){
+            	HX_GC_STACKFRAME(&_hx_pos_8577865ab46301b9_78_keys)
+HXLINE(  79)		::Array< ::String > a =  ::__string_hash_keys(this->h);
+HXLINE(  80)		return  ::haxe::iterators::ArrayIterator_obj::__alloc( HX_CTX ,a);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(StringMap_obj,keys,return )
+
+ ::Dynamic StringMap_obj::iterator(){
+            	HX_GC_STACKFRAME(&_hx_pos_8577865ab46301b9_83_iterator)
+HXLINE(  84)		::cpp::VirtualArray a =  ::__string_hash_values(this->h);
+HXLINE(  85)		return  ::haxe::iterators::ArrayIterator_obj::__alloc( HX_CTX ,a);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(StringMap_obj,iterator,return )
+
+void StringMap_obj::clear(){
+            	HX_STACKFRAME(&_hx_pos_8577865ab46301b9_105_clear)
+HXDLIN( 105)		 ::__string_hash_clear(this->h);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(StringMap_obj,clear,(void))
+
+
+::hx::ObjectPtr< StringMap_obj > StringMap_obj::__new() {
+	::hx::ObjectPtr< StringMap_obj > __this = new StringMap_obj();
+	__this->__construct();
+	return __this;
+}
+
+::hx::ObjectPtr< StringMap_obj > StringMap_obj::__alloc(::hx::Ctx *_hx_ctx) {
+	StringMap_obj *__this = (StringMap_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(StringMap_obj), true, "haxe.ds.StringMap"));
+	*(void **)__this = StringMap_obj::_hx_vtable;
+	__this->__construct();
+	return __this;
+}
+
+StringMap_obj::StringMap_obj()
+{
+}
+
+void StringMap_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(StringMap);
+	HX_MARK_MEMBER_NAME(h,"h");
+	HX_MARK_END_CLASS();
+}
+
+void StringMap_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(h,"h");
+}
+
+::hx::Val StringMap_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 1:
+		if (HX_FIELD_EQ(inName,"h") ) { return ::hx::Val( h ); }
+		break;
+	case 3:
+		if (HX_FIELD_EQ(inName,"set") ) { return ::hx::Val( set_dyn() ); }
+		if (HX_FIELD_EQ(inName,"get") ) { return ::hx::Val( get_dyn() ); }
+		break;
+	case 4:
+		if (HX_FIELD_EQ(inName,"keys") ) { return ::hx::Val( keys_dyn() ); }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"clear") ) { return ::hx::Val( clear_dyn() ); }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"exists") ) { return ::hx::Val( exists_dyn() ); }
+		if (HX_FIELD_EQ(inName,"remove") ) { return ::hx::Val( remove_dyn() ); }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"iterator") ) { return ::hx::Val( iterator_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val StringMap_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 1:
+		if (HX_FIELD_EQ(inName,"h") ) { h=inValue.Cast<  ::Dynamic >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void StringMap_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("h",68,00,00,00));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo StringMap_obj_sMemberStorageInfo[] = {
+	{::hx::fsObject /*  ::Dynamic */ ,(int)offsetof(StringMap_obj,h),HX_("h",68,00,00,00)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *StringMap_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String StringMap_obj_sMemberFields[] = {
+	HX_("h",68,00,00,00),
+	HX_("set",a2,9b,57,00),
+	HX_("get",96,80,4e,00),
+	HX_("exists",dc,1d,e0,bf),
+	HX_("remove",44,9c,88,04),
+	HX_("keys",f4,e1,06,47),
+	HX_("iterator",ee,49,9a,93),
+	HX_("clear",8d,71,5b,48),
+	::String(null()) };
+
+::hx::Class StringMap_obj::__mClass;
+
+void StringMap_obj::__register()
+{
+	StringMap_obj _hx_dummy;
+	StringMap_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.ds.StringMap",d4,d5,d6,62);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(StringMap_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< StringMap_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = StringMap_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = StringMap_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace ds
diff --git a/Sources/c_snikket/src/haxe/ds/TreeNode.cpp b/Sources/c_snikket/src/haxe/ds/TreeNode.cpp
new file mode 100644
index 0000000..9605420
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/ds/TreeNode.cpp
@@ -0,0 +1,196 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_ds_TreeNode
+#include <haxe/ds/TreeNode.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_bd32df1abf02b23a_252_new,"haxe.ds.TreeNode","new",0x88d32f89,"haxe.ds.TreeNode.new","/usr/local/lib/haxe/std/haxe/ds/BalancedTree.hx",252,0xee0b42c4)
+namespace haxe{
+namespace ds{
+
+void TreeNode_obj::__construct( ::haxe::ds::TreeNode l, ::Dynamic k, ::Dynamic v, ::haxe::ds::TreeNode r,::hx::Null< int >  __o_h){
+            		int h = __o_h.Default(-1);
+            	HX_STACKFRAME(&_hx_pos_bd32df1abf02b23a_252_new)
+HXLINE( 253)		this->left = l;
+HXLINE( 254)		this->key = k;
+HXLINE( 255)		this->value = v;
+HXLINE( 256)		this->right = r;
+HXLINE( 257)		if ((h == -1)) {
+HXLINE( 258)			int _hx_tmp;
+HXDLIN( 258)			 ::haxe::ds::TreeNode _this = this->left;
+HXDLIN( 258)			int _hx_tmp1;
+HXDLIN( 258)			if (::hx::IsNull( _this )) {
+HXLINE( 258)				_hx_tmp1 = 0;
+            			}
+            			else {
+HXLINE( 258)				_hx_tmp1 = _this->_height;
+            			}
+HXDLIN( 258)			 ::haxe::ds::TreeNode _this1 = this->right;
+HXDLIN( 258)			int _hx_tmp2;
+HXDLIN( 258)			if (::hx::IsNull( _this1 )) {
+HXLINE( 258)				_hx_tmp2 = 0;
+            			}
+            			else {
+HXLINE( 258)				_hx_tmp2 = _this1->_height;
+            			}
+HXDLIN( 258)			if ((_hx_tmp1 > _hx_tmp2)) {
+HXLINE( 258)				 ::haxe::ds::TreeNode _this2 = this->left;
+HXDLIN( 258)				if (::hx::IsNull( _this2 )) {
+HXLINE( 258)					_hx_tmp = 0;
+            				}
+            				else {
+HXLINE( 258)					_hx_tmp = _this2->_height;
+            				}
+            			}
+            			else {
+HXLINE( 258)				 ::haxe::ds::TreeNode _this3 = this->right;
+HXDLIN( 258)				if (::hx::IsNull( _this3 )) {
+HXLINE( 258)					_hx_tmp = 0;
+            				}
+            				else {
+HXLINE( 258)					_hx_tmp = _this3->_height;
+            				}
+            			}
+HXDLIN( 258)			this->_height = (_hx_tmp + 1);
+            		}
+            		else {
+HXLINE( 260)			this->_height = h;
+            		}
+            	}
+
+Dynamic TreeNode_obj::__CreateEmpty() { return new TreeNode_obj; }
+
+void *TreeNode_obj::_hx_vtable = 0;
+
+Dynamic TreeNode_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< TreeNode_obj > _hx_result = new TreeNode_obj();
+	_hx_result->__construct(inArgs[0],inArgs[1],inArgs[2],inArgs[3],inArgs[4]);
+	return _hx_result;
+}
+
+bool TreeNode_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x723fa5d5;
+}
+
+
+TreeNode_obj::TreeNode_obj()
+{
+}
+
+void TreeNode_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(TreeNode);
+	HX_MARK_MEMBER_NAME(left,"left");
+	HX_MARK_MEMBER_NAME(right,"right");
+	HX_MARK_MEMBER_NAME(key,"key");
+	HX_MARK_MEMBER_NAME(value,"value");
+	HX_MARK_MEMBER_NAME(_height,"_height");
+	HX_MARK_END_CLASS();
+}
+
+void TreeNode_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(left,"left");
+	HX_VISIT_MEMBER_NAME(right,"right");
+	HX_VISIT_MEMBER_NAME(key,"key");
+	HX_VISIT_MEMBER_NAME(value,"value");
+	HX_VISIT_MEMBER_NAME(_height,"_height");
+}
+
+::hx::Val TreeNode_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"key") ) { return ::hx::Val( key ); }
+		break;
+	case 4:
+		if (HX_FIELD_EQ(inName,"left") ) { return ::hx::Val( left ); }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"right") ) { return ::hx::Val( right ); }
+		if (HX_FIELD_EQ(inName,"value") ) { return ::hx::Val( value ); }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"_height") ) { return ::hx::Val( _height ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val TreeNode_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"key") ) { key=inValue.Cast<  ::Dynamic >(); return inValue; }
+		break;
+	case 4:
+		if (HX_FIELD_EQ(inName,"left") ) { left=inValue.Cast<  ::haxe::ds::TreeNode >(); return inValue; }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"right") ) { right=inValue.Cast<  ::haxe::ds::TreeNode >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"value") ) { value=inValue.Cast<  ::Dynamic >(); return inValue; }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"_height") ) { _height=inValue.Cast< int >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void TreeNode_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("left",07,08,b0,47));
+	outFields->push(HX_("right",dc,0b,64,e9));
+	outFields->push(HX_("key",9f,89,51,00));
+	outFields->push(HX_("value",71,7f,b8,31));
+	outFields->push(HX_("_height",86,19,c3,70));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo TreeNode_obj_sMemberStorageInfo[] = {
+	{::hx::fsObject /*  ::haxe::ds::TreeNode */ ,(int)offsetof(TreeNode_obj,left),HX_("left",07,08,b0,47)},
+	{::hx::fsObject /*  ::haxe::ds::TreeNode */ ,(int)offsetof(TreeNode_obj,right),HX_("right",dc,0b,64,e9)},
+	{::hx::fsObject /*  ::Dynamic */ ,(int)offsetof(TreeNode_obj,key),HX_("key",9f,89,51,00)},
+	{::hx::fsObject /*  ::Dynamic */ ,(int)offsetof(TreeNode_obj,value),HX_("value",71,7f,b8,31)},
+	{::hx::fsInt,(int)offsetof(TreeNode_obj,_height),HX_("_height",86,19,c3,70)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *TreeNode_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String TreeNode_obj_sMemberFields[] = {
+	HX_("left",07,08,b0,47),
+	HX_("right",dc,0b,64,e9),
+	HX_("key",9f,89,51,00),
+	HX_("value",71,7f,b8,31),
+	HX_("_height",86,19,c3,70),
+	::String(null()) };
+
+::hx::Class TreeNode_obj::__mClass;
+
+void TreeNode_obj::__register()
+{
+	TreeNode_obj _hx_dummy;
+	TreeNode_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.ds.TreeNode",17,b7,b8,9b);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(TreeNode_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< TreeNode_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = TreeNode_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = TreeNode_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace ds
diff --git a/Sources/c_snikket/src/haxe/ds/_List/ListNode.cpp b/Sources/c_snikket/src/haxe/ds/_List/ListNode.cpp
new file mode 100644
index 0000000..260f747
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/ds/_List/ListNode.cpp
@@ -0,0 +1,121 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_ds__List_ListNode
+#include <haxe/ds/_List/ListNode.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_d7fe8fcac3c6136e_266_new,"haxe.ds._List.ListNode","new",0x5847787a,"haxe.ds._List.ListNode.new","/usr/local/lib/haxe/std/haxe/ds/List.hx",266,0x54f95eac)
+namespace haxe{
+namespace ds{
+namespace _List{
+
+void ListNode_obj::__construct( ::Dynamic item, ::haxe::ds::_List::ListNode next){
+            	HX_STACKFRAME(&_hx_pos_d7fe8fcac3c6136e_266_new)
+HXLINE( 267)		this->item = item;
+HXLINE( 268)		this->next = next;
+            	}
+
+Dynamic ListNode_obj::__CreateEmpty() { return new ListNode_obj; }
+
+void *ListNode_obj::_hx_vtable = 0;
+
+Dynamic ListNode_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< ListNode_obj > _hx_result = new ListNode_obj();
+	_hx_result->__construct(inArgs[0],inArgs[1]);
+	return _hx_result;
+}
+
+bool ListNode_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x567ed068;
+}
+
+
+ListNode_obj::ListNode_obj()
+{
+}
+
+void ListNode_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(ListNode);
+	HX_MARK_MEMBER_NAME(item,"item");
+	HX_MARK_MEMBER_NAME(next,"next");
+	HX_MARK_END_CLASS();
+}
+
+void ListNode_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(item,"item");
+	HX_VISIT_MEMBER_NAME(next,"next");
+}
+
+::hx::Val ListNode_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"item") ) { return ::hx::Val( item ); }
+		if (HX_FIELD_EQ(inName,"next") ) { return ::hx::Val( next ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val ListNode_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"item") ) { item=inValue.Cast<  ::Dynamic >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"next") ) { next=inValue.Cast<  ::haxe::ds::_List::ListNode >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void ListNode_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("item",13,c5,bf,45));
+	outFields->push(HX_("next",f3,84,02,49));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo ListNode_obj_sMemberStorageInfo[] = {
+	{::hx::fsObject /*  ::Dynamic */ ,(int)offsetof(ListNode_obj,item),HX_("item",13,c5,bf,45)},
+	{::hx::fsObject /*  ::haxe::ds::_List::ListNode */ ,(int)offsetof(ListNode_obj,next),HX_("next",f3,84,02,49)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *ListNode_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String ListNode_obj_sMemberFields[] = {
+	HX_("item",13,c5,bf,45),
+	HX_("next",f3,84,02,49),
+	::String(null()) };
+
+::hx::Class ListNode_obj::__mClass;
+
+void ListNode_obj::__register()
+{
+	ListNode_obj _hx_dummy;
+	ListNode_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.ds._List.ListNode",88,73,d7,1e);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(ListNode_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< ListNode_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = ListNode_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = ListNode_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace ds
+} // end namespace _List
diff --git a/Sources/c_snikket/src/haxe/exceptions/NotImplementedException.cpp b/Sources/c_snikket/src/haxe/exceptions/NotImplementedException.cpp
new file mode 100644
index 0000000..f11b7b2
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/exceptions/NotImplementedException.cpp
@@ -0,0 +1,84 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_Exception
+#include <haxe/Exception.h>
+#endif
+#ifndef INCLUDED_haxe_exceptions_NotImplementedException
+#include <haxe/exceptions/NotImplementedException.h>
+#endif
+#ifndef INCLUDED_haxe_exceptions_PosException
+#include <haxe/exceptions/PosException.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_6becf3ac06fb2a12_8_new,"haxe.exceptions.NotImplementedException","new",0xcfd1d5d0,"haxe.exceptions.NotImplementedException.new","/usr/local/lib/haxe/std/haxe/exceptions/NotImplementedException.hx",8,0x37dfbb3d)
+namespace haxe{
+namespace exceptions{
+
+void NotImplementedException_obj::__construct(::String __o_message, ::haxe::Exception previous, ::Dynamic pos){
+            		::String message = __o_message;
+            		if (::hx::IsNull(__o_message)) message = HX_("Not implemented",15,1e,32,34);
+            	HX_STACKFRAME(&_hx_pos_6becf3ac06fb2a12_8_new)
+HXDLIN(   8)		super::__construct(message,previous,pos);
+            	}
+
+Dynamic NotImplementedException_obj::__CreateEmpty() { return new NotImplementedException_obj; }
+
+void *NotImplementedException_obj::_hx_vtable = 0;
+
+Dynamic NotImplementedException_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< NotImplementedException_obj > _hx_result = new NotImplementedException_obj();
+	_hx_result->__construct(inArgs[0],inArgs[1],inArgs[2]);
+	return _hx_result;
+}
+
+bool NotImplementedException_obj::_hx_isInstanceOf(int inClassId) {
+	if (inClassId<=(int)0x65f7252d) {
+		if (inClassId<=(int)0x081bdbd6) {
+			return inClassId==(int)0x00000001 || inClassId==(int)0x081bdbd6;
+		} else {
+			return inClassId==(int)0x65f7252d;
+		}
+	} else {
+		return inClassId==(int)0x677ddc49;
+	}
+}
+
+
+NotImplementedException_obj::NotImplementedException_obj()
+{
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *NotImplementedException_obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo *NotImplementedException_obj_sStaticStorageInfo = 0;
+#endif
+
+::hx::Class NotImplementedException_obj::__mClass;
+
+void NotImplementedException_obj::__register()
+{
+	NotImplementedException_obj _hx_dummy;
+	NotImplementedException_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.exceptions.NotImplementedException",de,ed,a6,1b);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< NotImplementedException_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = NotImplementedException_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = NotImplementedException_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace exceptions
diff --git a/Sources/c_snikket/src/haxe/exceptions/PosException.cpp b/Sources/c_snikket/src/haxe/exceptions/PosException.cpp
new file mode 100644
index 0000000..b71d149
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/exceptions/PosException.cpp
@@ -0,0 +1,136 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_Exception
+#include <haxe/Exception.h>
+#endif
+#ifndef INCLUDED_haxe_exceptions_PosException
+#include <haxe/exceptions/PosException.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_9487fa79a58895e3_12_new,"haxe.exceptions.PosException","new",0x9ed038cf,"haxe.exceptions.PosException.new","/usr/local/lib/haxe/std/haxe/exceptions/PosException.hx",12,0x18a37ec4)
+HX_LOCAL_STACK_FRAME(_hx_pos_9487fa79a58895e3_25_toString,"haxe.exceptions.PosException","toString",0x179675dd,"haxe.exceptions.PosException.toString","/usr/local/lib/haxe/std/haxe/exceptions/PosException.hx",25,0x18a37ec4)
+namespace haxe{
+namespace exceptions{
+
+void PosException_obj::__construct(::String message, ::haxe::Exception previous, ::Dynamic pos){
+            	HX_STACKFRAME(&_hx_pos_9487fa79a58895e3_12_new)
+HXLINE(  13)		super::__construct(message,previous,null());
+HXLINE(  14)		if (::hx::IsNull( pos )) {
+HXLINE(  15)			this->posInfos = ::hx::SourceInfo(HX_("(unknown)",87,5d,fc,5f),0,HX_("(unknown)",87,5d,fc,5f),HX_("(unknown)",87,5d,fc,5f));
+            		}
+            		else {
+HXLINE(  17)			this->posInfos = pos;
+            		}
+            	}
+
+Dynamic PosException_obj::__CreateEmpty() { return new PosException_obj; }
+
+void *PosException_obj::_hx_vtable = 0;
+
+Dynamic PosException_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< PosException_obj > _hx_result = new PosException_obj();
+	_hx_result->__construct(inArgs[0],inArgs[1],inArgs[2]);
+	return _hx_result;
+}
+
+bool PosException_obj::_hx_isInstanceOf(int inClassId) {
+	if (inClassId<=(int)0x65f7252d) {
+		return inClassId==(int)0x00000001 || inClassId==(int)0x65f7252d;
+	} else {
+		return inClassId==(int)0x677ddc49;
+	}
+}
+
+::String PosException_obj::toString(){
+            	HX_STACKFRAME(&_hx_pos_9487fa79a58895e3_25_toString)
+HXDLIN(  25)		::String _hx_tmp = ((HX_("",00,00,00,00) + this->super::toString()) + HX_(" in ",7b,e0,76,15));
+HXDLIN(  25)		return ( (::String)((((((((_hx_tmp + this->posInfos->__Field(HX_("className",a3,92,3d,dc),::hx::paccDynamic)) + HX_(".",2e,00,00,00)) + this->posInfos->__Field(HX_("methodName",cc,19,0f,12),::hx::paccDynamic)) + HX_(" at ",ad,d3,70,15)) + this->posInfos->__Field(HX_("fileName",e7,5a,43,62),::hx::paccDynamic)) + HX_(":",3a,00,00,00)) + this->posInfos->__Field(HX_("lineNumber",dd,81,22,76),::hx::paccDynamic))) );
+            	}
+
+
+
+PosException_obj::PosException_obj()
+{
+}
+
+void PosException_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(PosException);
+	HX_MARK_MEMBER_NAME(posInfos,"posInfos");
+	 ::haxe::Exception_obj::__Mark(HX_MARK_ARG);
+	HX_MARK_END_CLASS();
+}
+
+void PosException_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(posInfos,"posInfos");
+	 ::haxe::Exception_obj::__Visit(HX_VISIT_ARG);
+}
+
+::hx::Val PosException_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 8:
+		if (HX_FIELD_EQ(inName,"posInfos") ) { return ::hx::Val( posInfos ); }
+		if (HX_FIELD_EQ(inName,"toString") ) { return ::hx::Val( toString_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val PosException_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 8:
+		if (HX_FIELD_EQ(inName,"posInfos") ) { posInfos=inValue.Cast<  ::Dynamic >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void PosException_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("posInfos",11,82,2e,5a));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo PosException_obj_sMemberStorageInfo[] = {
+	{::hx::fsObject /*  ::Dynamic */ ,(int)offsetof(PosException_obj,posInfos),HX_("posInfos",11,82,2e,5a)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *PosException_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String PosException_obj_sMemberFields[] = {
+	HX_("posInfos",11,82,2e,5a),
+	HX_("toString",ac,d0,6e,38),
+	::String(null()) };
+
+::hx::Class PosException_obj::__mClass;
+
+void PosException_obj::__register()
+{
+	PosException_obj _hx_dummy;
+	PosException_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.exceptions.PosException",5d,25,5a,6b);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(PosException_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< PosException_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = PosException_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = PosException_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace exceptions
diff --git a/Sources/c_snikket/src/haxe/format/JsonParser.cpp b/Sources/c_snikket/src/haxe/format/JsonParser.cpp
new file mode 100644
index 0000000..29776d6
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/format/JsonParser.cpp
@@ -0,0 +1,793 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Reflect
+#include <Reflect.h>
+#endif
+#ifndef INCLUDED_Std
+#include <Std.h>
+#endif
+#ifndef INCLUDED_StringBuf
+#include <StringBuf.h>
+#endif
+#ifndef INCLUDED_haxe_format_JsonParser
+#include <haxe/format/JsonParser.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_325103750a35722e_51_new,"haxe.format.JsonParser","new",0xa017eec8,"haxe.format.JsonParser.new","/usr/local/lib/haxe/std/haxe/format/JsonParser.hx",51,0x4a8b222b)
+HX_LOCAL_STACK_FRAME(_hx_pos_325103750a35722e_56_doParse,"haxe.format.JsonParser","doParse",0xa959e310,"haxe.format.JsonParser.doParse","/usr/local/lib/haxe/std/haxe/format/JsonParser.hx",56,0x4a8b222b)
+HX_LOCAL_STACK_FRAME(_hx_pos_325103750a35722e_71_parseRec,"haxe.format.JsonParser","parseRec",0xda258b75,"haxe.format.JsonParser.parseRec","/usr/local/lib/haxe/std/haxe/format/JsonParser.hx",71,0x4a8b222b)
+HX_LOCAL_STACK_FRAME(_hx_pos_325103750a35722e_152_parseString,"haxe.format.JsonParser","parseString",0x8c919bcc,"haxe.format.JsonParser.parseString","/usr/local/lib/haxe/std/haxe/format/JsonParser.hx",152,0x4a8b222b)
+HX_LOCAL_STACK_FRAME(_hx_pos_325103750a35722e_316_invalidChar,"haxe.format.JsonParser","invalidChar",0xa9f373d5,"haxe.format.JsonParser.invalidChar","/usr/local/lib/haxe/std/haxe/format/JsonParser.hx",316,0x4a8b222b)
+HX_LOCAL_STACK_FRAME(_hx_pos_325103750a35722e_322_invalidNumber,"haxe.format.JsonParser","invalidNumber",0x8e9d1988,"haxe.format.JsonParser.invalidNumber","/usr/local/lib/haxe/std/haxe/format/JsonParser.hx",322,0x4a8b222b)
+namespace haxe{
+namespace format{
+
+void JsonParser_obj::__construct(::String str){
+            	HX_STACKFRAME(&_hx_pos_325103750a35722e_51_new)
+HXLINE(  52)		this->str = str;
+HXLINE(  53)		this->pos = 0;
+            	}
+
+Dynamic JsonParser_obj::__CreateEmpty() { return new JsonParser_obj; }
+
+void *JsonParser_obj::_hx_vtable = 0;
+
+Dynamic JsonParser_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< JsonParser_obj > _hx_result = new JsonParser_obj();
+	_hx_result->__construct(inArgs[0]);
+	return _hx_result;
+}
+
+bool JsonParser_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x0ae51690;
+}
+
+ ::Dynamic JsonParser_obj::doParse(){
+            	HX_STACKFRAME(&_hx_pos_325103750a35722e_56_doParse)
+HXLINE(  57)		 ::Dynamic result = this->parseRec();
+HXLINE(  58)		int c;
+HXLINE(  59)		while(true){
+HXLINE(  59)			c = this->str.cca(this->pos++);
+HXDLIN(  59)			if (!((c != 0))) {
+HXLINE(  59)				goto _hx_goto_1;
+            			}
+HXLINE(  60)			switch((int)(c)){
+            				case (int)9: case (int)10: case (int)13: case (int)32: {
+            				}
+            				break;
+            				default:{
+HXLINE(  64)					this->invalidChar();
+            				}
+            			}
+            		}
+            		_hx_goto_1:;
+HXLINE(  67)		return result;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(JsonParser_obj,doParse,return )
+
+ ::Dynamic JsonParser_obj::parseRec(){
+            	HX_STACKFRAME(&_hx_pos_325103750a35722e_71_parseRec)
+HXDLIN(  71)		while(true){
+HXLINE(  72)			int c = this->str.cca(this->pos++);
+HXLINE(  73)			switch((int)(c)){
+            				case (int)9: case (int)10: case (int)13: case (int)32: {
+            				}
+            				break;
+            				case (int)34: {
+HXLINE( 143)					return this->parseString();
+            				}
+            				break;
+            				case (int)45: case (int)48: case (int)49: case (int)50: case (int)51: case (int)52: case (int)53: case (int)54: case (int)55: case (int)56: case (int)57: {
+HXLINE( 145)					int c1 = c;
+HXDLIN( 145)					int start = (this->pos - 1);
+HXDLIN( 145)					bool minus = (c1 == 45);
+HXDLIN( 145)					bool digit = !(minus);
+HXDLIN( 145)					bool zero = (c1 == 48);
+HXDLIN( 145)					bool point = false;
+HXDLIN( 145)					bool e = false;
+HXDLIN( 145)					bool pm = false;
+HXDLIN( 145)					bool end = false;
+HXDLIN( 145)					do {
+HXLINE( 145)						c1 = this->str.cca(this->pos++);
+HXDLIN( 145)						switch((int)(c1)){
+            							case (int)43: case (int)45: {
+HXLINE( 145)								bool _hx_tmp;
+HXDLIN( 145)								if (e) {
+HXLINE( 145)									_hx_tmp = pm;
+            								}
+            								else {
+HXLINE( 145)									_hx_tmp = true;
+            								}
+HXDLIN( 145)								if (_hx_tmp) {
+HXLINE( 145)									this->invalidNumber(start);
+            								}
+HXDLIN( 145)								digit = false;
+HXDLIN( 145)								pm = true;
+            							}
+            							break;
+            							case (int)46: {
+HXLINE( 145)								bool _hx_tmp1;
+HXDLIN( 145)								bool _hx_tmp2;
+HXDLIN( 145)								if (!(minus)) {
+HXLINE( 145)									_hx_tmp2 = point;
+            								}
+            								else {
+HXLINE( 145)									_hx_tmp2 = true;
+            								}
+HXDLIN( 145)								if (!(_hx_tmp2)) {
+HXLINE( 145)									_hx_tmp1 = e;
+            								}
+            								else {
+HXLINE( 145)									_hx_tmp1 = true;
+            								}
+HXDLIN( 145)								if (_hx_tmp1) {
+HXLINE( 145)									this->invalidNumber(start);
+            								}
+HXDLIN( 145)								digit = false;
+HXDLIN( 145)								point = true;
+            							}
+            							break;
+            							case (int)48: {
+HXLINE( 145)								bool _hx_tmp3;
+HXDLIN( 145)								if (zero) {
+HXLINE( 145)									_hx_tmp3 = !(point);
+            								}
+            								else {
+HXLINE( 145)									_hx_tmp3 = false;
+            								}
+HXDLIN( 145)								if (_hx_tmp3) {
+HXLINE( 145)									this->invalidNumber(start);
+            								}
+HXDLIN( 145)								if (minus) {
+HXLINE( 145)									minus = false;
+HXDLIN( 145)									zero = true;
+            								}
+HXDLIN( 145)								digit = true;
+            							}
+            							break;
+            							case (int)49: case (int)50: case (int)51: case (int)52: case (int)53: case (int)54: case (int)55: case (int)56: case (int)57: {
+HXLINE( 145)								bool _hx_tmp4;
+HXDLIN( 145)								if (zero) {
+HXLINE( 145)									_hx_tmp4 = !(point);
+            								}
+            								else {
+HXLINE( 145)									_hx_tmp4 = false;
+            								}
+HXDLIN( 145)								if (_hx_tmp4) {
+HXLINE( 145)									this->invalidNumber(start);
+            								}
+HXDLIN( 145)								if (minus) {
+HXLINE( 145)									minus = false;
+            								}
+HXDLIN( 145)								digit = true;
+HXDLIN( 145)								zero = false;
+            							}
+            							break;
+            							case (int)69: case (int)101: {
+HXLINE( 145)								bool _hx_tmp5;
+HXDLIN( 145)								bool _hx_tmp6;
+HXDLIN( 145)								if (!(minus)) {
+HXLINE( 145)									_hx_tmp6 = zero;
+            								}
+            								else {
+HXLINE( 145)									_hx_tmp6 = true;
+            								}
+HXDLIN( 145)								if (!(_hx_tmp6)) {
+HXLINE( 145)									_hx_tmp5 = e;
+            								}
+            								else {
+HXLINE( 145)									_hx_tmp5 = true;
+            								}
+HXDLIN( 145)								if (_hx_tmp5) {
+HXLINE( 145)									this->invalidNumber(start);
+            								}
+HXDLIN( 145)								digit = false;
+HXDLIN( 145)								e = true;
+            							}
+            							break;
+            							default:{
+HXLINE( 145)								if (!(digit)) {
+HXLINE( 145)									this->invalidNumber(start);
+            								}
+HXDLIN( 145)								this->pos--;
+HXDLIN( 145)								end = true;
+            							}
+            						}
+            					} while(!(end));
+;
+HXDLIN( 145)					Float f = ::Std_obj::parseFloat(this->str.substr(start,(this->pos - start)));
+HXDLIN( 145)					if (point) {
+HXLINE( 145)						return f;
+            					}
+            					else {
+HXLINE( 145)						int i = ::Std_obj::_hx_int(f);
+HXDLIN( 145)						if ((i == f)) {
+HXLINE( 145)							return i;
+            						}
+            						else {
+HXLINE( 145)							return f;
+            						}
+            					}
+            				}
+            				break;
+            				case (int)91: {
+HXLINE( 103)					::cpp::VirtualArray arr = ::cpp::VirtualArray_obj::__new(0);
+HXDLIN( 103)					 ::Dynamic comma = null();
+HXLINE( 104)					while(true){
+HXLINE( 105)						int c2 = this->str.cca(this->pos++);
+HXLINE( 106)						switch((int)(c2)){
+            							case (int)9: case (int)10: case (int)13: case (int)32: {
+            							}
+            							break;
+            							case (int)44: {
+HXLINE( 113)								if (( (bool)(comma) )) {
+HXLINE( 113)									comma = false;
+            								}
+            								else {
+HXLINE( 113)									this->invalidChar();
+            								}
+            							}
+            							break;
+            							case (int)93: {
+HXLINE( 110)								if (::hx::IsEq( comma,false )) {
+HXLINE( 110)									this->invalidChar();
+            								}
+HXLINE( 111)								return arr;
+            							}
+            							break;
+            							default:{
+HXLINE( 115)								if (( (bool)(comma) )) {
+HXLINE( 115)									this->invalidChar();
+            								}
+HXLINE( 116)								this->pos--;
+HXLINE( 117)								arr->push(this->parseRec());
+HXLINE( 118)								comma = true;
+            							}
+            						}
+            					}
+            				}
+            				break;
+            				case (int)102: {
+HXLINE( 129)					int save = this->pos;
+HXLINE( 130)					bool _hx_tmp7;
+HXDLIN( 130)					bool _hx_tmp8;
+HXDLIN( 130)					bool _hx_tmp9;
+HXDLIN( 130)					if ((this->str.cca(this->pos++) == 97)) {
+HXLINE( 130)						_hx_tmp9 = (this->str.cca(this->pos++) != 108);
+            					}
+            					else {
+HXLINE( 130)						_hx_tmp9 = true;
+            					}
+HXDLIN( 130)					if (!(_hx_tmp9)) {
+HXLINE( 130)						_hx_tmp8 = (this->str.cca(this->pos++) != 115);
+            					}
+            					else {
+HXLINE( 130)						_hx_tmp8 = true;
+            					}
+HXDLIN( 130)					if (!(_hx_tmp8)) {
+HXLINE( 130)						_hx_tmp7 = (this->str.cca(this->pos++) != 101);
+            					}
+            					else {
+HXLINE( 130)						_hx_tmp7 = true;
+            					}
+HXDLIN( 130)					if (_hx_tmp7) {
+HXLINE( 131)						this->pos = save;
+HXLINE( 132)						this->invalidChar();
+            					}
+HXLINE( 134)					return false;
+            				}
+            				break;
+            				case (int)110: {
+HXLINE( 136)					int save1 = this->pos;
+HXLINE( 137)					bool _hx_tmp10;
+HXDLIN( 137)					bool _hx_tmp11;
+HXDLIN( 137)					if ((this->str.cca(this->pos++) == 117)) {
+HXLINE( 137)						_hx_tmp11 = (this->str.cca(this->pos++) != 108);
+            					}
+            					else {
+HXLINE( 137)						_hx_tmp11 = true;
+            					}
+HXDLIN( 137)					if (!(_hx_tmp11)) {
+HXLINE( 137)						_hx_tmp10 = (this->str.cca(this->pos++) != 108);
+            					}
+            					else {
+HXLINE( 137)						_hx_tmp10 = true;
+            					}
+HXDLIN( 137)					if (_hx_tmp10) {
+HXLINE( 138)						this->pos = save1;
+HXLINE( 139)						this->invalidChar();
+            					}
+HXLINE( 141)					return null();
+            				}
+            				break;
+            				case (int)116: {
+HXLINE( 122)					int save2 = this->pos;
+HXLINE( 123)					bool _hx_tmp12;
+HXDLIN( 123)					bool _hx_tmp13;
+HXDLIN( 123)					if ((this->str.cca(this->pos++) == 114)) {
+HXLINE( 123)						_hx_tmp13 = (this->str.cca(this->pos++) != 117);
+            					}
+            					else {
+HXLINE( 123)						_hx_tmp13 = true;
+            					}
+HXDLIN( 123)					if (!(_hx_tmp13)) {
+HXLINE( 123)						_hx_tmp12 = (this->str.cca(this->pos++) != 101);
+            					}
+            					else {
+HXLINE( 123)						_hx_tmp12 = true;
+            					}
+HXDLIN( 123)					if (_hx_tmp12) {
+HXLINE( 124)						this->pos = save2;
+HXLINE( 125)						this->invalidChar();
+            					}
+HXLINE( 127)					return true;
+            				}
+            				break;
+            				case (int)123: {
+HXLINE(  77)					 ::Dynamic obj =  ::Dynamic(::hx::Anon_obj::Create(0));
+HXDLIN(  77)					::String field = null();
+HXDLIN(  77)					 ::Dynamic comma1 = null();
+HXLINE(  78)					while(true){
+HXLINE(  79)						int c3 = this->str.cca(this->pos++);
+HXLINE(  80)						switch((int)(c3)){
+            							case (int)9: case (int)10: case (int)13: case (int)32: {
+            							}
+            							break;
+            							case (int)34: {
+HXLINE(  96)								bool _hx_tmp14;
+HXDLIN(  96)								if (::hx::IsNull( field )) {
+HXLINE(  96)									_hx_tmp14 = ( (bool)(comma1) );
+            								}
+            								else {
+HXLINE(  96)									_hx_tmp14 = true;
+            								}
+HXDLIN(  96)								if (_hx_tmp14) {
+HXLINE(  96)									this->invalidChar();
+            								}
+HXLINE(  97)								field = this->parseString();
+            							}
+            							break;
+            							case (int)44: {
+HXLINE(  94)								if (( (bool)(comma1) )) {
+HXLINE(  94)									comma1 = false;
+            								}
+            								else {
+HXLINE(  94)									this->invalidChar();
+            								}
+            							}
+            							break;
+            							case (int)58: {
+HXLINE(  88)								if (::hx::IsNull( field )) {
+HXLINE(  89)									this->invalidChar();
+            								}
+HXLINE(  90)								::Reflect_obj::setField(obj,field,this->parseRec());
+HXLINE(  91)								field = null();
+HXLINE(  92)								comma1 = true;
+            							}
+            							break;
+            							case (int)125: {
+HXLINE(  84)								bool _hx_tmp15;
+HXDLIN(  84)								if (::hx::IsNull( field )) {
+HXLINE(  84)									_hx_tmp15 = ::hx::IsEq( comma1,false );
+            								}
+            								else {
+HXLINE(  84)									_hx_tmp15 = true;
+            								}
+HXDLIN(  84)								if (_hx_tmp15) {
+HXLINE(  85)									this->invalidChar();
+            								}
+HXLINE(  86)								return obj;
+            							}
+            							break;
+            							default:{
+HXLINE(  99)								this->invalidChar();
+            							}
+            						}
+            					}
+            				}
+            				break;
+            				default:{
+HXLINE( 147)					this->invalidChar();
+            				}
+            			}
+            		}
+HXLINE(  71)		return null();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(JsonParser_obj,parseRec,return )
+
+::String JsonParser_obj::parseString(){
+            	HX_GC_STACKFRAME(&_hx_pos_325103750a35722e_152_parseString)
+HXLINE( 153)		int start = this->pos;
+HXLINE( 154)		 ::StringBuf buf = null();
+HXLINE( 156)		int prev = -1;
+HXLINE( 163)		while(true){
+HXLINE( 164)			int c = this->str.cca(this->pos++);
+HXLINE( 165)			if ((c == 34)) {
+HXLINE( 166)				goto _hx_goto_8;
+            			}
+HXLINE( 167)			if ((c == 92)) {
+HXLINE( 168)				if (::hx::IsNull( buf )) {
+HXLINE( 169)					buf =  ::StringBuf_obj::__alloc( HX_CTX );
+            				}
+HXLINE( 171)				{
+HXLINE( 171)					::String s = this->str;
+HXDLIN( 171)					 ::Dynamic len = ((this->pos - start) - 1);
+HXDLIN( 171)					if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 171)						buf->flush();
+            					}
+HXDLIN( 171)					if (::hx::IsNull( buf->b )) {
+HXLINE( 171)						buf->b = ::Array_obj< ::String >::__new(1)->init(0,s.substr(start,len));
+            					}
+            					else {
+HXLINE( 171)						::Array< ::String > buf1 = buf->b;
+HXDLIN( 171)						buf1->push(s.substr(start,len));
+            					}
+            				}
+HXLINE( 172)				c = this->str.cca(this->pos++);
+HXLINE( 174)				bool _hx_tmp;
+HXDLIN( 174)				if ((c != 117)) {
+HXLINE( 174)					_hx_tmp = (prev != -1);
+            				}
+            				else {
+HXLINE( 174)					_hx_tmp = false;
+            				}
+HXDLIN( 174)				if (_hx_tmp) {
+HXLINE( 175)					{
+HXLINE( 175)						::String x = ::String::fromCharCode(65533);
+HXDLIN( 175)						if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 175)							buf->flush();
+            						}
+HXDLIN( 175)						if (::hx::IsNull( buf->b )) {
+HXLINE( 175)							buf->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(x));
+            						}
+            						else {
+HXLINE( 175)							::Array< ::String > buf2 = buf->b;
+HXDLIN( 175)							buf2->push(::Std_obj::string(x));
+            						}
+            					}
+HXDLIN( 175)					prev = -1;
+            				}
+HXLINE( 177)				switch((int)(c)){
+            					case (int)34: case (int)47: case (int)92: {
+HXLINE( 189)						if ((c >= 127)) {
+HXLINE( 189)							::String x1 = ::String::fromCharCode(c);
+HXDLIN( 189)							if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 189)								buf->flush();
+            							}
+HXDLIN( 189)							if (::hx::IsNull( buf->b )) {
+HXLINE( 189)								buf->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(x1));
+            							}
+            							else {
+HXLINE( 189)								::Array< ::String > buf3 = buf->b;
+HXDLIN( 189)								buf3->push(::Std_obj::string(x1));
+            							}
+            						}
+            						else {
+HXLINE( 189)							if (::hx::IsNull( buf->charBuf )) {
+HXLINE( 189)								buf->charBuf = ::Array_obj< char >::__new();
+            							}
+HXDLIN( 189)							buf->charBuf->push(c);
+            						}
+            					}
+            					break;
+            					case (int)98: {
+HXLINE( 185)						if (::hx::IsNull( buf->charBuf )) {
+HXLINE( 185)							buf->charBuf = ::Array_obj< char >::__new();
+            						}
+HXDLIN( 185)						buf->charBuf->push(8);
+            					}
+            					break;
+            					case (int)102: {
+HXLINE( 187)						if (::hx::IsNull( buf->charBuf )) {
+HXLINE( 187)							buf->charBuf = ::Array_obj< char >::__new();
+            						}
+HXDLIN( 187)						buf->charBuf->push(12);
+            					}
+            					break;
+            					case (int)110: {
+HXLINE( 181)						if (::hx::IsNull( buf->charBuf )) {
+HXLINE( 181)							buf->charBuf = ::Array_obj< char >::__new();
+            						}
+HXDLIN( 181)						buf->charBuf->push(10);
+            					}
+            					break;
+            					case (int)114: {
+HXLINE( 179)						if (::hx::IsNull( buf->charBuf )) {
+HXLINE( 179)							buf->charBuf = ::Array_obj< char >::__new();
+            						}
+HXDLIN( 179)						buf->charBuf->push(13);
+            					}
+            					break;
+            					case (int)116: {
+HXLINE( 183)						if (::hx::IsNull( buf->charBuf )) {
+HXLINE( 183)							buf->charBuf = ::Array_obj< char >::__new();
+            						}
+HXDLIN( 183)						buf->charBuf->push(9);
+            					}
+            					break;
+            					case (int)117: {
+HXLINE( 191)						int uc = ( (int)(::Std_obj::parseInt((HX_("0x",48,2a,00,00) + this->str.substr(this->pos,4)))) );
+HXLINE( 192)						 ::haxe::format::JsonParser _hx_tmp1 = ::hx::ObjectPtr<OBJ_>(this);
+HXDLIN( 192)						_hx_tmp1->pos = (_hx_tmp1->pos + 4);
+HXLINE( 210)						if ((prev != -1)) {
+HXLINE( 211)							bool _hx_tmp2;
+HXDLIN( 211)							if ((uc >= 56320)) {
+HXLINE( 211)								_hx_tmp2 = (uc > 57343);
+            							}
+            							else {
+HXLINE( 211)								_hx_tmp2 = true;
+            							}
+HXDLIN( 211)							if (_hx_tmp2) {
+HXLINE( 212)								{
+HXLINE( 212)									::String x2 = ::String::fromCharCode(65533);
+HXDLIN( 212)									if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 212)										buf->flush();
+            									}
+HXDLIN( 212)									if (::hx::IsNull( buf->b )) {
+HXLINE( 212)										buf->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(x2));
+            									}
+            									else {
+HXLINE( 212)										::Array< ::String > buf4 = buf->b;
+HXDLIN( 212)										buf4->push(::Std_obj::string(x2));
+            									}
+            								}
+HXDLIN( 212)								prev = -1;
+            							}
+            							else {
+HXLINE( 214)								{
+HXLINE( 214)									int c1 = ((((prev - 55296) << 10) + (uc - 56320)) + 65536);
+HXDLIN( 214)									if ((c1 >= 127)) {
+HXLINE( 214)										::String x3 = ::String::fromCharCode(c1);
+HXDLIN( 214)										if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 214)											buf->flush();
+            										}
+HXDLIN( 214)										if (::hx::IsNull( buf->b )) {
+HXLINE( 214)											buf->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(x3));
+            										}
+            										else {
+HXLINE( 214)											::Array< ::String > buf5 = buf->b;
+HXDLIN( 214)											buf5->push(::Std_obj::string(x3));
+            										}
+            									}
+            									else {
+HXLINE( 214)										if (::hx::IsNull( buf->charBuf )) {
+HXLINE( 214)											buf->charBuf = ::Array_obj< char >::__new();
+            										}
+HXDLIN( 214)										buf->charBuf->push(c1);
+            									}
+            								}
+HXLINE( 215)								prev = -1;
+            							}
+            						}
+            						else {
+HXLINE( 217)							bool _hx_tmp3;
+HXDLIN( 217)							if ((uc >= 55296)) {
+HXLINE( 217)								_hx_tmp3 = (uc <= 56319);
+            							}
+            							else {
+HXLINE( 217)								_hx_tmp3 = false;
+            							}
+HXDLIN( 217)							if (_hx_tmp3) {
+HXLINE( 218)								prev = uc;
+            							}
+            							else {
+HXLINE( 220)								if ((uc >= 127)) {
+HXLINE( 220)									::String x4 = ::String::fromCharCode(uc);
+HXDLIN( 220)									if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 220)										buf->flush();
+            									}
+HXDLIN( 220)									if (::hx::IsNull( buf->b )) {
+HXLINE( 220)										buf->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(x4));
+            									}
+            									else {
+HXLINE( 220)										::Array< ::String > buf6 = buf->b;
+HXDLIN( 220)										buf6->push(::Std_obj::string(x4));
+            									}
+            								}
+            								else {
+HXLINE( 220)									if (::hx::IsNull( buf->charBuf )) {
+HXLINE( 220)										buf->charBuf = ::Array_obj< char >::__new();
+            									}
+HXDLIN( 220)									buf->charBuf->push(uc);
+            								}
+            							}
+            						}
+            					}
+            					break;
+            					default:{
+HXLINE( 223)						HX_STACK_DO_THROW((((HX_("Invalid escape sequence \\",73,af,f7,b2) + ::String::fromCharCode(c)) + HX_(" at position ",0a,c2,01,e0)) + (this->pos - 1)));
+            					}
+            				}
+HXLINE( 225)				start = this->pos;
+            			}
+            			else {
+HXLINE( 241)				if ((c == 0)) {
+HXLINE( 242)					HX_STACK_DO_THROW(HX_("Unclosed string",ac,02,ef,ea));
+            				}
+            			}
+            		}
+            		_hx_goto_8:;
+HXLINE( 245)		if ((prev != -1)) {
+HXLINE( 246)			{
+HXLINE( 246)				::String x5 = ::String::fromCharCode(65533);
+HXDLIN( 246)				if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 246)					buf->flush();
+            				}
+HXDLIN( 246)				if (::hx::IsNull( buf->b )) {
+HXLINE( 246)					buf->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(x5));
+            				}
+            				else {
+HXLINE( 246)					::Array< ::String > buf7 = buf->b;
+HXDLIN( 246)					buf7->push(::Std_obj::string(x5));
+            				}
+            			}
+HXDLIN( 246)			prev = -1;
+            		}
+HXLINE( 248)		if (::hx::IsNull( buf )) {
+HXLINE( 249)			return this->str.substr(start,((this->pos - start) - 1));
+            		}
+            		else {
+HXLINE( 251)			{
+HXLINE( 251)				::String s1 = this->str;
+HXDLIN( 251)				 ::Dynamic len1 = ((this->pos - start) - 1);
+HXDLIN( 251)				if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 251)					buf->flush();
+            				}
+HXDLIN( 251)				if (::hx::IsNull( buf->b )) {
+HXLINE( 251)					buf->b = ::Array_obj< ::String >::__new(1)->init(0,s1.substr(start,len1));
+            				}
+            				else {
+HXLINE( 251)					::Array< ::String > buf8 = buf->b;
+HXDLIN( 251)					buf8->push(s1.substr(start,len1));
+            				}
+            			}
+HXLINE( 252)			return buf->toString();
+            		}
+HXLINE( 248)		return null();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(JsonParser_obj,parseString,return )
+
+void JsonParser_obj::invalidChar(){
+            	HX_STACKFRAME(&_hx_pos_325103750a35722e_316_invalidChar)
+HXLINE( 317)		this->pos--;
+HXLINE( 318)		::String _hx_tmp = ((HX_("Invalid char ",81,66,ec,29) + this->str.cca(this->pos)) + HX_(" at position ",0a,c2,01,e0));
+HXDLIN( 318)		HX_STACK_DO_THROW((_hx_tmp + this->pos));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(JsonParser_obj,invalidChar,(void))
+
+void JsonParser_obj::invalidNumber(int start){
+            	HX_STACKFRAME(&_hx_pos_325103750a35722e_322_invalidNumber)
+HXDLIN( 322)		HX_STACK_DO_THROW((((HX_("Invalid number at position ",d8,9d,6f,13) + start) + HX_(": ",a6,32,00,00)) + this->str.substr(start,(this->pos - start))));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(JsonParser_obj,invalidNumber,(void))
+
+
+::hx::ObjectPtr< JsonParser_obj > JsonParser_obj::__new(::String str) {
+	::hx::ObjectPtr< JsonParser_obj > __this = new JsonParser_obj();
+	__this->__construct(str);
+	return __this;
+}
+
+::hx::ObjectPtr< JsonParser_obj > JsonParser_obj::__alloc(::hx::Ctx *_hx_ctx,::String str) {
+	JsonParser_obj *__this = (JsonParser_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(JsonParser_obj), true, "haxe.format.JsonParser"));
+	*(void **)__this = JsonParser_obj::_hx_vtable;
+	__this->__construct(str);
+	return __this;
+}
+
+JsonParser_obj::JsonParser_obj()
+{
+}
+
+void JsonParser_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(JsonParser);
+	HX_MARK_MEMBER_NAME(str,"str");
+	HX_MARK_MEMBER_NAME(pos,"pos");
+	HX_MARK_END_CLASS();
+}
+
+void JsonParser_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(str,"str");
+	HX_VISIT_MEMBER_NAME(pos,"pos");
+}
+
+::hx::Val JsonParser_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"str") ) { return ::hx::Val( str ); }
+		if (HX_FIELD_EQ(inName,"pos") ) { return ::hx::Val( pos ); }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"doParse") ) { return ::hx::Val( doParse_dyn() ); }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"parseRec") ) { return ::hx::Val( parseRec_dyn() ); }
+		break;
+	case 11:
+		if (HX_FIELD_EQ(inName,"parseString") ) { return ::hx::Val( parseString_dyn() ); }
+		if (HX_FIELD_EQ(inName,"invalidChar") ) { return ::hx::Val( invalidChar_dyn() ); }
+		break;
+	case 13:
+		if (HX_FIELD_EQ(inName,"invalidNumber") ) { return ::hx::Val( invalidNumber_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val JsonParser_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"str") ) { str=inValue.Cast< ::String >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"pos") ) { pos=inValue.Cast< int >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void JsonParser_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("str",b1,a8,57,00));
+	outFields->push(HX_("pos",94,5d,55,00));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo JsonParser_obj_sMemberStorageInfo[] = {
+	{::hx::fsString,(int)offsetof(JsonParser_obj,str),HX_("str",b1,a8,57,00)},
+	{::hx::fsInt,(int)offsetof(JsonParser_obj,pos),HX_("pos",94,5d,55,00)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *JsonParser_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String JsonParser_obj_sMemberFields[] = {
+	HX_("str",b1,a8,57,00),
+	HX_("pos",94,5d,55,00),
+	HX_("doParse",a8,70,82,f0),
+	HX_("parseRec",dd,e2,78,d6),
+	HX_("parseString",64,d5,6c,8c),
+	HX_("invalidChar",6d,ad,ce,a9),
+	HX_("invalidNumber",20,e9,eb,a6),
+	::String(null()) };
+
+::hx::Class JsonParser_obj::__mClass;
+
+void JsonParser_obj::__register()
+{
+	JsonParser_obj _hx_dummy;
+	JsonParser_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.format.JsonParser",d6,2a,bf,29);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(JsonParser_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< JsonParser_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = JsonParser_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = JsonParser_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace format
diff --git a/Sources/c_snikket/src/haxe/format/JsonPrinter.cpp b/Sources/c_snikket/src/haxe/format/JsonPrinter.cpp
new file mode 100644
index 0000000..3dc30e1
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/format/JsonPrinter.cpp
@@ -0,0 +1,822 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_95f339a1d026d52c
+#define INCLUDED_95f339a1d026d52c
+#include "hxMath.h"
+#endif
+#ifndef INCLUDED_Date
+#include <Date.h>
+#endif
+#ifndef INCLUDED_Reflect
+#include <Reflect.h>
+#endif
+#ifndef INCLUDED_Std
+#include <Std.h>
+#endif
+#ifndef INCLUDED_StringBuf
+#include <StringBuf.h>
+#endif
+#ifndef INCLUDED_StringTools
+#include <StringTools.h>
+#endif
+#ifndef INCLUDED_Type
+#include <Type.h>
+#endif
+#ifndef INCLUDED_ValueType
+#include <ValueType.h>
+#endif
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+#ifndef INCLUDED_haxe_ds_StringMap
+#include <haxe/ds/StringMap.h>
+#endif
+#ifndef INCLUDED_haxe_format_JsonPrinter
+#include <haxe/format/JsonPrinter.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_9c6ac6b04494726e_56_new,"haxe.format.JsonPrinter","new",0xeb68de75,"haxe.format.JsonPrinter.new","/usr/local/lib/haxe/std/haxe/format/JsonPrinter.hx",56,0xce74b8b8)
+HX_LOCAL_STACK_FRAME(_hx_pos_9c6ac6b04494726e_81_write,"haxe.format.JsonPrinter","write",0x755dea34,"haxe.format.JsonPrinter.write","/usr/local/lib/haxe/std/haxe/format/JsonPrinter.hx",81,0xce74b8b8)
+static const ::String _hx_array_data_f7b98003_4[] = {
+	HX_("null",87,9e,0e,49),
+};
+static const ::String _hx_array_data_f7b98003_5[] = {
+	HX_("\"<fun>\"",09,3c,cc,8b),
+};
+static const ::String _hx_array_data_f7b98003_6[] = {
+	HX_("\"???\"",45,2f,74,bd),
+};
+HX_LOCAL_STACK_FRAME(_hx_pos_9c6ac6b04494726e_158_classString,"haxe.format.JsonPrinter","classString",0x9219ba3e,"haxe.format.JsonPrinter.classString","/usr/local/lib/haxe/std/haxe/format/JsonPrinter.hx",158,0xce74b8b8)
+HX_LOCAL_STACK_FRAME(_hx_pos_9c6ac6b04494726e_165_fieldsString,"haxe.format.JsonPrinter","fieldsString",0x974bd375,"haxe.format.JsonPrinter.fieldsString","/usr/local/lib/haxe/std/haxe/format/JsonPrinter.hx",165,0xce74b8b8)
+HX_LOCAL_STACK_FRAME(_hx_pos_9c6ac6b04494726e_196_quote,"haxe.format.JsonPrinter","quote",0x02f6a091,"haxe.format.JsonPrinter.quote","/usr/local/lib/haxe/std/haxe/format/JsonPrinter.hx",196,0xce74b8b8)
+static const ::String _hx_array_data_f7b98003_12[] = {
+	HX_("\\b",86,50,00,00),
+};
+static const ::String _hx_array_data_f7b98003_13[] = {
+	HX_("\\t",98,50,00,00),
+};
+static const ::String _hx_array_data_f7b98003_14[] = {
+	HX_("\\n",92,50,00,00),
+};
+static const ::String _hx_array_data_f7b98003_15[] = {
+	HX_("\\f",8a,50,00,00),
+};
+static const ::String _hx_array_data_f7b98003_16[] = {
+	HX_("\\r",96,50,00,00),
+};
+static const ::String _hx_array_data_f7b98003_17[] = {
+	HX_("\\\"",46,50,00,00),
+};
+static const ::String _hx_array_data_f7b98003_18[] = {
+	HX_("\\\\",80,50,00,00),
+};
+HX_LOCAL_STACK_FRAME(_hx_pos_9c6ac6b04494726e_44_print,"haxe.format.JsonPrinter","print",0x6d8fd582,"haxe.format.JsonPrinter.print","/usr/local/lib/haxe/std/haxe/format/JsonPrinter.hx",44,0xce74b8b8)
+namespace haxe{
+namespace format{
+
+void JsonPrinter_obj::__construct( ::Dynamic replacer,::String space){
+            	HX_GC_STACKFRAME(&_hx_pos_9c6ac6b04494726e_56_new)
+HXLINE(  57)		this->replacer = replacer;
+HXLINE(  58)		this->indent = space;
+HXLINE(  59)		this->pretty = ::hx::IsNotNull( space );
+HXLINE(  60)		this->nind = 0;
+HXLINE(  67)		this->buf =  ::StringBuf_obj::__alloc( HX_CTX );
+            	}
+
+Dynamic JsonPrinter_obj::__CreateEmpty() { return new JsonPrinter_obj; }
+
+void *JsonPrinter_obj::_hx_vtable = 0;
+
+Dynamic JsonPrinter_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< JsonPrinter_obj > _hx_result = new JsonPrinter_obj();
+	_hx_result->__construct(inArgs[0],inArgs[1]);
+	return _hx_result;
+}
+
+bool JsonPrinter_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x385642d1;
+}
+
+void JsonPrinter_obj::write( ::Dynamic k, ::Dynamic v){
+            	HX_STACKFRAME(&_hx_pos_9c6ac6b04494726e_81_write)
+HXLINE(  82)		if (::hx::IsNotNull( this->replacer )) {
+HXLINE(  83)			v = this->replacer(k,v);
+            		}
+HXLINE(  84)		{
+HXLINE(  84)			 ::ValueType _g = ::Type_obj::_hx_typeof(v);
+HXDLIN(  84)			switch((int)(_g->_hx_getIndex())){
+            				case (int)0: {
+HXLINE( 136)					 ::StringBuf _this = this->buf;
+HXDLIN( 136)					if (::hx::IsNotNull( _this->charBuf )) {
+HXLINE( 136)						_this->flush();
+            					}
+HXDLIN( 136)					if (::hx::IsNull( _this->b )) {
+HXLINE( 136)						_this->b = ::Array_obj< ::String >::fromData( _hx_array_data_f7b98003_4,1);
+            					}
+            					else {
+HXLINE( 136)						_this->b->push(HX_("null",87,9e,0e,49));
+            					}
+            				}
+            				break;
+            				case (int)1: {
+HXLINE(  90)					::String v1 = ( (::String)(v) );
+HXDLIN(  90)					{
+HXLINE(  90)						 ::StringBuf _this1 = this->buf;
+HXDLIN(  90)						if (::hx::IsNotNull( _this1->charBuf )) {
+HXLINE(  90)							_this1->flush();
+            						}
+HXDLIN(  90)						if (::hx::IsNull( _this1->b )) {
+HXLINE(  90)							_this1->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(v1));
+            						}
+            						else {
+HXLINE(  90)							::Array< ::String > _this2 = _this1->b;
+HXDLIN(  90)							_this2->push(::Std_obj::string(v1));
+            						}
+            					}
+            				}
+            				break;
+            				case (int)2: {
+HXLINE(  92)					::String v2;
+HXDLIN(  92)					if (::Math_obj::isFinite(( (Float)(v) ))) {
+HXLINE(  92)						v2 = ::Std_obj::string(v);
+            					}
+            					else {
+HXLINE(  92)						v2 = HX_("null",87,9e,0e,49);
+            					}
+HXDLIN(  92)					{
+HXLINE(  92)						 ::StringBuf _this3 = this->buf;
+HXDLIN(  92)						if (::hx::IsNotNull( _this3->charBuf )) {
+HXLINE(  92)							_this3->flush();
+            						}
+HXDLIN(  92)						if (::hx::IsNull( _this3->b )) {
+HXLINE(  92)							_this3->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(v2));
+            						}
+            						else {
+HXLINE(  92)							::Array< ::String > _this4 = _this3->b;
+HXDLIN(  92)							_this4->push(::Std_obj::string(v2));
+            						}
+            					}
+            				}
+            				break;
+            				case (int)3: {
+HXLINE( 134)					::String v3 = ( (::String)(v) );
+HXDLIN( 134)					{
+HXLINE( 134)						 ::StringBuf _this5 = this->buf;
+HXDLIN( 134)						if (::hx::IsNotNull( _this5->charBuf )) {
+HXLINE( 134)							_this5->flush();
+            						}
+HXDLIN( 134)						if (::hx::IsNull( _this5->b )) {
+HXLINE( 134)							_this5->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(v3));
+            						}
+            						else {
+HXLINE( 134)							::Array< ::String > _this6 = _this5->b;
+HXDLIN( 134)							_this6->push(::Std_obj::string(v3));
+            						}
+            					}
+            				}
+            				break;
+            				case (int)4: {
+HXLINE(  88)					this->fieldsString(v,::Reflect_obj::fields(v));
+            				}
+            				break;
+            				case (int)5: {
+HXLINE(  94)					 ::StringBuf _this7 = this->buf;
+HXDLIN(  94)					if (::hx::IsNotNull( _this7->charBuf )) {
+HXLINE(  94)						_this7->flush();
+            					}
+HXDLIN(  94)					if (::hx::IsNull( _this7->b )) {
+HXLINE(  94)						_this7->b = ::Array_obj< ::String >::fromData( _hx_array_data_f7b98003_5,1);
+            					}
+            					else {
+HXLINE(  94)						_this7->b->push(HX_("\"<fun>\"",09,3c,cc,8b));
+            					}
+            				}
+            				break;
+            				case (int)6: {
+HXLINE(  95)					::hx::Class c = _g->_hx_getObject(0).StaticCast< ::hx::Class >();
+HXLINE(  96)					if (::hx::IsPointerEq( c,::hx::ClassOf< ::String >() )) {
+HXLINE(  97)						this->quote(( (::String)(v) ));
+            					}
+            					else {
+HXLINE(  98)						if (::hx::IsPointerEq( c,::hx::ArrayBase::__mClass )) {
+HXLINE(  99)							::cpp::VirtualArray v4 = ( (::cpp::VirtualArray)(v) );
+HXLINE( 100)							{
+HXLINE( 100)								 ::StringBuf _this8 = this->buf;
+HXDLIN( 100)								{
+HXLINE( 100)									if (::hx::IsNull( _this8->charBuf )) {
+HXLINE( 100)										_this8->charBuf = ::Array_obj< char >::__new();
+            									}
+HXDLIN( 100)									_this8->charBuf->push(91);
+            								}
+            							}
+HXLINE( 102)							int len = v4->get_length();
+HXLINE( 103)							int last = (len - 1);
+HXLINE( 104)							{
+HXLINE( 104)								int _g1 = 0;
+HXDLIN( 104)								int _g2 = len;
+HXDLIN( 104)								while((_g1 < _g2)){
+HXLINE( 104)									_g1 = (_g1 + 1);
+HXDLIN( 104)									int i = (_g1 - 1);
+HXLINE( 105)									if ((i > 0)) {
+HXLINE( 106)										 ::StringBuf _this9 = this->buf;
+HXDLIN( 106)										{
+HXLINE( 106)											if (::hx::IsNull( _this9->charBuf )) {
+HXLINE( 106)												_this9->charBuf = ::Array_obj< char >::__new();
+            											}
+HXDLIN( 106)											_this9->charBuf->push(44);
+            										}
+            									}
+            									else {
+HXLINE( 108)										this->nind++;
+            									}
+HXLINE( 109)									if (this->pretty) {
+HXLINE( 109)										 ::StringBuf _this10 = this->buf;
+HXDLIN( 109)										{
+HXLINE( 109)											if (::hx::IsNull( _this10->charBuf )) {
+HXLINE( 109)												_this10->charBuf = ::Array_obj< char >::__new();
+            											}
+HXDLIN( 109)											_this10->charBuf->push(10);
+            										}
+            									}
+HXLINE( 110)									if (this->pretty) {
+HXLINE( 110)										::String v5 = ::StringTools_obj::lpad(HX_("",00,00,00,00),this->indent,(this->nind * this->indent.length));
+HXDLIN( 110)										{
+HXLINE( 110)											 ::StringBuf _this11 = this->buf;
+HXDLIN( 110)											if (::hx::IsNotNull( _this11->charBuf )) {
+HXLINE( 110)												_this11->flush();
+            											}
+HXDLIN( 110)											if (::hx::IsNull( _this11->b )) {
+HXLINE( 110)												_this11->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(v5));
+            											}
+            											else {
+HXLINE( 110)												::Array< ::String > _this12 = _this11->b;
+HXDLIN( 110)												_this12->push(::Std_obj::string(v5));
+            											}
+            										}
+            									}
+HXLINE( 111)									this->write(i,v4->__get(i));
+HXLINE( 112)									if ((i == last)) {
+HXLINE( 113)										this->nind--;
+HXLINE( 114)										if (this->pretty) {
+HXLINE( 114)											 ::StringBuf _this13 = this->buf;
+HXDLIN( 114)											{
+HXLINE( 114)												if (::hx::IsNull( _this13->charBuf )) {
+HXLINE( 114)													_this13->charBuf = ::Array_obj< char >::__new();
+            												}
+HXDLIN( 114)												_this13->charBuf->push(10);
+            											}
+            										}
+HXLINE( 115)										if (this->pretty) {
+HXLINE( 115)											::String v6 = ::StringTools_obj::lpad(HX_("",00,00,00,00),this->indent,(this->nind * this->indent.length));
+HXDLIN( 115)											{
+HXLINE( 115)												 ::StringBuf _this14 = this->buf;
+HXDLIN( 115)												if (::hx::IsNotNull( _this14->charBuf )) {
+HXLINE( 115)													_this14->flush();
+            												}
+HXDLIN( 115)												if (::hx::IsNull( _this14->b )) {
+HXLINE( 115)													_this14->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(v6));
+            												}
+            												else {
+HXLINE( 115)													::Array< ::String > _this15 = _this14->b;
+HXDLIN( 115)													_this15->push(::Std_obj::string(v6));
+            												}
+            											}
+            										}
+            									}
+            								}
+            							}
+HXLINE( 118)							{
+HXLINE( 118)								 ::StringBuf _this16 = this->buf;
+HXDLIN( 118)								{
+HXLINE( 118)									if (::hx::IsNull( _this16->charBuf )) {
+HXLINE( 118)										_this16->charBuf = ::Array_obj< char >::__new();
+            									}
+HXDLIN( 118)									_this16->charBuf->push(93);
+            								}
+            							}
+            						}
+            						else {
+HXLINE( 119)							if (::hx::IsPointerEq( c,::hx::ClassOf< ::haxe::ds::StringMap >() )) {
+HXLINE( 120)								 ::haxe::ds::StringMap v7 = ( ( ::haxe::ds::StringMap)(v) );
+HXLINE( 121)								 ::Dynamic o =  ::Dynamic(::hx::Anon_obj::Create(0));
+HXLINE( 122)								{
+HXLINE( 122)									 ::Dynamic k1 = v7->keys();
+HXDLIN( 122)									while(( (bool)(k1->__Field(HX_("hasNext",6d,a5,46,18),::hx::paccDynamic)()) )){
+HXLINE( 122)										::String k2 = ( (::String)(k1->__Field(HX_("next",f3,84,02,49),::hx::paccDynamic)()) );
+HXLINE( 123)										::Reflect_obj::setField(o,k2,v7->get(k2));
+            									}
+            								}
+HXLINE( 124)								{
+HXLINE( 124)									 ::Dynamic v8 = o;
+HXDLIN( 124)									this->fieldsString(v8,::Reflect_obj::fields(v8));
+            								}
+            							}
+            							else {
+HXLINE( 125)								if (::hx::IsPointerEq( c,::hx::ClassOf< ::Date >() )) {
+HXLINE( 126)									 ::Date v9 = ( ( ::Date)(v) );
+HXLINE( 127)									this->quote(v9->toString());
+            								}
+            								else {
+HXLINE( 129)									this->classString(v);
+            								}
+            							}
+            						}
+            					}
+            				}
+            				break;
+            				case (int)7: {
+HXLINE( 130)					::hx::Class _g3 = _g->_hx_getObject(0).StaticCast< ::hx::Class >();
+HXDLIN( 130)					{
+HXLINE( 131)						int i1 = _hx_getEnumValueIndex(v);
+HXLINE( 132)						{
+HXLINE( 132)							::String v10 = ::Std_obj::string(i1);
+HXDLIN( 132)							{
+HXLINE( 132)								 ::StringBuf _this17 = this->buf;
+HXDLIN( 132)								if (::hx::IsNotNull( _this17->charBuf )) {
+HXLINE( 132)									_this17->flush();
+            								}
+HXDLIN( 132)								if (::hx::IsNull( _this17->b )) {
+HXLINE( 132)									_this17->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(v10));
+            								}
+            								else {
+HXLINE( 132)									::Array< ::String > _this18 = _this17->b;
+HXDLIN( 132)									_this18->push(::Std_obj::string(v10));
+            								}
+            							}
+            						}
+            					}
+            				}
+            				break;
+            				case (int)8: {
+HXLINE(  86)					 ::StringBuf _this19 = this->buf;
+HXDLIN(  86)					if (::hx::IsNotNull( _this19->charBuf )) {
+HXLINE(  86)						_this19->flush();
+            					}
+HXDLIN(  86)					if (::hx::IsNull( _this19->b )) {
+HXLINE(  86)						_this19->b = ::Array_obj< ::String >::fromData( _hx_array_data_f7b98003_6,1);
+            					}
+            					else {
+HXLINE(  86)						_this19->b->push(HX_("\"???\"",45,2f,74,bd));
+            					}
+            				}
+            				break;
+            			}
+            		}
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(JsonPrinter_obj,write,(void))
+
+void JsonPrinter_obj::classString( ::Dynamic v){
+            	HX_STACKFRAME(&_hx_pos_9c6ac6b04494726e_158_classString)
+HXDLIN( 158)		this->fieldsString(v,::Type_obj::getInstanceFields(::Type_obj::getClass(v)));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(JsonPrinter_obj,classString,(void))
+
+void JsonPrinter_obj::fieldsString( ::Dynamic v,::Array< ::String > fields){
+            	HX_STACKFRAME(&_hx_pos_9c6ac6b04494726e_165_fieldsString)
+HXLINE( 166)		{
+HXLINE( 166)			 ::StringBuf _this = this->buf;
+HXDLIN( 166)			{
+HXLINE( 166)				if (::hx::IsNull( _this->charBuf )) {
+HXLINE( 166)					_this->charBuf = ::Array_obj< char >::__new();
+            				}
+HXDLIN( 166)				_this->charBuf->push(123);
+            			}
+            		}
+HXLINE( 167)		int len = fields->length;
+HXLINE( 168)		int last = (len - 1);
+HXLINE( 169)		bool first = true;
+HXLINE( 170)		{
+HXLINE( 170)			int _g = 0;
+HXDLIN( 170)			int _g1 = len;
+HXDLIN( 170)			while((_g < _g1)){
+HXLINE( 170)				_g = (_g + 1);
+HXDLIN( 170)				int i = (_g - 1);
+HXLINE( 171)				::String f = fields->__get(i);
+HXLINE( 172)				 ::Dynamic value = ::Reflect_obj::field(v,f);
+HXLINE( 173)				if (::Reflect_obj::isFunction(value)) {
+HXLINE( 174)					continue;
+            				}
+HXLINE( 175)				if (first) {
+HXLINE( 176)					this->nind++;
+HXLINE( 177)					first = false;
+            				}
+            				else {
+HXLINE( 179)					 ::StringBuf _this1 = this->buf;
+HXDLIN( 179)					{
+HXLINE( 179)						if (::hx::IsNull( _this1->charBuf )) {
+HXLINE( 179)							_this1->charBuf = ::Array_obj< char >::__new();
+            						}
+HXDLIN( 179)						_this1->charBuf->push(44);
+            					}
+            				}
+HXLINE( 180)				if (this->pretty) {
+HXLINE( 180)					 ::StringBuf _this2 = this->buf;
+HXDLIN( 180)					{
+HXLINE( 180)						if (::hx::IsNull( _this2->charBuf )) {
+HXLINE( 180)							_this2->charBuf = ::Array_obj< char >::__new();
+            						}
+HXDLIN( 180)						_this2->charBuf->push(10);
+            					}
+            				}
+HXLINE( 181)				if (this->pretty) {
+HXLINE( 181)					::String v1 = ::StringTools_obj::lpad(HX_("",00,00,00,00),this->indent,(this->nind * this->indent.length));
+HXDLIN( 181)					{
+HXLINE( 181)						 ::StringBuf _this3 = this->buf;
+HXDLIN( 181)						if (::hx::IsNotNull( _this3->charBuf )) {
+HXLINE( 181)							_this3->flush();
+            						}
+HXDLIN( 181)						if (::hx::IsNull( _this3->b )) {
+HXLINE( 181)							_this3->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(v1));
+            						}
+            						else {
+HXLINE( 181)							::Array< ::String > _this4 = _this3->b;
+HXDLIN( 181)							_this4->push(::Std_obj::string(v1));
+            						}
+            					}
+            				}
+HXLINE( 182)				this->quote(f);
+HXLINE( 183)				{
+HXLINE( 183)					 ::StringBuf _this5 = this->buf;
+HXDLIN( 183)					{
+HXLINE( 183)						if (::hx::IsNull( _this5->charBuf )) {
+HXLINE( 183)							_this5->charBuf = ::Array_obj< char >::__new();
+            						}
+HXDLIN( 183)						_this5->charBuf->push(58);
+            					}
+            				}
+HXLINE( 184)				if (this->pretty) {
+HXLINE( 185)					 ::StringBuf _this6 = this->buf;
+HXDLIN( 185)					{
+HXLINE( 185)						if (::hx::IsNull( _this6->charBuf )) {
+HXLINE( 185)							_this6->charBuf = ::Array_obj< char >::__new();
+            						}
+HXDLIN( 185)						_this6->charBuf->push(32);
+            					}
+            				}
+HXLINE( 186)				this->write(f,value);
+HXLINE( 187)				if ((i == last)) {
+HXLINE( 188)					this->nind--;
+HXLINE( 189)					if (this->pretty) {
+HXLINE( 189)						 ::StringBuf _this7 = this->buf;
+HXDLIN( 189)						{
+HXLINE( 189)							if (::hx::IsNull( _this7->charBuf )) {
+HXLINE( 189)								_this7->charBuf = ::Array_obj< char >::__new();
+            							}
+HXDLIN( 189)							_this7->charBuf->push(10);
+            						}
+            					}
+HXLINE( 190)					if (this->pretty) {
+HXLINE( 190)						::String v2 = ::StringTools_obj::lpad(HX_("",00,00,00,00),this->indent,(this->nind * this->indent.length));
+HXDLIN( 190)						{
+HXLINE( 190)							 ::StringBuf _this8 = this->buf;
+HXDLIN( 190)							if (::hx::IsNotNull( _this8->charBuf )) {
+HXLINE( 190)								_this8->flush();
+            							}
+HXDLIN( 190)							if (::hx::IsNull( _this8->b )) {
+HXLINE( 190)								_this8->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(v2));
+            							}
+            							else {
+HXLINE( 190)								::Array< ::String > _this9 = _this8->b;
+HXDLIN( 190)								_this9->push(::Std_obj::string(v2));
+            							}
+            						}
+            					}
+            				}
+            			}
+            		}
+HXLINE( 193)		{
+HXLINE( 193)			 ::StringBuf _this10 = this->buf;
+HXDLIN( 193)			{
+HXLINE( 193)				if (::hx::IsNull( _this10->charBuf )) {
+HXLINE( 193)					_this10->charBuf = ::Array_obj< char >::__new();
+            				}
+HXDLIN( 193)				_this10->charBuf->push(125);
+            			}
+            		}
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(JsonPrinter_obj,fieldsString,(void))
+
+void JsonPrinter_obj::quote(::String s){
+            	HX_STACKFRAME(&_hx_pos_9c6ac6b04494726e_196_quote)
+HXLINE( 203)		{
+HXLINE( 203)			 ::StringBuf _this = this->buf;
+HXDLIN( 203)			{
+HXLINE( 203)				if (::hx::IsNull( _this->charBuf )) {
+HXLINE( 203)					_this->charBuf = ::Array_obj< char >::__new();
+            				}
+HXDLIN( 203)				_this->charBuf->push(34);
+            			}
+            		}
+HXLINE( 204)		int i = 0;
+HXLINE( 205)		int length = s.length;
+HXLINE( 209)		while((i < length)){
+HXLINE( 210)			i = (i + 1);
+HXDLIN( 210)			int c = s.cca((i - 1));
+HXLINE( 211)			switch((int)(c)){
+            				case (int)8: {
+HXLINE( 223)					 ::StringBuf _this1 = this->buf;
+HXDLIN( 223)					if (::hx::IsNotNull( _this1->charBuf )) {
+HXLINE( 223)						_this1->flush();
+            					}
+HXDLIN( 223)					if (::hx::IsNull( _this1->b )) {
+HXLINE( 223)						_this1->b = ::Array_obj< ::String >::fromData( _hx_array_data_f7b98003_12,1);
+            					}
+            					else {
+HXLINE( 223)						_this1->b->push(HX_("\\b",86,50,00,00));
+            					}
+            				}
+            				break;
+            				case (int)9: {
+HXLINE( 221)					 ::StringBuf _this2 = this->buf;
+HXDLIN( 221)					if (::hx::IsNotNull( _this2->charBuf )) {
+HXLINE( 221)						_this2->flush();
+            					}
+HXDLIN( 221)					if (::hx::IsNull( _this2->b )) {
+HXLINE( 221)						_this2->b = ::Array_obj< ::String >::fromData( _hx_array_data_f7b98003_13,1);
+            					}
+            					else {
+HXLINE( 221)						_this2->b->push(HX_("\\t",98,50,00,00));
+            					}
+            				}
+            				break;
+            				case (int)10: {
+HXLINE( 217)					 ::StringBuf _this3 = this->buf;
+HXDLIN( 217)					if (::hx::IsNotNull( _this3->charBuf )) {
+HXLINE( 217)						_this3->flush();
+            					}
+HXDLIN( 217)					if (::hx::IsNull( _this3->b )) {
+HXLINE( 217)						_this3->b = ::Array_obj< ::String >::fromData( _hx_array_data_f7b98003_14,1);
+            					}
+            					else {
+HXLINE( 217)						_this3->b->push(HX_("\\n",92,50,00,00));
+            					}
+            				}
+            				break;
+            				case (int)12: {
+HXLINE( 225)					 ::StringBuf _this4 = this->buf;
+HXDLIN( 225)					if (::hx::IsNotNull( _this4->charBuf )) {
+HXLINE( 225)						_this4->flush();
+            					}
+HXDLIN( 225)					if (::hx::IsNull( _this4->b )) {
+HXLINE( 225)						_this4->b = ::Array_obj< ::String >::fromData( _hx_array_data_f7b98003_15,1);
+            					}
+            					else {
+HXLINE( 225)						_this4->b->push(HX_("\\f",8a,50,00,00));
+            					}
+            				}
+            				break;
+            				case (int)13: {
+HXLINE( 219)					 ::StringBuf _this5 = this->buf;
+HXDLIN( 219)					if (::hx::IsNotNull( _this5->charBuf )) {
+HXLINE( 219)						_this5->flush();
+            					}
+HXDLIN( 219)					if (::hx::IsNull( _this5->b )) {
+HXLINE( 219)						_this5->b = ::Array_obj< ::String >::fromData( _hx_array_data_f7b98003_16,1);
+            					}
+            					else {
+HXLINE( 219)						_this5->b->push(HX_("\\r",96,50,00,00));
+            					}
+            				}
+            				break;
+            				case (int)34: {
+HXLINE( 213)					 ::StringBuf _this6 = this->buf;
+HXDLIN( 213)					if (::hx::IsNotNull( _this6->charBuf )) {
+HXLINE( 213)						_this6->flush();
+            					}
+HXDLIN( 213)					if (::hx::IsNull( _this6->b )) {
+HXLINE( 213)						_this6->b = ::Array_obj< ::String >::fromData( _hx_array_data_f7b98003_17,1);
+            					}
+            					else {
+HXLINE( 213)						_this6->b->push(HX_("\\\"",46,50,00,00));
+            					}
+            				}
+            				break;
+            				case (int)92: {
+HXLINE( 215)					 ::StringBuf _this7 = this->buf;
+HXDLIN( 215)					if (::hx::IsNotNull( _this7->charBuf )) {
+HXLINE( 215)						_this7->flush();
+            					}
+HXDLIN( 215)					if (::hx::IsNull( _this7->b )) {
+HXLINE( 215)						_this7->b = ::Array_obj< ::String >::fromData( _hx_array_data_f7b98003_18,1);
+            					}
+            					else {
+HXLINE( 215)						_this7->b->push(HX_("\\\\",80,50,00,00));
+            					}
+            				}
+            				break;
+            				default:{
+HXLINE( 248)					 ::StringBuf _this8 = this->buf;
+HXDLIN( 248)					if ((c >= 127)) {
+HXLINE( 248)						::String x = ::String::fromCharCode(c);
+HXDLIN( 248)						if (::hx::IsNotNull( _this8->charBuf )) {
+HXLINE( 248)							_this8->flush();
+            						}
+HXDLIN( 248)						if (::hx::IsNull( _this8->b )) {
+HXLINE( 248)							_this8->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(x));
+            						}
+            						else {
+HXLINE( 248)							::Array< ::String > _this9 = _this8->b;
+HXDLIN( 248)							_this9->push(::Std_obj::string(x));
+            						}
+            					}
+            					else {
+HXLINE( 248)						if (::hx::IsNull( _this8->charBuf )) {
+HXLINE( 248)							_this8->charBuf = ::Array_obj< char >::__new();
+            						}
+HXDLIN( 248)						_this8->charBuf->push(c);
+            					}
+            				}
+            			}
+            		}
+HXLINE( 256)		{
+HXLINE( 256)			 ::StringBuf _this10 = this->buf;
+HXDLIN( 256)			{
+HXLINE( 256)				if (::hx::IsNull( _this10->charBuf )) {
+HXLINE( 256)					_this10->charBuf = ::Array_obj< char >::__new();
+            				}
+HXDLIN( 256)				_this10->charBuf->push(34);
+            			}
+            		}
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(JsonPrinter_obj,quote,(void))
+
+::String JsonPrinter_obj::print( ::Dynamic o, ::Dynamic replacer,::String space){
+            	HX_GC_STACKFRAME(&_hx_pos_9c6ac6b04494726e_44_print)
+HXLINE(  45)		 ::haxe::format::JsonPrinter printer =  ::haxe::format::JsonPrinter_obj::__alloc( HX_CTX ,replacer,space);
+HXLINE(  46)		printer->write(HX_("",00,00,00,00),o);
+HXLINE(  47)		return printer->buf->toString();
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC3(JsonPrinter_obj,print,return )
+
+
+::hx::ObjectPtr< JsonPrinter_obj > JsonPrinter_obj::__new( ::Dynamic replacer,::String space) {
+	::hx::ObjectPtr< JsonPrinter_obj > __this = new JsonPrinter_obj();
+	__this->__construct(replacer,space);
+	return __this;
+}
+
+::hx::ObjectPtr< JsonPrinter_obj > JsonPrinter_obj::__alloc(::hx::Ctx *_hx_ctx, ::Dynamic replacer,::String space) {
+	JsonPrinter_obj *__this = (JsonPrinter_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(JsonPrinter_obj), true, "haxe.format.JsonPrinter"));
+	*(void **)__this = JsonPrinter_obj::_hx_vtable;
+	__this->__construct(replacer,space);
+	return __this;
+}
+
+JsonPrinter_obj::JsonPrinter_obj()
+{
+}
+
+void JsonPrinter_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(JsonPrinter);
+	HX_MARK_MEMBER_NAME(buf,"buf");
+	HX_MARK_MEMBER_NAME(replacer,"replacer");
+	HX_MARK_MEMBER_NAME(indent,"indent");
+	HX_MARK_MEMBER_NAME(pretty,"pretty");
+	HX_MARK_MEMBER_NAME(nind,"nind");
+	HX_MARK_END_CLASS();
+}
+
+void JsonPrinter_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(buf,"buf");
+	HX_VISIT_MEMBER_NAME(replacer,"replacer");
+	HX_VISIT_MEMBER_NAME(indent,"indent");
+	HX_VISIT_MEMBER_NAME(pretty,"pretty");
+	HX_VISIT_MEMBER_NAME(nind,"nind");
+}
+
+::hx::Val JsonPrinter_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"buf") ) { return ::hx::Val( buf ); }
+		break;
+	case 4:
+		if (HX_FIELD_EQ(inName,"nind") ) { return ::hx::Val( nind ); }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"write") ) { return ::hx::Val( write_dyn() ); }
+		if (HX_FIELD_EQ(inName,"quote") ) { return ::hx::Val( quote_dyn() ); }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"indent") ) { return ::hx::Val( indent ); }
+		if (HX_FIELD_EQ(inName,"pretty") ) { return ::hx::Val( pretty ); }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"replacer") ) { return ::hx::Val( replacer ); }
+		break;
+	case 11:
+		if (HX_FIELD_EQ(inName,"classString") ) { return ::hx::Val( classString_dyn() ); }
+		break;
+	case 12:
+		if (HX_FIELD_EQ(inName,"fieldsString") ) { return ::hx::Val( fieldsString_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+bool JsonPrinter_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 5:
+		if (HX_FIELD_EQ(inName,"print") ) { outValue = print_dyn(); return true; }
+	}
+	return false;
+}
+
+::hx::Val JsonPrinter_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"buf") ) { buf=inValue.Cast<  ::StringBuf >(); return inValue; }
+		break;
+	case 4:
+		if (HX_FIELD_EQ(inName,"nind") ) { nind=inValue.Cast< int >(); return inValue; }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"indent") ) { indent=inValue.Cast< ::String >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"pretty") ) { pretty=inValue.Cast< bool >(); return inValue; }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"replacer") ) { replacer=inValue.Cast<  ::Dynamic >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void JsonPrinter_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("buf",33,c3,4a,00));
+	outFields->push(HX_("indent",6c,0c,f3,93));
+	outFields->push(HX_("pretty",b6,82,c1,ae));
+	outFields->push(HX_("nind",31,85,05,49));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo JsonPrinter_obj_sMemberStorageInfo[] = {
+	{::hx::fsObject /*  ::StringBuf */ ,(int)offsetof(JsonPrinter_obj,buf),HX_("buf",33,c3,4a,00)},
+	{::hx::fsObject /*  ::Dynamic */ ,(int)offsetof(JsonPrinter_obj,replacer),HX_("replacer",be,e5,16,18)},
+	{::hx::fsString,(int)offsetof(JsonPrinter_obj,indent),HX_("indent",6c,0c,f3,93)},
+	{::hx::fsBool,(int)offsetof(JsonPrinter_obj,pretty),HX_("pretty",b6,82,c1,ae)},
+	{::hx::fsInt,(int)offsetof(JsonPrinter_obj,nind),HX_("nind",31,85,05,49)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *JsonPrinter_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String JsonPrinter_obj_sMemberFields[] = {
+	HX_("buf",33,c3,4a,00),
+	HX_("replacer",be,e5,16,18),
+	HX_("indent",6c,0c,f3,93),
+	HX_("pretty",b6,82,c1,ae),
+	HX_("nind",31,85,05,49),
+	HX_("write",df,6c,59,d0),
+	HX_("classString",29,0f,79,88),
+	HX_("fieldsString",2a,cc,56,34),
+	HX_("quote",3c,23,f2,5d),
+	::String(null()) };
+
+::hx::Class JsonPrinter_obj::__mClass;
+
+static ::String JsonPrinter_obj_sStaticFields[] = {
+	HX_("print",2d,58,8b,c8),
+	::String(null())
+};
+
+void JsonPrinter_obj::__register()
+{
+	JsonPrinter_obj _hx_dummy;
+	JsonPrinter_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.format.JsonPrinter",03,80,b9,f7);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &JsonPrinter_obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(JsonPrinter_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(JsonPrinter_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< JsonPrinter_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = JsonPrinter_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = JsonPrinter_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace format
diff --git a/Sources/c_snikket/src/haxe/http/HttpBase.cpp b/Sources/c_snikket/src/haxe/http/HttpBase.cpp
new file mode 100644
index 0000000..b377b85
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/http/HttpBase.cpp
@@ -0,0 +1,371 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Reflect
+#include <Reflect.h>
+#endif
+#ifndef INCLUDED_haxe_http_HttpBase
+#include <haxe/http/HttpBase.h>
+#endif
+#ifndef INCLUDED_haxe_io_Bytes
+#include <haxe/io/Bytes.h>
+#endif
+#ifndef INCLUDED_haxe_io_Encoding
+#include <haxe/io/Encoding.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_d3f7691e8659205f_71_new,"haxe.http.HttpBase","new",0x98384fa9,"haxe.http.HttpBase.new","/usr/local/lib/haxe/std/haxe/http/HttpBase.hx",71,0x0b31f0aa)
+HX_LOCAL_STACK_FRAME(_hx_pos_d3f7691e8659205f_85_setHeader,"haxe.http.HttpBase","setHeader",0xf9141ad8,"haxe.http.HttpBase.setHeader","/usr/local/lib/haxe/std/haxe/http/HttpBase.hx",85,0x0b31f0aa)
+HX_LOCAL_STACK_FRAME(_hx_pos_d3f7691e8659205f_142_setPostData,"haxe.http.HttpBase","setPostData",0x36d5f0b5,"haxe.http.HttpBase.setPostData","/usr/local/lib/haxe/std/haxe/http/HttpBase.hx",142,0x0b31f0aa)
+HX_LOCAL_STACK_FRAME(_hx_pos_d3f7691e8659205f_196___default_onData,"haxe.http.HttpBase","__default_onData",0xb2f8141e,"haxe.http.HttpBase.__default_onData","/usr/local/lib/haxe/std/haxe/http/HttpBase.hx",196,0x0b31f0aa)
+HX_LOCAL_STACK_FRAME(_hx_pos_d3f7691e8659205f_205___default_onBytes,"haxe.http.HttpBase","__default_onBytes",0xcf297ff7,"haxe.http.HttpBase.__default_onBytes","/usr/local/lib/haxe/std/haxe/http/HttpBase.hx",205,0x0b31f0aa)
+HX_LOCAL_STACK_FRAME(_hx_pos_d3f7691e8659205f_214___default_onError,"haxe.http.HttpBase","__default_onError",0x84bb4354,"haxe.http.HttpBase.__default_onError","/usr/local/lib/haxe/std/haxe/http/HttpBase.hx",214,0x0b31f0aa)
+HX_LOCAL_STACK_FRAME(_hx_pos_d3f7691e8659205f_223___default_onStatus,"haxe.http.HttpBase","__default_onStatus",0x53b30a26,"haxe.http.HttpBase.__default_onStatus","/usr/local/lib/haxe/std/haxe/http/HttpBase.hx",223,0x0b31f0aa)
+HX_LOCAL_STACK_FRAME(_hx_pos_d3f7691e8659205f_229_hasOnData,"haxe.http.HttpBase","hasOnData",0xc242adec,"haxe.http.HttpBase.hasOnData","/usr/local/lib/haxe/std/haxe/http/HttpBase.hx",229,0x0b31f0aa)
+HX_LOCAL_STACK_FRAME(_hx_pos_d3f7691e8659205f_232_success,"haxe.http.HttpBase","success",0xfe1e7d8c,"haxe.http.HttpBase.success","/usr/local/lib/haxe/std/haxe/http/HttpBase.hx",232,0x0b31f0aa)
+HX_LOCAL_STACK_FRAME(_hx_pos_d3f7691e8659205f_241_get_responseData,"haxe.http.HttpBase","get_responseData",0x92ecd8eb,"haxe.http.HttpBase.get_responseData","/usr/local/lib/haxe/std/haxe/http/HttpBase.hx",241,0x0b31f0aa)
+namespace haxe{
+namespace http{
+
+void HttpBase_obj::__construct(::String url){
+            	HX_STACKFRAME(&_hx_pos_d3f7691e8659205f_71_new)
+HXLINE(  72)		this->url = url;
+HXLINE(  73)		this->headers = ::Array_obj< ::Dynamic>::__new(0);
+HXLINE(  74)		this->params = ::Array_obj< ::Dynamic>::__new(0);
+HXLINE(  75)		this->emptyOnData = this->onData;
+            	}
+
+Dynamic HttpBase_obj::__CreateEmpty() { return new HttpBase_obj; }
+
+void *HttpBase_obj::_hx_vtable = 0;
+
+Dynamic HttpBase_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< HttpBase_obj > _hx_result = new HttpBase_obj();
+	_hx_result->__construct(inArgs[0]);
+	return _hx_result;
+}
+
+bool HttpBase_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x10c0921f;
+}
+
+void HttpBase_obj::setHeader(::String name,::String value){
+            	HX_STACKFRAME(&_hx_pos_d3f7691e8659205f_85_setHeader)
+HXLINE(  86)		{
+HXLINE(  86)			int _g = 0;
+HXDLIN(  86)			int _g1 = this->headers->length;
+HXDLIN(  86)			while((_g < _g1)){
+HXLINE(  86)				_g = (_g + 1);
+HXDLIN(  86)				int i = (_g - 1);
+HXLINE(  87)				if (::hx::IsEq( this->headers->__get(i)->__Field(HX_("name",4b,72,ff,48),::hx::paccDynamic),name )) {
+HXLINE(  88)					this->headers[i] =  ::Dynamic(::hx::Anon_obj::Create(2)
+            						->setFixed(0,HX_("value",71,7f,b8,31),value)
+            						->setFixed(1,HX_("name",4b,72,ff,48),name));
+HXLINE(  89)					return;
+            				}
+            			}
+            		}
+HXLINE(  92)		this->headers->push( ::Dynamic(::hx::Anon_obj::Create(2)
+            			->setFixed(0,HX_("value",71,7f,b8,31),value)
+            			->setFixed(1,HX_("name",4b,72,ff,48),name)));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(HttpBase_obj,setHeader,(void))
+
+void HttpBase_obj::setPostData(::String data){
+            	HX_STACKFRAME(&_hx_pos_d3f7691e8659205f_142_setPostData)
+HXLINE( 143)		this->postData = data;
+HXLINE( 144)		this->postBytes = null();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(HttpBase_obj,setPostData,(void))
+
+HX_BEGIN_DEFAULT_FUNC(__default_onData,HttpBase_obj)
+void _hx_run(::String data){
+            	HX_STACKFRAME(&_hx_pos_d3f7691e8659205f_196___default_onData)
+            	}
+HX_END_LOCAL_FUNC1((void))
+HX_END_DEFAULT_FUNC
+
+HX_BEGIN_DEFAULT_FUNC(__default_onBytes,HttpBase_obj)
+void _hx_run( ::haxe::io::Bytes data){
+            	HX_STACKFRAME(&_hx_pos_d3f7691e8659205f_205___default_onBytes)
+            	}
+HX_END_LOCAL_FUNC1((void))
+HX_END_DEFAULT_FUNC
+
+HX_BEGIN_DEFAULT_FUNC(__default_onError,HttpBase_obj)
+void _hx_run(::String msg){
+            	HX_STACKFRAME(&_hx_pos_d3f7691e8659205f_214___default_onError)
+            	}
+HX_END_LOCAL_FUNC1((void))
+HX_END_DEFAULT_FUNC
+
+HX_BEGIN_DEFAULT_FUNC(__default_onStatus,HttpBase_obj)
+void _hx_run(int status){
+            	HX_STACKFRAME(&_hx_pos_d3f7691e8659205f_223___default_onStatus)
+            	}
+HX_END_LOCAL_FUNC1((void))
+HX_END_DEFAULT_FUNC
+
+bool HttpBase_obj::hasOnData(){
+            	HX_STACKFRAME(&_hx_pos_d3f7691e8659205f_229_hasOnData)
+HXDLIN( 229)		return !(::Reflect_obj::compareMethods(this->onData,this->emptyOnData));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(HttpBase_obj,hasOnData,return )
+
+void HttpBase_obj::success( ::haxe::io::Bytes data){
+            	HX_STACKFRAME(&_hx_pos_d3f7691e8659205f_232_success)
+HXLINE( 233)		this->responseBytes = data;
+HXLINE( 234)		this->responseAsString = null();
+HXLINE( 235)		if (this->hasOnData()) {
+HXLINE( 236)			 ::Dynamic _hx_tmp = this->onData;
+HXDLIN( 236)			_hx_tmp(this->get_responseData());
+            		}
+HXLINE( 238)		this->onBytes(this->responseBytes);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(HttpBase_obj,success,(void))
+
+::String HttpBase_obj::get_responseData(){
+            	HX_STACKFRAME(&_hx_pos_d3f7691e8659205f_241_get_responseData)
+HXLINE( 242)		bool _hx_tmp;
+HXDLIN( 242)		if (::hx::IsNull( this->responseAsString )) {
+HXLINE( 242)			_hx_tmp = ::hx::IsNotNull( this->responseBytes );
+            		}
+            		else {
+HXLINE( 242)			_hx_tmp = false;
+            		}
+HXDLIN( 242)		if (_hx_tmp) {
+HXLINE( 246)			this->responseAsString = this->responseBytes->getString(0,this->responseBytes->length,::haxe::io::Encoding_obj::UTF8_dyn());
+            		}
+HXLINE( 249)		return this->responseAsString;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(HttpBase_obj,get_responseData,return )
+
+
+void HttpBase_obj::__alloc_dynamic_functions(::hx::Ctx *_hx_ctx,HttpBase_obj *_hx_obj) {
+	if (!_hx_obj->onStatus.mPtr) _hx_obj->onStatus = new __default_onStatus(_hx_obj);
+	if (!_hx_obj->onError.mPtr) _hx_obj->onError = new __default_onError(_hx_obj);
+	if (!_hx_obj->onBytes.mPtr) _hx_obj->onBytes = new __default_onBytes(_hx_obj);
+	if (!_hx_obj->onData.mPtr) _hx_obj->onData = new __default_onData(_hx_obj);
+}
+::hx::ObjectPtr< HttpBase_obj > HttpBase_obj::__new(::String url) {
+	::hx::ObjectPtr< HttpBase_obj > __this = new HttpBase_obj();
+	__this->__construct(url);
+	return __this;
+}
+
+::hx::ObjectPtr< HttpBase_obj > HttpBase_obj::__alloc(::hx::Ctx *_hx_ctx,::String url) {
+	HttpBase_obj *__this = (HttpBase_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(HttpBase_obj), true, "haxe.http.HttpBase"));
+	*(void **)__this = HttpBase_obj::_hx_vtable;
+	haxe::http::HttpBase_obj::__alloc_dynamic_functions(_hx_ctx,__this);
+	__this->__construct(url);
+	return __this;
+}
+
+HttpBase_obj::HttpBase_obj()
+{
+	onStatus = new __default_onStatus(this);
+	onError = new __default_onError(this);
+	onBytes = new __default_onBytes(this);
+	onData = new __default_onData(this);
+}
+
+void HttpBase_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(HttpBase);
+	HX_MARK_MEMBER_NAME(url,"url");
+	HX_MARK_MEMBER_NAME(responseBytes,"responseBytes");
+	HX_MARK_MEMBER_NAME(responseAsString,"responseAsString");
+	HX_MARK_MEMBER_NAME(postData,"postData");
+	HX_MARK_MEMBER_NAME(postBytes,"postBytes");
+	HX_MARK_MEMBER_NAME(headers,"headers");
+	HX_MARK_MEMBER_NAME(params,"params");
+	HX_MARK_MEMBER_NAME(emptyOnData,"emptyOnData");
+	HX_MARK_MEMBER_NAME(onData,"onData");
+	HX_MARK_MEMBER_NAME(onBytes,"onBytes");
+	HX_MARK_MEMBER_NAME(onError,"onError");
+	HX_MARK_MEMBER_NAME(onStatus,"onStatus");
+	HX_MARK_END_CLASS();
+}
+
+void HttpBase_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(url,"url");
+	HX_VISIT_MEMBER_NAME(responseBytes,"responseBytes");
+	HX_VISIT_MEMBER_NAME(responseAsString,"responseAsString");
+	HX_VISIT_MEMBER_NAME(postData,"postData");
+	HX_VISIT_MEMBER_NAME(postBytes,"postBytes");
+	HX_VISIT_MEMBER_NAME(headers,"headers");
+	HX_VISIT_MEMBER_NAME(params,"params");
+	HX_VISIT_MEMBER_NAME(emptyOnData,"emptyOnData");
+	HX_VISIT_MEMBER_NAME(onData,"onData");
+	HX_VISIT_MEMBER_NAME(onBytes,"onBytes");
+	HX_VISIT_MEMBER_NAME(onError,"onError");
+	HX_VISIT_MEMBER_NAME(onStatus,"onStatus");
+}
+
+::hx::Val HttpBase_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"url") ) { return ::hx::Val( url ); }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"params") ) { return ::hx::Val( params ); }
+		if (HX_FIELD_EQ(inName,"onData") ) { return ::hx::Val( onData ); }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"headers") ) { return ::hx::Val( headers ); }
+		if (HX_FIELD_EQ(inName,"onBytes") ) { return ::hx::Val( onBytes ); }
+		if (HX_FIELD_EQ(inName,"onError") ) { return ::hx::Val( onError ); }
+		if (HX_FIELD_EQ(inName,"success") ) { return ::hx::Val( success_dyn() ); }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"postData") ) { return ::hx::Val( postData ); }
+		if (HX_FIELD_EQ(inName,"onStatus") ) { return ::hx::Val( onStatus ); }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"postBytes") ) { return ::hx::Val( postBytes ); }
+		if (HX_FIELD_EQ(inName,"setHeader") ) { return ::hx::Val( setHeader_dyn() ); }
+		if (HX_FIELD_EQ(inName,"hasOnData") ) { return ::hx::Val( hasOnData_dyn() ); }
+		break;
+	case 11:
+		if (HX_FIELD_EQ(inName,"emptyOnData") ) { return ::hx::Val( emptyOnData ); }
+		if (HX_FIELD_EQ(inName,"setPostData") ) { return ::hx::Val( setPostData_dyn() ); }
+		break;
+	case 12:
+		if (HX_FIELD_EQ(inName,"responseData") ) { if (inCallProp == ::hx::paccAlways) return ::hx::Val( get_responseData() ); }
+		break;
+	case 13:
+		if (HX_FIELD_EQ(inName,"responseBytes") ) { return ::hx::Val( responseBytes ); }
+		break;
+	case 16:
+		if (HX_FIELD_EQ(inName,"responseAsString") ) { return ::hx::Val( responseAsString ); }
+		if (HX_FIELD_EQ(inName,"get_responseData") ) { return ::hx::Val( get_responseData_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val HttpBase_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"url") ) { url=inValue.Cast< ::String >(); return inValue; }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"params") ) { params=inValue.Cast< ::Array< ::Dynamic> >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"onData") ) { onData=inValue.Cast<  ::Dynamic >(); return inValue; }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"headers") ) { headers=inValue.Cast< ::Array< ::Dynamic> >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"onBytes") ) { onBytes=inValue.Cast<  ::Dynamic >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"onError") ) { onError=inValue.Cast<  ::Dynamic >(); return inValue; }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"postData") ) { postData=inValue.Cast< ::String >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"onStatus") ) { onStatus=inValue.Cast<  ::Dynamic >(); return inValue; }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"postBytes") ) { postBytes=inValue.Cast<  ::haxe::io::Bytes >(); return inValue; }
+		break;
+	case 11:
+		if (HX_FIELD_EQ(inName,"emptyOnData") ) { emptyOnData=inValue.Cast<  ::Dynamic >(); return inValue; }
+		break;
+	case 13:
+		if (HX_FIELD_EQ(inName,"responseBytes") ) { responseBytes=inValue.Cast<  ::haxe::io::Bytes >(); return inValue; }
+		break;
+	case 16:
+		if (HX_FIELD_EQ(inName,"responseAsString") ) { responseAsString=inValue.Cast< ::String >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void HttpBase_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("url",6f,2b,59,00));
+	outFields->push(HX_("responseData",4b,05,e9,c4));
+	outFields->push(HX_("responseBytes",2a,96,0b,70));
+	outFields->push(HX_("responseAsString",04,87,c8,68));
+	outFields->push(HX_("postData",aa,b6,a2,00));
+	outFields->push(HX_("postBytes",eb,17,cd,76));
+	outFields->push(HX_("headers",46,52,08,63));
+	outFields->push(HX_("params",46,fb,7a,ed));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo HttpBase_obj_sMemberStorageInfo[] = {
+	{::hx::fsString,(int)offsetof(HttpBase_obj,url),HX_("url",6f,2b,59,00)},
+	{::hx::fsObject /*  ::haxe::io::Bytes */ ,(int)offsetof(HttpBase_obj,responseBytes),HX_("responseBytes",2a,96,0b,70)},
+	{::hx::fsString,(int)offsetof(HttpBase_obj,responseAsString),HX_("responseAsString",04,87,c8,68)},
+	{::hx::fsString,(int)offsetof(HttpBase_obj,postData),HX_("postData",aa,b6,a2,00)},
+	{::hx::fsObject /*  ::haxe::io::Bytes */ ,(int)offsetof(HttpBase_obj,postBytes),HX_("postBytes",eb,17,cd,76)},
+	{::hx::fsObject /* ::Array< ::Dynamic> */ ,(int)offsetof(HttpBase_obj,headers),HX_("headers",46,52,08,63)},
+	{::hx::fsObject /* ::Array< ::Dynamic> */ ,(int)offsetof(HttpBase_obj,params),HX_("params",46,fb,7a,ed)},
+	{::hx::fsObject /*  ::Dynamic */ ,(int)offsetof(HttpBase_obj,emptyOnData),HX_("emptyOnData",56,f5,15,ad)},
+	{::hx::fsObject /*  ::Dynamic */ ,(int)offsetof(HttpBase_obj,onData),HX_("onData",e9,5e,ed,e4)},
+	{::hx::fsObject /*  ::Dynamic */ ,(int)offsetof(HttpBase_obj,onBytes),HX_("onBytes",cc,a6,d5,53)},
+	{::hx::fsObject /*  ::Dynamic */ ,(int)offsetof(HttpBase_obj,onError),HX_("onError",29,6a,67,09)},
+	{::hx::fsObject /*  ::Dynamic */ ,(int)offsetof(HttpBase_obj,onStatus),HX_("onStatus",b1,dd,a8,e5)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *HttpBase_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String HttpBase_obj_sMemberFields[] = {
+	HX_("url",6f,2b,59,00),
+	HX_("responseBytes",2a,96,0b,70),
+	HX_("responseAsString",04,87,c8,68),
+	HX_("postData",aa,b6,a2,00),
+	HX_("postBytes",eb,17,cd,76),
+	HX_("headers",46,52,08,63),
+	HX_("params",46,fb,7a,ed),
+	HX_("emptyOnData",56,f5,15,ad),
+	HX_("setHeader",cf,7e,a7,5c),
+	HX_("setPostData",6c,80,03,31),
+	HX_("onData",e9,5e,ed,e4),
+	HX_("onBytes",cc,a6,d5,53),
+	HX_("onError",29,6a,67,09),
+	HX_("onStatus",b1,dd,a8,e5),
+	HX_("hasOnData",e3,11,d6,25),
+	HX_("success",c3,25,4e,b8),
+	HX_("get_responseData",d4,f1,87,c9),
+	::String(null()) };
+
+::hx::Class HttpBase_obj::__mClass;
+
+void HttpBase_obj::__register()
+{
+	HttpBase_obj _hx_dummy;
+	HttpBase_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.http.HttpBase",37,47,c3,bd);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(HttpBase_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< HttpBase_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = HttpBase_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = HttpBase_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace http
diff --git a/Sources/c_snikket/src/haxe/io/Bytes.cpp b/Sources/c_snikket/src/haxe/io/Bytes.cpp
new file mode 100644
index 0000000..0e6e4aa
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/io/Bytes.cpp
@@ -0,0 +1,441 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Std
+#include <Std.h>
+#endif
+#ifndef INCLUDED_StringBuf
+#include <StringBuf.h>
+#endif
+#ifndef INCLUDED_haxe_io_Bytes
+#include <haxe/io/Bytes.h>
+#endif
+#ifndef INCLUDED_haxe_io_Encoding
+#include <haxe/io/Encoding.h>
+#endif
+#ifndef INCLUDED_haxe_io_Error
+#include <haxe/io/Error.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_dd4549ff8fa56c0b_34_new,"haxe.io.Bytes","new",0x3938d57d,"haxe.io.Bytes.new","/usr/local/lib/haxe/std/haxe/io/Bytes.hx",34,0xd68ef8f0)
+HX_LOCAL_STACK_FRAME(_hx_pos_dd4549ff8fa56c0b_90_blit,"haxe.io.Bytes","blit",0xd098ac78,"haxe.io.Bytes.blit","/usr/local/lib/haxe/std/haxe/io/Bytes.hx",90,0xd68ef8f0)
+HX_LOCAL_STACK_FRAME(_hx_pos_dd4549ff8fa56c0b_144_fill,"haxe.io.Bytes","fill",0xd33b42c6,"haxe.io.Bytes.fill","/usr/local/lib/haxe/std/haxe/io/Bytes.hx",144,0xd68ef8f0)
+HX_LOCAL_STACK_FRAME(_hx_pos_dd4549ff8fa56c0b_155_sub,"haxe.io.Bytes","sub",0x393cae9d,"haxe.io.Bytes.sub","/usr/local/lib/haxe/std/haxe/io/Bytes.hx",155,0xd68ef8f0)
+HX_LOCAL_STACK_FRAME(_hx_pos_dd4549ff8fa56c0b_415_getString,"haxe.io.Bytes","getString",0xa16beae4,"haxe.io.Bytes.getString","/usr/local/lib/haxe/std/haxe/io/Bytes.hx",415,0xd68ef8f0)
+HX_LOCAL_STACK_FRAME(_hx_pos_dd4549ff8fa56c0b_516_toString,"haxe.io.Bytes","toString",0x0291226f,"haxe.io.Bytes.toString","/usr/local/lib/haxe/std/haxe/io/Bytes.hx",516,0xd68ef8f0)
+HX_LOCAL_STACK_FRAME(_hx_pos_dd4549ff8fa56c0b_524_toHex,"haxe.io.Bytes","toHex",0x14173a7d,"haxe.io.Bytes.toHex","/usr/local/lib/haxe/std/haxe/io/Bytes.hx",524,0xd68ef8f0)
+HX_LOCAL_STACK_FRAME(_hx_pos_dd4549ff8fa56c0b_549_alloc,"haxe.io.Bytes","alloc",0x2199ead2,"haxe.io.Bytes.alloc","/usr/local/lib/haxe/std/haxe/io/Bytes.hx",549,0xd68ef8f0)
+HX_LOCAL_STACK_FRAME(_hx_pos_dd4549ff8fa56c0b_580_ofString,"haxe.io.Bytes","ofString",0x6e53bb0b,"haxe.io.Bytes.ofString","/usr/local/lib/haxe/std/haxe/io/Bytes.hx",580,0xd68ef8f0)
+HX_LOCAL_STACK_FRAME(_hx_pos_dd4549ff8fa56c0b_664_ofData,"haxe.io.Bytes","ofData",0x4f3005e4,"haxe.io.Bytes.ofData","/usr/local/lib/haxe/std/haxe/io/Bytes.hx",664,0xd68ef8f0)
+HX_LOCAL_STACK_FRAME(_hx_pos_dd4549ff8fa56c0b_673_ofHex,"haxe.io.Bytes","ofHex",0x2d236861,"haxe.io.Bytes.ofHex","/usr/local/lib/haxe/std/haxe/io/Bytes.hx",673,0xd68ef8f0)
+namespace haxe{
+namespace io{
+
+void Bytes_obj::__construct(int length,::Array< unsigned char > b){
+            	HX_STACKFRAME(&_hx_pos_dd4549ff8fa56c0b_34_new)
+HXLINE(  35)		this->length = length;
+HXLINE(  36)		this->b = b;
+            	}
+
+Dynamic Bytes_obj::__CreateEmpty() { return new Bytes_obj; }
+
+void *Bytes_obj::_hx_vtable = 0;
+
+Dynamic Bytes_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Bytes_obj > _hx_result = new Bytes_obj();
+	_hx_result->__construct(inArgs[0],inArgs[1]);
+	return _hx_result;
+}
+
+bool Bytes_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x195c64b7;
+}
+
+void Bytes_obj::blit(int pos, ::haxe::io::Bytes src,int srcpos,int len){
+            	HX_STACKFRAME(&_hx_pos_dd4549ff8fa56c0b_90_blit)
+HXLINE(  92)		bool _hx_tmp;
+HXDLIN(  92)		bool _hx_tmp1;
+HXDLIN(  92)		bool _hx_tmp2;
+HXDLIN(  92)		bool _hx_tmp3;
+HXDLIN(  92)		if ((pos >= 0)) {
+HXLINE(  92)			_hx_tmp3 = (srcpos < 0);
+            		}
+            		else {
+HXLINE(  92)			_hx_tmp3 = true;
+            		}
+HXDLIN(  92)		if (!(_hx_tmp3)) {
+HXLINE(  92)			_hx_tmp2 = (len < 0);
+            		}
+            		else {
+HXLINE(  92)			_hx_tmp2 = true;
+            		}
+HXDLIN(  92)		if (!(_hx_tmp2)) {
+HXLINE(  92)			_hx_tmp1 = ((pos + len) > this->length);
+            		}
+            		else {
+HXLINE(  92)			_hx_tmp1 = true;
+            		}
+HXDLIN(  92)		if (!(_hx_tmp1)) {
+HXLINE(  92)			_hx_tmp = ((srcpos + len) > src->length);
+            		}
+            		else {
+HXLINE(  92)			_hx_tmp = true;
+            		}
+HXDLIN(  92)		if (_hx_tmp) {
+HXLINE(  93)			HX_STACK_DO_THROW(::haxe::io::Error_obj::OutsideBounds_dyn());
+            		}
+HXLINE( 111)		this->b->blit(pos,src->b,srcpos,len);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC4(Bytes_obj,blit,(void))
+
+void Bytes_obj::fill(int pos,int len,int value){
+            	HX_STACKFRAME(&_hx_pos_dd4549ff8fa56c0b_144_fill)
+HXDLIN( 144)		 ::__hxcpp_memory_memset(this->b,pos,len,value);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC3(Bytes_obj,fill,(void))
+
+ ::haxe::io::Bytes Bytes_obj::sub(int pos,int len){
+            	HX_GC_STACKFRAME(&_hx_pos_dd4549ff8fa56c0b_155_sub)
+HXLINE( 157)		bool _hx_tmp;
+HXDLIN( 157)		bool _hx_tmp1;
+HXDLIN( 157)		if ((pos >= 0)) {
+HXLINE( 157)			_hx_tmp1 = (len < 0);
+            		}
+            		else {
+HXLINE( 157)			_hx_tmp1 = true;
+            		}
+HXDLIN( 157)		if (!(_hx_tmp1)) {
+HXLINE( 157)			_hx_tmp = ((pos + len) > this->length);
+            		}
+            		else {
+HXLINE( 157)			_hx_tmp = true;
+            		}
+HXDLIN( 157)		if (_hx_tmp) {
+HXLINE( 158)			HX_STACK_DO_THROW(::haxe::io::Error_obj::OutsideBounds_dyn());
+            		}
+HXLINE( 178)		return  ::haxe::io::Bytes_obj::__alloc( HX_CTX ,len,this->b->slice(pos,(pos + len)));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(Bytes_obj,sub,return )
+
+::String Bytes_obj::getString(int pos,int len, ::haxe::io::Encoding encoding){
+            	HX_STACKFRAME(&_hx_pos_dd4549ff8fa56c0b_415_getString)
+HXLINE( 416)		bool _hx_tmp = ::hx::IsNull( encoding );
+HXLINE( 419)		bool _hx_tmp1;
+HXDLIN( 419)		bool _hx_tmp2;
+HXDLIN( 419)		if ((pos >= 0)) {
+HXLINE( 419)			_hx_tmp2 = (len < 0);
+            		}
+            		else {
+HXLINE( 419)			_hx_tmp2 = true;
+            		}
+HXDLIN( 419)		if (!(_hx_tmp2)) {
+HXLINE( 419)			_hx_tmp1 = ((pos + len) > this->length);
+            		}
+            		else {
+HXLINE( 419)			_hx_tmp1 = true;
+            		}
+HXDLIN( 419)		if (_hx_tmp1) {
+HXLINE( 420)			HX_STACK_DO_THROW(::haxe::io::Error_obj::OutsideBounds_dyn());
+            		}
+HXLINE( 428)		::String result = HX_("",00,00,00,00);
+HXLINE( 429)		 ::__hxcpp_string_of_bytes(this->b,result,pos,len);
+HXLINE( 430)		return result;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC3(Bytes_obj,getString,return )
+
+::String Bytes_obj::toString(){
+            	HX_STACKFRAME(&_hx_pos_dd4549ff8fa56c0b_516_toString)
+HXDLIN( 516)		return this->getString(0,this->length,null());
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Bytes_obj,toString,return )
+
+::String Bytes_obj::toHex(){
+            	HX_GC_STACKFRAME(&_hx_pos_dd4549ff8fa56c0b_524_toHex)
+HXLINE( 525)		 ::StringBuf s =  ::StringBuf_obj::__alloc( HX_CTX );
+HXLINE( 526)		::Array< ::Dynamic> chars = ::Array_obj< ::Dynamic>::__new(0);
+HXLINE( 527)		::String str = HX_("0123456789abcdef",68,7e,d5,ef);
+HXLINE( 528)		{
+HXLINE( 528)			int _g = 0;
+HXDLIN( 528)			int _g1 = str.length;
+HXDLIN( 528)			while((_g < _g1)){
+HXLINE( 528)				_g = (_g + 1);
+HXDLIN( 528)				int i = (_g - 1);
+HXLINE( 529)				chars->push(str.charCodeAt(i));
+            			}
+            		}
+HXLINE( 530)		{
+HXLINE( 530)			int _g2 = 0;
+HXDLIN( 530)			int _g3 = this->length;
+HXDLIN( 530)			while((_g2 < _g3)){
+HXLINE( 530)				_g2 = (_g2 + 1);
+HXDLIN( 530)				int i1 = (_g2 - 1);
+HXLINE( 531)				int c = ( (int)(this->b->__get(i1)) );
+HXLINE( 532)				{
+HXLINE( 532)					int c1 = ( (int)(chars->__get((c >> 4))) );
+HXDLIN( 532)					if ((c1 >= 127)) {
+HXLINE( 532)						::String x = ::String::fromCharCode(c1);
+HXDLIN( 532)						if (::hx::IsNotNull( s->charBuf )) {
+HXLINE( 532)							s->flush();
+            						}
+HXDLIN( 532)						if (::hx::IsNull( s->b )) {
+HXLINE( 532)							s->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(x));
+            						}
+            						else {
+HXLINE( 532)							::Array< ::String > s1 = s->b;
+HXDLIN( 532)							s1->push(::Std_obj::string(x));
+            						}
+            					}
+            					else {
+HXLINE( 532)						if (::hx::IsNull( s->charBuf )) {
+HXLINE( 532)							s->charBuf = ::Array_obj< char >::__new();
+            						}
+HXDLIN( 532)						s->charBuf->push(c1);
+            					}
+            				}
+HXLINE( 533)				{
+HXLINE( 533)					int c2 = ( (int)(chars->__get((c & 15))) );
+HXDLIN( 533)					if ((c2 >= 127)) {
+HXLINE( 533)						::String x1 = ::String::fromCharCode(c2);
+HXDLIN( 533)						if (::hx::IsNotNull( s->charBuf )) {
+HXLINE( 533)							s->flush();
+            						}
+HXDLIN( 533)						if (::hx::IsNull( s->b )) {
+HXLINE( 533)							s->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(x1));
+            						}
+            						else {
+HXLINE( 533)							::Array< ::String > s2 = s->b;
+HXDLIN( 533)							s2->push(::Std_obj::string(x1));
+            						}
+            					}
+            					else {
+HXLINE( 533)						if (::hx::IsNull( s->charBuf )) {
+HXLINE( 533)							s->charBuf = ::Array_obj< char >::__new();
+            						}
+HXDLIN( 533)						s->charBuf->push(c2);
+            					}
+            				}
+            			}
+            		}
+HXLINE( 535)		return s->toString();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Bytes_obj,toHex,return )
+
+ ::haxe::io::Bytes Bytes_obj::alloc(int length){
+            	HX_GC_STACKFRAME(&_hx_pos_dd4549ff8fa56c0b_549_alloc)
+HXLINE( 557)		::Array< unsigned char > a = ::Array_obj< unsigned char >::__new();
+HXLINE( 558)		if ((length > 0)) {
+HXLINE( 559)			_hx_array_set_size_exact(a,length);
+            		}
+HXLINE( 560)		return  ::haxe::io::Bytes_obj::__alloc( HX_CTX ,length,a);
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Bytes_obj,alloc,return )
+
+ ::haxe::io::Bytes Bytes_obj::ofString(::String s, ::haxe::io::Encoding encoding){
+            	HX_GC_STACKFRAME(&_hx_pos_dd4549ff8fa56c0b_580_ofString)
+HXLINE( 591)		::Array< unsigned char > a = ::Array_obj< unsigned char >::__new();
+HXLINE( 592)		 ::__hxcpp_bytes_of_string(a,s);
+HXLINE( 593)		return  ::haxe::io::Bytes_obj::__alloc( HX_CTX ,a->length,a);
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(Bytes_obj,ofString,return )
+
+ ::haxe::io::Bytes Bytes_obj::ofData(::Array< unsigned char > b){
+            	HX_GC_STACKFRAME(&_hx_pos_dd4549ff8fa56c0b_664_ofData)
+HXDLIN( 664)		return  ::haxe::io::Bytes_obj::__alloc( HX_CTX ,b->length,b);
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Bytes_obj,ofData,return )
+
+ ::haxe::io::Bytes Bytes_obj::ofHex(::String s){
+            	HX_STACKFRAME(&_hx_pos_dd4549ff8fa56c0b_673_ofHex)
+HXLINE( 674)		int len = s.length;
+HXLINE( 675)		if (((len & 1) != 0)) {
+HXLINE( 676)			HX_STACK_DO_THROW(HX_("Not a hex string (odd number of digits)",96,4b,d1,a4));
+            		}
+HXLINE( 677)		 ::haxe::io::Bytes ret = ::haxe::io::Bytes_obj::alloc((len >> 1));
+HXLINE( 678)		{
+HXLINE( 678)			int _g = 0;
+HXDLIN( 678)			int _g1 = ret->length;
+HXDLIN( 678)			while((_g < _g1)){
+HXLINE( 678)				_g = (_g + 1);
+HXDLIN( 678)				int i = (_g - 1);
+HXLINE( 679)				int high = s.cca((i * 2));
+HXLINE( 680)				int low = s.cca(((i * 2) + 1));
+HXLINE( 681)				high = ((high & 15) + (((high & 64) >> 6) * 9));
+HXLINE( 682)				low = ((low & 15) + (((low & 64) >> 6) * 9));
+HXLINE( 683)				ret->b[i] = ( (unsigned char)((((high << 4) | low) & 255)) );
+            			}
+            		}
+HXLINE( 686)		return ret;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Bytes_obj,ofHex,return )
+
+
+::hx::ObjectPtr< Bytes_obj > Bytes_obj::__new(int length,::Array< unsigned char > b) {
+	::hx::ObjectPtr< Bytes_obj > __this = new Bytes_obj();
+	__this->__construct(length,b);
+	return __this;
+}
+
+::hx::ObjectPtr< Bytes_obj > Bytes_obj::__alloc(::hx::Ctx *_hx_ctx,int length,::Array< unsigned char > b) {
+	Bytes_obj *__this = (Bytes_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Bytes_obj), true, "haxe.io.Bytes"));
+	*(void **)__this = Bytes_obj::_hx_vtable;
+	__this->__construct(length,b);
+	return __this;
+}
+
+Bytes_obj::Bytes_obj()
+{
+}
+
+void Bytes_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(Bytes);
+	HX_MARK_MEMBER_NAME(length,"length");
+	HX_MARK_MEMBER_NAME(b,"b");
+	HX_MARK_END_CLASS();
+}
+
+void Bytes_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(length,"length");
+	HX_VISIT_MEMBER_NAME(b,"b");
+}
+
+::hx::Val Bytes_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 1:
+		if (HX_FIELD_EQ(inName,"b") ) { return ::hx::Val( b ); }
+		break;
+	case 3:
+		if (HX_FIELD_EQ(inName,"sub") ) { return ::hx::Val( sub_dyn() ); }
+		break;
+	case 4:
+		if (HX_FIELD_EQ(inName,"blit") ) { return ::hx::Val( blit_dyn() ); }
+		if (HX_FIELD_EQ(inName,"fill") ) { return ::hx::Val( fill_dyn() ); }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"toHex") ) { return ::hx::Val( toHex_dyn() ); }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"length") ) { return ::hx::Val( length ); }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"toString") ) { return ::hx::Val( toString_dyn() ); }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"getString") ) { return ::hx::Val( getString_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+bool Bytes_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 5:
+		if (HX_FIELD_EQ(inName,"alloc") ) { outValue = alloc_dyn(); return true; }
+		if (HX_FIELD_EQ(inName,"ofHex") ) { outValue = ofHex_dyn(); return true; }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"ofData") ) { outValue = ofData_dyn(); return true; }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"ofString") ) { outValue = ofString_dyn(); return true; }
+	}
+	return false;
+}
+
+::hx::Val Bytes_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 1:
+		if (HX_FIELD_EQ(inName,"b") ) { b=inValue.Cast< ::Array< unsigned char > >(); return inValue; }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"length") ) { length=inValue.Cast< int >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void Bytes_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("length",e6,94,07,9f));
+	outFields->push(HX_("b",62,00,00,00));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo Bytes_obj_sMemberStorageInfo[] = {
+	{::hx::fsInt,(int)offsetof(Bytes_obj,length),HX_("length",e6,94,07,9f)},
+	{::hx::fsObject /* ::Array< unsigned char > */ ,(int)offsetof(Bytes_obj,b),HX_("b",62,00,00,00)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *Bytes_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String Bytes_obj_sMemberFields[] = {
+	HX_("length",e6,94,07,9f),
+	HX_("b",62,00,00,00),
+	HX_("blit",35,38,19,41),
+	HX_("fill",83,ce,bb,43),
+	HX_("sub",80,a9,57,00),
+	HX_("getString",07,b2,86,8d),
+	HX_("toString",ac,d0,6e,38),
+	HX_("toHex",20,f4,10,14),
+	::String(null()) };
+
+::hx::Class Bytes_obj::__mClass;
+
+static ::String Bytes_obj_sStaticFields[] = {
+	HX_("alloc",75,a4,93,21),
+	HX_("ofString",48,69,31,a4),
+	HX_("ofData",e1,ba,b8,49),
+	HX_("ofHex",04,22,1d,2d),
+	::String(null())
+};
+
+void Bytes_obj::__register()
+{
+	Bytes_obj _hx_dummy;
+	Bytes_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.io.Bytes",0b,53,6f,9f);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &Bytes_obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(Bytes_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(Bytes_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< Bytes_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Bytes_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Bytes_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace io
diff --git a/Sources/c_snikket/src/haxe/io/BytesBuffer.cpp b/Sources/c_snikket/src/haxe/io/BytesBuffer.cpp
new file mode 100644
index 0000000..aa069a8
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/io/BytesBuffer.cpp
@@ -0,0 +1,142 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_io_Bytes
+#include <haxe/io/Bytes.h>
+#endif
+#ifndef INCLUDED_haxe_io_BytesBuffer
+#include <haxe/io/BytesBuffer.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_20ad791bf00c982a_52_new,"haxe.io.BytesBuffer","new",0x022790dd,"haxe.io.BytesBuffer.new","/usr/local/lib/haxe/std/haxe/io/BytesBuffer.hx",52,0xad7eed50)
+HX_LOCAL_STACK_FRAME(_hx_pos_20ad791bf00c982a_202_getBytes,"haxe.io.BytesBuffer","getBytes",0x1e9f7258,"haxe.io.BytesBuffer.getBytes","/usr/local/lib/haxe/std/haxe/io/BytesBuffer.hx",202,0xad7eed50)
+namespace haxe{
+namespace io{
+
+void BytesBuffer_obj::__construct(){
+            	HX_STACKFRAME(&_hx_pos_20ad791bf00c982a_52_new)
+HXDLIN(  52)		this->b = ::Array_obj< unsigned char >::__new();
+            	}
+
+Dynamic BytesBuffer_obj::__CreateEmpty() { return new BytesBuffer_obj; }
+
+void *BytesBuffer_obj::_hx_vtable = 0;
+
+Dynamic BytesBuffer_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< BytesBuffer_obj > _hx_result = new BytesBuffer_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool BytesBuffer_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x183160df;
+}
+
+ ::haxe::io::Bytes BytesBuffer_obj::getBytes(){
+            	HX_GC_STACKFRAME(&_hx_pos_20ad791bf00c982a_202_getBytes)
+HXLINE( 220)		 ::haxe::io::Bytes bytes =  ::haxe::io::Bytes_obj::__alloc( HX_CTX ,this->b->length,this->b);
+HXLINE( 222)		this->b = null();
+HXLINE( 223)		return bytes;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(BytesBuffer_obj,getBytes,return )
+
+
+::hx::ObjectPtr< BytesBuffer_obj > BytesBuffer_obj::__new() {
+	::hx::ObjectPtr< BytesBuffer_obj > __this = new BytesBuffer_obj();
+	__this->__construct();
+	return __this;
+}
+
+::hx::ObjectPtr< BytesBuffer_obj > BytesBuffer_obj::__alloc(::hx::Ctx *_hx_ctx) {
+	BytesBuffer_obj *__this = (BytesBuffer_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(BytesBuffer_obj), true, "haxe.io.BytesBuffer"));
+	*(void **)__this = BytesBuffer_obj::_hx_vtable;
+	__this->__construct();
+	return __this;
+}
+
+BytesBuffer_obj::BytesBuffer_obj()
+{
+}
+
+void BytesBuffer_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(BytesBuffer);
+	HX_MARK_MEMBER_NAME(b,"b");
+	HX_MARK_END_CLASS();
+}
+
+void BytesBuffer_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(b,"b");
+}
+
+::hx::Val BytesBuffer_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 1:
+		if (HX_FIELD_EQ(inName,"b") ) { return ::hx::Val( b ); }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"getBytes") ) { return ::hx::Val( getBytes_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val BytesBuffer_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 1:
+		if (HX_FIELD_EQ(inName,"b") ) { b=inValue.Cast< ::Array< unsigned char > >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void BytesBuffer_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("b",62,00,00,00));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo BytesBuffer_obj_sMemberStorageInfo[] = {
+	{::hx::fsObject /* ::Array< unsigned char > */ ,(int)offsetof(BytesBuffer_obj,b),HX_("b",62,00,00,00)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *BytesBuffer_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String BytesBuffer_obj_sMemberFields[] = {
+	HX_("b",62,00,00,00),
+	HX_("getBytes",f5,17,6f,1d),
+	::String(null()) };
+
+::hx::Class BytesBuffer_obj::__mClass;
+
+void BytesBuffer_obj::__register()
+{
+	BytesBuffer_obj _hx_dummy;
+	BytesBuffer_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.io.BytesBuffer",6b,de,c4,a0);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(BytesBuffer_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< BytesBuffer_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = BytesBuffer_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = BytesBuffer_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace io
diff --git a/Sources/c_snikket/src/haxe/io/BytesInput.cpp b/Sources/c_snikket/src/haxe/io/BytesInput.cpp
new file mode 100644
index 0000000..629c960
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/io/BytesInput.cpp
@@ -0,0 +1,266 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_io_Bytes
+#include <haxe/io/Bytes.h>
+#endif
+#ifndef INCLUDED_haxe_io_BytesInput
+#include <haxe/io/BytesInput.h>
+#endif
+#ifndef INCLUDED_haxe_io_Eof
+#include <haxe/io/Eof.h>
+#endif
+#ifndef INCLUDED_haxe_io_Error
+#include <haxe/io/Error.h>
+#endif
+#ifndef INCLUDED_haxe_io_Input
+#include <haxe/io/Input.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_3a888173c8ad0c39_39_new,"haxe.io.BytesInput","new",0x7fa18571,"haxe.io.BytesInput.new","/usr/local/lib/haxe/std/haxe/io/BytesInput.hx",39,0x977e71a2)
+HX_LOCAL_STACK_FRAME(_hx_pos_3a888173c8ad0c39_96_readByte,"haxe.io.BytesInput","readByte",0xb70e46cd,"haxe.io.BytesInput.readByte","/usr/local/lib/haxe/std/haxe/io/BytesInput.hx",96,0x977e71a2)
+HX_LOCAL_STACK_FRAME(_hx_pos_3a888173c8ad0c39_119_readBytes,"haxe.io.BytesInput","readBytes",0x756fad06,"haxe.io.BytesInput.readBytes","/usr/local/lib/haxe/std/haxe/io/BytesInput.hx",119,0x977e71a2)
+namespace haxe{
+namespace io{
+
+void BytesInput_obj::__construct( ::haxe::io::Bytes b, ::Dynamic pos, ::Dynamic len){
+            	HX_STACKFRAME(&_hx_pos_3a888173c8ad0c39_39_new)
+HXLINE(  40)		if (::hx::IsNull( pos )) {
+HXLINE(  41)			pos = 0;
+            		}
+HXLINE(  42)		if (::hx::IsNull( len )) {
+HXLINE(  43)			len = (b->length - ( (int)(pos) ));
+            		}
+HXLINE(  44)		bool _hx_tmp;
+HXDLIN(  44)		bool _hx_tmp1;
+HXDLIN(  44)		if (::hx::IsGreaterEq( pos,0 )) {
+HXLINE(  44)			_hx_tmp1 = ::hx::IsLess( len,0 );
+            		}
+            		else {
+HXLINE(  44)			_hx_tmp1 = true;
+            		}
+HXDLIN(  44)		if (!(_hx_tmp1)) {
+HXLINE(  44)			_hx_tmp = ((pos + len) > b->length);
+            		}
+            		else {
+HXLINE(  44)			_hx_tmp = true;
+            		}
+HXDLIN(  44)		if (_hx_tmp) {
+HXLINE(  45)			HX_STACK_DO_THROW(::haxe::io::Error_obj::OutsideBounds_dyn());
+            		}
+HXLINE(  57)		this->b = b->b;
+HXLINE(  58)		this->pos = ( (int)(pos) );
+HXLINE(  59)		this->len = ( (int)(len) );
+HXLINE(  60)		this->totlen = ( (int)(len) );
+            	}
+
+Dynamic BytesInput_obj::__CreateEmpty() { return new BytesInput_obj; }
+
+void *BytesInput_obj::_hx_vtable = 0;
+
+Dynamic BytesInput_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< BytesInput_obj > _hx_result = new BytesInput_obj();
+	_hx_result->__construct(inArgs[0],inArgs[1],inArgs[2]);
+	return _hx_result;
+}
+
+bool BytesInput_obj::_hx_isInstanceOf(int inClassId) {
+	if (inClassId<=(int)0x19e22056) {
+		return inClassId==(int)0x00000001 || inClassId==(int)0x19e22056;
+	} else {
+		return inClassId==(int)0x7e26810b;
+	}
+}
+
+int BytesInput_obj::readByte(){
+            	HX_GC_STACKFRAME(&_hx_pos_3a888173c8ad0c39_96_readByte)
+HXLINE( 100)		if ((this->len == 0)) {
+HXLINE( 101)			HX_STACK_DO_THROW( ::haxe::io::Eof_obj::__alloc( HX_CTX ));
+            		}
+HXLINE( 102)		this->len--;
+HXLINE( 106)		return ( (int)(this->b->__get(this->pos++)) );
+            	}
+
+
+int BytesInput_obj::readBytes( ::haxe::io::Bytes buf,int pos,int len){
+            	HX_GC_STACKFRAME(&_hx_pos_3a888173c8ad0c39_119_readBytes)
+HXLINE( 121)		bool _hx_tmp;
+HXDLIN( 121)		bool _hx_tmp1;
+HXDLIN( 121)		if ((pos >= 0)) {
+HXLINE( 121)			_hx_tmp1 = (len < 0);
+            		}
+            		else {
+HXLINE( 121)			_hx_tmp1 = true;
+            		}
+HXDLIN( 121)		if (!(_hx_tmp1)) {
+HXLINE( 121)			_hx_tmp = ((pos + len) > buf->length);
+            		}
+            		else {
+HXLINE( 121)			_hx_tmp = true;
+            		}
+HXDLIN( 121)		if (_hx_tmp) {
+HXLINE( 122)			HX_STACK_DO_THROW(::haxe::io::Error_obj::OutsideBounds_dyn());
+            		}
+HXLINE( 151)		bool _hx_tmp2;
+HXDLIN( 151)		if ((this->len == 0)) {
+HXLINE( 151)			_hx_tmp2 = (len > 0);
+            		}
+            		else {
+HXLINE( 151)			_hx_tmp2 = false;
+            		}
+HXDLIN( 151)		if (_hx_tmp2) {
+HXLINE( 152)			HX_STACK_DO_THROW( ::haxe::io::Eof_obj::__alloc( HX_CTX ));
+            		}
+HXLINE( 153)		if ((this->len < len)) {
+HXLINE( 154)			len = this->len;
+            		}
+HXLINE( 163)		::Array< unsigned char > b1 = this->b;
+HXLINE( 164)		::Array< unsigned char > b2 = buf->b;
+HXLINE( 165)		{
+HXLINE( 165)			int _g = 0;
+HXDLIN( 165)			int _g1 = len;
+HXDLIN( 165)			while((_g < _g1)){
+HXLINE( 165)				_g = (_g + 1);
+HXDLIN( 165)				int i = (_g - 1);
+HXLINE( 166)				b2[(pos + i)] = b1->__get((this->pos + i));
+            			}
+            		}
+HXLINE( 168)		 ::haxe::io::BytesInput _hx_tmp3 = ::hx::ObjectPtr<OBJ_>(this);
+HXDLIN( 168)		_hx_tmp3->pos = (_hx_tmp3->pos + len);
+HXLINE( 169)		 ::haxe::io::BytesInput _hx_tmp4 = ::hx::ObjectPtr<OBJ_>(this);
+HXDLIN( 169)		_hx_tmp4->len = (_hx_tmp4->len - len);
+HXLINE( 171)		return len;
+            	}
+
+
+
+::hx::ObjectPtr< BytesInput_obj > BytesInput_obj::__new( ::haxe::io::Bytes b, ::Dynamic pos, ::Dynamic len) {
+	::hx::ObjectPtr< BytesInput_obj > __this = new BytesInput_obj();
+	__this->__construct(b,pos,len);
+	return __this;
+}
+
+::hx::ObjectPtr< BytesInput_obj > BytesInput_obj::__alloc(::hx::Ctx *_hx_ctx, ::haxe::io::Bytes b, ::Dynamic pos, ::Dynamic len) {
+	BytesInput_obj *__this = (BytesInput_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(BytesInput_obj), true, "haxe.io.BytesInput"));
+	*(void **)__this = BytesInput_obj::_hx_vtable;
+	__this->__construct(b,pos,len);
+	return __this;
+}
+
+BytesInput_obj::BytesInput_obj()
+{
+}
+
+void BytesInput_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(BytesInput);
+	HX_MARK_MEMBER_NAME(b,"b");
+	HX_MARK_MEMBER_NAME(pos,"pos");
+	HX_MARK_MEMBER_NAME(len,"len");
+	HX_MARK_MEMBER_NAME(totlen,"totlen");
+	HX_MARK_END_CLASS();
+}
+
+void BytesInput_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(b,"b");
+	HX_VISIT_MEMBER_NAME(pos,"pos");
+	HX_VISIT_MEMBER_NAME(len,"len");
+	HX_VISIT_MEMBER_NAME(totlen,"totlen");
+}
+
+::hx::Val BytesInput_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 1:
+		if (HX_FIELD_EQ(inName,"b") ) { return ::hx::Val( b ); }
+		break;
+	case 3:
+		if (HX_FIELD_EQ(inName,"pos") ) { return ::hx::Val( pos ); }
+		if (HX_FIELD_EQ(inName,"len") ) { return ::hx::Val( len ); }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"totlen") ) { return ::hx::Val( totlen ); }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"readByte") ) { return ::hx::Val( readByte_dyn() ); }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"readBytes") ) { return ::hx::Val( readBytes_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val BytesInput_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 1:
+		if (HX_FIELD_EQ(inName,"b") ) { b=inValue.Cast< ::Array< unsigned char > >(); return inValue; }
+		break;
+	case 3:
+		if (HX_FIELD_EQ(inName,"pos") ) { pos=inValue.Cast< int >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"len") ) { len=inValue.Cast< int >(); return inValue; }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"totlen") ) { totlen=inValue.Cast< int >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void BytesInput_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("b",62,00,00,00));
+	outFields->push(HX_("pos",94,5d,55,00));
+	outFields->push(HX_("len",d5,4b,52,00));
+	outFields->push(HX_("totlen",dc,4a,df,97));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo BytesInput_obj_sMemberStorageInfo[] = {
+	{::hx::fsObject /* ::Array< unsigned char > */ ,(int)offsetof(BytesInput_obj,b),HX_("b",62,00,00,00)},
+	{::hx::fsInt,(int)offsetof(BytesInput_obj,pos),HX_("pos",94,5d,55,00)},
+	{::hx::fsInt,(int)offsetof(BytesInput_obj,len),HX_("len",d5,4b,52,00)},
+	{::hx::fsInt,(int)offsetof(BytesInput_obj,totlen),HX_("totlen",dc,4a,df,97)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *BytesInput_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String BytesInput_obj_sMemberFields[] = {
+	HX_("b",62,00,00,00),
+	HX_("pos",94,5d,55,00),
+	HX_("len",d5,4b,52,00),
+	HX_("totlen",dc,4a,df,97),
+	HX_("readByte",7e,f9,1a,69),
+	HX_("readBytes",35,55,7f,8e),
+	::String(null()) };
+
+::hx::Class BytesInput_obj::__mClass;
+
+void BytesInput_obj::__register()
+{
+	BytesInput_obj _hx_dummy;
+	BytesInput_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.io.BytesInput",ff,f8,5b,64);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(BytesInput_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< BytesInput_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = BytesInput_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = BytesInput_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace io
diff --git a/Sources/c_snikket/src/haxe/io/BytesOutput.cpp b/Sources/c_snikket/src/haxe/io/BytesOutput.cpp
new file mode 100644
index 0000000..c48d74b
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/io/BytesOutput.cpp
@@ -0,0 +1,206 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_io_Bytes
+#include <haxe/io/Bytes.h>
+#endif
+#ifndef INCLUDED_haxe_io_BytesBuffer
+#include <haxe/io/BytesBuffer.h>
+#endif
+#ifndef INCLUDED_haxe_io_BytesOutput
+#include <haxe/io/BytesOutput.h>
+#endif
+#ifndef INCLUDED_haxe_io_Error
+#include <haxe/io/Error.h>
+#endif
+#ifndef INCLUDED_haxe_io_Output
+#include <haxe/io/Output.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_d4ef99928b9cced0_40_new,"haxe.io.BytesOutput","new",0x130b775e,"haxe.io.BytesOutput.new","/usr/local/lib/haxe/std/haxe/io/BytesOutput.hx",40,0xe13b11ef)
+HX_LOCAL_STACK_FRAME(_hx_pos_d4ef99928b9cced0_55_writeByte,"haxe.io.BytesOutput","writeByte",0xed1b0d05,"haxe.io.BytesOutput.writeByte","/usr/local/lib/haxe/std/haxe/io/BytesOutput.hx",55,0xe13b11ef)
+HX_LOCAL_STACK_FRAME(_hx_pos_d4ef99928b9cced0_59_writeBytes,"haxe.io.BytesOutput","writeBytes",0x8a9057ce,"haxe.io.BytesOutput.writeBytes","/usr/local/lib/haxe/std/haxe/io/BytesOutput.hx",59,0xe13b11ef)
+HX_LOCAL_STACK_FRAME(_hx_pos_d4ef99928b9cced0_143_getBytes,"haxe.io.BytesOutput","getBytes",0x9fe35837,"haxe.io.BytesOutput.getBytes","/usr/local/lib/haxe/std/haxe/io/BytesOutput.hx",143,0xe13b11ef)
+namespace haxe{
+namespace io{
+
+void BytesOutput_obj::__construct(){
+            	HX_GC_STACKFRAME(&_hx_pos_d4ef99928b9cced0_40_new)
+HXDLIN(  40)		this->b =  ::haxe::io::BytesBuffer_obj::__alloc( HX_CTX );
+            	}
+
+Dynamic BytesOutput_obj::__CreateEmpty() { return new BytesOutput_obj; }
+
+void *BytesOutput_obj::_hx_vtable = 0;
+
+Dynamic BytesOutput_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< BytesOutput_obj > _hx_result = new BytesOutput_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool BytesOutput_obj::_hx_isInstanceOf(int inClassId) {
+	if (inClassId<=(int)0x0a55a26d) {
+		return inClassId==(int)0x00000001 || inClassId==(int)0x0a55a26d;
+	} else {
+		return inClassId==(int)0x541db2e0;
+	}
+}
+
+void BytesOutput_obj::writeByte(int c){
+            	HX_STACKFRAME(&_hx_pos_d4ef99928b9cced0_55_writeByte)
+HXDLIN(  55)		this->b->b->push(c);
+            	}
+
+
+int BytesOutput_obj::writeBytes( ::haxe::io::Bytes buf,int pos,int len){
+            	HX_STACKFRAME(&_hx_pos_d4ef99928b9cced0_59_writeBytes)
+HXLINE(  65)		{
+HXLINE(  65)			 ::haxe::io::BytesBuffer _this = this->b;
+HXDLIN(  65)			bool _hx_tmp;
+HXDLIN(  65)			bool _hx_tmp1;
+HXDLIN(  65)			if ((pos >= 0)) {
+HXLINE(  65)				_hx_tmp1 = (len < 0);
+            			}
+            			else {
+HXLINE(  65)				_hx_tmp1 = true;
+            			}
+HXDLIN(  65)			if (!(_hx_tmp1)) {
+HXLINE(  65)				_hx_tmp = ((pos + len) > buf->length);
+            			}
+            			else {
+HXLINE(  65)				_hx_tmp = true;
+            			}
+HXDLIN(  65)			if (_hx_tmp) {
+HXLINE(  65)				HX_STACK_DO_THROW(::haxe::io::Error_obj::OutsideBounds_dyn());
+            			}
+HXDLIN(  65)			::Array< unsigned char > b1 = _this->b;
+HXDLIN(  65)			::Array< unsigned char > b2 = buf->b;
+HXDLIN(  65)			{
+HXLINE(  65)				int _g = pos;
+HXDLIN(  65)				int _g1 = (pos + len);
+HXDLIN(  65)				while((_g < _g1)){
+HXLINE(  65)					_g = (_g + 1);
+HXDLIN(  65)					int i = (_g - 1);
+HXDLIN(  65)					_this->b->push(b2->__get(i));
+            				}
+            			}
+            		}
+HXLINE(  67)		return len;
+            	}
+
+
+ ::haxe::io::Bytes BytesOutput_obj::getBytes(){
+            	HX_STACKFRAME(&_hx_pos_d4ef99928b9cced0_143_getBytes)
+HXDLIN( 143)		return this->b->getBytes();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(BytesOutput_obj,getBytes,return )
+
+
+::hx::ObjectPtr< BytesOutput_obj > BytesOutput_obj::__new() {
+	::hx::ObjectPtr< BytesOutput_obj > __this = new BytesOutput_obj();
+	__this->__construct();
+	return __this;
+}
+
+::hx::ObjectPtr< BytesOutput_obj > BytesOutput_obj::__alloc(::hx::Ctx *_hx_ctx) {
+	BytesOutput_obj *__this = (BytesOutput_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(BytesOutput_obj), true, "haxe.io.BytesOutput"));
+	*(void **)__this = BytesOutput_obj::_hx_vtable;
+	__this->__construct();
+	return __this;
+}
+
+BytesOutput_obj::BytesOutput_obj()
+{
+}
+
+void BytesOutput_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(BytesOutput);
+	HX_MARK_MEMBER_NAME(b,"b");
+	HX_MARK_END_CLASS();
+}
+
+void BytesOutput_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(b,"b");
+}
+
+::hx::Val BytesOutput_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 1:
+		if (HX_FIELD_EQ(inName,"b") ) { return ::hx::Val( b ); }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"getBytes") ) { return ::hx::Val( getBytes_dyn() ); }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"writeByte") ) { return ::hx::Val( writeByte_dyn() ); }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"writeBytes") ) { return ::hx::Val( writeBytes_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val BytesOutput_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 1:
+		if (HX_FIELD_EQ(inName,"b") ) { b=inValue.Cast<  ::haxe::io::BytesBuffer >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void BytesOutput_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("b",62,00,00,00));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo BytesOutput_obj_sMemberStorageInfo[] = {
+	{::hx::fsObject /*  ::haxe::io::BytesBuffer */ ,(int)offsetof(BytesOutput_obj,b),HX_("b",62,00,00,00)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *BytesOutput_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String BytesOutput_obj_sMemberFields[] = {
+	HX_("b",62,00,00,00),
+	HX_("writeByte",87,13,d7,49),
+	HX_("writeBytes",0c,03,5a,52),
+	HX_("getBytes",f5,17,6f,1d),
+	::String(null()) };
+
+::hx::Class BytesOutput_obj::__mClass;
+
+void BytesOutput_obj::__register()
+{
+	BytesOutput_obj _hx_dummy;
+	BytesOutput_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.io.BytesOutput",6c,30,b1,dc);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(BytesOutput_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< BytesOutput_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = BytesOutput_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = BytesOutput_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace io
diff --git a/Sources/c_snikket/src/haxe/io/Encoding.cpp b/Sources/c_snikket/src/haxe/io/Encoding.cpp
new file mode 100644
index 0000000..15e0ea8
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/io/Encoding.cpp
@@ -0,0 +1,78 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_io_Encoding
+#include <haxe/io/Encoding.h>
+#endif
+namespace haxe{
+namespace io{
+
+::haxe::io::Encoding Encoding_obj::RawNative;
+
+::haxe::io::Encoding Encoding_obj::UTF8;
+
+bool Encoding_obj::__GetStatic(const ::String &inName, ::Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	if (inName==HX_("RawNative",7f,51,9c,e8)) { outValue = Encoding_obj::RawNative; return true; }
+	if (inName==HX_("UTF8",51,1d,6f,38)) { outValue = Encoding_obj::UTF8; return true; }
+	return super::__GetStatic(inName, outValue, inCallProp);
+}
+
+HX_DEFINE_CREATE_ENUM(Encoding_obj)
+
+int Encoding_obj::__FindIndex(::String inName)
+{
+	if (inName==HX_("RawNative",7f,51,9c,e8)) return 1;
+	if (inName==HX_("UTF8",51,1d,6f,38)) return 0;
+	return super::__FindIndex(inName);
+}
+
+int Encoding_obj::__FindArgCount(::String inName)
+{
+	if (inName==HX_("RawNative",7f,51,9c,e8)) return 0;
+	if (inName==HX_("UTF8",51,1d,6f,38)) return 0;
+	return super::__FindArgCount(inName);
+}
+
+::hx::Val Encoding_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	if (inName==HX_("RawNative",7f,51,9c,e8)) return RawNative;
+	if (inName==HX_("UTF8",51,1d,6f,38)) return UTF8;
+	return super::__Field(inName,inCallProp);
+}
+
+static ::String Encoding_obj_sStaticFields[] = {
+	HX_("UTF8",51,1d,6f,38),
+	HX_("RawNative",7f,51,9c,e8),
+	::String(null())
+};
+
+::hx::Class Encoding_obj::__mClass;
+
+Dynamic __Create_Encoding_obj() { return new Encoding_obj; }
+
+void Encoding_obj::__register()
+{
+
+::hx::Static(__mClass) = ::hx::_hx_RegisterClass(HX_("haxe.io.Encoding",33,a6,6d,22), ::hx::TCanCast< Encoding_obj >,Encoding_obj_sStaticFields,0,
+	&__Create_Encoding_obj, &__Create,
+	&super::__SGetClass(), &CreateEncoding_obj, 0
+#ifdef HXCPP_VISIT_ALLOCS
+    , 0
+#endif
+#ifdef HXCPP_SCRIPTABLE
+    , 0
+#endif
+);
+	__mClass->mGetStaticField = &Encoding_obj::__GetStatic;
+}
+
+void Encoding_obj::__boot()
+{
+RawNative = ::hx::CreateConstEnum< Encoding_obj >(HX_("RawNative",7f,51,9c,e8),1);
+UTF8 = ::hx::CreateConstEnum< Encoding_obj >(HX_("UTF8",51,1d,6f,38),0);
+}
+
+
+} // end namespace haxe
+} // end namespace io
diff --git a/Sources/c_snikket/src/haxe/io/Eof.cpp b/Sources/c_snikket/src/haxe/io/Eof.cpp
new file mode 100644
index 0000000..0c1f1f5
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/io/Eof.cpp
@@ -0,0 +1,89 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_io_Eof
+#include <haxe/io/Eof.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_c4f7e3feda612c90_29_new,"haxe.io.Eof","new",0x2166e64e,"haxe.io.Eof.new","/usr/local/lib/haxe/std/haxe/io/Eof.hx",29,0x6ea6ebff)
+HX_LOCAL_STACK_FRAME(_hx_pos_c4f7e3feda612c90_33_toString,"haxe.io.Eof","toString",0xf9ff7bfe,"haxe.io.Eof.toString","/usr/local/lib/haxe/std/haxe/io/Eof.hx",33,0x6ea6ebff)
+namespace haxe{
+namespace io{
+
+void Eof_obj::__construct(){
+            	HX_STACKFRAME(&_hx_pos_c4f7e3feda612c90_29_new)
+            	}
+
+Dynamic Eof_obj::__CreateEmpty() { return new Eof_obj; }
+
+void *Eof_obj::_hx_vtable = 0;
+
+Dynamic Eof_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Eof_obj > _hx_result = new Eof_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool Eof_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x1d7955d0;
+}
+
+::String Eof_obj::toString(){
+            	HX_STACKFRAME(&_hx_pos_c4f7e3feda612c90_33_toString)
+HXDLIN(  33)		return HX_("Eof",9c,bc,34,00);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Eof_obj,toString,return )
+
+
+Eof_obj::Eof_obj()
+{
+}
+
+::hx::Val Eof_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 8:
+		if (HX_FIELD_EQ(inName,"toString") ) { return ::hx::Val( toString_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *Eof_obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo *Eof_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String Eof_obj_sMemberFields[] = {
+	HX_("toString",ac,d0,6e,38),
+	::String(null()) };
+
+::hx::Class Eof_obj::__mClass;
+
+void Eof_obj::__register()
+{
+	Eof_obj _hx_dummy;
+	Eof_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.io.Eof",5c,67,0e,25);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(Eof_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< Eof_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Eof_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Eof_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace io
diff --git a/Sources/c_snikket/src/haxe/io/Error.cpp b/Sources/c_snikket/src/haxe/io/Error.cpp
new file mode 100644
index 0000000..be96d93
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/io/Error.cpp
@@ -0,0 +1,98 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_io_Error
+#include <haxe/io/Error.h>
+#endif
+namespace haxe{
+namespace io{
+
+::haxe::io::Error Error_obj::Blocked;
+
+::haxe::io::Error Error_obj::Custom( ::Dynamic e)
+{
+	return ::hx::CreateEnum< Error_obj >(HX_("Custom",d1,fb,26,74),3,1)->_hx_init(0,e);
+}
+
+::haxe::io::Error Error_obj::OutsideBounds;
+
+::haxe::io::Error Error_obj::Overflow;
+
+bool Error_obj::__GetStatic(const ::String &inName, ::Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	if (inName==HX_("Blocked",cc,a2,4f,12)) { outValue = Error_obj::Blocked; return true; }
+	if (inName==HX_("Custom",d1,fb,26,74)) { outValue = Error_obj::Custom_dyn(); return true; }
+	if (inName==HX_("OutsideBounds",5a,c1,82,38)) { outValue = Error_obj::OutsideBounds; return true; }
+	if (inName==HX_("Overflow",62,9f,ed,1a)) { outValue = Error_obj::Overflow; return true; }
+	return super::__GetStatic(inName, outValue, inCallProp);
+}
+
+HX_DEFINE_CREATE_ENUM(Error_obj)
+
+int Error_obj::__FindIndex(::String inName)
+{
+	if (inName==HX_("Blocked",cc,a2,4f,12)) return 0;
+	if (inName==HX_("Custom",d1,fb,26,74)) return 3;
+	if (inName==HX_("OutsideBounds",5a,c1,82,38)) return 2;
+	if (inName==HX_("Overflow",62,9f,ed,1a)) return 1;
+	return super::__FindIndex(inName);
+}
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Error_obj,Custom,return)
+
+int Error_obj::__FindArgCount(::String inName)
+{
+	if (inName==HX_("Blocked",cc,a2,4f,12)) return 0;
+	if (inName==HX_("Custom",d1,fb,26,74)) return 1;
+	if (inName==HX_("OutsideBounds",5a,c1,82,38)) return 0;
+	if (inName==HX_("Overflow",62,9f,ed,1a)) return 0;
+	return super::__FindArgCount(inName);
+}
+
+::hx::Val Error_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	if (inName==HX_("Blocked",cc,a2,4f,12)) return Blocked;
+	if (inName==HX_("Custom",d1,fb,26,74)) return Custom_dyn();
+	if (inName==HX_("OutsideBounds",5a,c1,82,38)) return OutsideBounds;
+	if (inName==HX_("Overflow",62,9f,ed,1a)) return Overflow;
+	return super::__Field(inName,inCallProp);
+}
+
+static ::String Error_obj_sStaticFields[] = {
+	HX_("Blocked",cc,a2,4f,12),
+	HX_("Overflow",62,9f,ed,1a),
+	HX_("OutsideBounds",5a,c1,82,38),
+	HX_("Custom",d1,fb,26,74),
+	::String(null())
+};
+
+::hx::Class Error_obj::__mClass;
+
+Dynamic __Create_Error_obj() { return new Error_obj; }
+
+void Error_obj::__register()
+{
+
+::hx::Static(__mClass) = ::hx::_hx_RegisterClass(HX_("haxe.io.Error",68,16,01,55), ::hx::TCanCast< Error_obj >,Error_obj_sStaticFields,0,
+	&__Create_Error_obj, &__Create,
+	&super::__SGetClass(), &CreateError_obj, 0
+#ifdef HXCPP_VISIT_ALLOCS
+    , 0
+#endif
+#ifdef HXCPP_SCRIPTABLE
+    , 0
+#endif
+);
+	__mClass->mGetStaticField = &Error_obj::__GetStatic;
+}
+
+void Error_obj::__boot()
+{
+Blocked = ::hx::CreateConstEnum< Error_obj >(HX_("Blocked",cc,a2,4f,12),0);
+OutsideBounds = ::hx::CreateConstEnum< Error_obj >(HX_("OutsideBounds",5a,c1,82,38),2);
+Overflow = ::hx::CreateConstEnum< Error_obj >(HX_("Overflow",62,9f,ed,1a),1);
+}
+
+
+} // end namespace haxe
+} // end namespace io
diff --git a/Sources/c_snikket/src/haxe/io/Input.cpp b/Sources/c_snikket/src/haxe/io/Input.cpp
new file mode 100644
index 0000000..ad91507
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/io/Input.cpp
@@ -0,0 +1,309 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Std
+#include <Std.h>
+#endif
+#ifndef INCLUDED_haxe_Exception
+#include <haxe/Exception.h>
+#endif
+#ifndef INCLUDED_haxe_ValueException
+#include <haxe/ValueException.h>
+#endif
+#ifndef INCLUDED_haxe_exceptions_NotImplementedException
+#include <haxe/exceptions/NotImplementedException.h>
+#endif
+#ifndef INCLUDED_haxe_exceptions_PosException
+#include <haxe/exceptions/PosException.h>
+#endif
+#ifndef INCLUDED_haxe_io_Bytes
+#include <haxe/io/Bytes.h>
+#endif
+#ifndef INCLUDED_haxe_io_BytesBuffer
+#include <haxe/io/BytesBuffer.h>
+#endif
+#ifndef INCLUDED_haxe_io_Eof
+#include <haxe/io/Eof.h>
+#endif
+#ifndef INCLUDED_haxe_io_Error
+#include <haxe/io/Error.h>
+#endif
+#ifndef INCLUDED_haxe_io_Input
+#include <haxe/io/Input.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_220702dcc8429dc4_51_readByte,"haxe.io.Input","readByte",0x4de8a3c2,"haxe.io.Input.readByte","/usr/local/lib/haxe/std/haxe/io/Input.hx",51,0x3b290ab1)
+HX_LOCAL_STACK_FRAME(_hx_pos_220702dcc8429dc4_64_readBytes,"haxe.io.Input","readBytes",0xdda6a671,"haxe.io.Input.readBytes","/usr/local/lib/haxe/std/haxe/io/Input.hx",64,0x3b290ab1)
+HX_LOCAL_STACK_FRAME(_hx_pos_220702dcc8429dc4_92_close,"haxe.io.Input","close",0xfc421af4,"haxe.io.Input.close","/usr/local/lib/haxe/std/haxe/io/Input.hx",92,0x3b290ab1)
+HX_LOCAL_STACK_FRAME(_hx_pos_220702dcc8429dc4_94_set_bigEndian,"haxe.io.Input","set_bigEndian",0x96732a9a,"haxe.io.Input.set_bigEndian","/usr/local/lib/haxe/std/haxe/io/Input.hx",94,0x3b290ab1)
+HX_LOCAL_STACK_FRAME(_hx_pos_220702dcc8429dc4_106_readAll,"haxe.io.Input","readAll",0xaed6e9a7,"haxe.io.Input.readAll","/usr/local/lib/haxe/std/haxe/io/Input.hx",106,0x3b290ab1)
+HX_LOCAL_STACK_FRAME(_hx_pos_220702dcc8429dc4_281_readInt32,"haxe.io.Input","readInt32",0xde2f3154,"haxe.io.Input.readInt32","/usr/local/lib/haxe/std/haxe/io/Input.hx",281,0x3b290ab1)
+namespace haxe{
+namespace io{
+
+void Input_obj::__construct() { }
+
+Dynamic Input_obj::__CreateEmpty() { return new Input_obj; }
+
+void *Input_obj::_hx_vtable = 0;
+
+Dynamic Input_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Input_obj > _hx_result = new Input_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool Input_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x19e22056;
+}
+
+int Input_obj::readByte(){
+            	HX_GC_STACKFRAME(&_hx_pos_220702dcc8429dc4_51_readByte)
+HXDLIN(  51)		HX_STACK_DO_THROW( ::haxe::exceptions::NotImplementedException_obj::__alloc( HX_CTX ,null(),null(),::hx::SourceInfo(HX_("haxe/io/Input.hx",f4,10,5a,cd),51,HX_("haxe.io.Input",aa,0e,f5,9f),HX_("readByte",7e,f9,1a,69))));
+HXDLIN(  51)		return 0;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Input_obj,readByte,return )
+
+int Input_obj::readBytes( ::haxe::io::Bytes s,int pos,int len){
+            	HX_STACKFRAME(&_hx_pos_220702dcc8429dc4_64_readBytes)
+HXLINE(  65)		int k = len;
+HXLINE(  66)		::Array< unsigned char > b = s->b;
+HXLINE(  67)		bool _hx_tmp;
+HXDLIN(  67)		bool _hx_tmp1;
+HXDLIN(  67)		if ((pos >= 0)) {
+HXLINE(  67)			_hx_tmp1 = (len < 0);
+            		}
+            		else {
+HXLINE(  67)			_hx_tmp1 = true;
+            		}
+HXDLIN(  67)		if (!(_hx_tmp1)) {
+HXLINE(  67)			_hx_tmp = ((pos + len) > s->length);
+            		}
+            		else {
+HXLINE(  67)			_hx_tmp = true;
+            		}
+HXDLIN(  67)		if (_hx_tmp) {
+HXLINE(  68)			HX_STACK_DO_THROW(::haxe::io::Error_obj::OutsideBounds_dyn());
+            		}
+HXLINE(  69)		try {
+            			HX_STACK_CATCHABLE( ::haxe::io::Eof, 0);
+            			HX_STACK_CATCHABLE( ::haxe::ValueException, 1);
+HXLINE(  70)			while((k > 0)){
+HXLINE(  76)				b[pos] = ( (unsigned char)(this->readByte()) );
+HXLINE(  80)				pos = (pos + 1);
+HXLINE(  81)				k = (k - 1);
+            			}
+            		} catch( ::Dynamic _hx_e) {
+            			if (_hx_e.IsClass<  ::haxe::io::Eof >() ){
+            				HX_STACK_BEGIN_CATCH
+            				 ::haxe::io::Eof eof = _hx_e;
+            			}
+            			else if (_hx_e.IsClass<  ::haxe::ValueException >() ){
+            				HX_STACK_BEGIN_CATCH
+            				 ::haxe::ValueException _g = _hx_e;
+HXLINE(  83)				{
+HXLINE(  83)					null();
+            				}
+HXLINE(  69)				if (!(::Std_obj::isOfType(_g->value,::hx::ClassOf< ::haxe::io::Eof >()))) {
+HXLINE(  69)					HX_STACK_DO_THROW(_g);
+            				}
+            			}
+            			else {
+            				HX_STACK_DO_THROW(_hx_e);
+            			}
+            		}
+HXLINE(  84)		return (len - k);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC3(Input_obj,readBytes,return )
+
+void Input_obj::close(){
+            	HX_STACKFRAME(&_hx_pos_220702dcc8429dc4_92_close)
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Input_obj,close,(void))
+
+bool Input_obj::set_bigEndian(bool b){
+            	HX_STACKFRAME(&_hx_pos_220702dcc8429dc4_94_set_bigEndian)
+HXLINE(  95)		this->bigEndian = b;
+HXLINE(  96)		return b;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Input_obj,set_bigEndian,return )
+
+ ::haxe::io::Bytes Input_obj::readAll( ::Dynamic bufsize){
+            	HX_GC_STACKFRAME(&_hx_pos_220702dcc8429dc4_106_readAll)
+HXLINE( 107)		if (::hx::IsNull( bufsize )) {
+HXLINE( 111)			bufsize = 16384;
+            		}
+HXLINE( 114)		 ::haxe::io::Bytes buf = ::haxe::io::Bytes_obj::alloc(( (int)(bufsize) ));
+HXLINE( 115)		 ::haxe::io::BytesBuffer total =  ::haxe::io::BytesBuffer_obj::__alloc( HX_CTX );
+HXLINE( 116)		try {
+            			HX_STACK_CATCHABLE( ::haxe::io::Eof, 0);
+            			HX_STACK_CATCHABLE( ::haxe::ValueException, 1);
+HXLINE( 117)			while(true){
+HXLINE( 118)				int len = this->readBytes(buf,0,( (int)(bufsize) ));
+HXLINE( 119)				if ((len == 0)) {
+HXLINE( 120)					HX_STACK_DO_THROW(::haxe::io::Error_obj::Blocked_dyn());
+            				}
+HXLINE( 121)				{
+HXLINE( 121)					bool _hx_tmp;
+HXDLIN( 121)					if ((len >= 0)) {
+HXLINE( 121)						_hx_tmp = (len > buf->length);
+            					}
+            					else {
+HXLINE( 121)						_hx_tmp = true;
+            					}
+HXDLIN( 121)					if (_hx_tmp) {
+HXLINE( 121)						HX_STACK_DO_THROW(::haxe::io::Error_obj::OutsideBounds_dyn());
+            					}
+HXDLIN( 121)					::Array< unsigned char > b1 = total->b;
+HXDLIN( 121)					::Array< unsigned char > b2 = buf->b;
+HXDLIN( 121)					{
+HXLINE( 121)						int _g = 0;
+HXDLIN( 121)						int _g1 = len;
+HXDLIN( 121)						while((_g < _g1)){
+HXLINE( 121)							_g = (_g + 1);
+HXDLIN( 121)							int i = (_g - 1);
+HXDLIN( 121)							total->b->push(b2->__get(i));
+            						}
+            					}
+            				}
+            			}
+            		} catch( ::Dynamic _hx_e) {
+            			if (_hx_e.IsClass<  ::haxe::io::Eof >() ){
+            				HX_STACK_BEGIN_CATCH
+            				 ::haxe::io::Eof e = _hx_e;
+            			}
+            			else if (_hx_e.IsClass<  ::haxe::ValueException >() ){
+            				HX_STACK_BEGIN_CATCH
+            				 ::haxe::ValueException _g2 = _hx_e;
+HXLINE( 123)				{
+HXLINE( 123)					null();
+            				}
+HXLINE( 116)				if (!(::Std_obj::isOfType(_g2->value,::hx::ClassOf< ::haxe::io::Eof >()))) {
+HXLINE( 116)					HX_STACK_DO_THROW(_g2);
+            				}
+            			}
+            			else {
+            				HX_STACK_DO_THROW(_hx_e);
+            			}
+            		}
+HXLINE( 124)		return total->getBytes();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Input_obj,readAll,return )
+
+int Input_obj::readInt32(){
+            	HX_STACKFRAME(&_hx_pos_220702dcc8429dc4_281_readInt32)
+HXLINE( 282)		int ch1 = this->readByte();
+HXLINE( 283)		int ch2 = this->readByte();
+HXLINE( 284)		int ch3 = this->readByte();
+HXLINE( 285)		int ch4 = this->readByte();
+HXLINE( 297)		if (this->bigEndian) {
+HXLINE( 297)			return (((ch4 | (ch3 << 8)) | (ch2 << 16)) | (ch1 << 24));
+            		}
+            		else {
+HXLINE( 297)			return (((ch1 | (ch2 << 8)) | (ch3 << 16)) | (ch4 << 24));
+            		}
+HXDLIN( 297)		return 0;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Input_obj,readInt32,return )
+
+
+Input_obj::Input_obj()
+{
+}
+
+::hx::Val Input_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 5:
+		if (HX_FIELD_EQ(inName,"close") ) { return ::hx::Val( close_dyn() ); }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"readAll") ) { return ::hx::Val( readAll_dyn() ); }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"readByte") ) { return ::hx::Val( readByte_dyn() ); }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"bigEndian") ) { return ::hx::Val( bigEndian ); }
+		if (HX_FIELD_EQ(inName,"readBytes") ) { return ::hx::Val( readBytes_dyn() ); }
+		if (HX_FIELD_EQ(inName,"readInt32") ) { return ::hx::Val( readInt32_dyn() ); }
+		break;
+	case 13:
+		if (HX_FIELD_EQ(inName,"set_bigEndian") ) { return ::hx::Val( set_bigEndian_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val Input_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 9:
+		if (HX_FIELD_EQ(inName,"bigEndian") ) { if (inCallProp == ::hx::paccAlways) return ::hx::Val( set_bigEndian(inValue.Cast< bool >()) );bigEndian=inValue.Cast< bool >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void Input_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("bigEndian",7b,d5,5a,20));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo Input_obj_sMemberStorageInfo[] = {
+	{::hx::fsBool,(int)offsetof(Input_obj,bigEndian),HX_("bigEndian",7b,d5,5a,20)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *Input_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String Input_obj_sMemberFields[] = {
+	HX_("bigEndian",7b,d5,5a,20),
+	HX_("readByte",7e,f9,1a,69),
+	HX_("readBytes",35,55,7f,8e),
+	HX_("close",b8,17,63,48),
+	HX_("set_bigEndian",5e,8b,c4,26),
+	HX_("readAll",6b,9f,c3,02),
+	HX_("readInt32",18,e0,07,8f),
+	::String(null()) };
+
+::hx::Class Input_obj::__mClass;
+
+void Input_obj::__register()
+{
+	Input_obj _hx_dummy;
+	Input_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.io.Input",aa,0e,f5,9f);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(Input_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< Input_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Input_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Input_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace io
diff --git a/Sources/c_snikket/src/haxe/io/Output.cpp b/Sources/c_snikket/src/haxe/io/Output.cpp
new file mode 100644
index 0000000..e676bd4
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/io/Output.cpp
@@ -0,0 +1,216 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_Exception
+#include <haxe/Exception.h>
+#endif
+#ifndef INCLUDED_haxe_exceptions_NotImplementedException
+#include <haxe/exceptions/NotImplementedException.h>
+#endif
+#ifndef INCLUDED_haxe_exceptions_PosException
+#include <haxe/exceptions/PosException.h>
+#endif
+#ifndef INCLUDED_haxe_io_Bytes
+#include <haxe/io/Bytes.h>
+#endif
+#ifndef INCLUDED_haxe_io_Encoding
+#include <haxe/io/Encoding.h>
+#endif
+#ifndef INCLUDED_haxe_io_Error
+#include <haxe/io/Error.h>
+#endif
+#ifndef INCLUDED_haxe_io_Output
+#include <haxe/io/Output.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_0e34c0ce46c21137_47_writeByte,"haxe.io.Output","writeByte",0xb4fe513a,"haxe.io.Output.writeByte","/usr/local/lib/haxe/std/haxe/io/Output.hx",47,0x72d66600)
+HX_LOCAL_STACK_FRAME(_hx_pos_0e34c0ce46c21137_57_writeBytes,"haxe.io.Output","writeBytes",0xa988c1f9,"haxe.io.Output.writeBytes","/usr/local/lib/haxe/std/haxe/io/Output.hx",57,0x72d66600)
+HX_LOCAL_STACK_FRAME(_hx_pos_0e34c0ce46c21137_92_close,"haxe.io.Output","close",0xe726bfeb,"haxe.io.Output.close","/usr/local/lib/haxe/std/haxe/io/Output.hx",92,0x72d66600)
+HX_LOCAL_STACK_FRAME(_hx_pos_0e34c0ce46c21137_103_write,"haxe.io.Output","write",0x6f1d1512,"haxe.io.Output.write","/usr/local/lib/haxe/std/haxe/io/Output.hx",103,0x72d66600)
+HX_LOCAL_STACK_FRAME(_hx_pos_0e34c0ce46c21137_121_writeFullBytes,"haxe.io.Output","writeFullBytes",0xc2c420ea,"haxe.io.Output.writeFullBytes","/usr/local/lib/haxe/std/haxe/io/Output.hx",121,0x72d66600)
+HX_LOCAL_STACK_FRAME(_hx_pos_0e34c0ce46c21137_246_prepare,"haxe.io.Output","prepare",0xcd01ec7a,"haxe.io.Output.prepare","/usr/local/lib/haxe/std/haxe/io/Output.hx",246,0x72d66600)
+HX_LOCAL_STACK_FRAME(_hx_pos_0e34c0ce46c21137_278_writeString,"haxe.io.Output","writeString",0x97e1cb83,"haxe.io.Output.writeString","/usr/local/lib/haxe/std/haxe/io/Output.hx",278,0x72d66600)
+namespace haxe{
+namespace io{
+
+void Output_obj::__construct() { }
+
+Dynamic Output_obj::__CreateEmpty() { return new Output_obj; }
+
+void *Output_obj::_hx_vtable = 0;
+
+Dynamic Output_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Output_obj > _hx_result = new Output_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool Output_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x0a55a26d;
+}
+
+void Output_obj::writeByte(int c){
+            	HX_GC_STACKFRAME(&_hx_pos_0e34c0ce46c21137_47_writeByte)
+HXDLIN(  47)		HX_STACK_DO_THROW( ::haxe::exceptions::NotImplementedException_obj::__alloc( HX_CTX ,null(),null(),::hx::SourceInfo(HX_("haxe/io/Output.hx",5d,da,8a,cb),47,HX_("haxe.io.Output",61,10,0b,c7),HX_("writeByte",87,13,d7,49))));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Output_obj,writeByte,(void))
+
+int Output_obj::writeBytes( ::haxe::io::Bytes s,int pos,int len){
+            	HX_STACKFRAME(&_hx_pos_0e34c0ce46c21137_57_writeBytes)
+HXLINE(  59)		bool _hx_tmp;
+HXDLIN(  59)		bool _hx_tmp1;
+HXDLIN(  59)		if ((pos >= 0)) {
+HXLINE(  59)			_hx_tmp1 = (len < 0);
+            		}
+            		else {
+HXLINE(  59)			_hx_tmp1 = true;
+            		}
+HXDLIN(  59)		if (!(_hx_tmp1)) {
+HXLINE(  59)			_hx_tmp = ((pos + len) > s->length);
+            		}
+            		else {
+HXLINE(  59)			_hx_tmp = true;
+            		}
+HXDLIN(  59)		if (_hx_tmp) {
+HXLINE(  60)			HX_STACK_DO_THROW(::haxe::io::Error_obj::OutsideBounds_dyn());
+            		}
+HXLINE(  62)		::Array< unsigned char > b = s->b;
+HXLINE(  63)		int k = len;
+HXLINE(  64)		while((k > 0)){
+HXLINE(  70)			this->writeByte(( (int)(b->__get(pos)) ));
+HXLINE(  76)			pos = (pos + 1);
+HXLINE(  77)			k = (k - 1);
+            		}
+HXLINE(  79)		return len;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC3(Output_obj,writeBytes,return )
+
+void Output_obj::close(){
+            	HX_STACKFRAME(&_hx_pos_0e34c0ce46c21137_92_close)
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Output_obj,close,(void))
+
+void Output_obj::write( ::haxe::io::Bytes s){
+            	HX_STACKFRAME(&_hx_pos_0e34c0ce46c21137_103_write)
+HXLINE( 104)		int l = s->length;
+HXLINE( 105)		int p = 0;
+HXLINE( 106)		while((l > 0)){
+HXLINE( 107)			int k = this->writeBytes(s,p,l);
+HXLINE( 108)			if ((k == 0)) {
+HXLINE( 109)				HX_STACK_DO_THROW(::haxe::io::Error_obj::Blocked_dyn());
+            			}
+HXLINE( 110)			p = (p + k);
+HXLINE( 111)			l = (l - k);
+            		}
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Output_obj,write,(void))
+
+void Output_obj::writeFullBytes( ::haxe::io::Bytes s,int pos,int len){
+            	HX_STACKFRAME(&_hx_pos_0e34c0ce46c21137_121_writeFullBytes)
+HXDLIN( 121)		while((len > 0)){
+HXLINE( 122)			int k = this->writeBytes(s,pos,len);
+HXLINE( 123)			pos = (pos + k);
+HXLINE( 124)			len = (len - k);
+            		}
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC3(Output_obj,writeFullBytes,(void))
+
+void Output_obj::prepare(int nbytes){
+            	HX_STACKFRAME(&_hx_pos_0e34c0ce46c21137_246_prepare)
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Output_obj,prepare,(void))
+
+void Output_obj::writeString(::String s, ::haxe::io::Encoding encoding){
+            	HX_STACKFRAME(&_hx_pos_0e34c0ce46c21137_278_writeString)
+HXLINE( 282)		 ::haxe::io::Bytes b = ::haxe::io::Bytes_obj::ofString(s,encoding);
+HXLINE( 284)		this->writeFullBytes(b,0,b->length);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(Output_obj,writeString,(void))
+
+
+Output_obj::Output_obj()
+{
+}
+
+::hx::Val Output_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 5:
+		if (HX_FIELD_EQ(inName,"close") ) { return ::hx::Val( close_dyn() ); }
+		if (HX_FIELD_EQ(inName,"write") ) { return ::hx::Val( write_dyn() ); }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"prepare") ) { return ::hx::Val( prepare_dyn() ); }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"writeByte") ) { return ::hx::Val( writeByte_dyn() ); }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"writeBytes") ) { return ::hx::Val( writeBytes_dyn() ); }
+		break;
+	case 11:
+		if (HX_FIELD_EQ(inName,"writeString") ) { return ::hx::Val( writeString_dyn() ); }
+		break;
+	case 14:
+		if (HX_FIELD_EQ(inName,"writeFullBytes") ) { return ::hx::Val( writeFullBytes_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *Output_obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo *Output_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String Output_obj_sMemberFields[] = {
+	HX_("writeByte",87,13,d7,49),
+	HX_("writeBytes",0c,03,5a,52),
+	HX_("close",b8,17,63,48),
+	HX_("write",df,6c,59,d0),
+	HX_("writeFullBytes",7d,e7,66,a4),
+	HX_("prepare",87,91,dd,37),
+	HX_("writeString",10,7b,29,a6),
+	::String(null()) };
+
+::hx::Class Output_obj::__mClass;
+
+void Output_obj::__register()
+{
+	Output_obj _hx_dummy;
+	Output_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.io.Output",61,10,0b,c7);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(Output_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< Output_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Output_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Output_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace io
diff --git a/Sources/c_snikket/src/haxe/io/Path.cpp b/Sources/c_snikket/src/haxe/io/Path.cpp
new file mode 100644
index 0000000..f7c576a
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/io/Path.cpp
@@ -0,0 +1,587 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Std
+#include <Std.h>
+#endif
+#ifndef INCLUDED_StringBuf
+#include <StringBuf.h>
+#endif
+#ifndef INCLUDED_StringTools
+#include <StringTools.h>
+#endif
+#ifndef INCLUDED_haxe_io_Path
+#include <haxe/io/Path.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_9ba24db561a9c477_76_new,"haxe.io.Path","new",0x1b96d677,"haxe.io.Path.new","/usr/local/lib/haxe/std/haxe/io/Path.hx",76,0xc99b0f1c)
+HX_LOCAL_STACK_FRAME(_hx_pos_9ba24db561a9c477_115_toString,"haxe.io.Path","toString",0xc0ab5735,"haxe.io.Path.toString","/usr/local/lib/haxe/std/haxe/io/Path.hx",115,0xc99b0f1c)
+HX_LOCAL_STACK_FRAME(_hx_pos_9ba24db561a9c477_134_withoutDirectory,"haxe.io.Path","withoutDirectory",0xdf35ce8e,"haxe.io.Path.withoutDirectory","/usr/local/lib/haxe/std/haxe/io/Path.hx",134,0xc99b0f1c)
+HX_LOCAL_STACK_FRAME(_hx_pos_9ba24db561a9c477_189_join,"haxe.io.Path","join",0x05c781f3,"haxe.io.Path.join","/usr/local/lib/haxe/std/haxe/io/Path.hx",189,0xc99b0f1c)
+HX_LOCAL_STACK_FRAME(_hx_pos_9ba24db561a9c477_210_normalize,"haxe.io.Path","normalize",0x585a68e4,"haxe.io.Path.normalize","/usr/local/lib/haxe/std/haxe/io/Path.hx",210,0xc99b0f1c)
+static const ::String _hx_array_data_4ec6cf05_10[] = {
+	HX_("/",2f,00,00,00),
+};
+static const ::String _hx_array_data_4ec6cf05_11[] = {
+	HX_(":",3a,00,00,00),
+};
+static const ::String _hx_array_data_4ec6cf05_12[] = {
+	HX_("/",2f,00,00,00),
+};
+HX_LOCAL_STACK_FRAME(_hx_pos_9ba24db561a9c477_271_addTrailingSlash,"haxe.io.Path","addTrailingSlash",0x8b4f8e69,"haxe.io.Path.addTrailingSlash","/usr/local/lib/haxe/std/haxe/io/Path.hx",271,0xc99b0f1c)
+HX_LOCAL_STACK_FRAME(_hx_pos_9ba24db561a9c477_299_removeTrailingSlashes,"haxe.io.Path","removeTrailingSlashes",0x2dc73462,"haxe.io.Path.removeTrailingSlashes","/usr/local/lib/haxe/std/haxe/io/Path.hx",299,0xc99b0f1c)
+HX_LOCAL_STACK_FRAME(_hx_pos_9ba24db561a9c477_314_isAbsolute,"haxe.io.Path","isAbsolute",0xb396db4a,"haxe.io.Path.isAbsolute","/usr/local/lib/haxe/std/haxe/io/Path.hx",314,0xc99b0f1c)
+namespace haxe{
+namespace io{
+
+void Path_obj::__construct(::String path){
+            	HX_STACKFRAME(&_hx_pos_9ba24db561a9c477_76_new)
+HXLINE(  77)		::String _hx_switch_0 = path;
+            		if (  (_hx_switch_0==HX_(".",2e,00,00,00)) ||  (_hx_switch_0==HX_("..",40,28,00,00)) ){
+HXLINE(  79)			this->dir = path;
+HXLINE(  80)			this->file = HX_("",00,00,00,00);
+HXLINE(  81)			return;
+HXLINE(  78)			goto _hx_goto_0;
+            		}
+            		_hx_goto_0:;
+HXLINE(  83)		int c1 = path.lastIndexOf(HX_("/",2f,00,00,00),null());
+HXLINE(  84)		int c2 = path.lastIndexOf(HX_("\\",5c,00,00,00),null());
+HXLINE(  85)		if ((c1 < c2)) {
+HXLINE(  86)			this->dir = path.substr(0,c2);
+HXLINE(  87)			path = path.substr((c2 + 1),null());
+HXLINE(  88)			this->backslash = true;
+            		}
+            		else {
+HXLINE(  89)			if ((c2 < c1)) {
+HXLINE(  90)				this->dir = path.substr(0,c1);
+HXLINE(  91)				path = path.substr((c1 + 1),null());
+            			}
+            			else {
+HXLINE(  93)				this->dir = null();
+            			}
+            		}
+HXLINE(  94)		int cp = path.lastIndexOf(HX_(".",2e,00,00,00),null());
+HXLINE(  95)		if ((cp != -1)) {
+HXLINE(  96)			this->ext = path.substr((cp + 1),null());
+HXLINE(  97)			this->file = path.substr(0,cp);
+            		}
+            		else {
+HXLINE(  99)			this->ext = null();
+HXLINE( 100)			this->file = path;
+            		}
+            	}
+
+Dynamic Path_obj::__CreateEmpty() { return new Path_obj; }
+
+void *Path_obj::_hx_vtable = 0;
+
+Dynamic Path_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Path_obj > _hx_result = new Path_obj();
+	_hx_result->__construct(inArgs[0]);
+	return _hx_result;
+}
+
+bool Path_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x026896d9;
+}
+
+::String Path_obj::toString(){
+            	HX_STACKFRAME(&_hx_pos_9ba24db561a9c477_115_toString)
+HXDLIN( 115)		::String _hx_tmp;
+HXDLIN( 115)		if (::hx::IsNull( this->dir )) {
+HXDLIN( 115)			_hx_tmp = HX_("",00,00,00,00);
+            		}
+            		else {
+HXDLIN( 115)			::String _hx_tmp1;
+HXDLIN( 115)			if (this->backslash) {
+HXDLIN( 115)				_hx_tmp1 = HX_("\\",5c,00,00,00);
+            			}
+            			else {
+HXDLIN( 115)				_hx_tmp1 = HX_("/",2f,00,00,00);
+            			}
+HXDLIN( 115)			_hx_tmp = (this->dir + _hx_tmp1);
+            		}
+HXDLIN( 115)		::String _hx_tmp2;
+HXDLIN( 115)		if (::hx::IsNull( this->ext )) {
+HXDLIN( 115)			_hx_tmp2 = HX_("",00,00,00,00);
+            		}
+            		else {
+HXDLIN( 115)			_hx_tmp2 = (HX_(".",2e,00,00,00) + this->ext);
+            		}
+HXDLIN( 115)		return ((_hx_tmp + this->file) + _hx_tmp2);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Path_obj,toString,return )
+
+::String Path_obj::withoutDirectory(::String path){
+            	HX_GC_STACKFRAME(&_hx_pos_9ba24db561a9c477_134_withoutDirectory)
+HXLINE( 135)		 ::haxe::io::Path s =  ::haxe::io::Path_obj::__alloc( HX_CTX ,path);
+HXLINE( 136)		s->dir = null();
+HXLINE( 137)		return s->toString();
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Path_obj,withoutDirectory,return )
+
+::String Path_obj::join(::Array< ::String > paths){
+            	HX_STACKFRAME(&_hx_pos_9ba24db561a9c477_189_join)
+HXLINE( 190)		::Array< ::String > _g = ::Array_obj< ::String >::__new(0);
+HXDLIN( 190)		{
+HXLINE( 190)			int _g1 = 0;
+HXDLIN( 190)			::Array< ::String > _g2 = paths;
+HXDLIN( 190)			while((_g1 < _g2->length)){
+HXLINE( 190)				::String v = _g2->__get(_g1);
+HXDLIN( 190)				_g1 = (_g1 + 1);
+HXDLIN( 190)				bool _hx_tmp;
+HXDLIN( 190)				if (::hx::IsNotNull( v )) {
+HXLINE( 190)					_hx_tmp = (v != HX_("",00,00,00,00));
+            				}
+            				else {
+HXLINE( 190)					_hx_tmp = false;
+            				}
+HXDLIN( 190)				if (_hx_tmp) {
+HXLINE( 190)					_g->push(v);
+            				}
+            			}
+            		}
+HXDLIN( 190)		::Array< ::String > paths1 = _g;
+HXLINE( 191)		if ((paths1->length == 0)) {
+HXLINE( 192)			return HX_("",00,00,00,00);
+            		}
+HXLINE( 194)		::String path = paths1->__get(0);
+HXLINE( 195)		{
+HXLINE( 195)			int _g3 = 1;
+HXDLIN( 195)			int _g4 = paths1->length;
+HXDLIN( 195)			while((_g3 < _g4)){
+HXLINE( 195)				_g3 = (_g3 + 1);
+HXDLIN( 195)				int i = (_g3 - 1);
+HXLINE( 196)				path = ::haxe::io::Path_obj::addTrailingSlash(path);
+HXLINE( 197)				path = (path + paths1->__get(i));
+            			}
+            		}
+HXLINE( 199)		return ::haxe::io::Path_obj::normalize(path);
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Path_obj,join,return )
+
+::String Path_obj::normalize(::String path){
+            	HX_GC_STACKFRAME(&_hx_pos_9ba24db561a9c477_210_normalize)
+HXLINE( 211)		::String slash = HX_("/",2f,00,00,00);
+HXLINE( 212)		path = path.split(HX_("\\",5c,00,00,00))->join(slash);
+HXLINE( 213)		if ((path == slash)) {
+HXLINE( 214)			return slash;
+            		}
+HXLINE( 216)		::Array< ::String > target = ::Array_obj< ::String >::__new(0);
+HXLINE( 218)		{
+HXLINE( 218)			int _g = 0;
+HXDLIN( 218)			::Array< ::String > _g1 = path.split(slash);
+HXDLIN( 218)			while((_g < _g1->length)){
+HXLINE( 218)				::String token = _g1->__get(_g);
+HXDLIN( 218)				_g = (_g + 1);
+HXLINE( 219)				bool _hx_tmp;
+HXDLIN( 219)				bool _hx_tmp1;
+HXDLIN( 219)				if ((token == HX_("..",40,28,00,00))) {
+HXLINE( 219)					_hx_tmp1 = (target->length > 0);
+            				}
+            				else {
+HXLINE( 219)					_hx_tmp1 = false;
+            				}
+HXDLIN( 219)				if (_hx_tmp1) {
+HXLINE( 219)					_hx_tmp = (target->__get((target->length - 1)) != HX_("..",40,28,00,00));
+            				}
+            				else {
+HXLINE( 219)					_hx_tmp = false;
+            				}
+HXDLIN( 219)				if (_hx_tmp) {
+HXLINE( 220)					target->pop();
+            				}
+            				else {
+HXLINE( 221)					if ((token == HX_("",00,00,00,00))) {
+HXLINE( 222)						bool _hx_tmp2;
+HXDLIN( 222)						if ((target->length <= 0)) {
+HXLINE( 222)							_hx_tmp2 = ::hx::IsEq( path.charCodeAt(0),47 );
+            						}
+            						else {
+HXLINE( 222)							_hx_tmp2 = true;
+            						}
+HXDLIN( 222)						if (_hx_tmp2) {
+HXLINE( 223)							target->push(token);
+            						}
+            					}
+            					else {
+HXLINE( 225)						if ((token != HX_(".",2e,00,00,00))) {
+HXLINE( 226)							target->push(token);
+            						}
+            					}
+            				}
+            			}
+            		}
+HXLINE( 230)		::String tmp = target->join(slash);
+HXLINE( 231)		 ::StringBuf acc =  ::StringBuf_obj::__alloc( HX_CTX );
+HXLINE( 232)		bool colon = false;
+HXLINE( 233)		bool slashes = false;
+HXLINE( 235)		{
+HXLINE( 235)			int _g_offset = 0;
+HXDLIN( 235)			::String _g_s = tmp;
+HXDLIN( 235)			while((_g_offset < _g_s.length)){
+HXLINE( 235)				::String s = _g_s;
+HXDLIN( 235)				_g_offset = (_g_offset + 1);
+HXDLIN( 235)				int index = (_g_offset - 1);
+HXDLIN( 235)				int c = s.cca(index);
+HXDLIN( 235)				bool _hx_tmp3;
+HXDLIN( 235)				if ((c >= 55296)) {
+HXLINE( 235)					_hx_tmp3 = (c <= 56319);
+            				}
+            				else {
+HXLINE( 235)					_hx_tmp3 = false;
+            				}
+HXDLIN( 235)				if (_hx_tmp3) {
+HXLINE( 639)					c = (((c - 55232) << 10) | (s.cca((index + 1)) & 1023));
+            				}
+HXLINE( 235)				int c1 = c;
+HXDLIN( 235)				if ((c1 >= 65536)) {
+HXLINE( 235)					_g_offset = (_g_offset + 1);
+            				}
+HXDLIN( 235)				int c2 = c1;
+HXLINE( 236)				switch((int)(c2)){
+            					case (int)47: {
+HXLINE( 244)						if (!(colon)) {
+HXLINE( 245)							slashes = true;
+            						}
+            						else {
+HXLINE( 246)							int i = c2;
+HXDLIN( 246)							{
+HXLINE( 247)								colon = false;
+HXLINE( 248)								if (slashes) {
+HXLINE( 249)									{
+HXLINE( 249)										if (::hx::IsNotNull( acc->charBuf )) {
+HXLINE( 249)											acc->flush();
+            										}
+HXDLIN( 249)										if (::hx::IsNull( acc->b )) {
+HXLINE( 249)											acc->b = ::Array_obj< ::String >::fromData( _hx_array_data_4ec6cf05_10,1);
+            										}
+            										else {
+HXLINE( 249)											acc->b->push(HX_("/",2f,00,00,00));
+            										}
+            									}
+HXLINE( 250)									slashes = false;
+            								}
+HXLINE( 252)								if ((i >= 127)) {
+HXLINE( 252)									::String x = ::String::fromCharCode(i);
+HXDLIN( 252)									if (::hx::IsNotNull( acc->charBuf )) {
+HXLINE( 252)										acc->flush();
+            									}
+HXDLIN( 252)									if (::hx::IsNull( acc->b )) {
+HXLINE( 252)										acc->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(x));
+            									}
+            									else {
+HXLINE( 252)										::Array< ::String > acc1 = acc->b;
+HXDLIN( 252)										acc1->push(::Std_obj::string(x));
+            									}
+            								}
+            								else {
+HXLINE( 252)									if (::hx::IsNull( acc->charBuf )) {
+HXLINE( 252)										acc->charBuf = ::Array_obj< char >::__new();
+            									}
+HXDLIN( 252)									acc->charBuf->push(i);
+            								}
+            							}
+            						}
+            					}
+            					break;
+            					case (int)58: {
+HXLINE( 242)						{
+HXLINE( 242)							if (::hx::IsNotNull( acc->charBuf )) {
+HXLINE( 242)								acc->flush();
+            							}
+HXDLIN( 242)							if (::hx::IsNull( acc->b )) {
+HXLINE( 242)								acc->b = ::Array_obj< ::String >::fromData( _hx_array_data_4ec6cf05_11,1);
+            							}
+            							else {
+HXLINE( 242)								acc->b->push(HX_(":",3a,00,00,00));
+            							}
+            						}
+HXLINE( 243)						colon = true;
+            					}
+            					break;
+            					default:{
+HXLINE( 246)						int i1 = c2;
+HXDLIN( 246)						{
+HXLINE( 247)							colon = false;
+HXLINE( 248)							if (slashes) {
+HXLINE( 249)								{
+HXLINE( 249)									if (::hx::IsNotNull( acc->charBuf )) {
+HXLINE( 249)										acc->flush();
+            									}
+HXDLIN( 249)									if (::hx::IsNull( acc->b )) {
+HXLINE( 249)										acc->b = ::Array_obj< ::String >::fromData( _hx_array_data_4ec6cf05_12,1);
+            									}
+            									else {
+HXLINE( 249)										acc->b->push(HX_("/",2f,00,00,00));
+            									}
+            								}
+HXLINE( 250)								slashes = false;
+            							}
+HXLINE( 252)							if ((i1 >= 127)) {
+HXLINE( 252)								::String x1 = ::String::fromCharCode(i1);
+HXDLIN( 252)								if (::hx::IsNotNull( acc->charBuf )) {
+HXLINE( 252)									acc->flush();
+            								}
+HXDLIN( 252)								if (::hx::IsNull( acc->b )) {
+HXLINE( 252)									acc->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(x1));
+            								}
+            								else {
+HXLINE( 252)									::Array< ::String > acc2 = acc->b;
+HXDLIN( 252)									acc2->push(::Std_obj::string(x1));
+            								}
+            							}
+            							else {
+HXLINE( 252)								if (::hx::IsNull( acc->charBuf )) {
+HXLINE( 252)									acc->charBuf = ::Array_obj< char >::__new();
+            								}
+HXDLIN( 252)								acc->charBuf->push(i1);
+            							}
+            						}
+            					}
+            				}
+            			}
+            		}
+HXLINE( 256)		return acc->toString();
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Path_obj,normalize,return )
+
+::String Path_obj::addTrailingSlash(::String path){
+            	HX_STACKFRAME(&_hx_pos_9ba24db561a9c477_271_addTrailingSlash)
+HXLINE( 272)		if ((path.length == 0)) {
+HXLINE( 273)			return HX_("/",2f,00,00,00);
+            		}
+HXLINE( 274)		int c1 = path.lastIndexOf(HX_("/",2f,00,00,00),null());
+HXLINE( 275)		int c2 = path.lastIndexOf(HX_("\\",5c,00,00,00),null());
+HXLINE( 276)		if ((c1 < c2)) {
+HXLINE( 277)			if ((c2 != (path.length - 1))) {
+HXLINE( 278)				return (path + HX_("\\",5c,00,00,00));
+            			}
+            			else {
+HXLINE( 280)				return path;
+            			}
+            		}
+            		else {
+HXLINE( 282)			if ((c1 != (path.length - 1))) {
+HXLINE( 283)				return (path + HX_("/",2f,00,00,00));
+            			}
+            			else {
+HXLINE( 285)				return path;
+            			}
+            		}
+HXLINE( 276)		return null();
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Path_obj,addTrailingSlash,return )
+
+::String Path_obj::removeTrailingSlashes(::String path){
+            	HX_STACKFRAME(&_hx_pos_9ba24db561a9c477_299_removeTrailingSlashes)
+HXLINE( 300)		while(true){
+HXLINE( 301)			 ::Dynamic _g = path.charCodeAt((path.length - 1));
+HXDLIN( 301)			if (::hx::IsNull( _g )) {
+HXLINE( 305)				goto _hx_goto_14;
+            			}
+            			else {
+HXLINE( 301)				 ::Dynamic _hx_switch_0 = _g;
+            				if (  (_hx_switch_0==47) ||  (_hx_switch_0==92) ){
+HXLINE( 303)					path = path.substr(0,-1);
+HXDLIN( 303)					goto _hx_goto_15;
+            				}
+            				/* default */{
+HXLINE( 305)					goto _hx_goto_14;
+            				}
+            				_hx_goto_15:;
+            			}
+            		}
+            		_hx_goto_14:;
+HXLINE( 308)		return path;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Path_obj,removeTrailingSlashes,return )
+
+bool Path_obj::isAbsolute(::String path){
+            	HX_STACKFRAME(&_hx_pos_9ba24db561a9c477_314_isAbsolute)
+HXLINE( 315)		if (::StringTools_obj::startsWith(path,HX_("/",2f,00,00,00))) {
+HXLINE( 316)			return true;
+            		}
+HXLINE( 317)		if ((path.charAt(1) == HX_(":",3a,00,00,00))) {
+HXLINE( 318)			return true;
+            		}
+HXLINE( 319)		if (::StringTools_obj::startsWith(path,HX_("\\\\",80,50,00,00))) {
+HXLINE( 320)			return true;
+            		}
+HXLINE( 321)		return false;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Path_obj,isAbsolute,return )
+
+
+::hx::ObjectPtr< Path_obj > Path_obj::__new(::String path) {
+	::hx::ObjectPtr< Path_obj > __this = new Path_obj();
+	__this->__construct(path);
+	return __this;
+}
+
+::hx::ObjectPtr< Path_obj > Path_obj::__alloc(::hx::Ctx *_hx_ctx,::String path) {
+	Path_obj *__this = (Path_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Path_obj), true, "haxe.io.Path"));
+	*(void **)__this = Path_obj::_hx_vtable;
+	__this->__construct(path);
+	return __this;
+}
+
+Path_obj::Path_obj()
+{
+}
+
+void Path_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(Path);
+	HX_MARK_MEMBER_NAME(dir,"dir");
+	HX_MARK_MEMBER_NAME(file,"file");
+	HX_MARK_MEMBER_NAME(ext,"ext");
+	HX_MARK_MEMBER_NAME(backslash,"backslash");
+	HX_MARK_END_CLASS();
+}
+
+void Path_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(dir,"dir");
+	HX_VISIT_MEMBER_NAME(file,"file");
+	HX_VISIT_MEMBER_NAME(ext,"ext");
+	HX_VISIT_MEMBER_NAME(backslash,"backslash");
+}
+
+::hx::Val Path_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"dir") ) { return ::hx::Val( dir ); }
+		if (HX_FIELD_EQ(inName,"ext") ) { return ::hx::Val( ext ); }
+		break;
+	case 4:
+		if (HX_FIELD_EQ(inName,"file") ) { return ::hx::Val( file ); }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"toString") ) { return ::hx::Val( toString_dyn() ); }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"backslash") ) { return ::hx::Val( backslash ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+bool Path_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"join") ) { outValue = join_dyn(); return true; }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"normalize") ) { outValue = normalize_dyn(); return true; }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"isAbsolute") ) { outValue = isAbsolute_dyn(); return true; }
+		break;
+	case 16:
+		if (HX_FIELD_EQ(inName,"withoutDirectory") ) { outValue = withoutDirectory_dyn(); return true; }
+		if (HX_FIELD_EQ(inName,"addTrailingSlash") ) { outValue = addTrailingSlash_dyn(); return true; }
+		break;
+	case 21:
+		if (HX_FIELD_EQ(inName,"removeTrailingSlashes") ) { outValue = removeTrailingSlashes_dyn(); return true; }
+	}
+	return false;
+}
+
+::hx::Val Path_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"dir") ) { dir=inValue.Cast< ::String >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"ext") ) { ext=inValue.Cast< ::String >(); return inValue; }
+		break;
+	case 4:
+		if (HX_FIELD_EQ(inName,"file") ) { file=inValue.Cast< ::String >(); return inValue; }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"backslash") ) { backslash=inValue.Cast< bool >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void Path_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("dir",4d,3d,4c,00));
+	outFields->push(HX_("file",7c,ce,bb,43));
+	outFields->push(HX_("ext",a1,0c,4d,00));
+	outFields->push(HX_("backslash",b6,b8,45,c8));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo Path_obj_sMemberStorageInfo[] = {
+	{::hx::fsString,(int)offsetof(Path_obj,dir),HX_("dir",4d,3d,4c,00)},
+	{::hx::fsString,(int)offsetof(Path_obj,file),HX_("file",7c,ce,bb,43)},
+	{::hx::fsString,(int)offsetof(Path_obj,ext),HX_("ext",a1,0c,4d,00)},
+	{::hx::fsBool,(int)offsetof(Path_obj,backslash),HX_("backslash",b6,b8,45,c8)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *Path_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String Path_obj_sMemberFields[] = {
+	HX_("dir",4d,3d,4c,00),
+	HX_("file",7c,ce,bb,43),
+	HX_("ext",a1,0c,4d,00),
+	HX_("backslash",b6,b8,45,c8),
+	HX_("toString",ac,d0,6e,38),
+	::String(null()) };
+
+::hx::Class Path_obj::__mClass;
+
+static ::String Path_obj_sStaticFields[] = {
+	HX_("withoutDirectory",05,17,d2,7a),
+	HX_("join",ea,33,65,46),
+	HX_("normalize",8d,37,a1,ab),
+	HX_("addTrailingSlash",e0,d6,eb,26),
+	HX_("removeTrailingSlashes",8b,dc,1d,43),
+	HX_("isAbsolute",81,e0,44,3e),
+	::String(null())
+};
+
+void Path_obj::__register()
+{
+	Path_obj _hx_dummy;
+	Path_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.io.Path",05,cf,c6,4e);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &Path_obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(Path_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(Path_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< Path_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Path_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Path_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace io
diff --git a/Sources/c_snikket/src/haxe/iterators/ArrayIterator.cpp b/Sources/c_snikket/src/haxe/iterators/ArrayIterator.cpp
new file mode 100644
index 0000000..be23a06
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/iterators/ArrayIterator.cpp
@@ -0,0 +1,147 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_iterators_ArrayIterator
+#include <haxe/iterators/ArrayIterator.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_44ded26575b0f4de_28_new,"haxe.iterators.ArrayIterator","new",0x70a754c8,"haxe.iterators.ArrayIterator.new","/usr/local/lib/haxe/std/haxe/iterators/ArrayIterator.hx",28,0xb40d6dcd)
+HX_LOCAL_STACK_FRAME(_hx_pos_44ded26575b0f4de_45_hasNext,"haxe.iterators.ArrayIterator","hasNext",0x74587dd5,"haxe.iterators.ArrayIterator.hasNext","/usr/local/lib/haxe/std/haxe/iterators/ArrayIterator.hx",45,0xb40d6dcd)
+HX_LOCAL_STACK_FRAME(_hx_pos_44ded26575b0f4de_53_next,"haxe.iterators.ArrayIterator","next",0x21c2db8b,"haxe.iterators.ArrayIterator.next","/usr/local/lib/haxe/std/haxe/iterators/ArrayIterator.hx",53,0xb40d6dcd)
+namespace haxe{
+namespace iterators{
+
+void ArrayIterator_obj::__construct(::cpp::VirtualArray array){
+            	HX_STACKFRAME(&_hx_pos_44ded26575b0f4de_28_new)
+HXLINE(  30)		this->current = 0;
+HXLINE(  37)		this->array = array;
+            	}
+
+Dynamic ArrayIterator_obj::__CreateEmpty() { return new ArrayIterator_obj; }
+
+void *ArrayIterator_obj::_hx_vtable = 0;
+
+Dynamic ArrayIterator_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< ArrayIterator_obj > _hx_result = new ArrayIterator_obj();
+	_hx_result->__construct(inArgs[0]);
+	return _hx_result;
+}
+
+bool ArrayIterator_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x189859c8;
+}
+
+bool ArrayIterator_obj::hasNext(){
+            	HX_STACKFRAME(&_hx_pos_44ded26575b0f4de_45_hasNext)
+HXDLIN(  45)		return (this->current < this->array->get_length());
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(ArrayIterator_obj,hasNext,return )
+
+ ::Dynamic ArrayIterator_obj::next(){
+            	HX_STACKFRAME(&_hx_pos_44ded26575b0f4de_53_next)
+HXDLIN(  53)		return this->array->__get(this->current++);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(ArrayIterator_obj,next,return )
+
+
+ArrayIterator_obj::ArrayIterator_obj()
+{
+}
+
+void ArrayIterator_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(ArrayIterator);
+	HX_MARK_MEMBER_NAME(array,"array");
+	HX_MARK_MEMBER_NAME(current,"current");
+	HX_MARK_END_CLASS();
+}
+
+void ArrayIterator_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(array,"array");
+	HX_VISIT_MEMBER_NAME(current,"current");
+}
+
+::hx::Val ArrayIterator_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"next") ) { return ::hx::Val( next_dyn() ); }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"array") ) { return ::hx::Val( array ); }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"current") ) { return ::hx::Val( current ); }
+		if (HX_FIELD_EQ(inName,"hasNext") ) { return ::hx::Val( hasNext_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val ArrayIterator_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 5:
+		if (HX_FIELD_EQ(inName,"array") ) { array=inValue.Cast< ::cpp::VirtualArray >(); return inValue; }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"current") ) { current=inValue.Cast< int >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void ArrayIterator_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("array",99,6d,8f,25));
+	outFields->push(HX_("current",39,9c,e3,cb));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo ArrayIterator_obj_sMemberStorageInfo[] = {
+	{::hx::fsObject /* ::cpp::VirtualArray */ ,(int)offsetof(ArrayIterator_obj,array),HX_("array",99,6d,8f,25)},
+	{::hx::fsInt,(int)offsetof(ArrayIterator_obj,current),HX_("current",39,9c,e3,cb)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *ArrayIterator_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String ArrayIterator_obj_sMemberFields[] = {
+	HX_("array",99,6d,8f,25),
+	HX_("current",39,9c,e3,cb),
+	HX_("hasNext",6d,a5,46,18),
+	HX_("next",f3,84,02,49),
+	::String(null()) };
+
+::hx::Class ArrayIterator_obj::__mClass;
+
+void ArrayIterator_obj::__register()
+{
+	ArrayIterator_obj _hx_dummy;
+	ArrayIterator_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.iterators.ArrayIterator",d6,90,23,99);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(ArrayIterator_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< ArrayIterator_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = ArrayIterator_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = ArrayIterator_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace iterators
diff --git a/Sources/c_snikket/src/haxe/iterators/MapKeyValueIterator.cpp b/Sources/c_snikket/src/haxe/iterators/MapKeyValueIterator.cpp
new file mode 100644
index 0000000..1c9f88b
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/iterators/MapKeyValueIterator.cpp
@@ -0,0 +1,166 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+#ifndef INCLUDED_haxe_iterators_MapKeyValueIterator
+#include <haxe/iterators/MapKeyValueIterator.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_2013d4993119aacc_35_new,"haxe.iterators.MapKeyValueIterator","new",0x902a97fd,"haxe.iterators.MapKeyValueIterator.new","/usr/local/lib/haxe/std/haxe/iterators/MapKeyValueIterator.hx",35,0x99dcf1f8)
+HX_LOCAL_STACK_FRAME(_hx_pos_2013d4993119aacc_44_hasNext,"haxe.iterators.MapKeyValueIterator","hasNext",0x6e75ff8a,"haxe.iterators.MapKeyValueIterator.hasNext","/usr/local/lib/haxe/std/haxe/iterators/MapKeyValueIterator.hx",44,0x99dcf1f8)
+HX_LOCAL_STACK_FRAME(_hx_pos_2013d4993119aacc_50_next,"haxe.iterators.MapKeyValueIterator","next",0x951a66b6,"haxe.iterators.MapKeyValueIterator.next","/usr/local/lib/haxe/std/haxe/iterators/MapKeyValueIterator.hx",50,0x99dcf1f8)
+namespace haxe{
+namespace iterators{
+
+void MapKeyValueIterator_obj::__construct(::Dynamic map){
+            	HX_STACKFRAME(&_hx_pos_2013d4993119aacc_35_new)
+HXLINE(  36)		this->map = map;
+HXLINE(  37)		this->keys = ::haxe::IMap_obj::keys(map);
+            	}
+
+Dynamic MapKeyValueIterator_obj::__CreateEmpty() { return new MapKeyValueIterator_obj; }
+
+void *MapKeyValueIterator_obj::_hx_vtable = 0;
+
+Dynamic MapKeyValueIterator_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< MapKeyValueIterator_obj > _hx_result = new MapKeyValueIterator_obj();
+	_hx_result->__construct(inArgs[0]);
+	return _hx_result;
+}
+
+bool MapKeyValueIterator_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x5732dffd;
+}
+
+bool MapKeyValueIterator_obj::hasNext(){
+            	HX_STACKFRAME(&_hx_pos_2013d4993119aacc_44_hasNext)
+HXDLIN(  44)		return ( (bool)(this->keys->__Field(HX_("hasNext",6d,a5,46,18),::hx::paccDynamic)()) );
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(MapKeyValueIterator_obj,hasNext,return )
+
+ ::Dynamic MapKeyValueIterator_obj::next(){
+            	HX_STACKFRAME(&_hx_pos_2013d4993119aacc_50_next)
+HXLINE(  51)		 ::Dynamic key = this->keys->__Field(HX_("next",f3,84,02,49),::hx::paccDynamic)();
+HXLINE(  52)		return  ::Dynamic(::hx::Anon_obj::Create(2)
+            			->setFixed(0,HX_("key",9f,89,51,00),key)
+            			->setFixed(1,HX_("value",71,7f,b8,31),::haxe::IMap_obj::get(this->map,key)));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(MapKeyValueIterator_obj,next,return )
+
+
+::hx::ObjectPtr< MapKeyValueIterator_obj > MapKeyValueIterator_obj::__new(::Dynamic map) {
+	::hx::ObjectPtr< MapKeyValueIterator_obj > __this = new MapKeyValueIterator_obj();
+	__this->__construct(map);
+	return __this;
+}
+
+::hx::ObjectPtr< MapKeyValueIterator_obj > MapKeyValueIterator_obj::__alloc(::hx::Ctx *_hx_ctx,::Dynamic map) {
+	MapKeyValueIterator_obj *__this = (MapKeyValueIterator_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(MapKeyValueIterator_obj), true, "haxe.iterators.MapKeyValueIterator"));
+	*(void **)__this = MapKeyValueIterator_obj::_hx_vtable;
+	__this->__construct(map);
+	return __this;
+}
+
+MapKeyValueIterator_obj::MapKeyValueIterator_obj()
+{
+}
+
+void MapKeyValueIterator_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(MapKeyValueIterator);
+	HX_MARK_MEMBER_NAME(map,"map");
+	HX_MARK_MEMBER_NAME(keys,"keys");
+	HX_MARK_END_CLASS();
+}
+
+void MapKeyValueIterator_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(map,"map");
+	HX_VISIT_MEMBER_NAME(keys,"keys");
+}
+
+::hx::Val MapKeyValueIterator_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"map") ) { return ::hx::Val( map ); }
+		break;
+	case 4:
+		if (HX_FIELD_EQ(inName,"keys") ) { return ::hx::Val( keys ); }
+		if (HX_FIELD_EQ(inName,"next") ) { return ::hx::Val( next_dyn() ); }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"hasNext") ) { return ::hx::Val( hasNext_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val MapKeyValueIterator_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"map") ) { map=inValue.Cast< ::Dynamic >(); return inValue; }
+		break;
+	case 4:
+		if (HX_FIELD_EQ(inName,"keys") ) { keys=inValue.Cast<  ::Dynamic >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void MapKeyValueIterator_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("map",9c,0a,53,00));
+	outFields->push(HX_("keys",f4,e1,06,47));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo MapKeyValueIterator_obj_sMemberStorageInfo[] = {
+	{::hx::fsObject /* ::Dynamic */ ,(int)offsetof(MapKeyValueIterator_obj,map),HX_("map",9c,0a,53,00)},
+	{::hx::fsObject /*  ::Dynamic */ ,(int)offsetof(MapKeyValueIterator_obj,keys),HX_("keys",f4,e1,06,47)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *MapKeyValueIterator_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String MapKeyValueIterator_obj_sMemberFields[] = {
+	HX_("map",9c,0a,53,00),
+	HX_("keys",f4,e1,06,47),
+	HX_("hasNext",6d,a5,46,18),
+	HX_("next",f3,84,02,49),
+	::String(null()) };
+
+::hx::Class MapKeyValueIterator_obj::__mClass;
+
+void MapKeyValueIterator_obj::__register()
+{
+	MapKeyValueIterator_obj _hx_dummy;
+	MapKeyValueIterator_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.iterators.MapKeyValueIterator",8b,d5,ad,b4);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(MapKeyValueIterator_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< MapKeyValueIterator_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = MapKeyValueIterator_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = MapKeyValueIterator_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace iterators
diff --git a/Sources/c_snikket/src/haxe/xml/Parser.cpp b/Sources/c_snikket/src/haxe/xml/Parser.cpp
new file mode 100644
index 0000000..1237bc5
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/xml/Parser.cpp
@@ -0,0 +1,1062 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Std
+#include <Std.h>
+#endif
+#ifndef INCLUDED_StringBuf
+#include <StringBuf.h>
+#endif
+#ifndef INCLUDED_Xml
+#include <Xml.h>
+#endif
+#ifndef INCLUDED__Xml_XmlType_Impl_
+#include <_Xml/XmlType_Impl_.h>
+#endif
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+#ifndef INCLUDED_haxe_ds_StringMap
+#include <haxe/ds/StringMap.h>
+#endif
+#ifndef INCLUDED_haxe_xml_Parser
+#include <haxe/xml/Parser.h>
+#endif
+#ifndef INCLUDED_haxe_xml_XmlParserException
+#include <haxe/xml/XmlParserException.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_4387901c245e1a2b_115_parse,"haxe.xml.Parser","parse",0x937905c3,"haxe.xml.Parser.parse","/usr/local/lib/haxe/std/haxe/xml/Parser.hx",115,0x9bd139bb)
+HX_LOCAL_STACK_FRAME(_hx_pos_4387901c245e1a2b_121_doParse,"haxe.xml.Parser","doParse",0x2e9a6a38,"haxe.xml.Parser.doParse","/usr/local/lib/haxe/std/haxe/xml/Parser.hx",121,0x9bd139bb)
+HX_LOCAL_STACK_FRAME(_hx_pos_4387901c245e1a2b_100_boot,"haxe.xml.Parser","boot",0x0af6f0a2,"haxe.xml.Parser.boot","/usr/local/lib/haxe/std/haxe/xml/Parser.hx",100,0x9bd139bb)
+namespace haxe{
+namespace xml{
+
+void Parser_obj::__construct() { }
+
+Dynamic Parser_obj::__CreateEmpty() { return new Parser_obj; }
+
+void *Parser_obj::_hx_vtable = 0;
+
+Dynamic Parser_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Parser_obj > _hx_result = new Parser_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool Parser_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x1c6f1730;
+}
+
+ ::haxe::ds::StringMap Parser_obj::escapes;
+
+ ::Xml Parser_obj::parse(::String str,::hx::Null< bool >  __o_strict){
+            		bool strict = __o_strict.Default(false);
+            	HX_STACKFRAME(&_hx_pos_4387901c245e1a2b_115_parse)
+HXLINE( 116)		 ::Xml doc = ::Xml_obj::createDocument();
+HXLINE( 117)		::haxe::xml::Parser_obj::doParse(str,strict,0,doc);
+HXLINE( 118)		return doc;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(Parser_obj,parse,return )
+
+int Parser_obj::doParse(::String str,bool strict,::hx::Null< int >  __o_p, ::Xml parent){
+            		int p = __o_p.Default(0);
+            	HX_GC_STACKFRAME(&_hx_pos_4387901c245e1a2b_121_doParse)
+HXLINE( 122)		 ::Xml xml = null();
+HXLINE( 123)		int state = 1;
+HXLINE( 124)		int next = 1;
+HXLINE( 125)		::String aname = null();
+HXLINE( 126)		int start = 0;
+HXLINE( 127)		int nsubs = 0;
+HXLINE( 128)		int nbrackets = 0;
+HXLINE( 129)		 ::StringBuf buf =  ::StringBuf_obj::__alloc( HX_CTX );
+HXLINE( 131)		int escapeNext = 1;
+HXLINE( 132)		int attrValQuote = -1;
+HXLINE( 137)		while((p < str.length)){
+HXLINE( 138)			int c = str.cca(p);
+HXLINE( 139)			switch((int)(state)){
+            				case (int)0: {
+HXLINE( 141)					switch((int)(c)){
+            						case (int)9: case (int)10: case (int)13: case (int)32: {
+            						}
+            						break;
+            						default:{
+HXLINE( 144)							state = next;
+HXLINE( 145)							continue;
+            						}
+            					}
+            				}
+            				break;
+            				case (int)1: {
+HXLINE( 148)					if ((c == 60)) {
+HXLINE( 150)						state = 0;
+HXLINE( 151)						next = 2;
+            					}
+            					else {
+HXLINE( 153)						start = p;
+HXLINE( 154)						state = 13;
+HXLINE( 155)						continue;
+            					}
+            				}
+            				break;
+            				case (int)2: {
+HXLINE( 179)					switch((int)(c)){
+            						case (int)33: {
+HXLINE( 181)							if ((str.cca((p + 1)) == 91)) {
+HXLINE( 182)								p = (p + 2);
+HXLINE( 183)								if ((str.substr(p,6).toUpperCase() != HX_("CDATA[",ce,73,5f,1c))) {
+HXLINE( 184)									HX_STACK_DO_THROW( ::haxe::xml::XmlParserException_obj::__alloc( HX_CTX ,HX_("Expected <![CDATA[",1c,11,1f,2d),str,p));
+            								}
+HXLINE( 185)								p = (p + 5);
+HXLINE( 186)								state = 17;
+HXLINE( 187)								start = (p + 1);
+            							}
+            							else {
+HXLINE( 188)								bool _hx_tmp;
+HXDLIN( 188)								if ((str.cca((p + 1)) != 68)) {
+HXLINE( 188)									_hx_tmp = (str.cca((p + 1)) == 100);
+            								}
+            								else {
+HXLINE( 188)									_hx_tmp = true;
+            								}
+HXDLIN( 188)								if (_hx_tmp) {
+HXLINE( 189)									if ((str.substr((p + 2),6).toUpperCase() != HX_("OCTYPE",ce,19,d4,61))) {
+HXLINE( 190)										HX_STACK_DO_THROW( ::haxe::xml::XmlParserException_obj::__alloc( HX_CTX ,HX_("Expected <!DOCTYPE",c5,0b,26,b6),str,p));
+            									}
+HXLINE( 191)									p = (p + 8);
+HXLINE( 192)									state = 16;
+HXLINE( 193)									start = (p + 1);
+            								}
+            								else {
+HXLINE( 194)									bool _hx_tmp1;
+HXDLIN( 194)									if ((str.cca((p + 1)) == 45)) {
+HXLINE( 194)										_hx_tmp1 = (str.cca((p + 2)) != 45);
+            									}
+            									else {
+HXLINE( 194)										_hx_tmp1 = true;
+            									}
+HXDLIN( 194)									if (_hx_tmp1) {
+HXLINE( 194)										HX_STACK_DO_THROW( ::haxe::xml::XmlParserException_obj::__alloc( HX_CTX ,HX_("Expected <!--",8d,3d,c1,53),str,p));
+            									}
+            									else {
+HXLINE( 196)										p = (p + 2);
+HXLINE( 197)										state = 15;
+HXLINE( 198)										start = (p + 1);
+            									}
+            								}
+            							}
+            						}
+            						break;
+            						case (int)47: {
+HXLINE( 204)							if (::hx::IsNull( parent )) {
+HXLINE( 205)								HX_STACK_DO_THROW( ::haxe::xml::XmlParserException_obj::__alloc( HX_CTX ,HX_("Expected node name",a1,85,63,3f),str,p));
+            							}
+HXLINE( 206)							start = (p + 1);
+HXLINE( 207)							state = 0;
+HXLINE( 208)							next = 10;
+            						}
+            						break;
+            						case (int)63: {
+HXLINE( 201)							state = 14;
+HXLINE( 202)							start = p;
+            						}
+            						break;
+            						default:{
+HXLINE( 210)							state = 3;
+HXLINE( 211)							start = p;
+HXLINE( 212)							continue;
+            						}
+            					}
+            				}
+            				break;
+            				case (int)3: {
+HXLINE( 215)					bool _hx_tmp2;
+HXDLIN( 215)					bool _hx_tmp3;
+HXDLIN( 215)					bool _hx_tmp4;
+HXDLIN( 215)					bool _hx_tmp5;
+HXDLIN( 215)					bool _hx_tmp6;
+HXDLIN( 215)					bool _hx_tmp7;
+HXDLIN( 215)					bool _hx_tmp8;
+HXDLIN( 215)					if ((c >= 97)) {
+HXLINE( 215)						_hx_tmp8 = (c <= 122);
+            					}
+            					else {
+HXLINE( 215)						_hx_tmp8 = false;
+            					}
+HXDLIN( 215)					if (!(_hx_tmp8)) {
+HXLINE( 215)						if ((c >= 65)) {
+HXLINE( 215)							_hx_tmp7 = (c <= 90);
+            						}
+            						else {
+HXLINE( 215)							_hx_tmp7 = false;
+            						}
+            					}
+            					else {
+HXLINE( 215)						_hx_tmp7 = true;
+            					}
+HXDLIN( 215)					if (!(_hx_tmp7)) {
+HXLINE( 215)						if ((c >= 48)) {
+HXLINE( 215)							_hx_tmp6 = (c <= 57);
+            						}
+            						else {
+HXLINE( 215)							_hx_tmp6 = false;
+            						}
+            					}
+            					else {
+HXLINE( 215)						_hx_tmp6 = true;
+            					}
+HXDLIN( 215)					if (!(_hx_tmp6)) {
+HXLINE( 215)						_hx_tmp5 = (c == 58);
+            					}
+            					else {
+HXLINE( 215)						_hx_tmp5 = true;
+            					}
+HXDLIN( 215)					if (!(_hx_tmp5)) {
+HXLINE( 215)						_hx_tmp4 = (c == 46);
+            					}
+            					else {
+HXLINE( 215)						_hx_tmp4 = true;
+            					}
+HXDLIN( 215)					if (!(_hx_tmp4)) {
+HXLINE( 215)						_hx_tmp3 = (c == 95);
+            					}
+            					else {
+HXLINE( 215)						_hx_tmp3 = true;
+            					}
+HXDLIN( 215)					if (!(_hx_tmp3)) {
+HXLINE( 215)						_hx_tmp2 = (c == 45);
+            					}
+            					else {
+HXLINE( 215)						_hx_tmp2 = true;
+            					}
+HXDLIN( 215)					if (!(_hx_tmp2)) {
+HXLINE( 216)						if ((p == start)) {
+HXLINE( 217)							HX_STACK_DO_THROW( ::haxe::xml::XmlParserException_obj::__alloc( HX_CTX ,HX_("Expected node name",a1,85,63,3f),str,p));
+            						}
+HXLINE( 218)						xml = ::Xml_obj::createElement(str.substr(start,(p - start)));
+HXLINE( 219)						{
+HXLINE( 219)							parent->addChild(xml);
+HXDLIN( 219)							nsubs = (nsubs + 1);
+            						}
+HXLINE( 220)						state = 0;
+HXLINE( 221)						next = 4;
+HXLINE( 222)						continue;
+            					}
+            				}
+            				break;
+            				case (int)4: {
+HXLINE( 225)					switch((int)(c)){
+            						case (int)47: {
+HXLINE( 227)							state = 11;
+            						}
+            						break;
+            						case (int)62: {
+HXLINE( 229)							state = 9;
+            						}
+            						break;
+            						default:{
+HXLINE( 231)							state = 5;
+HXLINE( 232)							start = p;
+HXLINE( 233)							continue;
+            						}
+            					}
+            				}
+            				break;
+            				case (int)5: {
+HXLINE( 236)					bool _hx_tmp9;
+HXDLIN( 236)					bool _hx_tmp10;
+HXDLIN( 236)					bool _hx_tmp11;
+HXDLIN( 236)					bool _hx_tmp12;
+HXDLIN( 236)					bool _hx_tmp13;
+HXDLIN( 236)					bool _hx_tmp14;
+HXDLIN( 236)					bool _hx_tmp15;
+HXDLIN( 236)					if ((c >= 97)) {
+HXLINE( 236)						_hx_tmp15 = (c <= 122);
+            					}
+            					else {
+HXLINE( 236)						_hx_tmp15 = false;
+            					}
+HXDLIN( 236)					if (!(_hx_tmp15)) {
+HXLINE( 236)						if ((c >= 65)) {
+HXLINE( 236)							_hx_tmp14 = (c <= 90);
+            						}
+            						else {
+HXLINE( 236)							_hx_tmp14 = false;
+            						}
+            					}
+            					else {
+HXLINE( 236)						_hx_tmp14 = true;
+            					}
+HXDLIN( 236)					if (!(_hx_tmp14)) {
+HXLINE( 236)						if ((c >= 48)) {
+HXLINE( 236)							_hx_tmp13 = (c <= 57);
+            						}
+            						else {
+HXLINE( 236)							_hx_tmp13 = false;
+            						}
+            					}
+            					else {
+HXLINE( 236)						_hx_tmp13 = true;
+            					}
+HXDLIN( 236)					if (!(_hx_tmp13)) {
+HXLINE( 236)						_hx_tmp12 = (c == 58);
+            					}
+            					else {
+HXLINE( 236)						_hx_tmp12 = true;
+            					}
+HXDLIN( 236)					if (!(_hx_tmp12)) {
+HXLINE( 236)						_hx_tmp11 = (c == 46);
+            					}
+            					else {
+HXLINE( 236)						_hx_tmp11 = true;
+            					}
+HXDLIN( 236)					if (!(_hx_tmp11)) {
+HXLINE( 236)						_hx_tmp10 = (c == 95);
+            					}
+            					else {
+HXLINE( 236)						_hx_tmp10 = true;
+            					}
+HXDLIN( 236)					if (!(_hx_tmp10)) {
+HXLINE( 236)						_hx_tmp9 = (c == 45);
+            					}
+            					else {
+HXLINE( 236)						_hx_tmp9 = true;
+            					}
+HXDLIN( 236)					if (!(_hx_tmp9)) {
+HXLINE( 238)						if ((start == p)) {
+HXLINE( 239)							HX_STACK_DO_THROW( ::haxe::xml::XmlParserException_obj::__alloc( HX_CTX ,HX_("Expected attribute name",57,65,2b,54),str,p));
+            						}
+HXLINE( 237)						::String tmp = str.substr(start,(p - start));
+HXLINE( 241)						aname = tmp;
+HXLINE( 242)						if (xml->exists(aname)) {
+HXLINE( 243)							HX_STACK_DO_THROW( ::haxe::xml::XmlParserException_obj::__alloc( HX_CTX ,((HX_("Duplicate attribute [",22,75,cb,05) + aname) + HX_("]",5d,00,00,00)),str,p));
+            						}
+HXLINE( 244)						state = 0;
+HXLINE( 245)						next = 6;
+HXLINE( 246)						continue;
+            					}
+            				}
+            				break;
+            				case (int)6: {
+HXLINE( 249)					if ((c == 61)) {
+HXLINE( 251)						state = 0;
+HXLINE( 252)						next = 7;
+            					}
+            					else {
+HXLINE( 254)						HX_STACK_DO_THROW( ::haxe::xml::XmlParserException_obj::__alloc( HX_CTX ,HX_("Expected =",b5,dc,23,c6),str,p));
+            					}
+            				}
+            				break;
+            				case (int)7: {
+HXLINE( 257)					switch((int)(c)){
+            						case (int)34: case (int)39: {
+HXLINE( 259)							buf =  ::StringBuf_obj::__alloc( HX_CTX );
+HXLINE( 260)							state = 8;
+HXLINE( 261)							start = (p + 1);
+HXLINE( 262)							attrValQuote = c;
+            						}
+            						break;
+            						default:{
+HXLINE( 264)							HX_STACK_DO_THROW( ::haxe::xml::XmlParserException_obj::__alloc( HX_CTX ,HX_("Expected \"",9a,dc,23,c6),str,p));
+            						}
+            					}
+            				}
+            				break;
+            				case (int)8: {
+HXLINE( 267)					switch((int)(c)){
+            						case (int)38: {
+HXLINE( 269)							{
+HXLINE( 269)								 ::Dynamic len = (p - start);
+HXDLIN( 269)								if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 269)									buf->flush();
+            								}
+HXDLIN( 269)								if (::hx::IsNull( buf->b )) {
+HXLINE( 269)									buf->b = ::Array_obj< ::String >::__new(1)->init(0,str.substr(start,len));
+            								}
+            								else {
+HXLINE( 269)									::Array< ::String > buf1 = buf->b;
+HXDLIN( 269)									buf1->push(str.substr(start,len));
+            								}
+            							}
+HXLINE( 270)							state = 18;
+HXLINE( 271)							escapeNext = 8;
+HXLINE( 272)							start = (p + 1);
+            						}
+            						break;
+            						case (int)60: case (int)62: {
+HXLINE( 273)							if (strict) {
+HXLINE( 275)								HX_STACK_DO_THROW( ::haxe::xml::XmlParserException_obj::__alloc( HX_CTX ,((HX_("Invalid unescaped ",ff,da,cb,cc) + ::String::fromCharCode(c)) + HX_(" in attribute value",52,5a,ca,13)),str,p));
+            							}
+            							else {
+HXLINE( 276)								if ((c == attrValQuote)) {
+HXLINE( 277)									{
+HXLINE( 277)										 ::Dynamic len1 = (p - start);
+HXDLIN( 277)										if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 277)											buf->flush();
+            										}
+HXDLIN( 277)										if (::hx::IsNull( buf->b )) {
+HXLINE( 277)											buf->b = ::Array_obj< ::String >::__new(1)->init(0,str.substr(start,len1));
+            										}
+            										else {
+HXLINE( 277)											::Array< ::String > buf2 = buf->b;
+HXDLIN( 277)											buf2->push(str.substr(start,len1));
+            										}
+            									}
+HXLINE( 278)									::String val = buf->toString();
+HXLINE( 279)									buf =  ::StringBuf_obj::__alloc( HX_CTX );
+HXLINE( 280)									xml->set(aname,val);
+HXLINE( 281)									state = 0;
+HXLINE( 282)									next = 4;
+            								}
+            							}
+            						}
+            						break;
+            						default:{
+HXLINE( 276)							if ((c == attrValQuote)) {
+HXLINE( 277)								{
+HXLINE( 277)									 ::Dynamic len2 = (p - start);
+HXDLIN( 277)									if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 277)										buf->flush();
+            									}
+HXDLIN( 277)									if (::hx::IsNull( buf->b )) {
+HXLINE( 277)										buf->b = ::Array_obj< ::String >::__new(1)->init(0,str.substr(start,len2));
+            									}
+            									else {
+HXLINE( 277)										::Array< ::String > buf3 = buf->b;
+HXDLIN( 277)										buf3->push(str.substr(start,len2));
+            									}
+            								}
+HXLINE( 278)								::String val1 = buf->toString();
+HXLINE( 279)								buf =  ::StringBuf_obj::__alloc( HX_CTX );
+HXLINE( 280)								xml->set(aname,val1);
+HXLINE( 281)								state = 0;
+HXLINE( 282)								next = 4;
+            							}
+            						}
+            					}
+            				}
+            				break;
+            				case (int)9: {
+HXLINE( 285)					p = ::haxe::xml::Parser_obj::doParse(str,strict,p,xml);
+HXLINE( 286)					start = p;
+HXLINE( 287)					state = 1;
+            				}
+            				break;
+            				case (int)10: {
+HXLINE( 305)					bool _hx_tmp16;
+HXDLIN( 305)					bool _hx_tmp17;
+HXDLIN( 305)					bool _hx_tmp18;
+HXDLIN( 305)					bool _hx_tmp19;
+HXDLIN( 305)					bool _hx_tmp20;
+HXDLIN( 305)					bool _hx_tmp21;
+HXDLIN( 305)					bool _hx_tmp22;
+HXDLIN( 305)					if ((c >= 97)) {
+HXLINE( 305)						_hx_tmp22 = (c <= 122);
+            					}
+            					else {
+HXLINE( 305)						_hx_tmp22 = false;
+            					}
+HXDLIN( 305)					if (!(_hx_tmp22)) {
+HXLINE( 305)						if ((c >= 65)) {
+HXLINE( 305)							_hx_tmp21 = (c <= 90);
+            						}
+            						else {
+HXLINE( 305)							_hx_tmp21 = false;
+            						}
+            					}
+            					else {
+HXLINE( 305)						_hx_tmp21 = true;
+            					}
+HXDLIN( 305)					if (!(_hx_tmp21)) {
+HXLINE( 305)						if ((c >= 48)) {
+HXLINE( 305)							_hx_tmp20 = (c <= 57);
+            						}
+            						else {
+HXLINE( 305)							_hx_tmp20 = false;
+            						}
+            					}
+            					else {
+HXLINE( 305)						_hx_tmp20 = true;
+            					}
+HXDLIN( 305)					if (!(_hx_tmp20)) {
+HXLINE( 305)						_hx_tmp19 = (c == 58);
+            					}
+            					else {
+HXLINE( 305)						_hx_tmp19 = true;
+            					}
+HXDLIN( 305)					if (!(_hx_tmp19)) {
+HXLINE( 305)						_hx_tmp18 = (c == 46);
+            					}
+            					else {
+HXLINE( 305)						_hx_tmp18 = true;
+            					}
+HXDLIN( 305)					if (!(_hx_tmp18)) {
+HXLINE( 305)						_hx_tmp17 = (c == 95);
+            					}
+            					else {
+HXLINE( 305)						_hx_tmp17 = true;
+            					}
+HXDLIN( 305)					if (!(_hx_tmp17)) {
+HXLINE( 305)						_hx_tmp16 = (c == 45);
+            					}
+            					else {
+HXLINE( 305)						_hx_tmp16 = true;
+            					}
+HXDLIN( 305)					if (!(_hx_tmp16)) {
+HXLINE( 306)						if ((start == p)) {
+HXLINE( 307)							HX_STACK_DO_THROW( ::haxe::xml::XmlParserException_obj::__alloc( HX_CTX ,HX_("Expected node name",a1,85,63,3f),str,p));
+            						}
+HXLINE( 309)						::String v = str.substr(start,(p - start));
+HXLINE( 310)						bool _hx_tmp23;
+HXDLIN( 310)						if (::hx::IsNotNull( parent )) {
+HXLINE( 310)							_hx_tmp23 = (parent->nodeType != 0);
+            						}
+            						else {
+HXLINE( 310)							_hx_tmp23 = true;
+            						}
+HXDLIN( 310)						if (_hx_tmp23) {
+HXLINE( 311)							HX_STACK_DO_THROW( ::haxe::xml::XmlParserException_obj::__alloc( HX_CTX ,((HX_("Unexpected </",42,6f,35,1e) + v) + HX_(">, tag is not open",35,30,75,b8)),str,p));
+            						}
+HXLINE( 313)						if ((parent->nodeType != ::Xml_obj::Element)) {
+HXLINE( 313)							HX_STACK_DO_THROW((HX_("Bad node type, expected Element but found ",d8,90,8b,bb) + ::_Xml::XmlType_Impl__obj::toString(parent->nodeType)));
+            						}
+HXDLIN( 313)						if ((v != parent->nodeName)) {
+HXLINE( 314)							if ((parent->nodeType != ::Xml_obj::Element)) {
+HXLINE( 314)								HX_STACK_DO_THROW((HX_("Bad node type, expected Element but found ",d8,90,8b,bb) + ::_Xml::XmlType_Impl__obj::toString(parent->nodeType)));
+            							}
+HXDLIN( 314)							HX_STACK_DO_THROW( ::haxe::xml::XmlParserException_obj::__alloc( HX_CTX ,((HX_("Expected </",fb,40,3d,99) + parent->nodeName) + HX_(">",3e,00,00,00)),str,p));
+            						}
+HXLINE( 316)						state = 0;
+HXLINE( 317)						next = 12;
+HXLINE( 318)						continue;
+            					}
+            				}
+            				break;
+            				case (int)11: {
+HXLINE( 289)					if ((c == 62)) {
+HXLINE( 291)						state = 1;
+            					}
+            					else {
+HXLINE( 293)						HX_STACK_DO_THROW( ::haxe::xml::XmlParserException_obj::__alloc( HX_CTX ,HX_("Expected >",b6,dc,23,c6),str,p));
+            					}
+            				}
+            				break;
+            				case (int)12: {
+HXLINE( 296)					if ((c == 62)) {
+HXLINE( 298)						if ((nsubs == 0)) {
+HXLINE( 299)							parent->addChild(::Xml_obj::createPCData(HX_("",00,00,00,00)));
+            						}
+HXLINE( 300)						return p;
+            					}
+            					else {
+HXLINE( 302)						HX_STACK_DO_THROW( ::haxe::xml::XmlParserException_obj::__alloc( HX_CTX ,HX_("Expected >",b6,dc,23,c6),str,p));
+            					}
+            				}
+            				break;
+            				case (int)13: {
+HXLINE( 158)					if ((c == 60)) {
+HXLINE( 159)						{
+HXLINE( 159)							 ::Dynamic len3 = (p - start);
+HXDLIN( 159)							if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 159)								buf->flush();
+            							}
+HXDLIN( 159)							if (::hx::IsNull( buf->b )) {
+HXLINE( 159)								buf->b = ::Array_obj< ::String >::__new(1)->init(0,str.substr(start,len3));
+            							}
+            							else {
+HXLINE( 159)								::Array< ::String > buf4 = buf->b;
+HXDLIN( 159)								buf4->push(str.substr(start,len3));
+            							}
+            						}
+HXLINE( 160)						 ::Xml child = ::Xml_obj::createPCData(buf->toString());
+HXLINE( 161)						buf =  ::StringBuf_obj::__alloc( HX_CTX );
+HXLINE( 162)						{
+HXLINE( 162)							parent->addChild(child);
+HXDLIN( 162)							nsubs = (nsubs + 1);
+            						}
+HXLINE( 163)						state = 0;
+HXLINE( 164)						next = 2;
+            					}
+            					else {
+HXLINE( 165)						if ((c == 38)) {
+HXLINE( 166)							{
+HXLINE( 166)								 ::Dynamic len4 = (p - start);
+HXDLIN( 166)								if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 166)									buf->flush();
+            								}
+HXDLIN( 166)								if (::hx::IsNull( buf->b )) {
+HXLINE( 166)									buf->b = ::Array_obj< ::String >::__new(1)->init(0,str.substr(start,len4));
+            								}
+            								else {
+HXLINE( 166)									::Array< ::String > buf5 = buf->b;
+HXDLIN( 166)									buf5->push(str.substr(start,len4));
+            								}
+            							}
+HXLINE( 167)							state = 18;
+HXLINE( 168)							escapeNext = 13;
+HXLINE( 169)							start = (p + 1);
+            						}
+            					}
+            				}
+            				break;
+            				case (int)14: {
+HXLINE( 336)					bool _hx_tmp24;
+HXDLIN( 336)					if ((c == 63)) {
+HXLINE( 336)						_hx_tmp24 = (str.cca((p + 1)) == 62);
+            					}
+            					else {
+HXLINE( 336)						_hx_tmp24 = false;
+            					}
+HXDLIN( 336)					if (_hx_tmp24) {
+HXLINE( 337)						p = (p + 1);
+HXLINE( 338)						::String str1 = str.substr((start + 1),((p - start) - 2));
+HXLINE( 339)						{
+HXLINE( 339)							parent->addChild(::Xml_obj::createProcessingInstruction(str1));
+HXDLIN( 339)							nsubs = (nsubs + 1);
+            						}
+HXLINE( 340)						state = 1;
+            					}
+            				}
+            				break;
+            				case (int)15: {
+HXLINE( 321)					bool _hx_tmp25;
+HXDLIN( 321)					bool _hx_tmp26;
+HXDLIN( 321)					if ((c == 45)) {
+HXLINE( 321)						_hx_tmp26 = (str.cca((p + 1)) == 45);
+            					}
+            					else {
+HXLINE( 321)						_hx_tmp26 = false;
+            					}
+HXDLIN( 321)					if (_hx_tmp26) {
+HXLINE( 321)						_hx_tmp25 = (str.cca((p + 2)) == 62);
+            					}
+            					else {
+HXLINE( 321)						_hx_tmp25 = false;
+            					}
+HXDLIN( 321)					if (_hx_tmp25) {
+HXLINE( 322)						{
+HXLINE( 322)							parent->addChild(::Xml_obj::createComment(str.substr(start,(p - start))));
+HXDLIN( 322)							nsubs = (nsubs + 1);
+            						}
+HXLINE( 323)						p = (p + 2);
+HXLINE( 324)						state = 1;
+            					}
+            				}
+            				break;
+            				case (int)16: {
+HXLINE( 327)					if ((c == 91)) {
+HXLINE( 328)						nbrackets = (nbrackets + 1);
+            					}
+            					else {
+HXLINE( 329)						if ((c == 93)) {
+HXLINE( 330)							nbrackets = (nbrackets - 1);
+            						}
+            						else {
+HXLINE( 331)							bool _hx_tmp27;
+HXDLIN( 331)							if ((c == 62)) {
+HXLINE( 331)								_hx_tmp27 = (nbrackets == 0);
+            							}
+            							else {
+HXLINE( 331)								_hx_tmp27 = false;
+            							}
+HXDLIN( 331)							if (_hx_tmp27) {
+HXLINE( 332)								{
+HXLINE( 332)									parent->addChild(::Xml_obj::createDocType(str.substr(start,(p - start))));
+HXDLIN( 332)									nsubs = (nsubs + 1);
+            								}
+HXLINE( 333)								state = 1;
+            							}
+            						}
+            					}
+            				}
+            				break;
+            				case (int)17: {
+HXLINE( 172)					bool _hx_tmp28;
+HXDLIN( 172)					bool _hx_tmp29;
+HXDLIN( 172)					if ((c == 93)) {
+HXLINE( 172)						_hx_tmp29 = (str.cca((p + 1)) == 93);
+            					}
+            					else {
+HXLINE( 172)						_hx_tmp29 = false;
+            					}
+HXDLIN( 172)					if (_hx_tmp29) {
+HXLINE( 172)						_hx_tmp28 = (str.cca((p + 2)) == 62);
+            					}
+            					else {
+HXLINE( 172)						_hx_tmp28 = false;
+            					}
+HXDLIN( 172)					if (_hx_tmp28) {
+HXLINE( 173)						 ::Xml child1 = ::Xml_obj::createCData(str.substr(start,(p - start)));
+HXLINE( 174)						{
+HXLINE( 174)							parent->addChild(child1);
+HXDLIN( 174)							nsubs = (nsubs + 1);
+            						}
+HXLINE( 175)						p = (p + 2);
+HXLINE( 176)						state = 1;
+            					}
+            				}
+            				break;
+            				case (int)18: {
+HXLINE( 343)					if ((c == 59)) {
+HXLINE( 344)						::String s = str.substr(start,(p - start));
+HXLINE( 345)						if ((s.cca(0) == 35)) {
+HXLINE( 346)							 ::Dynamic c1;
+HXDLIN( 346)							if ((s.cca(1) == 120)) {
+HXLINE( 346)								c1 = ::Std_obj::parseInt((HX_("0",30,00,00,00) + s.substr(1,(s.length - 1))));
+            							}
+            							else {
+HXLINE( 346)								c1 = ::Std_obj::parseInt(s.substr(1,(s.length - 1)));
+            							}
+HXLINE( 366)							{
+HXLINE( 366)								int c2 = ( (int)(c1) );
+HXDLIN( 366)								if ((c2 >= 127)) {
+HXLINE( 366)									::String x = ::String::fromCharCode(c2);
+HXDLIN( 366)									if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 366)										buf->flush();
+            									}
+HXDLIN( 366)									if (::hx::IsNull( buf->b )) {
+HXLINE( 366)										buf->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(x));
+            									}
+            									else {
+HXLINE( 366)										::Array< ::String > buf6 = buf->b;
+HXDLIN( 366)										buf6->push(::Std_obj::string(x));
+            									}
+            								}
+            								else {
+HXLINE( 366)									if (::hx::IsNull( buf->charBuf )) {
+HXLINE( 366)										buf->charBuf = ::Array_obj< char >::__new();
+            									}
+HXDLIN( 366)									buf->charBuf->push(c2);
+            								}
+            							}
+            						}
+            						else {
+HXLINE( 367)							if (!(::haxe::xml::Parser_obj::escapes->exists(s))) {
+HXLINE( 368)								if (strict) {
+HXLINE( 369)									HX_STACK_DO_THROW( ::haxe::xml::XmlParserException_obj::__alloc( HX_CTX ,(HX_("Undefined entity: ",39,48,f2,48) + s),str,p));
+            								}
+HXLINE( 370)								{
+HXLINE( 370)									::String x1 = ((HX_("&",26,00,00,00) + s) + HX_(";",3b,00,00,00));
+HXDLIN( 370)									if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 370)										buf->flush();
+            									}
+HXDLIN( 370)									if (::hx::IsNull( buf->b )) {
+HXLINE( 370)										buf->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(x1));
+            									}
+            									else {
+HXLINE( 370)										::Array< ::String > buf7 = buf->b;
+HXDLIN( 370)										buf7->push(::Std_obj::string(x1));
+            									}
+            								}
+            							}
+            							else {
+HXLINE( 372)								::String x2 = ::haxe::xml::Parser_obj::escapes->get_string(s);
+HXDLIN( 372)								if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 372)									buf->flush();
+            								}
+HXDLIN( 372)								if (::hx::IsNull( buf->b )) {
+HXLINE( 372)									buf->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(x2));
+            								}
+            								else {
+HXLINE( 372)									::Array< ::String > buf8 = buf->b;
+HXDLIN( 372)									buf8->push(::Std_obj::string(x2));
+            								}
+            							}
+            						}
+HXLINE( 374)						start = (p + 1);
+HXLINE( 375)						state = escapeNext;
+            					}
+            					else {
+HXLINE( 376)						bool _hx_tmp30;
+HXDLIN( 376)						bool _hx_tmp31;
+HXDLIN( 376)						bool _hx_tmp32;
+HXDLIN( 376)						bool _hx_tmp33;
+HXDLIN( 376)						bool _hx_tmp34;
+HXDLIN( 376)						bool _hx_tmp35;
+HXDLIN( 376)						bool _hx_tmp36;
+HXDLIN( 376)						bool _hx_tmp37;
+HXDLIN( 376)						if ((c >= 97)) {
+HXLINE( 376)							_hx_tmp37 = (c <= 122);
+            						}
+            						else {
+HXLINE( 376)							_hx_tmp37 = false;
+            						}
+HXDLIN( 376)						if (!(_hx_tmp37)) {
+HXLINE( 376)							if ((c >= 65)) {
+HXLINE( 376)								_hx_tmp36 = (c <= 90);
+            							}
+            							else {
+HXLINE( 376)								_hx_tmp36 = false;
+            							}
+            						}
+            						else {
+HXLINE( 376)							_hx_tmp36 = true;
+            						}
+HXDLIN( 376)						if (!(_hx_tmp36)) {
+HXLINE( 376)							if ((c >= 48)) {
+HXLINE( 376)								_hx_tmp35 = (c <= 57);
+            							}
+            							else {
+HXLINE( 376)								_hx_tmp35 = false;
+            							}
+            						}
+            						else {
+HXLINE( 376)							_hx_tmp35 = true;
+            						}
+HXDLIN( 376)						if (!(_hx_tmp35)) {
+HXLINE( 376)							_hx_tmp34 = (c == 58);
+            						}
+            						else {
+HXLINE( 376)							_hx_tmp34 = true;
+            						}
+HXDLIN( 376)						if (!(_hx_tmp34)) {
+HXLINE( 376)							_hx_tmp33 = (c == 46);
+            						}
+            						else {
+HXLINE( 376)							_hx_tmp33 = true;
+            						}
+HXDLIN( 376)						if (!(_hx_tmp33)) {
+HXLINE( 376)							_hx_tmp32 = (c == 95);
+            						}
+            						else {
+HXLINE( 376)							_hx_tmp32 = true;
+            						}
+HXDLIN( 376)						if (!(_hx_tmp32)) {
+HXLINE( 376)							_hx_tmp31 = (c == 45);
+            						}
+            						else {
+HXLINE( 376)							_hx_tmp31 = true;
+            						}
+HXDLIN( 376)						if (!(_hx_tmp31)) {
+HXLINE( 376)							_hx_tmp30 = (c != 35);
+            						}
+            						else {
+HXLINE( 376)							_hx_tmp30 = false;
+            						}
+HXDLIN( 376)						if (_hx_tmp30) {
+HXLINE( 377)							if (strict) {
+HXLINE( 378)								HX_STACK_DO_THROW( ::haxe::xml::XmlParserException_obj::__alloc( HX_CTX ,(HX_("Invalid character in entity: ",24,85,11,30) + ::String::fromCharCode(c)),str,p));
+            							}
+HXLINE( 379)							{
+HXLINE( 379)								if (::hx::IsNull( buf->charBuf )) {
+HXLINE( 379)									buf->charBuf = ::Array_obj< char >::__new();
+            								}
+HXDLIN( 379)								buf->charBuf->push(38);
+            							}
+HXLINE( 380)							{
+HXLINE( 380)								 ::Dynamic len5 = (p - start);
+HXDLIN( 380)								if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 380)									buf->flush();
+            								}
+HXDLIN( 380)								if (::hx::IsNull( buf->b )) {
+HXLINE( 380)									buf->b = ::Array_obj< ::String >::__new(1)->init(0,str.substr(start,len5));
+            								}
+            								else {
+HXLINE( 380)									::Array< ::String > buf9 = buf->b;
+HXDLIN( 380)									buf9->push(str.substr(start,len5));
+            								}
+            							}
+HXLINE( 381)							p = (p - 1);
+HXLINE( 382)							start = (p + 1);
+HXLINE( 383)							state = escapeNext;
+            						}
+            					}
+            				}
+            				break;
+            			}
+HXLINE( 386)			p = (p + 1);
+            		}
+HXLINE( 389)		if ((state == 1)) {
+HXLINE( 390)			start = p;
+HXLINE( 391)			state = 13;
+            		}
+HXLINE( 394)		if ((state == 13)) {
+HXLINE( 395)			if ((parent->nodeType == 0)) {
+HXLINE( 396)				if ((parent->nodeType != ::Xml_obj::Element)) {
+HXLINE( 396)					HX_STACK_DO_THROW((HX_("Bad node type, expected Element but found ",d8,90,8b,bb) + ::_Xml::XmlType_Impl__obj::toString(parent->nodeType)));
+            				}
+HXDLIN( 396)				HX_STACK_DO_THROW( ::haxe::xml::XmlParserException_obj::__alloc( HX_CTX ,((HX_("Unclosed node <",79,04,e1,00) + parent->nodeName) + HX_(">",3e,00,00,00)),str,p));
+            			}
+HXLINE( 398)			bool _hx_tmp38;
+HXDLIN( 398)			if ((p == start)) {
+HXLINE( 398)				_hx_tmp38 = (nsubs == 0);
+            			}
+            			else {
+HXLINE( 398)				_hx_tmp38 = true;
+            			}
+HXDLIN( 398)			if (_hx_tmp38) {
+HXLINE( 399)				{
+HXLINE( 399)					 ::Dynamic len6 = (p - start);
+HXDLIN( 399)					if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 399)						buf->flush();
+            					}
+HXDLIN( 399)					if (::hx::IsNull( buf->b )) {
+HXLINE( 399)						buf->b = ::Array_obj< ::String >::__new(1)->init(0,str.substr(start,len6));
+            					}
+            					else {
+HXLINE( 399)						::Array< ::String > buf10 = buf->b;
+HXDLIN( 399)						buf10->push(str.substr(start,len6));
+            					}
+            				}
+HXLINE( 400)				{
+HXLINE( 400)					parent->addChild(::Xml_obj::createPCData(buf->toString()));
+HXDLIN( 400)					nsubs = (nsubs + 1);
+            				}
+            			}
+HXLINE( 402)			return p;
+            		}
+HXLINE( 405)		bool _hx_tmp39;
+HXDLIN( 405)		bool _hx_tmp40;
+HXDLIN( 405)		if (!(strict)) {
+HXLINE( 405)			_hx_tmp40 = (state == 18);
+            		}
+            		else {
+HXLINE( 405)			_hx_tmp40 = false;
+            		}
+HXDLIN( 405)		if (_hx_tmp40) {
+HXLINE( 405)			_hx_tmp39 = (escapeNext == 13);
+            		}
+            		else {
+HXLINE( 405)			_hx_tmp39 = false;
+            		}
+HXDLIN( 405)		if (_hx_tmp39) {
+HXLINE( 406)			{
+HXLINE( 406)				if (::hx::IsNull( buf->charBuf )) {
+HXLINE( 406)					buf->charBuf = ::Array_obj< char >::__new();
+            				}
+HXDLIN( 406)				buf->charBuf->push(38);
+            			}
+HXLINE( 407)			{
+HXLINE( 407)				 ::Dynamic len7 = (p - start);
+HXDLIN( 407)				if (::hx::IsNotNull( buf->charBuf )) {
+HXLINE( 407)					buf->flush();
+            				}
+HXDLIN( 407)				if (::hx::IsNull( buf->b )) {
+HXLINE( 407)					buf->b = ::Array_obj< ::String >::__new(1)->init(0,str.substr(start,len7));
+            				}
+            				else {
+HXLINE( 407)					::Array< ::String > buf11 = buf->b;
+HXDLIN( 407)					buf11->push(str.substr(start,len7));
+            				}
+            			}
+HXLINE( 408)			{
+HXLINE( 408)				parent->addChild(::Xml_obj::createPCData(buf->toString()));
+HXDLIN( 408)				nsubs = (nsubs + 1);
+            			}
+HXLINE( 409)			return p;
+            		}
+HXLINE( 412)		HX_STACK_DO_THROW( ::haxe::xml::XmlParserException_obj::__alloc( HX_CTX ,HX_("Unexpected end",2c,3e,ab,50),str,p));
+HXDLIN( 412)		return 0;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC4(Parser_obj,doParse,return )
+
+
+Parser_obj::Parser_obj()
+{
+}
+
+bool Parser_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 5:
+		if (HX_FIELD_EQ(inName,"parse") ) { outValue = parse_dyn(); return true; }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"escapes") ) { outValue = ( escapes ); return true; }
+		if (HX_FIELD_EQ(inName,"doParse") ) { outValue = doParse_dyn(); return true; }
+	}
+	return false;
+}
+
+bool Parser_obj::__SetStatic(const ::String &inName,Dynamic &ioValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 7:
+		if (HX_FIELD_EQ(inName,"escapes") ) { escapes=ioValue.Cast<  ::haxe::ds::StringMap >(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *Parser_obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo Parser_obj_sStaticStorageInfo[] = {
+	{::hx::fsObject /*  ::haxe::ds::StringMap */ ,(void *) &Parser_obj::escapes,HX_("escapes",d2,cd,20,a4)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+#endif
+
+static void Parser_obj_sMarkStatics(HX_MARK_PARAMS) {
+	HX_MARK_MEMBER_NAME(Parser_obj::escapes,"escapes");
+};
+
+#ifdef HXCPP_VISIT_ALLOCS
+static void Parser_obj_sVisitStatics(HX_VISIT_PARAMS) {
+	HX_VISIT_MEMBER_NAME(Parser_obj::escapes,"escapes");
+};
+
+#endif
+
+::hx::Class Parser_obj::__mClass;
+
+static ::String Parser_obj_sStaticFields[] = {
+	HX_("escapes",d2,cd,20,a4),
+	HX_("parse",33,90,55,bd),
+	HX_("doParse",a8,70,82,f0),
+	::String(null())
+};
+
+void Parser_obj::__register()
+{
+	Parser_obj _hx_dummy;
+	Parser_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.xml.Parser",fe,49,90,c4);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &Parser_obj::__GetStatic;
+	__mClass->mSetStaticField = &Parser_obj::__SetStatic;
+	__mClass->mMarkFunc = Parser_obj_sMarkStatics;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(Parser_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< Parser_obj >;
+#ifdef HXCPP_VISIT_ALLOCS
+	__mClass->mVisitFunc = Parser_obj_sVisitStatics;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Parser_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Parser_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+void Parser_obj::__boot()
+{
+{
+            		HX_BEGIN_LOCAL_FUNC_S0(::hx::LocalFunc,_hx_Closure_0) HXARGC(0)
+            		 ::haxe::ds::StringMap _hx_run(){
+            			HX_GC_STACKFRAME(&_hx_pos_4387901c245e1a2b_100_boot)
+HXLINE( 101)			 ::haxe::ds::StringMap h =  ::haxe::ds::StringMap_obj::__alloc( HX_CTX );
+HXLINE( 102)			h->set(HX_("lt",88,5e,00,00),HX_("<",3c,00,00,00));
+HXLINE( 103)			h->set(HX_("gt",2d,5a,00,00),HX_(">",3e,00,00,00));
+HXLINE( 104)			h->set(HX_("amp",04,fa,49,00),HX_("&",26,00,00,00));
+HXLINE( 105)			h->set(HX_("quot",09,45,0a,4b),HX_("\"",22,00,00,00));
+HXLINE( 106)			h->set(HX_("apos",d3,0f,73,40),HX_("'",27,00,00,00));
+HXLINE( 107)			return h;
+            		}
+            		HX_END_LOCAL_FUNC0(return)
+
+            	HX_STACKFRAME(&_hx_pos_4387901c245e1a2b_100_boot)
+HXDLIN( 100)		escapes = ( ( ::haxe::ds::StringMap)( ::Dynamic(new _hx_Closure_0())()) );
+            	}
+}
+
+} // end namespace haxe
+} // end namespace xml
diff --git a/Sources/c_snikket/src/haxe/xml/Printer.cpp b/Sources/c_snikket/src/haxe/xml/Printer.cpp
new file mode 100644
index 0000000..6e89882
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/xml/Printer.cpp
@@ -0,0 +1,782 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_EReg
+#include <EReg.h>
+#endif
+#ifndef INCLUDED_Std
+#include <Std.h>
+#endif
+#ifndef INCLUDED_StringBuf
+#include <StringBuf.h>
+#endif
+#ifndef INCLUDED_StringTools
+#include <StringTools.h>
+#endif
+#ifndef INCLUDED_Xml
+#include <Xml.h>
+#endif
+#ifndef INCLUDED__Xml_XmlType_Impl_
+#include <_Xml/XmlType_Impl_.h>
+#endif
+#ifndef INCLUDED_haxe_xml_Printer
+#include <haxe/xml/Printer.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_2f9c3fa4cd4885c0_44_new,"haxe.xml.Printer","new",0x896dce4d,"haxe.xml.Printer.new","/usr/local/lib/haxe/std/haxe/xml/Printer.hx",44,0x9a833f28)
+HX_LOCAL_STACK_FRAME(_hx_pos_2f9c3fa4cd4885c0_50_writeNode,"haxe.xml.Printer","writeNode",0x6952ac2e,"haxe.xml.Printer.writeNode","/usr/local/lib/haxe/std/haxe/xml/Printer.hx",50,0x9a833f28)
+static const ::String _hx_array_data_d3e3a3db_5[] = {
+	HX_("\"",22,00,00,00),
+};
+static const ::String _hx_array_data_d3e3a3db_6[] = {
+	HX_(">",3e,00,00,00),
+};
+static const ::String _hx_array_data_d3e3a3db_7[] = {
+	HX_("\n",0a,00,00,00),
+};
+static const ::String _hx_array_data_d3e3a3db_8[] = {
+	HX_(">",3e,00,00,00),
+};
+static const ::String _hx_array_data_d3e3a3db_9[] = {
+	HX_("\n",0a,00,00,00),
+};
+static const ::String _hx_array_data_d3e3a3db_10[] = {
+	HX_("/>",2f,29,00,00),
+};
+static const ::String _hx_array_data_d3e3a3db_11[] = {
+	HX_("\n",0a,00,00,00),
+};
+static const ::String _hx_array_data_d3e3a3db_12[] = {
+	HX_("\n",0a,00,00,00),
+};
+static const ::String _hx_array_data_d3e3a3db_13[] = {
+	HX_("]]>",de,e2,46,00),
+};
+static const ::String _hx_array_data_d3e3a3db_14[] = {
+	HX_("\n",0a,00,00,00),
+};
+static const ::String _hx_array_data_d3e3a3db_15[] = {
+	HX_("\n",0a,00,00,00),
+};
+static const ::String _hx_array_data_d3e3a3db_16[] = {
+	HX_("\n",0a,00,00,00),
+};
+static const ::String _hx_array_data_d3e3a3db_17[] = {
+	HX_("\n",0a,00,00,00),
+};
+HX_LOCAL_STACK_FRAME(_hx_pos_2f9c3fa4cd4885c0_114_hasChildren,"haxe.xml.Printer","hasChildren",0xeb7e31a6,"haxe.xml.Printer.hasChildren","/usr/local/lib/haxe/std/haxe/xml/Printer.hx",114,0x9a833f28)
+HX_LOCAL_STACK_FRAME(_hx_pos_2f9c3fa4cd4885c0_35_print,"haxe.xml.Printer","print",0x4a926b5a,"haxe.xml.Printer.print","/usr/local/lib/haxe/std/haxe/xml/Printer.hx",35,0x9a833f28)
+namespace haxe{
+namespace xml{
+
+void Printer_obj::__construct(bool pretty){
+            	HX_GC_STACKFRAME(&_hx_pos_2f9c3fa4cd4885c0_44_new)
+HXLINE(  45)		this->output =  ::StringBuf_obj::__alloc( HX_CTX );
+HXLINE(  46)		this->pretty = pretty;
+            	}
+
+Dynamic Printer_obj::__CreateEmpty() { return new Printer_obj; }
+
+void *Printer_obj::_hx_vtable = 0;
+
+Dynamic Printer_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Printer_obj > _hx_result = new Printer_obj();
+	_hx_result->__construct(inArgs[0]);
+	return _hx_result;
+}
+
+bool Printer_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x5ef86269;
+}
+
+void Printer_obj::writeNode( ::Xml value,::String tabs){
+            	HX_GC_STACKFRAME(&_hx_pos_2f9c3fa4cd4885c0_50_writeNode)
+HXDLIN(  50)		switch((int)(value->nodeType)){
+            			case (int)0: {
+HXLINE(  68)				{
+HXLINE(  68)					::String input = (tabs + HX_("<",3c,00,00,00));
+HXDLIN(  68)					{
+HXLINE(  68)						 ::StringBuf _this = this->output;
+HXDLIN(  68)						if (::hx::IsNotNull( _this->charBuf )) {
+HXLINE(  68)							_this->flush();
+            						}
+HXDLIN(  68)						if (::hx::IsNull( _this->b )) {
+HXLINE(  68)							_this->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(input));
+            						}
+            						else {
+HXLINE(  68)							::Array< ::String > _this1 = _this->b;
+HXDLIN(  68)							_this1->push(::Std_obj::string(input));
+            						}
+            					}
+            				}
+HXLINE(  69)				{
+HXLINE(  69)					if ((value->nodeType != ::Xml_obj::Element)) {
+HXLINE(  69)						HX_STACK_DO_THROW((HX_("Bad node type, expected Element but found ",d8,90,8b,bb) + ::_Xml::XmlType_Impl__obj::toString(value->nodeType)));
+            					}
+HXDLIN(  69)					::String input1 = value->nodeName;
+HXDLIN(  69)					{
+HXLINE(  69)						 ::StringBuf _this2 = this->output;
+HXDLIN(  69)						if (::hx::IsNotNull( _this2->charBuf )) {
+HXLINE(  69)							_this2->flush();
+            						}
+HXDLIN(  69)						if (::hx::IsNull( _this2->b )) {
+HXLINE(  69)							_this2->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(input1));
+            						}
+            						else {
+HXLINE(  69)							::Array< ::String > _this3 = _this2->b;
+HXDLIN(  69)							_this3->push(::Std_obj::string(input1));
+            						}
+            					}
+            				}
+HXLINE(  70)				{
+HXLINE(  70)					 ::Dynamic attribute = value->attributes();
+HXDLIN(  70)					while(( (bool)(attribute->__Field(HX_("hasNext",6d,a5,46,18),::hx::paccDynamic)()) )){
+HXLINE(  70)						::String attribute1 = ( (::String)(attribute->__Field(HX_("next",f3,84,02,49),::hx::paccDynamic)()) );
+HXLINE(  71)						{
+HXLINE(  71)							::String input2 = ((HX_(" ",20,00,00,00) + attribute1) + HX_("=\"",45,35,00,00));
+HXDLIN(  71)							{
+HXLINE(  71)								 ::StringBuf _this4 = this->output;
+HXDLIN(  71)								if (::hx::IsNotNull( _this4->charBuf )) {
+HXLINE(  71)									_this4->flush();
+            								}
+HXDLIN(  71)								if (::hx::IsNull( _this4->b )) {
+HXLINE(  71)									_this4->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(input2));
+            								}
+            								else {
+HXLINE(  71)									::Array< ::String > _this5 = _this4->b;
+HXDLIN(  71)									_this5->push(::Std_obj::string(input2));
+            								}
+            							}
+            						}
+HXLINE(  72)						{
+HXLINE(  72)							::String input3 = ::StringTools_obj::htmlEscape(value->get(attribute1),true);
+HXDLIN(  72)							{
+HXLINE(  72)								 ::StringBuf _this6 = this->output;
+HXDLIN(  72)								if (::hx::IsNotNull( _this6->charBuf )) {
+HXLINE(  72)									_this6->flush();
+            								}
+HXDLIN(  72)								if (::hx::IsNull( _this6->b )) {
+HXLINE(  72)									_this6->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(input3));
+            								}
+            								else {
+HXLINE(  72)									::Array< ::String > _this7 = _this6->b;
+HXDLIN(  72)									_this7->push(::Std_obj::string(input3));
+            								}
+            							}
+            						}
+HXLINE(  73)						{
+HXLINE(  73)							 ::StringBuf _this8 = this->output;
+HXDLIN(  73)							if (::hx::IsNotNull( _this8->charBuf )) {
+HXLINE(  73)								_this8->flush();
+            							}
+HXDLIN(  73)							if (::hx::IsNull( _this8->b )) {
+HXLINE(  73)								_this8->b = ::Array_obj< ::String >::fromData( _hx_array_data_d3e3a3db_5,1);
+            							}
+            							else {
+HXLINE(  73)								_this8->b->push(HX_("\"",22,00,00,00));
+            							}
+            						}
+            					}
+            				}
+HXLINE(  75)				if (this->hasChildren(value)) {
+HXLINE(  76)					{
+HXLINE(  76)						 ::StringBuf _this9 = this->output;
+HXDLIN(  76)						if (::hx::IsNotNull( _this9->charBuf )) {
+HXLINE(  76)							_this9->flush();
+            						}
+HXDLIN(  76)						if (::hx::IsNull( _this9->b )) {
+HXLINE(  76)							_this9->b = ::Array_obj< ::String >::fromData( _hx_array_data_d3e3a3db_6,1);
+            						}
+            						else {
+HXLINE(  76)							_this9->b->push(HX_(">",3e,00,00,00));
+            						}
+            					}
+HXLINE(  77)					if (this->pretty) {
+HXLINE(  77)						 ::StringBuf _this10 = this->output;
+HXDLIN(  77)						if (::hx::IsNotNull( _this10->charBuf )) {
+HXLINE(  77)							_this10->flush();
+            						}
+HXDLIN(  77)						if (::hx::IsNull( _this10->b )) {
+HXLINE(  77)							_this10->b = ::Array_obj< ::String >::fromData( _hx_array_data_d3e3a3db_7,1);
+            						}
+            						else {
+HXLINE(  77)							_this10->b->push(HX_("\n",0a,00,00,00));
+            						}
+            					}
+HXLINE(  78)					{
+HXLINE(  78)						bool _hx_tmp;
+HXDLIN(  78)						if ((value->nodeType != ::Xml_obj::Document)) {
+HXLINE(  78)							_hx_tmp = (value->nodeType != ::Xml_obj::Element);
+            						}
+            						else {
+HXLINE(  78)							_hx_tmp = false;
+            						}
+HXDLIN(  78)						if (_hx_tmp) {
+HXLINE(  78)							HX_STACK_DO_THROW((HX_("Bad node type, expected Element or Document but found ",a0,d6,ba,79) + ::_Xml::XmlType_Impl__obj::toString(value->nodeType)));
+            						}
+HXDLIN(  78)						int _g_current = 0;
+HXDLIN(  78)						::Array< ::Dynamic> _g_array = value->children;
+HXDLIN(  78)						while((_g_current < _g_array->length)){
+HXLINE(  78)							_g_current = (_g_current + 1);
+HXDLIN(  78)							 ::Xml child = _g_array->__get((_g_current - 1)).StaticCast<  ::Xml >();
+HXLINE(  79)							::String _hx_tmp1;
+HXDLIN(  79)							if (this->pretty) {
+HXLINE(  79)								_hx_tmp1 = (tabs + HX_("\t",09,00,00,00));
+            							}
+            							else {
+HXLINE(  79)								_hx_tmp1 = tabs;
+            							}
+HXDLIN(  79)							this->writeNode(child,_hx_tmp1);
+            						}
+            					}
+HXLINE(  81)					{
+HXLINE(  81)						::String input4 = (tabs + HX_("</",73,34,00,00));
+HXDLIN(  81)						{
+HXLINE(  81)							 ::StringBuf _this11 = this->output;
+HXDLIN(  81)							if (::hx::IsNotNull( _this11->charBuf )) {
+HXLINE(  81)								_this11->flush();
+            							}
+HXDLIN(  81)							if (::hx::IsNull( _this11->b )) {
+HXLINE(  81)								_this11->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(input4));
+            							}
+            							else {
+HXLINE(  81)								::Array< ::String > _this12 = _this11->b;
+HXDLIN(  81)								_this12->push(::Std_obj::string(input4));
+            							}
+            						}
+            					}
+HXLINE(  82)					{
+HXLINE(  82)						if ((value->nodeType != ::Xml_obj::Element)) {
+HXLINE(  82)							HX_STACK_DO_THROW((HX_("Bad node type, expected Element but found ",d8,90,8b,bb) + ::_Xml::XmlType_Impl__obj::toString(value->nodeType)));
+            						}
+HXDLIN(  82)						::String input5 = value->nodeName;
+HXDLIN(  82)						{
+HXLINE(  82)							 ::StringBuf _this13 = this->output;
+HXDLIN(  82)							if (::hx::IsNotNull( _this13->charBuf )) {
+HXLINE(  82)								_this13->flush();
+            							}
+HXDLIN(  82)							if (::hx::IsNull( _this13->b )) {
+HXLINE(  82)								_this13->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(input5));
+            							}
+            							else {
+HXLINE(  82)								::Array< ::String > _this14 = _this13->b;
+HXDLIN(  82)								_this14->push(::Std_obj::string(input5));
+            							}
+            						}
+            					}
+HXLINE(  83)					{
+HXLINE(  83)						 ::StringBuf _this15 = this->output;
+HXDLIN(  83)						if (::hx::IsNotNull( _this15->charBuf )) {
+HXLINE(  83)							_this15->flush();
+            						}
+HXDLIN(  83)						if (::hx::IsNull( _this15->b )) {
+HXLINE(  83)							_this15->b = ::Array_obj< ::String >::fromData( _hx_array_data_d3e3a3db_8,1);
+            						}
+            						else {
+HXLINE(  83)							_this15->b->push(HX_(">",3e,00,00,00));
+            						}
+            					}
+HXLINE(  84)					if (this->pretty) {
+HXLINE(  84)						 ::StringBuf _this16 = this->output;
+HXDLIN(  84)						if (::hx::IsNotNull( _this16->charBuf )) {
+HXLINE(  84)							_this16->flush();
+            						}
+HXDLIN(  84)						if (::hx::IsNull( _this16->b )) {
+HXLINE(  84)							_this16->b = ::Array_obj< ::String >::fromData( _hx_array_data_d3e3a3db_9,1);
+            						}
+            						else {
+HXLINE(  84)							_this16->b->push(HX_("\n",0a,00,00,00));
+            						}
+            					}
+            				}
+            				else {
+HXLINE(  86)					{
+HXLINE(  86)						 ::StringBuf _this17 = this->output;
+HXDLIN(  86)						if (::hx::IsNotNull( _this17->charBuf )) {
+HXLINE(  86)							_this17->flush();
+            						}
+HXDLIN(  86)						if (::hx::IsNull( _this17->b )) {
+HXLINE(  86)							_this17->b = ::Array_obj< ::String >::fromData( _hx_array_data_d3e3a3db_10,1);
+            						}
+            						else {
+HXLINE(  86)							_this17->b->push(HX_("/>",2f,29,00,00));
+            						}
+            					}
+HXLINE(  87)					if (this->pretty) {
+HXLINE(  87)						 ::StringBuf _this18 = this->output;
+HXDLIN(  87)						if (::hx::IsNotNull( _this18->charBuf )) {
+HXLINE(  87)							_this18->flush();
+            						}
+HXDLIN(  87)						if (::hx::IsNull( _this18->b )) {
+HXLINE(  87)							_this18->b = ::Array_obj< ::String >::fromData( _hx_array_data_d3e3a3db_11,1);
+            						}
+            						else {
+HXLINE(  87)							_this18->b->push(HX_("\n",0a,00,00,00));
+            						}
+            					}
+            				}
+            			}
+            			break;
+            			case (int)1: {
+HXLINE(  90)				bool _hx_tmp2;
+HXDLIN(  90)				if ((value->nodeType != ::Xml_obj::Document)) {
+HXLINE(  90)					_hx_tmp2 = (value->nodeType == ::Xml_obj::Element);
+            				}
+            				else {
+HXLINE(  90)					_hx_tmp2 = true;
+            				}
+HXDLIN(  90)				if (_hx_tmp2) {
+HXLINE(  90)					HX_STACK_DO_THROW((HX_("Bad node type, unexpected ",be,79,d5,11) + ::_Xml::XmlType_Impl__obj::toString(value->nodeType)));
+            				}
+HXDLIN(  90)				::String nodeValue = value->nodeValue;
+HXLINE(  91)				if ((nodeValue.length != 0)) {
+HXLINE(  92)					{
+HXLINE(  92)						::String input6 = (tabs + ::StringTools_obj::htmlEscape(nodeValue,null()));
+HXDLIN(  92)						{
+HXLINE(  92)							 ::StringBuf _this19 = this->output;
+HXDLIN(  92)							if (::hx::IsNotNull( _this19->charBuf )) {
+HXLINE(  92)								_this19->flush();
+            							}
+HXDLIN(  92)							if (::hx::IsNull( _this19->b )) {
+HXLINE(  92)								_this19->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(input6));
+            							}
+            							else {
+HXLINE(  92)								::Array< ::String > _this20 = _this19->b;
+HXDLIN(  92)								_this20->push(::Std_obj::string(input6));
+            							}
+            						}
+            					}
+HXLINE(  93)					if (this->pretty) {
+HXLINE(  93)						 ::StringBuf _this21 = this->output;
+HXDLIN(  93)						if (::hx::IsNotNull( _this21->charBuf )) {
+HXLINE(  93)							_this21->flush();
+            						}
+HXDLIN(  93)						if (::hx::IsNull( _this21->b )) {
+HXLINE(  93)							_this21->b = ::Array_obj< ::String >::fromData( _hx_array_data_d3e3a3db_12,1);
+            						}
+            						else {
+HXLINE(  93)							_this21->b->push(HX_("\n",0a,00,00,00));
+            						}
+            					}
+            				}
+            			}
+            			break;
+            			case (int)2: {
+HXLINE(  52)				{
+HXLINE(  52)					::String input7 = (tabs + HX_("<![CDATA[",a4,fc,95,b4));
+HXDLIN(  52)					{
+HXLINE(  52)						 ::StringBuf _this22 = this->output;
+HXDLIN(  52)						if (::hx::IsNotNull( _this22->charBuf )) {
+HXLINE(  52)							_this22->flush();
+            						}
+HXDLIN(  52)						if (::hx::IsNull( _this22->b )) {
+HXLINE(  52)							_this22->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(input7));
+            						}
+            						else {
+HXLINE(  52)							::Array< ::String > _this23 = _this22->b;
+HXDLIN(  52)							_this23->push(::Std_obj::string(input7));
+            						}
+            					}
+            				}
+HXLINE(  53)				{
+HXLINE(  53)					bool _hx_tmp3;
+HXDLIN(  53)					if ((value->nodeType != ::Xml_obj::Document)) {
+HXLINE(  53)						_hx_tmp3 = (value->nodeType == ::Xml_obj::Element);
+            					}
+            					else {
+HXLINE(  53)						_hx_tmp3 = true;
+            					}
+HXDLIN(  53)					if (_hx_tmp3) {
+HXLINE(  53)						HX_STACK_DO_THROW((HX_("Bad node type, unexpected ",be,79,d5,11) + ::_Xml::XmlType_Impl__obj::toString(value->nodeType)));
+            					}
+HXDLIN(  53)					::String input8 = value->nodeValue;
+HXDLIN(  53)					{
+HXLINE(  53)						 ::StringBuf _this24 = this->output;
+HXDLIN(  53)						if (::hx::IsNotNull( _this24->charBuf )) {
+HXLINE(  53)							_this24->flush();
+            						}
+HXDLIN(  53)						if (::hx::IsNull( _this24->b )) {
+HXLINE(  53)							_this24->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(input8));
+            						}
+            						else {
+HXLINE(  53)							::Array< ::String > _this25 = _this24->b;
+HXDLIN(  53)							_this25->push(::Std_obj::string(input8));
+            						}
+            					}
+            				}
+HXLINE(  54)				{
+HXLINE(  54)					 ::StringBuf _this26 = this->output;
+HXDLIN(  54)					if (::hx::IsNotNull( _this26->charBuf )) {
+HXLINE(  54)						_this26->flush();
+            					}
+HXDLIN(  54)					if (::hx::IsNull( _this26->b )) {
+HXLINE(  54)						_this26->b = ::Array_obj< ::String >::fromData( _hx_array_data_d3e3a3db_13,1);
+            					}
+            					else {
+HXLINE(  54)						_this26->b->push(HX_("]]>",de,e2,46,00));
+            					}
+            				}
+HXLINE(  55)				if (this->pretty) {
+HXLINE(  55)					 ::StringBuf _this27 = this->output;
+HXDLIN(  55)					if (::hx::IsNotNull( _this27->charBuf )) {
+HXLINE(  55)						_this27->flush();
+            					}
+HXDLIN(  55)					if (::hx::IsNull( _this27->b )) {
+HXLINE(  55)						_this27->b = ::Array_obj< ::String >::fromData( _hx_array_data_d3e3a3db_14,1);
+            					}
+            					else {
+HXLINE(  55)						_this27->b->push(HX_("\n",0a,00,00,00));
+            					}
+            				}
+            			}
+            			break;
+            			case (int)3: {
+HXLINE(  57)				bool _hx_tmp4;
+HXDLIN(  57)				if ((value->nodeType != ::Xml_obj::Document)) {
+HXLINE(  57)					_hx_tmp4 = (value->nodeType == ::Xml_obj::Element);
+            				}
+            				else {
+HXLINE(  57)					_hx_tmp4 = true;
+            				}
+HXDLIN(  57)				if (_hx_tmp4) {
+HXLINE(  57)					HX_STACK_DO_THROW((HX_("Bad node type, unexpected ",be,79,d5,11) + ::_Xml::XmlType_Impl__obj::toString(value->nodeType)));
+            				}
+HXDLIN(  57)				::String commentContent = value->nodeValue;
+HXLINE(  58)				commentContent =  ::EReg_obj::__alloc( HX_CTX ,HX_("[\n\r\t]+",59,8e,1a,2d),HX_("g",67,00,00,00))->replace(commentContent,HX_("",00,00,00,00));
+HXLINE(  59)				commentContent = ((HX_("<!--",05,ff,c1,27) + commentContent) + HX_("-->",de,4c,22,00));
+HXLINE(  60)				{
+HXLINE(  60)					 ::StringBuf _this28 = this->output;
+HXDLIN(  60)					if (::hx::IsNotNull( _this28->charBuf )) {
+HXLINE(  60)						_this28->flush();
+            					}
+HXDLIN(  60)					if (::hx::IsNull( _this28->b )) {
+HXLINE(  60)						_this28->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(tabs));
+            					}
+            					else {
+HXLINE(  60)						::Array< ::String > _this29 = _this28->b;
+HXDLIN(  60)						_this29->push(::Std_obj::string(tabs));
+            					}
+            				}
+HXLINE(  61)				{
+HXLINE(  61)					::String input9 = ::StringTools_obj::trim(commentContent);
+HXDLIN(  61)					{
+HXLINE(  61)						 ::StringBuf _this30 = this->output;
+HXDLIN(  61)						if (::hx::IsNotNull( _this30->charBuf )) {
+HXLINE(  61)							_this30->flush();
+            						}
+HXDLIN(  61)						if (::hx::IsNull( _this30->b )) {
+HXLINE(  61)							_this30->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(input9));
+            						}
+            						else {
+HXLINE(  61)							::Array< ::String > _this31 = _this30->b;
+HXDLIN(  61)							_this31->push(::Std_obj::string(input9));
+            						}
+            					}
+            				}
+HXLINE(  62)				if (this->pretty) {
+HXLINE(  62)					 ::StringBuf _this32 = this->output;
+HXDLIN(  62)					if (::hx::IsNotNull( _this32->charBuf )) {
+HXLINE(  62)						_this32->flush();
+            					}
+HXDLIN(  62)					if (::hx::IsNull( _this32->b )) {
+HXLINE(  62)						_this32->b = ::Array_obj< ::String >::fromData( _hx_array_data_d3e3a3db_15,1);
+            					}
+            					else {
+HXLINE(  62)						_this32->b->push(HX_("\n",0a,00,00,00));
+            					}
+            				}
+            			}
+            			break;
+            			case (int)4: {
+HXLINE(  99)				{
+HXLINE(  99)					bool input10;
+HXDLIN(  99)					if ((value->nodeType != ::Xml_obj::Document)) {
+HXLINE(  99)						input10 = (value->nodeType == ::Xml_obj::Element);
+            					}
+            					else {
+HXLINE(  99)						input10 = true;
+            					}
+HXDLIN(  99)					if (input10) {
+HXLINE(  99)						HX_STACK_DO_THROW((HX_("Bad node type, unexpected ",be,79,d5,11) + ::_Xml::XmlType_Impl__obj::toString(value->nodeType)));
+            					}
+HXDLIN(  99)					::String input11 = ((HX_("<!DOCTYPE ",33,6c,bb,ab) + value->nodeValue) + HX_(">",3e,00,00,00));
+HXDLIN(  99)					{
+HXLINE(  99)						 ::StringBuf _this33 = this->output;
+HXDLIN(  99)						if (::hx::IsNotNull( _this33->charBuf )) {
+HXLINE(  99)							_this33->flush();
+            						}
+HXDLIN(  99)						if (::hx::IsNull( _this33->b )) {
+HXLINE(  99)							_this33->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(input11));
+            						}
+            						else {
+HXLINE(  99)							::Array< ::String > _this34 = _this33->b;
+HXDLIN(  99)							_this34->push(::Std_obj::string(input11));
+            						}
+            					}
+            				}
+HXLINE( 100)				if (this->pretty) {
+HXLINE( 100)					 ::StringBuf _this35 = this->output;
+HXDLIN( 100)					if (::hx::IsNotNull( _this35->charBuf )) {
+HXLINE( 100)						_this35->flush();
+            					}
+HXDLIN( 100)					if (::hx::IsNull( _this35->b )) {
+HXLINE( 100)						_this35->b = ::Array_obj< ::String >::fromData( _hx_array_data_d3e3a3db_16,1);
+            					}
+            					else {
+HXLINE( 100)						_this35->b->push(HX_("\n",0a,00,00,00));
+            					}
+            				}
+            			}
+            			break;
+            			case (int)5: {
+HXLINE(  96)				{
+HXLINE(  96)					bool input12;
+HXDLIN(  96)					if ((value->nodeType != ::Xml_obj::Document)) {
+HXLINE(  96)						input12 = (value->nodeType == ::Xml_obj::Element);
+            					}
+            					else {
+HXLINE(  96)						input12 = true;
+            					}
+HXDLIN(  96)					if (input12) {
+HXLINE(  96)						HX_STACK_DO_THROW((HX_("Bad node type, unexpected ",be,79,d5,11) + ::_Xml::XmlType_Impl__obj::toString(value->nodeType)));
+            					}
+HXDLIN(  96)					::String input13 = ((HX_("<?",83,34,00,00) + value->nodeValue) + HX_("?>",1f,37,00,00));
+HXDLIN(  96)					{
+HXLINE(  96)						 ::StringBuf _this36 = this->output;
+HXDLIN(  96)						if (::hx::IsNotNull( _this36->charBuf )) {
+HXLINE(  96)							_this36->flush();
+            						}
+HXDLIN(  96)						if (::hx::IsNull( _this36->b )) {
+HXLINE(  96)							_this36->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(input13));
+            						}
+            						else {
+HXLINE(  96)							::Array< ::String > _this37 = _this36->b;
+HXDLIN(  96)							_this37->push(::Std_obj::string(input13));
+            						}
+            					}
+            				}
+HXLINE(  97)				if (this->pretty) {
+HXLINE(  97)					 ::StringBuf _this38 = this->output;
+HXDLIN(  97)					if (::hx::IsNotNull( _this38->charBuf )) {
+HXLINE(  97)						_this38->flush();
+            					}
+HXDLIN(  97)					if (::hx::IsNull( _this38->b )) {
+HXLINE(  97)						_this38->b = ::Array_obj< ::String >::fromData( _hx_array_data_d3e3a3db_17,1);
+            					}
+            					else {
+HXLINE(  97)						_this38->b->push(HX_("\n",0a,00,00,00));
+            					}
+            				}
+            			}
+            			break;
+            			case (int)6: {
+HXLINE(  64)				bool _hx_tmp5;
+HXDLIN(  64)				if ((value->nodeType != ::Xml_obj::Document)) {
+HXLINE(  64)					_hx_tmp5 = (value->nodeType != ::Xml_obj::Element);
+            				}
+            				else {
+HXLINE(  64)					_hx_tmp5 = false;
+            				}
+HXDLIN(  64)				if (_hx_tmp5) {
+HXLINE(  64)					HX_STACK_DO_THROW((HX_("Bad node type, expected Element or Document but found ",a0,d6,ba,79) + ::_Xml::XmlType_Impl__obj::toString(value->nodeType)));
+            				}
+HXDLIN(  64)				int _g_current1 = 0;
+HXDLIN(  64)				::Array< ::Dynamic> _g_array1 = value->children;
+HXDLIN(  64)				while((_g_current1 < _g_array1->length)){
+HXLINE(  64)					_g_current1 = (_g_current1 + 1);
+HXDLIN(  64)					 ::Xml child1 = _g_array1->__get((_g_current1 - 1)).StaticCast<  ::Xml >();
+HXLINE(  65)					this->writeNode(child1,tabs);
+            				}
+            			}
+            			break;
+            		}
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(Printer_obj,writeNode,(void))
+
+bool Printer_obj::hasChildren( ::Xml value){
+            	HX_STACKFRAME(&_hx_pos_2f9c3fa4cd4885c0_114_hasChildren)
+HXLINE( 115)		{
+HXLINE( 115)			bool _hx_tmp;
+HXDLIN( 115)			if ((value->nodeType != ::Xml_obj::Document)) {
+HXLINE( 115)				_hx_tmp = (value->nodeType != ::Xml_obj::Element);
+            			}
+            			else {
+HXLINE( 115)				_hx_tmp = false;
+            			}
+HXDLIN( 115)			if (_hx_tmp) {
+HXLINE( 115)				HX_STACK_DO_THROW((HX_("Bad node type, expected Element or Document but found ",a0,d6,ba,79) + ::_Xml::XmlType_Impl__obj::toString(value->nodeType)));
+            			}
+HXDLIN( 115)			int _g_current = 0;
+HXDLIN( 115)			::Array< ::Dynamic> _g_array = value->children;
+HXDLIN( 115)			while((_g_current < _g_array->length)){
+HXLINE( 115)				_g_current = (_g_current + 1);
+HXDLIN( 115)				 ::Xml child = _g_array->__get((_g_current - 1)).StaticCast<  ::Xml >();
+HXLINE( 116)				switch((int)(child->nodeType)){
+            					case (int)0: case (int)1: {
+HXLINE( 118)						return true;
+            					}
+            					break;
+            					case (int)2: case (int)3: {
+HXLINE( 120)						bool _hx_tmp1;
+HXDLIN( 120)						if ((child->nodeType != ::Xml_obj::Document)) {
+HXLINE( 120)							_hx_tmp1 = (child->nodeType == ::Xml_obj::Element);
+            						}
+            						else {
+HXLINE( 120)							_hx_tmp1 = true;
+            						}
+HXDLIN( 120)						if (_hx_tmp1) {
+HXLINE( 120)							HX_STACK_DO_THROW((HX_("Bad node type, unexpected ",be,79,d5,11) + ::_Xml::XmlType_Impl__obj::toString(child->nodeType)));
+            						}
+HXDLIN( 120)						if ((::StringTools_obj::ltrim(child->nodeValue).length != 0)) {
+HXLINE( 121)							return true;
+            						}
+            					}
+            					break;
+            					default:{
+            					}
+            				}
+            			}
+            		}
+HXLINE( 126)		return false;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Printer_obj,hasChildren,return )
+
+::String Printer_obj::print( ::Xml xml, ::Dynamic __o_pretty){
+            		 ::Dynamic pretty = __o_pretty;
+            		if (::hx::IsNull(__o_pretty)) pretty = false;
+            	HX_GC_STACKFRAME(&_hx_pos_2f9c3fa4cd4885c0_35_print)
+HXLINE(  36)		 ::haxe::xml::Printer printer =  ::haxe::xml::Printer_obj::__alloc( HX_CTX ,( (bool)(pretty) ));
+HXLINE(  37)		printer->writeNode(xml,HX_("",00,00,00,00));
+HXLINE(  38)		return printer->output->toString();
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(Printer_obj,print,return )
+
+
+::hx::ObjectPtr< Printer_obj > Printer_obj::__new(bool pretty) {
+	::hx::ObjectPtr< Printer_obj > __this = new Printer_obj();
+	__this->__construct(pretty);
+	return __this;
+}
+
+::hx::ObjectPtr< Printer_obj > Printer_obj::__alloc(::hx::Ctx *_hx_ctx,bool pretty) {
+	Printer_obj *__this = (Printer_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Printer_obj), true, "haxe.xml.Printer"));
+	*(void **)__this = Printer_obj::_hx_vtable;
+	__this->__construct(pretty);
+	return __this;
+}
+
+Printer_obj::Printer_obj()
+{
+}
+
+void Printer_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(Printer);
+	HX_MARK_MEMBER_NAME(output,"output");
+	HX_MARK_MEMBER_NAME(pretty,"pretty");
+	HX_MARK_END_CLASS();
+}
+
+void Printer_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(output,"output");
+	HX_VISIT_MEMBER_NAME(pretty,"pretty");
+}
+
+::hx::Val Printer_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 6:
+		if (HX_FIELD_EQ(inName,"output") ) { return ::hx::Val( output ); }
+		if (HX_FIELD_EQ(inName,"pretty") ) { return ::hx::Val( pretty ); }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"writeNode") ) { return ::hx::Val( writeNode_dyn() ); }
+		break;
+	case 11:
+		if (HX_FIELD_EQ(inName,"hasChildren") ) { return ::hx::Val( hasChildren_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+bool Printer_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 5:
+		if (HX_FIELD_EQ(inName,"print") ) { outValue = print_dyn(); return true; }
+	}
+	return false;
+}
+
+::hx::Val Printer_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 6:
+		if (HX_FIELD_EQ(inName,"output") ) { output=inValue.Cast<  ::StringBuf >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"pretty") ) { pretty=inValue.Cast< bool >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void Printer_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("output",01,0f,81,0c));
+	outFields->push(HX_("pretty",b6,82,c1,ae));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo Printer_obj_sMemberStorageInfo[] = {
+	{::hx::fsObject /*  ::StringBuf */ ,(int)offsetof(Printer_obj,output),HX_("output",01,0f,81,0c)},
+	{::hx::fsBool,(int)offsetof(Printer_obj,pretty),HX_("pretty",b6,82,c1,ae)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *Printer_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String Printer_obj_sMemberFields[] = {
+	HX_("output",01,0f,81,0c),
+	HX_("pretty",b6,82,c1,ae),
+	HX_("writeNode",81,fe,bd,51),
+	HX_("hasChildren",b9,fe,20,43),
+	::String(null()) };
+
+::hx::Class Printer_obj::__mClass;
+
+static ::String Printer_obj_sStaticFields[] = {
+	HX_("print",2d,58,8b,c8),
+	::String(null())
+};
+
+void Printer_obj::__register()
+{
+	Printer_obj _hx_dummy;
+	Printer_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.xml.Printer",db,a3,e3,d3);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &Printer_obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(Printer_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(Printer_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< Printer_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Printer_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Printer_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace xml
diff --git a/Sources/c_snikket/src/haxe/xml/XmlParserException.cpp b/Sources/c_snikket/src/haxe/xml/XmlParserException.cpp
new file mode 100644
index 0000000..d304181
--- /dev/null
+++ b/Sources/c_snikket/src/haxe/xml/XmlParserException.cpp
@@ -0,0 +1,205 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Type
+#include <Type.h>
+#endif
+#ifndef INCLUDED_haxe_xml_XmlParserException
+#include <haxe/xml/XmlParserException.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_6a0d351bb43bf432_75_new,"haxe.xml.XmlParserException","new",0xcd6fdfea,"haxe.xml.XmlParserException.new","/usr/local/lib/haxe/std/haxe/xml/Parser.hx",75,0x9bd139bb)
+HX_LOCAL_STACK_FRAME(_hx_pos_6a0d351bb43bf432_95_toString,"haxe.xml.XmlParserException","toString",0xed7c2ce2,"haxe.xml.XmlParserException.toString","/usr/local/lib/haxe/std/haxe/xml/Parser.hx",95,0x9bd139bb)
+namespace haxe{
+namespace xml{
+
+void XmlParserException_obj::__construct(::String message,::String xml,int position){
+            	HX_STACKFRAME(&_hx_pos_6a0d351bb43bf432_75_new)
+HXLINE(  76)		this->xml = xml;
+HXLINE(  77)		this->message = message;
+HXLINE(  78)		this->position = position;
+HXLINE(  79)		this->lineNumber = 1;
+HXLINE(  80)		this->positionAtLine = 0;
+HXLINE(  82)		{
+HXLINE(  82)			int _g = 0;
+HXDLIN(  82)			int _g1 = position;
+HXDLIN(  82)			while((_g < _g1)){
+HXLINE(  82)				_g = (_g + 1);
+HXDLIN(  82)				int i = (_g - 1);
+HXLINE(  83)				int c = xml.cca(i);
+HXLINE(  84)				if ((c == 10)) {
+HXLINE(  85)					this->lineNumber++;
+HXLINE(  86)					this->positionAtLine = 0;
+            				}
+            				else {
+HXLINE(  88)					if ((c != 13)) {
+HXLINE(  89)						this->positionAtLine++;
+            					}
+            				}
+            			}
+            		}
+            	}
+
+Dynamic XmlParserException_obj::__CreateEmpty() { return new XmlParserException_obj; }
+
+void *XmlParserException_obj::_hx_vtable = 0;
+
+Dynamic XmlParserException_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< XmlParserException_obj > _hx_result = new XmlParserException_obj();
+	_hx_result->__construct(inArgs[0],inArgs[1],inArgs[2]);
+	return _hx_result;
+}
+
+bool XmlParserException_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x75f2332a;
+}
+
+::String XmlParserException_obj::toString(){
+            	HX_STACKFRAME(&_hx_pos_6a0d351bb43bf432_95_toString)
+HXDLIN(  95)		::String _hx_tmp = (::Type_obj::getClassName(::Type_obj::getClass(::hx::ObjectPtr<OBJ_>(this))) + HX_(": ",a6,32,00,00));
+HXDLIN(  95)		return (((((_hx_tmp + this->message) + HX_(" at line ",df,96,71,22)) + this->lineNumber) + HX_(" char ",6a,28,1f,11)) + this->positionAtLine);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(XmlParserException_obj,toString,return )
+
+
+::hx::ObjectPtr< XmlParserException_obj > XmlParserException_obj::__new(::String message,::String xml,int position) {
+	::hx::ObjectPtr< XmlParserException_obj > __this = new XmlParserException_obj();
+	__this->__construct(message,xml,position);
+	return __this;
+}
+
+::hx::ObjectPtr< XmlParserException_obj > XmlParserException_obj::__alloc(::hx::Ctx *_hx_ctx,::String message,::String xml,int position) {
+	XmlParserException_obj *__this = (XmlParserException_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(XmlParserException_obj), true, "haxe.xml.XmlParserException"));
+	*(void **)__this = XmlParserException_obj::_hx_vtable;
+	__this->__construct(message,xml,position);
+	return __this;
+}
+
+XmlParserException_obj::XmlParserException_obj()
+{
+}
+
+void XmlParserException_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(XmlParserException);
+	HX_MARK_MEMBER_NAME(message,"message");
+	HX_MARK_MEMBER_NAME(lineNumber,"lineNumber");
+	HX_MARK_MEMBER_NAME(positionAtLine,"positionAtLine");
+	HX_MARK_MEMBER_NAME(position,"position");
+	HX_MARK_MEMBER_NAME(xml,"xml");
+	HX_MARK_END_CLASS();
+}
+
+void XmlParserException_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(message,"message");
+	HX_VISIT_MEMBER_NAME(lineNumber,"lineNumber");
+	HX_VISIT_MEMBER_NAME(positionAtLine,"positionAtLine");
+	HX_VISIT_MEMBER_NAME(position,"position");
+	HX_VISIT_MEMBER_NAME(xml,"xml");
+}
+
+::hx::Val XmlParserException_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"xml") ) { return ::hx::Val( xml ); }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"message") ) { return ::hx::Val( message ); }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"position") ) { return ::hx::Val( position ); }
+		if (HX_FIELD_EQ(inName,"toString") ) { return ::hx::Val( toString_dyn() ); }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"lineNumber") ) { return ::hx::Val( lineNumber ); }
+		break;
+	case 14:
+		if (HX_FIELD_EQ(inName,"positionAtLine") ) { return ::hx::Val( positionAtLine ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val XmlParserException_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"xml") ) { xml=inValue.Cast< ::String >(); return inValue; }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"message") ) { message=inValue.Cast< ::String >(); return inValue; }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"position") ) { position=inValue.Cast< int >(); return inValue; }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"lineNumber") ) { lineNumber=inValue.Cast< int >(); return inValue; }
+		break;
+	case 14:
+		if (HX_FIELD_EQ(inName,"positionAtLine") ) { positionAtLine=inValue.Cast< int >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void XmlParserException_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("message",c7,35,11,9a));
+	outFields->push(HX_("lineNumber",dd,81,22,76));
+	outFields->push(HX_("positionAtLine",10,08,98,1a));
+	outFields->push(HX_("position",a9,a0,fa,ca));
+	outFields->push(HX_("xml",d7,6d,5b,00));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo XmlParserException_obj_sMemberStorageInfo[] = {
+	{::hx::fsString,(int)offsetof(XmlParserException_obj,message),HX_("message",c7,35,11,9a)},
+	{::hx::fsInt,(int)offsetof(XmlParserException_obj,lineNumber),HX_("lineNumber",dd,81,22,76)},
+	{::hx::fsInt,(int)offsetof(XmlParserException_obj,positionAtLine),HX_("positionAtLine",10,08,98,1a)},
+	{::hx::fsInt,(int)offsetof(XmlParserException_obj,position),HX_("position",a9,a0,fa,ca)},
+	{::hx::fsString,(int)offsetof(XmlParserException_obj,xml),HX_("xml",d7,6d,5b,00)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *XmlParserException_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String XmlParserException_obj_sMemberFields[] = {
+	HX_("message",c7,35,11,9a),
+	HX_("lineNumber",dd,81,22,76),
+	HX_("positionAtLine",10,08,98,1a),
+	HX_("position",a9,a0,fa,ca),
+	HX_("xml",d7,6d,5b,00),
+	HX_("toString",ac,d0,6e,38),
+	::String(null()) };
+
+::hx::Class XmlParserException_obj::__mClass;
+
+void XmlParserException_obj::__register()
+{
+	XmlParserException_obj _hx_dummy;
+	XmlParserException_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("haxe.xml.XmlParserException",f8,62,fb,04);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(XmlParserException_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< XmlParserException_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = XmlParserException_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = XmlParserException_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace haxe
+} // end namespace xml
diff --git a/Sources/c_snikket/src/hsluv/Hsluv.cpp b/Sources/c_snikket/src/hsluv/Hsluv.cpp
new file mode 100644
index 0000000..28f479c
--- /dev/null
+++ b/Sources/c_snikket/src/hsluv/Hsluv.cpp
@@ -0,0 +1,841 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_95f339a1d026d52c
+#define INCLUDED_95f339a1d026d52c
+#include "hxMath.h"
+#endif
+#ifndef INCLUDED_Std
+#include <Std.h>
+#endif
+#ifndef INCLUDED_hsluv_Hsluv
+#include <hsluv/Hsluv.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_72_new,"hsluv.Hsluv","new",0xd01091a8,"hsluv.Hsluv.new","hsluv/Hsluv.hx",72,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_151_rgbToHex,"hsluv.Hsluv","rgbToHex",0x5aeaf38b,"hsluv.Hsluv.rgbToHex","hsluv/Hsluv.hx",151,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_165_xyzToRgb,"hsluv.Hsluv","xyzToRgb",0x37343af1,"hsluv.Hsluv.xyzToRgb","hsluv/Hsluv.hx",165,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_204_luvToXyz,"hsluv.Hsluv","luvToXyz",0x49183249,"hsluv.Hsluv.luvToXyz","hsluv/Hsluv.hx",204,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_237_lchToLuv,"hsluv.Hsluv","lchToLuv",0xc38dacf9,"hsluv.Hsluv.lchToLuv","hsluv/Hsluv.hx",237,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_249_calculateBoundingLines,"hsluv.Hsluv","calculateBoundingLines",0xe9896a6d,"hsluv.Hsluv.calculateBoundingLines","hsluv/Hsluv.hx",249,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_335_calcMaxChromaHsluv,"hsluv.Hsluv","calcMaxChromaHsluv",0x9a0d4135,"hsluv.Hsluv.calcMaxChromaHsluv","hsluv/Hsluv.hx",335,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_346_hsluvToLch,"hsluv.Hsluv","hsluvToLch",0xd6a5c00c,"hsluv.Hsluv.hsluvToLch","hsluv/Hsluv.hx",346,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_414_hsluvToRgb,"hsluv.Hsluv","hsluvToRgb",0xd6aa5108,"hsluv.Hsluv.hsluvToRgb","hsluv/Hsluv.hx",414,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_428_hsluvToHex,"hsluv.Hsluv","hsluvToHex",0xd6a2b8d6,"hsluv.Hsluv.hsluvToHex","hsluv/Hsluv.hx",428,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_100_fromLinear,"hsluv.Hsluv","fromLinear",0x2de1cea7,"hsluv.Hsluv.fromLinear","hsluv/Hsluv.hx",100,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_130_lToY,"hsluv.Hsluv","lToY",0x3d0f872a,"hsluv.Hsluv.lToY","hsluv/Hsluv.hx",130,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_137_rgbChannelToHex,"hsluv.Hsluv","rgbChannelToHex",0x76cd5452,"hsluv.Hsluv.rgbChannelToHex","hsluv/Hsluv.hx",137,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_298_distanceFromOriginAngle,"hsluv.Hsluv","distanceFromOriginAngle",0xf7a4dc56,"hsluv.Hsluv.distanceFromOriginAngle","hsluv/Hsluv.hx",298,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_312_min6,"hsluv.Hsluv","min6",0x3dc8ac1c,"hsluv.Hsluv.min6","hsluv/Hsluv.hx",312,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_74_boot,"hsluv.Hsluv","boot",0x3687e1ea,"hsluv.Hsluv.boot","hsluv/Hsluv.hx",74,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_76_boot,"hsluv.Hsluv","boot",0x3687e1ea,"hsluv.Hsluv.boot","hsluv/Hsluv.hx",76,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_78_boot,"hsluv.Hsluv","boot",0x3687e1ea,"hsluv.Hsluv.boot","hsluv/Hsluv.hx",78,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_79_boot,"hsluv.Hsluv","boot",0x3687e1ea,"hsluv.Hsluv.boot","hsluv/Hsluv.hx",79,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_82_boot,"hsluv.Hsluv","boot",0x3687e1ea,"hsluv.Hsluv.boot","hsluv/Hsluv.hx",82,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_83_boot,"hsluv.Hsluv","boot",0x3687e1ea,"hsluv.Hsluv.boot","hsluv/Hsluv.hx",83,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_86_boot,"hsluv.Hsluv","boot",0x3687e1ea,"hsluv.Hsluv.boot","hsluv/Hsluv.hx",86,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_87_boot,"hsluv.Hsluv","boot",0x3687e1ea,"hsluv.Hsluv.boot","hsluv/Hsluv.hx",87,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_88_boot,"hsluv.Hsluv","boot",0x3687e1ea,"hsluv.Hsluv.boot","hsluv/Hsluv.hx",88,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_90_boot,"hsluv.Hsluv","boot",0x3687e1ea,"hsluv.Hsluv.boot","hsluv/Hsluv.hx",90,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_91_boot,"hsluv.Hsluv","boot",0x3687e1ea,"hsluv.Hsluv.boot","hsluv/Hsluv.hx",91,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_92_boot,"hsluv.Hsluv","boot",0x3687e1ea,"hsluv.Hsluv.boot","hsluv/Hsluv.hx",92,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_94_boot,"hsluv.Hsluv","boot",0x3687e1ea,"hsluv.Hsluv.boot","hsluv/Hsluv.hx",94,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_95_boot,"hsluv.Hsluv","boot",0x3687e1ea,"hsluv.Hsluv.boot","hsluv/Hsluv.hx",95,0x09d4c3c9)
+HX_LOCAL_STACK_FRAME(_hx_pos_d5dc22b6e2ff60be_96_boot,"hsluv.Hsluv","boot",0x3687e1ea,"hsluv.Hsluv.boot","hsluv/Hsluv.hx",96,0x09d4c3c9)
+namespace hsluv{
+
+void Hsluv_obj::__construct(){
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_72_new)
+            	}
+
+Dynamic Hsluv_obj::__CreateEmpty() { return new Hsluv_obj; }
+
+void *Hsluv_obj::_hx_vtable = 0;
+
+Dynamic Hsluv_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Hsluv_obj > _hx_result = new Hsluv_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool Hsluv_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x29e47ee8;
+}
+
+void Hsluv_obj::rgbToHex(){
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_151_rgbToHex)
+HXLINE( 152)		this->hex = HX_("#",23,00,00,00);
+HXLINE( 153)		 ::hsluv::Hsluv _hx_tmp = ::hx::ObjectPtr<OBJ_>(this);
+HXDLIN( 153)		::String _hx_tmp1 = _hx_tmp->hex;
+HXDLIN( 153)		_hx_tmp->hex = (_hx_tmp1 + ::hsluv::Hsluv_obj::rgbChannelToHex(this->rgb_r));
+HXLINE( 154)		 ::hsluv::Hsluv _hx_tmp2 = ::hx::ObjectPtr<OBJ_>(this);
+HXDLIN( 154)		::String _hx_tmp3 = _hx_tmp2->hex;
+HXDLIN( 154)		_hx_tmp2->hex = (_hx_tmp3 + ::hsluv::Hsluv_obj::rgbChannelToHex(this->rgb_g));
+HXLINE( 155)		 ::hsluv::Hsluv _hx_tmp4 = ::hx::ObjectPtr<OBJ_>(this);
+HXDLIN( 155)		::String _hx_tmp5 = _hx_tmp4->hex;
+HXDLIN( 155)		_hx_tmp4->hex = (_hx_tmp5 + ::hsluv::Hsluv_obj::rgbChannelToHex(this->rgb_b));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Hsluv_obj,rgbToHex,(void))
+
+void Hsluv_obj::xyzToRgb(){
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_165_xyzToRgb)
+HXLINE( 166)		this->rgb_r = ::hsluv::Hsluv_obj::fromLinear((((::hsluv::Hsluv_obj::m_r0 * this->xyz_x) + (::hsluv::Hsluv_obj::m_r1 * this->xyz_y)) + (::hsluv::Hsluv_obj::m_r2 * this->xyz_z)));
+HXLINE( 167)		this->rgb_g = ::hsluv::Hsluv_obj::fromLinear((((::hsluv::Hsluv_obj::m_g0 * this->xyz_x) + (::hsluv::Hsluv_obj::m_g1 * this->xyz_y)) + (::hsluv::Hsluv_obj::m_g2 * this->xyz_z)));
+HXLINE( 168)		this->rgb_b = ::hsluv::Hsluv_obj::fromLinear((((::hsluv::Hsluv_obj::m_b0 * this->xyz_x) + (::hsluv::Hsluv_obj::m_b1 * this->xyz_y)) + (::hsluv::Hsluv_obj::m_b2 * this->xyz_z)));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Hsluv_obj,xyzToRgb,(void))
+
+void Hsluv_obj::luvToXyz(){
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_204_luvToXyz)
+HXLINE( 205)		if ((this->luv_l == 0)) {
+HXLINE( 206)			this->xyz_x = ( (Float)(0) );
+HXLINE( 207)			this->xyz_y = ( (Float)(0) );
+HXLINE( 208)			this->xyz_z = ( (Float)(0) );
+HXLINE( 209)			return;
+            		}
+HXLINE( 212)		Float varU = ((this->luv_u / (( (Float)(13) ) * this->luv_l)) + ::hsluv::Hsluv_obj::refU);
+HXLINE( 213)		Float varV = ((this->luv_v / (( (Float)(13) ) * this->luv_l)) + ::hsluv::Hsluv_obj::refV);
+HXLINE( 215)		this->xyz_y = ::hsluv::Hsluv_obj::lToY(this->luv_l);
+HXLINE( 216)		this->xyz_x = (( (Float)(0) ) - (((( (Float)(9) ) * this->xyz_y) * varU) / (((varU - ( (Float)(4) )) * varV) - (varU * varV))));
+HXLINE( 217)		this->xyz_z = ((((( (Float)(9) ) * this->xyz_y) - ((( (Float)(15) ) * varV) * this->xyz_y)) - (varV * this->xyz_x)) / (( (Float)(3) ) * varV));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Hsluv_obj,luvToXyz,(void))
+
+void Hsluv_obj::lchToLuv(){
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_237_lchToLuv)
+HXLINE( 238)		Float Hrad = ((this->lch_h / ((Float)180.0)) * ::Math_obj::PI);
+HXLINE( 239)		this->luv_l = this->lch_l;
+HXLINE( 240)		this->luv_u = (::Math_obj::cos(Hrad) * this->lch_c);
+HXLINE( 241)		this->luv_v = (::Math_obj::sin(Hrad) * this->lch_c);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Hsluv_obj,lchToLuv,(void))
+
+void Hsluv_obj::calculateBoundingLines(Float l){
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_249_calculateBoundingLines)
+HXLINE( 250)		Float sub1 = (::Math_obj::pow((l + 16),( (Float)(3) )) / ( (Float)(1560896) ));
+HXLINE( 251)		Float sub2;
+HXDLIN( 251)		if ((sub1 > ::hsluv::Hsluv_obj::epsilon)) {
+HXLINE( 251)			sub2 = sub1;
+            		}
+            		else {
+HXLINE( 251)			sub2 = (l / ::hsluv::Hsluv_obj::kappa);
+            		}
+HXLINE( 253)		Float s1r = (sub2 * ((( (Float)(284517) ) * ::hsluv::Hsluv_obj::m_r0) - (( (Float)(94839) ) * ::hsluv::Hsluv_obj::m_r2)));
+HXLINE( 254)		Float s2r = (sub2 * (((( (Float)(838422) ) * ::hsluv::Hsluv_obj::m_r2) + (( (Float)(769860) ) * ::hsluv::Hsluv_obj::m_r1)) + (( (Float)(731718) ) * ::hsluv::Hsluv_obj::m_r0)));
+HXLINE( 255)		Float s3r = (sub2 * ((( (Float)(632260) ) * ::hsluv::Hsluv_obj::m_r2) - (( (Float)(126452) ) * ::hsluv::Hsluv_obj::m_r1)));
+HXLINE( 257)		Float s1g = (sub2 * ((( (Float)(284517) ) * ::hsluv::Hsluv_obj::m_g0) - (( (Float)(94839) ) * ::hsluv::Hsluv_obj::m_g2)));
+HXLINE( 258)		Float s2g = (sub2 * (((( (Float)(838422) ) * ::hsluv::Hsluv_obj::m_g2) + (( (Float)(769860) ) * ::hsluv::Hsluv_obj::m_g1)) + (( (Float)(731718) ) * ::hsluv::Hsluv_obj::m_g0)));
+HXLINE( 259)		Float s3g = (sub2 * ((( (Float)(632260) ) * ::hsluv::Hsluv_obj::m_g2) - (( (Float)(126452) ) * ::hsluv::Hsluv_obj::m_g1)));
+HXLINE( 261)		Float s1b = (sub2 * ((( (Float)(284517) ) * ::hsluv::Hsluv_obj::m_b0) - (( (Float)(94839) ) * ::hsluv::Hsluv_obj::m_b2)));
+HXLINE( 262)		Float s2b = (sub2 * (((( (Float)(838422) ) * ::hsluv::Hsluv_obj::m_b2) + (( (Float)(769860) ) * ::hsluv::Hsluv_obj::m_b1)) + (( (Float)(731718) ) * ::hsluv::Hsluv_obj::m_b0)));
+HXLINE( 263)		Float s3b = (sub2 * ((( (Float)(632260) ) * ::hsluv::Hsluv_obj::m_b2) - (( (Float)(126452) ) * ::hsluv::Hsluv_obj::m_b1)));
+HXLINE( 265)		this->r0s = (s1r / s3r);
+HXLINE( 266)		this->r0i = ((s2r * l) / s3r);
+HXLINE( 267)		this->r1s = (s1r / (s3r + 126452));
+HXLINE( 268)		this->r1i = (((s2r - ( (Float)(769860) )) * l) / (s3r + 126452));
+HXLINE( 270)		this->g0s = (s1g / s3g);
+HXLINE( 271)		this->g0i = ((s2g * l) / s3g);
+HXLINE( 272)		this->g1s = (s1g / (s3g + 126452));
+HXLINE( 273)		this->g1i = (((s2g - ( (Float)(769860) )) * l) / (s3g + 126452));
+HXLINE( 275)		this->b0s = (s1b / s3b);
+HXLINE( 276)		this->b0i = ((s2b * l) / s3b);
+HXLINE( 277)		this->b1s = (s1b / (s3b + 126452));
+HXLINE( 278)		this->b1i = (((s2b - ( (Float)(769860) )) * l) / (s3b + 126452));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Hsluv_obj,calculateBoundingLines,(void))
+
+Float Hsluv_obj::calcMaxChromaHsluv(Float h){
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_335_calcMaxChromaHsluv)
+HXLINE( 336)		Float hueRad = (((h / ( (Float)(360) )) * ::Math_obj::PI) * ( (Float)(2) ));
+HXLINE( 337)		Float r0 = ::hsluv::Hsluv_obj::distanceFromOriginAngle(this->r0s,this->r0i,hueRad);
+HXLINE( 338)		Float r1 = ::hsluv::Hsluv_obj::distanceFromOriginAngle(this->r1s,this->r1i,hueRad);
+HXLINE( 339)		Float g0 = ::hsluv::Hsluv_obj::distanceFromOriginAngle(this->g0s,this->g0i,hueRad);
+HXLINE( 340)		Float g1 = ::hsluv::Hsluv_obj::distanceFromOriginAngle(this->g1s,this->g1i,hueRad);
+HXLINE( 341)		Float b0 = ::hsluv::Hsluv_obj::distanceFromOriginAngle(this->b0s,this->b0i,hueRad);
+HXLINE( 342)		Float b1 = ::hsluv::Hsluv_obj::distanceFromOriginAngle(this->b1s,this->b1i,hueRad);
+HXLINE( 343)		return ::hsluv::Hsluv_obj::min6(r0,r1,g0,g1,b0,b1);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Hsluv_obj,calcMaxChromaHsluv,return )
+
+void Hsluv_obj::hsluvToLch(){
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_346_hsluvToLch)
+HXLINE( 348)		if ((this->hsluv_l > ((Float)99.9999999))) {
+HXLINE( 349)			this->lch_l = ( (Float)(100) );
+HXLINE( 350)			this->lch_c = ( (Float)(0) );
+            		}
+            		else {
+HXLINE( 351)			if ((this->hsluv_l < ((Float)0.00000001))) {
+HXLINE( 352)				this->lch_l = ( (Float)(0) );
+HXLINE( 353)				this->lch_c = ( (Float)(0) );
+            			}
+            			else {
+HXLINE( 355)				this->lch_l = this->hsluv_l;
+HXLINE( 356)				this->calculateBoundingLines(this->hsluv_l);
+HXLINE( 357)				Float max = this->calcMaxChromaHsluv(this->hsluv_h);
+HXLINE( 358)				this->lch_c = ((max / ( (Float)(100) )) * this->hsluv_s);
+            			}
+            		}
+HXLINE( 360)		this->lch_h = this->hsluv_h;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Hsluv_obj,hsluvToLch,(void))
+
+void Hsluv_obj::hsluvToRgb(){
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_414_hsluvToRgb)
+HXLINE( 415)		this->hsluvToLch();
+HXLINE( 416)		this->lchToLuv();
+HXLINE( 417)		this->luvToXyz();
+HXLINE( 418)		this->xyzToRgb();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Hsluv_obj,hsluvToRgb,(void))
+
+void Hsluv_obj::hsluvToHex(){
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_428_hsluvToHex)
+HXLINE( 429)		this->hsluvToRgb();
+HXLINE( 430)		this->rgbToHex();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Hsluv_obj,hsluvToHex,(void))
+
+::String Hsluv_obj::hexChars;
+
+Float Hsluv_obj::refY;
+
+Float Hsluv_obj::refU;
+
+Float Hsluv_obj::refV;
+
+Float Hsluv_obj::kappa;
+
+Float Hsluv_obj::epsilon;
+
+Float Hsluv_obj::m_r0;
+
+Float Hsluv_obj::m_r1;
+
+Float Hsluv_obj::m_r2;
+
+Float Hsluv_obj::m_g0;
+
+Float Hsluv_obj::m_g1;
+
+Float Hsluv_obj::m_g2;
+
+Float Hsluv_obj::m_b0;
+
+Float Hsluv_obj::m_b1;
+
+Float Hsluv_obj::m_b2;
+
+Float Hsluv_obj::fromLinear(Float c){
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_100_fromLinear)
+HXDLIN( 100)		if ((c <= ((Float)0.0031308))) {
+HXLINE( 101)			return (((Float)12.92) * c);
+            		}
+            		else {
+HXLINE( 103)			return ((((Float)1.055) * ::Math_obj::pow(c,((Float)0.416666666666666685))) - ((Float)0.055));
+            		}
+HXLINE( 100)		return ((Float)0.);
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Hsluv_obj,fromLinear,return )
+
+Float Hsluv_obj::lToY(Float L){
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_130_lToY)
+HXDLIN( 130)		if ((L <= 8)) {
+HXLINE( 131)			return ((::hsluv::Hsluv_obj::refY * L) / ::hsluv::Hsluv_obj::kappa);
+            		}
+            		else {
+HXLINE( 133)			return (::hsluv::Hsluv_obj::refY * ::Math_obj::pow(((L + 16) / ( (Float)(116) )),( (Float)(3) )));
+            		}
+HXLINE( 130)		return ((Float)0.);
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Hsluv_obj,lToY,return )
+
+::String Hsluv_obj::rgbChannelToHex(Float chan){
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_137_rgbChannelToHex)
+HXLINE( 138)		int c = ::Math_obj::round((chan * ( (Float)(255) )));
+HXLINE( 139)		int digit2 = ::hx::Mod(c,16);
+HXLINE( 140)		int digit1 = ::Std_obj::_hx_int((( (Float)((c - digit2)) ) / ( (Float)(16) )));
+HXLINE( 141)		::String _hx_tmp = ::hsluv::Hsluv_obj::hexChars.charAt(digit1);
+HXDLIN( 141)		return (_hx_tmp + ::hsluv::Hsluv_obj::hexChars.charAt(digit2));
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Hsluv_obj,rgbChannelToHex,return )
+
+Float Hsluv_obj::distanceFromOriginAngle(Float slope,Float intercept,Float angle){
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_298_distanceFromOriginAngle)
+HXLINE( 299)		Float d = (intercept / (::Math_obj::sin(angle) - (slope * ::Math_obj::cos(angle))));
+HXLINE( 300)		if ((d < 0)) {
+HXLINE( 301)			return ::Math_obj::POSITIVE_INFINITY;
+            		}
+            		else {
+HXLINE( 303)			return d;
+            		}
+HXLINE( 300)		return ((Float)0.);
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC3(Hsluv_obj,distanceFromOriginAngle,return )
+
+Float Hsluv_obj::min6(Float f1,Float f2,Float f3,Float f4,Float f5,Float f6){
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_312_min6)
+HXDLIN( 312)		return ::Math_obj::min(f1,::Math_obj::min(f2,::Math_obj::min(f3,::Math_obj::min(f4,::Math_obj::min(f5,f6)))));
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC6(Hsluv_obj,min6,return )
+
+
+::hx::ObjectPtr< Hsluv_obj > Hsluv_obj::__new() {
+	::hx::ObjectPtr< Hsluv_obj > __this = new Hsluv_obj();
+	__this->__construct();
+	return __this;
+}
+
+::hx::ObjectPtr< Hsluv_obj > Hsluv_obj::__alloc(::hx::Ctx *_hx_ctx) {
+	Hsluv_obj *__this = (Hsluv_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Hsluv_obj), true, "hsluv.Hsluv"));
+	*(void **)__this = Hsluv_obj::_hx_vtable;
+	__this->__construct();
+	return __this;
+}
+
+Hsluv_obj::Hsluv_obj()
+{
+}
+
+void Hsluv_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(Hsluv);
+	HX_MARK_MEMBER_NAME(hex,"hex");
+	HX_MARK_MEMBER_NAME(rgb_r,"rgb_r");
+	HX_MARK_MEMBER_NAME(rgb_g,"rgb_g");
+	HX_MARK_MEMBER_NAME(rgb_b,"rgb_b");
+	HX_MARK_MEMBER_NAME(xyz_x,"xyz_x");
+	HX_MARK_MEMBER_NAME(xyz_y,"xyz_y");
+	HX_MARK_MEMBER_NAME(xyz_z,"xyz_z");
+	HX_MARK_MEMBER_NAME(luv_l,"luv_l");
+	HX_MARK_MEMBER_NAME(luv_u,"luv_u");
+	HX_MARK_MEMBER_NAME(luv_v,"luv_v");
+	HX_MARK_MEMBER_NAME(lch_l,"lch_l");
+	HX_MARK_MEMBER_NAME(lch_c,"lch_c");
+	HX_MARK_MEMBER_NAME(lch_h,"lch_h");
+	HX_MARK_MEMBER_NAME(hsluv_h,"hsluv_h");
+	HX_MARK_MEMBER_NAME(hsluv_s,"hsluv_s");
+	HX_MARK_MEMBER_NAME(hsluv_l,"hsluv_l");
+	HX_MARK_MEMBER_NAME(r0s,"r0s");
+	HX_MARK_MEMBER_NAME(r0i,"r0i");
+	HX_MARK_MEMBER_NAME(r1s,"r1s");
+	HX_MARK_MEMBER_NAME(r1i,"r1i");
+	HX_MARK_MEMBER_NAME(g0s,"g0s");
+	HX_MARK_MEMBER_NAME(g0i,"g0i");
+	HX_MARK_MEMBER_NAME(g1s,"g1s");
+	HX_MARK_MEMBER_NAME(g1i,"g1i");
+	HX_MARK_MEMBER_NAME(b0s,"b0s");
+	HX_MARK_MEMBER_NAME(b0i,"b0i");
+	HX_MARK_MEMBER_NAME(b1s,"b1s");
+	HX_MARK_MEMBER_NAME(b1i,"b1i");
+	HX_MARK_END_CLASS();
+}
+
+void Hsluv_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(hex,"hex");
+	HX_VISIT_MEMBER_NAME(rgb_r,"rgb_r");
+	HX_VISIT_MEMBER_NAME(rgb_g,"rgb_g");
+	HX_VISIT_MEMBER_NAME(rgb_b,"rgb_b");
+	HX_VISIT_MEMBER_NAME(xyz_x,"xyz_x");
+	HX_VISIT_MEMBER_NAME(xyz_y,"xyz_y");
+	HX_VISIT_MEMBER_NAME(xyz_z,"xyz_z");
+	HX_VISIT_MEMBER_NAME(luv_l,"luv_l");
+	HX_VISIT_MEMBER_NAME(luv_u,"luv_u");
+	HX_VISIT_MEMBER_NAME(luv_v,"luv_v");
+	HX_VISIT_MEMBER_NAME(lch_l,"lch_l");
+	HX_VISIT_MEMBER_NAME(lch_c,"lch_c");
+	HX_VISIT_MEMBER_NAME(lch_h,"lch_h");
+	HX_VISIT_MEMBER_NAME(hsluv_h,"hsluv_h");
+	HX_VISIT_MEMBER_NAME(hsluv_s,"hsluv_s");
+	HX_VISIT_MEMBER_NAME(hsluv_l,"hsluv_l");
+	HX_VISIT_MEMBER_NAME(r0s,"r0s");
+	HX_VISIT_MEMBER_NAME(r0i,"r0i");
+	HX_VISIT_MEMBER_NAME(r1s,"r1s");
+	HX_VISIT_MEMBER_NAME(r1i,"r1i");
+	HX_VISIT_MEMBER_NAME(g0s,"g0s");
+	HX_VISIT_MEMBER_NAME(g0i,"g0i");
+	HX_VISIT_MEMBER_NAME(g1s,"g1s");
+	HX_VISIT_MEMBER_NAME(g1i,"g1i");
+	HX_VISIT_MEMBER_NAME(b0s,"b0s");
+	HX_VISIT_MEMBER_NAME(b0i,"b0i");
+	HX_VISIT_MEMBER_NAME(b1s,"b1s");
+	HX_VISIT_MEMBER_NAME(b1i,"b1i");
+}
+
+::hx::Val Hsluv_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"hex") ) { return ::hx::Val( hex ); }
+		if (HX_FIELD_EQ(inName,"r0s") ) { return ::hx::Val( r0s ); }
+		if (HX_FIELD_EQ(inName,"r0i") ) { return ::hx::Val( r0i ); }
+		if (HX_FIELD_EQ(inName,"r1s") ) { return ::hx::Val( r1s ); }
+		if (HX_FIELD_EQ(inName,"r1i") ) { return ::hx::Val( r1i ); }
+		if (HX_FIELD_EQ(inName,"g0s") ) { return ::hx::Val( g0s ); }
+		if (HX_FIELD_EQ(inName,"g0i") ) { return ::hx::Val( g0i ); }
+		if (HX_FIELD_EQ(inName,"g1s") ) { return ::hx::Val( g1s ); }
+		if (HX_FIELD_EQ(inName,"g1i") ) { return ::hx::Val( g1i ); }
+		if (HX_FIELD_EQ(inName,"b0s") ) { return ::hx::Val( b0s ); }
+		if (HX_FIELD_EQ(inName,"b0i") ) { return ::hx::Val( b0i ); }
+		if (HX_FIELD_EQ(inName,"b1s") ) { return ::hx::Val( b1s ); }
+		if (HX_FIELD_EQ(inName,"b1i") ) { return ::hx::Val( b1i ); }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"rgb_r") ) { return ::hx::Val( rgb_r ); }
+		if (HX_FIELD_EQ(inName,"rgb_g") ) { return ::hx::Val( rgb_g ); }
+		if (HX_FIELD_EQ(inName,"rgb_b") ) { return ::hx::Val( rgb_b ); }
+		if (HX_FIELD_EQ(inName,"xyz_x") ) { return ::hx::Val( xyz_x ); }
+		if (HX_FIELD_EQ(inName,"xyz_y") ) { return ::hx::Val( xyz_y ); }
+		if (HX_FIELD_EQ(inName,"xyz_z") ) { return ::hx::Val( xyz_z ); }
+		if (HX_FIELD_EQ(inName,"luv_l") ) { return ::hx::Val( luv_l ); }
+		if (HX_FIELD_EQ(inName,"luv_u") ) { return ::hx::Val( luv_u ); }
+		if (HX_FIELD_EQ(inName,"luv_v") ) { return ::hx::Val( luv_v ); }
+		if (HX_FIELD_EQ(inName,"lch_l") ) { return ::hx::Val( lch_l ); }
+		if (HX_FIELD_EQ(inName,"lch_c") ) { return ::hx::Val( lch_c ); }
+		if (HX_FIELD_EQ(inName,"lch_h") ) { return ::hx::Val( lch_h ); }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"hsluv_h") ) { return ::hx::Val( hsluv_h ); }
+		if (HX_FIELD_EQ(inName,"hsluv_s") ) { return ::hx::Val( hsluv_s ); }
+		if (HX_FIELD_EQ(inName,"hsluv_l") ) { return ::hx::Val( hsluv_l ); }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"rgbToHex") ) { return ::hx::Val( rgbToHex_dyn() ); }
+		if (HX_FIELD_EQ(inName,"xyzToRgb") ) { return ::hx::Val( xyzToRgb_dyn() ); }
+		if (HX_FIELD_EQ(inName,"luvToXyz") ) { return ::hx::Val( luvToXyz_dyn() ); }
+		if (HX_FIELD_EQ(inName,"lchToLuv") ) { return ::hx::Val( lchToLuv_dyn() ); }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"hsluvToLch") ) { return ::hx::Val( hsluvToLch_dyn() ); }
+		if (HX_FIELD_EQ(inName,"hsluvToRgb") ) { return ::hx::Val( hsluvToRgb_dyn() ); }
+		if (HX_FIELD_EQ(inName,"hsluvToHex") ) { return ::hx::Val( hsluvToHex_dyn() ); }
+		break;
+	case 18:
+		if (HX_FIELD_EQ(inName,"calcMaxChromaHsluv") ) { return ::hx::Val( calcMaxChromaHsluv_dyn() ); }
+		break;
+	case 22:
+		if (HX_FIELD_EQ(inName,"calculateBoundingLines") ) { return ::hx::Val( calculateBoundingLines_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+bool Hsluv_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"refY") ) { outValue = ( refY ); return true; }
+		if (HX_FIELD_EQ(inName,"refU") ) { outValue = ( refU ); return true; }
+		if (HX_FIELD_EQ(inName,"refV") ) { outValue = ( refV ); return true; }
+		if (HX_FIELD_EQ(inName,"m_r0") ) { outValue = ( m_r0 ); return true; }
+		if (HX_FIELD_EQ(inName,"m_r1") ) { outValue = ( m_r1 ); return true; }
+		if (HX_FIELD_EQ(inName,"m_r2") ) { outValue = ( m_r2 ); return true; }
+		if (HX_FIELD_EQ(inName,"m_g0") ) { outValue = ( m_g0 ); return true; }
+		if (HX_FIELD_EQ(inName,"m_g1") ) { outValue = ( m_g1 ); return true; }
+		if (HX_FIELD_EQ(inName,"m_g2") ) { outValue = ( m_g2 ); return true; }
+		if (HX_FIELD_EQ(inName,"m_b0") ) { outValue = ( m_b0 ); return true; }
+		if (HX_FIELD_EQ(inName,"m_b1") ) { outValue = ( m_b1 ); return true; }
+		if (HX_FIELD_EQ(inName,"m_b2") ) { outValue = ( m_b2 ); return true; }
+		if (HX_FIELD_EQ(inName,"lToY") ) { outValue = lToY_dyn(); return true; }
+		if (HX_FIELD_EQ(inName,"min6") ) { outValue = min6_dyn(); return true; }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"kappa") ) { outValue = ( kappa ); return true; }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"epsilon") ) { outValue = ( epsilon ); return true; }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"hexChars") ) { outValue = ( hexChars ); return true; }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"fromLinear") ) { outValue = fromLinear_dyn(); return true; }
+		break;
+	case 15:
+		if (HX_FIELD_EQ(inName,"rgbChannelToHex") ) { outValue = rgbChannelToHex_dyn(); return true; }
+		break;
+	case 23:
+		if (HX_FIELD_EQ(inName,"distanceFromOriginAngle") ) { outValue = distanceFromOriginAngle_dyn(); return true; }
+	}
+	return false;
+}
+
+::hx::Val Hsluv_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"hex") ) { hex=inValue.Cast< ::String >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"r0s") ) { r0s=inValue.Cast< Float >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"r0i") ) { r0i=inValue.Cast< Float >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"r1s") ) { r1s=inValue.Cast< Float >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"r1i") ) { r1i=inValue.Cast< Float >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"g0s") ) { g0s=inValue.Cast< Float >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"g0i") ) { g0i=inValue.Cast< Float >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"g1s") ) { g1s=inValue.Cast< Float >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"g1i") ) { g1i=inValue.Cast< Float >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"b0s") ) { b0s=inValue.Cast< Float >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"b0i") ) { b0i=inValue.Cast< Float >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"b1s") ) { b1s=inValue.Cast< Float >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"b1i") ) { b1i=inValue.Cast< Float >(); return inValue; }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"rgb_r") ) { rgb_r=inValue.Cast< Float >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"rgb_g") ) { rgb_g=inValue.Cast< Float >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"rgb_b") ) { rgb_b=inValue.Cast< Float >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"xyz_x") ) { xyz_x=inValue.Cast< Float >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"xyz_y") ) { xyz_y=inValue.Cast< Float >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"xyz_z") ) { xyz_z=inValue.Cast< Float >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"luv_l") ) { luv_l=inValue.Cast< Float >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"luv_u") ) { luv_u=inValue.Cast< Float >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"luv_v") ) { luv_v=inValue.Cast< Float >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"lch_l") ) { lch_l=inValue.Cast< Float >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"lch_c") ) { lch_c=inValue.Cast< Float >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"lch_h") ) { lch_h=inValue.Cast< Float >(); return inValue; }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"hsluv_h") ) { hsluv_h=inValue.Cast< Float >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"hsluv_s") ) { hsluv_s=inValue.Cast< Float >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"hsluv_l") ) { hsluv_l=inValue.Cast< Float >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+bool Hsluv_obj::__SetStatic(const ::String &inName,Dynamic &ioValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"refY") ) { refY=ioValue.Cast< Float >(); return true; }
+		if (HX_FIELD_EQ(inName,"refU") ) { refU=ioValue.Cast< Float >(); return true; }
+		if (HX_FIELD_EQ(inName,"refV") ) { refV=ioValue.Cast< Float >(); return true; }
+		if (HX_FIELD_EQ(inName,"m_r0") ) { m_r0=ioValue.Cast< Float >(); return true; }
+		if (HX_FIELD_EQ(inName,"m_r1") ) { m_r1=ioValue.Cast< Float >(); return true; }
+		if (HX_FIELD_EQ(inName,"m_r2") ) { m_r2=ioValue.Cast< Float >(); return true; }
+		if (HX_FIELD_EQ(inName,"m_g0") ) { m_g0=ioValue.Cast< Float >(); return true; }
+		if (HX_FIELD_EQ(inName,"m_g1") ) { m_g1=ioValue.Cast< Float >(); return true; }
+		if (HX_FIELD_EQ(inName,"m_g2") ) { m_g2=ioValue.Cast< Float >(); return true; }
+		if (HX_FIELD_EQ(inName,"m_b0") ) { m_b0=ioValue.Cast< Float >(); return true; }
+		if (HX_FIELD_EQ(inName,"m_b1") ) { m_b1=ioValue.Cast< Float >(); return true; }
+		if (HX_FIELD_EQ(inName,"m_b2") ) { m_b2=ioValue.Cast< Float >(); return true; }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"kappa") ) { kappa=ioValue.Cast< Float >(); return true; }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"epsilon") ) { epsilon=ioValue.Cast< Float >(); return true; }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"hexChars") ) { hexChars=ioValue.Cast< ::String >(); return true; }
+	}
+	return false;
+}
+
+void Hsluv_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("hex",db,42,4f,00));
+	outFields->push(HX_("rgb_r",80,cb,0d,e8));
+	outFields->push(HX_("rgb_g",75,cb,0d,e8));
+	outFields->push(HX_("rgb_b",70,cb,0d,e8));
+	outFields->push(HX_("xyz_x",d2,53,6d,68));
+	outFields->push(HX_("xyz_y",d3,53,6d,68));
+	outFields->push(HX_("xyz_z",d4,53,6d,68));
+	outFields->push(HX_("luv_l",3a,7a,f6,7c));
+	outFields->push(HX_("luv_u",43,7a,f6,7c));
+	outFields->push(HX_("luv_v",44,7a,f6,7c));
+	outFields->push(HX_("lch_l",7e,03,06,71));
+	outFields->push(HX_("lch_c",75,03,06,71));
+	outFields->push(HX_("lch_h",7a,03,06,71));
+	outFields->push(HX_("hsluv_h",4b,37,b9,5c));
+	outFields->push(HX_("hsluv_s",56,37,b9,5c));
+	outFields->push(HX_("hsluv_l",4f,37,b9,5c));
+	outFields->push(HX_("r0s",35,ab,56,00));
+	outFields->push(HX_("r0i",2b,ab,56,00));
+	outFields->push(HX_("r1s",14,ac,56,00));
+	outFields->push(HX_("r1i",0a,ac,56,00));
+	outFields->push(HX_("g0s",6a,52,4e,00));
+	outFields->push(HX_("g0i",60,52,4e,00));
+	outFields->push(HX_("g1s",49,53,4e,00));
+	outFields->push(HX_("g1i",3f,53,4e,00));
+	outFields->push(HX_("b0s",25,87,4a,00));
+	outFields->push(HX_("b0i",1b,87,4a,00));
+	outFields->push(HX_("b1s",04,88,4a,00));
+	outFields->push(HX_("b1i",fa,87,4a,00));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo Hsluv_obj_sMemberStorageInfo[] = {
+	{::hx::fsString,(int)offsetof(Hsluv_obj,hex),HX_("hex",db,42,4f,00)},
+	{::hx::fsFloat,(int)offsetof(Hsluv_obj,rgb_r),HX_("rgb_r",80,cb,0d,e8)},
+	{::hx::fsFloat,(int)offsetof(Hsluv_obj,rgb_g),HX_("rgb_g",75,cb,0d,e8)},
+	{::hx::fsFloat,(int)offsetof(Hsluv_obj,rgb_b),HX_("rgb_b",70,cb,0d,e8)},
+	{::hx::fsFloat,(int)offsetof(Hsluv_obj,xyz_x),HX_("xyz_x",d2,53,6d,68)},
+	{::hx::fsFloat,(int)offsetof(Hsluv_obj,xyz_y),HX_("xyz_y",d3,53,6d,68)},
+	{::hx::fsFloat,(int)offsetof(Hsluv_obj,xyz_z),HX_("xyz_z",d4,53,6d,68)},
+	{::hx::fsFloat,(int)offsetof(Hsluv_obj,luv_l),HX_("luv_l",3a,7a,f6,7c)},
+	{::hx::fsFloat,(int)offsetof(Hsluv_obj,luv_u),HX_("luv_u",43,7a,f6,7c)},
+	{::hx::fsFloat,(int)offsetof(Hsluv_obj,luv_v),HX_("luv_v",44,7a,f6,7c)},
+	{::hx::fsFloat,(int)offsetof(Hsluv_obj,lch_l),HX_("lch_l",7e,03,06,71)},
+	{::hx::fsFloat,(int)offsetof(Hsluv_obj,lch_c),HX_("lch_c",75,03,06,71)},
+	{::hx::fsFloat,(int)offsetof(Hsluv_obj,lch_h),HX_("lch_h",7a,03,06,71)},
+	{::hx::fsFloat,(int)offsetof(Hsluv_obj,hsluv_h),HX_("hsluv_h",4b,37,b9,5c)},
+	{::hx::fsFloat,(int)offsetof(Hsluv_obj,hsluv_s),HX_("hsluv_s",56,37,b9,5c)},
+	{::hx::fsFloat,(int)offsetof(Hsluv_obj,hsluv_l),HX_("hsluv_l",4f,37,b9,5c)},
+	{::hx::fsFloat,(int)offsetof(Hsluv_obj,r0s),HX_("r0s",35,ab,56,00)},
+	{::hx::fsFloat,(int)offsetof(Hsluv_obj,r0i),HX_("r0i",2b,ab,56,00)},
+	{::hx::fsFloat,(int)offsetof(Hsluv_obj,r1s),HX_("r1s",14,ac,56,00)},
+	{::hx::fsFloat,(int)offsetof(Hsluv_obj,r1i),HX_("r1i",0a,ac,56,00)},
+	{::hx::fsFloat,(int)offsetof(Hsluv_obj,g0s),HX_("g0s",6a,52,4e,00)},
+	{::hx::fsFloat,(int)offsetof(Hsluv_obj,g0i),HX_("g0i",60,52,4e,00)},
+	{::hx::fsFloat,(int)offsetof(Hsluv_obj,g1s),HX_("g1s",49,53,4e,00)},
+	{::hx::fsFloat,(int)offsetof(Hsluv_obj,g1i),HX_("g1i",3f,53,4e,00)},
+	{::hx::fsFloat,(int)offsetof(Hsluv_obj,b0s),HX_("b0s",25,87,4a,00)},
+	{::hx::fsFloat,(int)offsetof(Hsluv_obj,b0i),HX_("b0i",1b,87,4a,00)},
+	{::hx::fsFloat,(int)offsetof(Hsluv_obj,b1s),HX_("b1s",04,88,4a,00)},
+	{::hx::fsFloat,(int)offsetof(Hsluv_obj,b1i),HX_("b1i",fa,87,4a,00)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo Hsluv_obj_sStaticStorageInfo[] = {
+	{::hx::fsString,(void *) &Hsluv_obj::hexChars,HX_("hexChars",02,90,2a,78)},
+	{::hx::fsFloat,(void *) &Hsluv_obj::refY,HX_("refY",a6,4f,a7,4b)},
+	{::hx::fsFloat,(void *) &Hsluv_obj::refU,HX_("refU",a2,4f,a7,4b)},
+	{::hx::fsFloat,(void *) &Hsluv_obj::refV,HX_("refV",a3,4f,a7,4b)},
+	{::hx::fsFloat,(void *) &Hsluv_obj::kappa,HX_("kappa",8b,22,53,dc)},
+	{::hx::fsFloat,(void *) &Hsluv_obj::epsilon,HX_("epsilon",6a,b5,be,ac)},
+	{::hx::fsFloat,(void *) &Hsluv_obj::m_r0,HX_("m_r0",50,bb,54,48)},
+	{::hx::fsFloat,(void *) &Hsluv_obj::m_r1,HX_("m_r1",51,bb,54,48)},
+	{::hx::fsFloat,(void *) &Hsluv_obj::m_r2,HX_("m_r2",52,bb,54,48)},
+	{::hx::fsFloat,(void *) &Hsluv_obj::m_g0,HX_("m_g0",bb,b1,54,48)},
+	{::hx::fsFloat,(void *) &Hsluv_obj::m_g1,HX_("m_g1",bc,b1,54,48)},
+	{::hx::fsFloat,(void *) &Hsluv_obj::m_g2,HX_("m_g2",bd,b1,54,48)},
+	{::hx::fsFloat,(void *) &Hsluv_obj::m_b0,HX_("m_b0",60,ad,54,48)},
+	{::hx::fsFloat,(void *) &Hsluv_obj::m_b1,HX_("m_b1",61,ad,54,48)},
+	{::hx::fsFloat,(void *) &Hsluv_obj::m_b2,HX_("m_b2",62,ad,54,48)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+#endif
+
+static ::String Hsluv_obj_sMemberFields[] = {
+	HX_("hex",db,42,4f,00),
+	HX_("rgb_r",80,cb,0d,e8),
+	HX_("rgb_g",75,cb,0d,e8),
+	HX_("rgb_b",70,cb,0d,e8),
+	HX_("xyz_x",d2,53,6d,68),
+	HX_("xyz_y",d3,53,6d,68),
+	HX_("xyz_z",d4,53,6d,68),
+	HX_("luv_l",3a,7a,f6,7c),
+	HX_("luv_u",43,7a,f6,7c),
+	HX_("luv_v",44,7a,f6,7c),
+	HX_("lch_l",7e,03,06,71),
+	HX_("lch_c",75,03,06,71),
+	HX_("lch_h",7a,03,06,71),
+	HX_("hsluv_h",4b,37,b9,5c),
+	HX_("hsluv_s",56,37,b9,5c),
+	HX_("hsluv_l",4f,37,b9,5c),
+	HX_("r0s",35,ab,56,00),
+	HX_("r0i",2b,ab,56,00),
+	HX_("r1s",14,ac,56,00),
+	HX_("r1i",0a,ac,56,00),
+	HX_("g0s",6a,52,4e,00),
+	HX_("g0i",60,52,4e,00),
+	HX_("g1s",49,53,4e,00),
+	HX_("g1i",3f,53,4e,00),
+	HX_("b0s",25,87,4a,00),
+	HX_("b0i",1b,87,4a,00),
+	HX_("b1s",04,88,4a,00),
+	HX_("b1i",fa,87,4a,00),
+	HX_("rgbToHex",d3,59,d1,09),
+	HX_("xyzToRgb",39,a1,1a,e6),
+	HX_("luvToXyz",91,98,fe,f7),
+	HX_("lchToLuv",41,13,74,72),
+	HX_("calculateBoundingLines",b5,3e,5b,c7),
+	HX_("calcMaxChromaHsluv",7d,51,bd,01),
+	HX_("hsluvToLch",54,48,a8,d8),
+	HX_("hsluvToRgb",50,d9,ac,d8),
+	HX_("hsluvToHex",1e,41,a5,d8),
+	::String(null()) };
+
+static void Hsluv_obj_sMarkStatics(HX_MARK_PARAMS) {
+	HX_MARK_MEMBER_NAME(Hsluv_obj::hexChars,"hexChars");
+	HX_MARK_MEMBER_NAME(Hsluv_obj::refY,"refY");
+	HX_MARK_MEMBER_NAME(Hsluv_obj::refU,"refU");
+	HX_MARK_MEMBER_NAME(Hsluv_obj::refV,"refV");
+	HX_MARK_MEMBER_NAME(Hsluv_obj::kappa,"kappa");
+	HX_MARK_MEMBER_NAME(Hsluv_obj::epsilon,"epsilon");
+	HX_MARK_MEMBER_NAME(Hsluv_obj::m_r0,"m_r0");
+	HX_MARK_MEMBER_NAME(Hsluv_obj::m_r1,"m_r1");
+	HX_MARK_MEMBER_NAME(Hsluv_obj::m_r2,"m_r2");
+	HX_MARK_MEMBER_NAME(Hsluv_obj::m_g0,"m_g0");
+	HX_MARK_MEMBER_NAME(Hsluv_obj::m_g1,"m_g1");
+	HX_MARK_MEMBER_NAME(Hsluv_obj::m_g2,"m_g2");
+	HX_MARK_MEMBER_NAME(Hsluv_obj::m_b0,"m_b0");
+	HX_MARK_MEMBER_NAME(Hsluv_obj::m_b1,"m_b1");
+	HX_MARK_MEMBER_NAME(Hsluv_obj::m_b2,"m_b2");
+};
+
+#ifdef HXCPP_VISIT_ALLOCS
+static void Hsluv_obj_sVisitStatics(HX_VISIT_PARAMS) {
+	HX_VISIT_MEMBER_NAME(Hsluv_obj::hexChars,"hexChars");
+	HX_VISIT_MEMBER_NAME(Hsluv_obj::refY,"refY");
+	HX_VISIT_MEMBER_NAME(Hsluv_obj::refU,"refU");
+	HX_VISIT_MEMBER_NAME(Hsluv_obj::refV,"refV");
+	HX_VISIT_MEMBER_NAME(Hsluv_obj::kappa,"kappa");
+	HX_VISIT_MEMBER_NAME(Hsluv_obj::epsilon,"epsilon");
+	HX_VISIT_MEMBER_NAME(Hsluv_obj::m_r0,"m_r0");
+	HX_VISIT_MEMBER_NAME(Hsluv_obj::m_r1,"m_r1");
+	HX_VISIT_MEMBER_NAME(Hsluv_obj::m_r2,"m_r2");
+	HX_VISIT_MEMBER_NAME(Hsluv_obj::m_g0,"m_g0");
+	HX_VISIT_MEMBER_NAME(Hsluv_obj::m_g1,"m_g1");
+	HX_VISIT_MEMBER_NAME(Hsluv_obj::m_g2,"m_g2");
+	HX_VISIT_MEMBER_NAME(Hsluv_obj::m_b0,"m_b0");
+	HX_VISIT_MEMBER_NAME(Hsluv_obj::m_b1,"m_b1");
+	HX_VISIT_MEMBER_NAME(Hsluv_obj::m_b2,"m_b2");
+};
+
+#endif
+
+::hx::Class Hsluv_obj::__mClass;
+
+static ::String Hsluv_obj_sStaticFields[] = {
+	HX_("hexChars",02,90,2a,78),
+	HX_("refY",a6,4f,a7,4b),
+	HX_("refU",a2,4f,a7,4b),
+	HX_("refV",a3,4f,a7,4b),
+	HX_("kappa",8b,22,53,dc),
+	HX_("epsilon",6a,b5,be,ac),
+	HX_("m_r0",50,bb,54,48),
+	HX_("m_r1",51,bb,54,48),
+	HX_("m_r2",52,bb,54,48),
+	HX_("m_g0",bb,b1,54,48),
+	HX_("m_g1",bc,b1,54,48),
+	HX_("m_g2",bd,b1,54,48),
+	HX_("m_b0",60,ad,54,48),
+	HX_("m_b1",61,ad,54,48),
+	HX_("m_b2",62,ad,54,48),
+	HX_("fromLinear",ef,56,e4,2f),
+	HX_("lToY",72,29,a3,47),
+	HX_("rgbChannelToHex",0a,c7,4f,40),
+	HX_("distanceFromOriginAngle",0e,c7,6c,31),
+	HX_("min6",64,4e,5c,48),
+	::String(null())
+};
+
+void Hsluv_obj::__register()
+{
+	Hsluv_obj _hx_dummy;
+	Hsluv_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("hsluv.Hsluv",b6,dd,34,2e);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &Hsluv_obj::__GetStatic;
+	__mClass->mSetStaticField = &Hsluv_obj::__SetStatic;
+	__mClass->mMarkFunc = Hsluv_obj_sMarkStatics;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(Hsluv_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(Hsluv_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< Hsluv_obj >;
+#ifdef HXCPP_VISIT_ALLOCS
+	__mClass->mVisitFunc = Hsluv_obj_sVisitStatics;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Hsluv_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Hsluv_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+void Hsluv_obj::__boot()
+{
+{
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_74_boot)
+HXDLIN(  74)		hexChars = HX_("0123456789abcdef",68,7e,d5,ef);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_76_boot)
+HXDLIN(  76)		refY = ((Float)1.0);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_78_boot)
+HXDLIN(  78)		refU = ((Float)0.19783000664283);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_79_boot)
+HXDLIN(  79)		refV = ((Float)0.46831999493879);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_82_boot)
+HXDLIN(  82)		kappa = ((Float)903.2962962);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_83_boot)
+HXDLIN(  83)		epsilon = ((Float)0.0088564516);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_86_boot)
+HXDLIN(  86)		m_r0 = ((Float)3.240969941904521);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_87_boot)
+HXDLIN(  87)		m_r1 = ((Float)-1.537383177570093);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_88_boot)
+HXDLIN(  88)		m_r2 = ((Float)-0.498610760293);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_90_boot)
+HXDLIN(  90)		m_g0 = ((Float)-0.96924363628087);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_91_boot)
+HXDLIN(  91)		m_g1 = ((Float)1.87596750150772);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_92_boot)
+HXDLIN(  92)		m_g2 = ((Float)0.041555057407175);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_94_boot)
+HXDLIN(  94)		m_b0 = ((Float)0.055630079696993);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_95_boot)
+HXDLIN(  95)		m_b1 = ((Float)-0.20397695888897);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_d5dc22b6e2ff60be_96_boot)
+HXDLIN(  96)		m_b2 = ((Float)1.056971514242878);
+            	}
+}
+
+} // end namespace hsluv
diff --git a/Sources/c_snikket/src/htmlparser/HtmlAttribute.cpp b/Sources/c_snikket/src/htmlparser/HtmlAttribute.cpp
new file mode 100644
index 0000000..f01ad06
--- /dev/null
+++ b/Sources/c_snikket/src/htmlparser/HtmlAttribute.cpp
@@ -0,0 +1,129 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_htmlparser_HtmlAttribute
+#include <htmlparser/HtmlAttribute.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_630f17b70ccedfe6_10_new,"htmlparser.HtmlAttribute","new",0x2f20ed9f,"htmlparser.HtmlAttribute.new","htmlparser/HtmlAttribute.hx",10,0x8ea4bcb2)
+namespace htmlparser{
+
+void HtmlAttribute_obj::__construct(::String name,::String value,::String quote){
+            	HX_STACKFRAME(&_hx_pos_630f17b70ccedfe6_10_new)
+HXLINE(  11)		this->name = name;
+HXLINE(  12)		this->value = value;
+HXLINE(  13)		this->quote = quote;
+            	}
+
+Dynamic HtmlAttribute_obj::__CreateEmpty() { return new HtmlAttribute_obj; }
+
+void *HtmlAttribute_obj::_hx_vtable = 0;
+
+Dynamic HtmlAttribute_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< HtmlAttribute_obj > _hx_result = new HtmlAttribute_obj();
+	_hx_result->__construct(inArgs[0],inArgs[1],inArgs[2]);
+	return _hx_result;
+}
+
+bool HtmlAttribute_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x49e2a647;
+}
+
+
+HtmlAttribute_obj::HtmlAttribute_obj()
+{
+}
+
+void HtmlAttribute_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(HtmlAttribute);
+	HX_MARK_MEMBER_NAME(name,"name");
+	HX_MARK_MEMBER_NAME(value,"value");
+	HX_MARK_MEMBER_NAME(quote,"quote");
+	HX_MARK_END_CLASS();
+}
+
+void HtmlAttribute_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(name,"name");
+	HX_VISIT_MEMBER_NAME(value,"value");
+	HX_VISIT_MEMBER_NAME(quote,"quote");
+}
+
+::hx::Val HtmlAttribute_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"name") ) { return ::hx::Val( name ); }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"value") ) { return ::hx::Val( value ); }
+		if (HX_FIELD_EQ(inName,"quote") ) { return ::hx::Val( quote ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val HtmlAttribute_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"name") ) { name=inValue.Cast< ::String >(); return inValue; }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"value") ) { value=inValue.Cast< ::String >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"quote") ) { quote=inValue.Cast< ::String >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void HtmlAttribute_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("name",4b,72,ff,48));
+	outFields->push(HX_("value",71,7f,b8,31));
+	outFields->push(HX_("quote",3c,23,f2,5d));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo HtmlAttribute_obj_sMemberStorageInfo[] = {
+	{::hx::fsString,(int)offsetof(HtmlAttribute_obj,name),HX_("name",4b,72,ff,48)},
+	{::hx::fsString,(int)offsetof(HtmlAttribute_obj,value),HX_("value",71,7f,b8,31)},
+	{::hx::fsString,(int)offsetof(HtmlAttribute_obj,quote),HX_("quote",3c,23,f2,5d)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *HtmlAttribute_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String HtmlAttribute_obj_sMemberFields[] = {
+	HX_("name",4b,72,ff,48),
+	HX_("value",71,7f,b8,31),
+	HX_("quote",3c,23,f2,5d),
+	::String(null()) };
+
+::hx::Class HtmlAttribute_obj::__mClass;
+
+void HtmlAttribute_obj::__register()
+{
+	HtmlAttribute_obj _hx_dummy;
+	HtmlAttribute_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("htmlparser.HtmlAttribute",2d,32,5c,c0);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(HtmlAttribute_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< HtmlAttribute_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = HtmlAttribute_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = HtmlAttribute_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace htmlparser
diff --git a/Sources/c_snikket/src/htmlparser/HtmlNode.cpp b/Sources/c_snikket/src/htmlparser/HtmlNode.cpp
new file mode 100644
index 0000000..2c4b39c
--- /dev/null
+++ b/Sources/c_snikket/src/htmlparser/HtmlNode.cpp
@@ -0,0 +1,108 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_htmlparser_HtmlNode
+#include <htmlparser/HtmlNode.h>
+#endif
+#ifndef INCLUDED_htmlparser_HtmlNodeElement
+#include <htmlparser/HtmlNodeElement.h>
+#endif
+
+namespace htmlparser{
+
+void HtmlNode_obj::__construct() { }
+
+Dynamic HtmlNode_obj::__CreateEmpty() { return new HtmlNode_obj; }
+
+void *HtmlNode_obj::_hx_vtable = 0;
+
+Dynamic HtmlNode_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< HtmlNode_obj > _hx_result = new HtmlNode_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool HtmlNode_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x0ca65a7f;
+}
+
+
+HtmlNode_obj::HtmlNode_obj()
+{
+}
+
+void HtmlNode_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(HtmlNode);
+	HX_MARK_MEMBER_NAME(parent,"parent");
+	HX_MARK_END_CLASS();
+}
+
+void HtmlNode_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(parent,"parent");
+}
+
+::hx::Val HtmlNode_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 6:
+		if (HX_FIELD_EQ(inName,"parent") ) { return ::hx::Val( parent ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val HtmlNode_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 6:
+		if (HX_FIELD_EQ(inName,"parent") ) { parent=inValue.Cast<  ::htmlparser::HtmlNodeElement >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void HtmlNode_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("parent",2a,05,7e,ed));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo HtmlNode_obj_sMemberStorageInfo[] = {
+	{::hx::fsObject /*  ::htmlparser::HtmlNodeElement */ ,(int)offsetof(HtmlNode_obj,parent),HX_("parent",2a,05,7e,ed)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *HtmlNode_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String HtmlNode_obj_sMemberFields[] = {
+	HX_("parent",2a,05,7e,ed),
+	::String(null()) };
+
+::hx::Class HtmlNode_obj::__mClass;
+
+void HtmlNode_obj::__register()
+{
+	HtmlNode_obj _hx_dummy;
+	HtmlNode_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("htmlparser.HtmlNode",91,81,77,fd);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(HtmlNode_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< HtmlNode_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = HtmlNode_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = HtmlNode_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace htmlparser
diff --git a/Sources/c_snikket/src/htmlparser/HtmlNodeElement.cpp b/Sources/c_snikket/src/htmlparser/HtmlNodeElement.cpp
new file mode 100644
index 0000000..3386084
--- /dev/null
+++ b/Sources/c_snikket/src/htmlparser/HtmlNodeElement.cpp
@@ -0,0 +1,214 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Std
+#include <Std.h>
+#endif
+#ifndef INCLUDED_haxe_Exception
+#include <haxe/Exception.h>
+#endif
+#ifndef INCLUDED_htmlparser_HtmlAttribute
+#include <htmlparser/HtmlAttribute.h>
+#endif
+#ifndef INCLUDED_htmlparser_HtmlNode
+#include <htmlparser/HtmlNode.h>
+#endif
+#ifndef INCLUDED_htmlparser_HtmlNodeElement
+#include <htmlparser/HtmlNodeElement.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_230db80db2eef571_30_new,"htmlparser.HtmlNodeElement","new",0x871a2b9d,"htmlparser.HtmlNodeElement.new","htmlparser/HtmlNodeElement.hx",30,0x4baf0ab4)
+HX_LOCAL_STACK_FRAME(_hx_pos_230db80db2eef571_39_addChild,"htmlparser.HtmlNodeElement","addChild",0xc82b975e,"htmlparser.HtmlNodeElement.addChild","htmlparser/HtmlNodeElement.hx",39,0x4baf0ab4)
+namespace htmlparser{
+
+void HtmlNodeElement_obj::__construct(::String name,::Array< ::Dynamic> attributes){
+            	HX_STACKFRAME(&_hx_pos_230db80db2eef571_30_new)
+HXLINE(  31)		this->name = name;
+HXLINE(  32)		this->attributes = attributes;
+HXLINE(  33)		this->nodes = ::Array_obj< ::Dynamic>::__new(0);
+HXLINE(  34)		this->children = ::Array_obj< ::Dynamic>::__new(0);
+            	}
+
+Dynamic HtmlNodeElement_obj::__CreateEmpty() { return new HtmlNodeElement_obj; }
+
+void *HtmlNodeElement_obj::_hx_vtable = 0;
+
+Dynamic HtmlNodeElement_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< HtmlNodeElement_obj > _hx_result = new HtmlNodeElement_obj();
+	_hx_result->__construct(inArgs[0],inArgs[1]);
+	return _hx_result;
+}
+
+bool HtmlNodeElement_obj::_hx_isInstanceOf(int inClassId) {
+	if (inClassId<=(int)0x0ca65a7f) {
+		return inClassId==(int)0x00000001 || inClassId==(int)0x0ca65a7f;
+	} else {
+		return inClassId==(int)0x234247c5;
+	}
+}
+
+void HtmlNodeElement_obj::addChild( ::htmlparser::HtmlNode node, ::htmlparser::HtmlNode beforeNode){
+            	HX_GC_STACKFRAME(&_hx_pos_230db80db2eef571_39_addChild)
+HXDLIN(  39)		if (::hx::IsNull( beforeNode )) {
+HXLINE(  41)			this->nodes->push(node);
+HXLINE(  42)			node->parent = ::hx::ObjectPtr<OBJ_>(this);
+HXLINE(  43)			if (::Std_obj::isOfType(node,::hx::ClassOf< ::htmlparser::HtmlNodeElement >())) {
+HXLINE(  43)				this->children->push(( ( ::htmlparser::HtmlNodeElement)(node) ));
+            			}
+            		}
+            		else {
+HXLINE(  47)			int n = this->nodes->indexOf(beforeNode,null());
+HXLINE(  48)			if ((n < 0)) {
+HXLINE(  48)				HX_STACK_DO_THROW( ::haxe::Exception_obj::__alloc( HX_CTX ,HX_("`beforeNode` is not found.",6e,0e,bc,84),null(),null()));
+            			}
+HXLINE(  49)			this->nodes->insert(n,node);
+HXLINE(  50)			node->parent = ::hx::ObjectPtr<OBJ_>(this);
+HXLINE(  51)			::Array< ::Dynamic> _g = ::Array_obj< ::Dynamic>::__new(0);
+HXDLIN(  51)			{
+HXLINE(  51)				int _g1 = 0;
+HXDLIN(  51)				::Array< ::Dynamic> _g2 = this->nodes;
+HXDLIN(  51)				while((_g1 < _g2->length)){
+HXLINE(  51)					 ::htmlparser::HtmlNode v = _g2->__get(_g1).StaticCast<  ::htmlparser::HtmlNode >();
+HXDLIN(  51)					_g1 = (_g1 + 1);
+HXDLIN(  51)					if (::Std_obj::isOfType(v,::hx::ClassOf< ::htmlparser::HtmlNodeElement >())) {
+HXLINE(  51)						_g->push(v);
+            					}
+            				}
+            			}
+HXDLIN(  51)			this->children = _g;
+            		}
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(HtmlNodeElement_obj,addChild,(void))
+
+
+::hx::ObjectPtr< HtmlNodeElement_obj > HtmlNodeElement_obj::__new(::String name,::Array< ::Dynamic> attributes) {
+	::hx::ObjectPtr< HtmlNodeElement_obj > __this = new HtmlNodeElement_obj();
+	__this->__construct(name,attributes);
+	return __this;
+}
+
+::hx::ObjectPtr< HtmlNodeElement_obj > HtmlNodeElement_obj::__alloc(::hx::Ctx *_hx_ctx,::String name,::Array< ::Dynamic> attributes) {
+	HtmlNodeElement_obj *__this = (HtmlNodeElement_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(HtmlNodeElement_obj), true, "htmlparser.HtmlNodeElement"));
+	*(void **)__this = HtmlNodeElement_obj::_hx_vtable;
+	__this->__construct(name,attributes);
+	return __this;
+}
+
+HtmlNodeElement_obj::HtmlNodeElement_obj()
+{
+}
+
+void HtmlNodeElement_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(HtmlNodeElement);
+	HX_MARK_MEMBER_NAME(name,"name");
+	HX_MARK_MEMBER_NAME(attributes,"attributes");
+	HX_MARK_MEMBER_NAME(nodes,"nodes");
+	HX_MARK_MEMBER_NAME(children,"children");
+	 ::htmlparser::HtmlNode_obj::__Mark(HX_MARK_ARG);
+	HX_MARK_END_CLASS();
+}
+
+void HtmlNodeElement_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(name,"name");
+	HX_VISIT_MEMBER_NAME(attributes,"attributes");
+	HX_VISIT_MEMBER_NAME(nodes,"nodes");
+	HX_VISIT_MEMBER_NAME(children,"children");
+	 ::htmlparser::HtmlNode_obj::__Visit(HX_VISIT_ARG);
+}
+
+::hx::Val HtmlNodeElement_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"name") ) { return ::hx::Val( name ); }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"nodes") ) { return ::hx::Val( nodes ); }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"children") ) { return ::hx::Val( children ); }
+		if (HX_FIELD_EQ(inName,"addChild") ) { return ::hx::Val( addChild_dyn() ); }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"attributes") ) { return ::hx::Val( attributes ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val HtmlNodeElement_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"name") ) { name=inValue.Cast< ::String >(); return inValue; }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"nodes") ) { nodes=inValue.Cast< ::Array< ::Dynamic> >(); return inValue; }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"children") ) { children=inValue.Cast< ::Array< ::Dynamic> >(); return inValue; }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"attributes") ) { attributes=inValue.Cast< ::Array< ::Dynamic> >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void HtmlNodeElement_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("name",4b,72,ff,48));
+	outFields->push(HX_("attributes",d7,a8,71,97));
+	outFields->push(HX_("nodes",31,b8,be,9f));
+	outFields->push(HX_("children",3f,19,6a,70));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo HtmlNodeElement_obj_sMemberStorageInfo[] = {
+	{::hx::fsString,(int)offsetof(HtmlNodeElement_obj,name),HX_("name",4b,72,ff,48)},
+	{::hx::fsObject /* ::Array< ::Dynamic> */ ,(int)offsetof(HtmlNodeElement_obj,attributes),HX_("attributes",d7,a8,71,97)},
+	{::hx::fsObject /* ::Array< ::Dynamic> */ ,(int)offsetof(HtmlNodeElement_obj,nodes),HX_("nodes",31,b8,be,9f)},
+	{::hx::fsObject /* ::Array< ::Dynamic> */ ,(int)offsetof(HtmlNodeElement_obj,children),HX_("children",3f,19,6a,70)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *HtmlNodeElement_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String HtmlNodeElement_obj_sMemberFields[] = {
+	HX_("name",4b,72,ff,48),
+	HX_("attributes",d7,a8,71,97),
+	HX_("nodes",31,b8,be,9f),
+	HX_("children",3f,19,6a,70),
+	HX_("addChild",bb,cf,16,bf),
+	::String(null()) };
+
+::hx::Class HtmlNodeElement_obj::__mClass;
+
+void HtmlNodeElement_obj::__register()
+{
+	HtmlNodeElement_obj _hx_dummy;
+	HtmlNodeElement_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("htmlparser.HtmlNodeElement",2b,19,23,54);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(HtmlNodeElement_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< HtmlNodeElement_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = HtmlNodeElement_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = HtmlNodeElement_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace htmlparser
diff --git a/Sources/c_snikket/src/htmlparser/HtmlNodeText.cpp b/Sources/c_snikket/src/htmlparser/HtmlNodeText.cpp
new file mode 100644
index 0000000..43c6ba6
--- /dev/null
+++ b/Sources/c_snikket/src/htmlparser/HtmlNodeText.cpp
@@ -0,0 +1,147 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_htmlparser_HtmlNode
+#include <htmlparser/HtmlNode.h>
+#endif
+#ifndef INCLUDED_htmlparser_HtmlNodeText
+#include <htmlparser/HtmlNodeText.h>
+#endif
+#ifndef INCLUDED_htmlparser_HtmlTools
+#include <htmlparser/HtmlTools.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_8a9116cd313e44a4_9_new,"htmlparser.HtmlNodeText","new",0xfdac7ed0,"htmlparser.HtmlNodeText.new","htmlparser/HtmlNodeText.hx",9,0xb3a973bf)
+HX_LOCAL_STACK_FRAME(_hx_pos_8a9116cd313e44a4_19_toText,"htmlparser.HtmlNodeText","toText",0xb9832f58,"htmlparser.HtmlNodeText.toText","htmlparser/HtmlNodeText.hx",19,0xb3a973bf)
+namespace htmlparser{
+
+void HtmlNodeText_obj::__construct(::String text){
+            	HX_STACKFRAME(&_hx_pos_8a9116cd313e44a4_9_new)
+HXDLIN(   9)		this->text = text;
+            	}
+
+Dynamic HtmlNodeText_obj::__CreateEmpty() { return new HtmlNodeText_obj; }
+
+void *HtmlNodeText_obj::_hx_vtable = 0;
+
+Dynamic HtmlNodeText_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< HtmlNodeText_obj > _hx_result = new HtmlNodeText_obj();
+	_hx_result->__construct(inArgs[0]);
+	return _hx_result;
+}
+
+bool HtmlNodeText_obj::_hx_isInstanceOf(int inClassId) {
+	if (inClassId<=(int)0x0ca65a7f) {
+		return inClassId==(int)0x00000001 || inClassId==(int)0x0ca65a7f;
+	} else {
+		return inClassId==(int)0x699e2404;
+	}
+}
+
+::String HtmlNodeText_obj::toText(){
+            	HX_STACKFRAME(&_hx_pos_8a9116cd313e44a4_19_toText)
+HXDLIN(  19)		return ::htmlparser::HtmlTools_obj::unescape(this->text);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(HtmlNodeText_obj,toText,return )
+
+
+::hx::ObjectPtr< HtmlNodeText_obj > HtmlNodeText_obj::__new(::String text) {
+	::hx::ObjectPtr< HtmlNodeText_obj > __this = new HtmlNodeText_obj();
+	__this->__construct(text);
+	return __this;
+}
+
+::hx::ObjectPtr< HtmlNodeText_obj > HtmlNodeText_obj::__alloc(::hx::Ctx *_hx_ctx,::String text) {
+	HtmlNodeText_obj *__this = (HtmlNodeText_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(HtmlNodeText_obj), true, "htmlparser.HtmlNodeText"));
+	*(void **)__this = HtmlNodeText_obj::_hx_vtable;
+	__this->__construct(text);
+	return __this;
+}
+
+HtmlNodeText_obj::HtmlNodeText_obj()
+{
+}
+
+void HtmlNodeText_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(HtmlNodeText);
+	HX_MARK_MEMBER_NAME(text,"text");
+	 ::htmlparser::HtmlNode_obj::__Mark(HX_MARK_ARG);
+	HX_MARK_END_CLASS();
+}
+
+void HtmlNodeText_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(text,"text");
+	 ::htmlparser::HtmlNode_obj::__Visit(HX_VISIT_ARG);
+}
+
+::hx::Val HtmlNodeText_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"text") ) { return ::hx::Val( text ); }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"toText") ) { return ::hx::Val( toText_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val HtmlNodeText_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"text") ) { text=inValue.Cast< ::String >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void HtmlNodeText_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("text",ad,cc,f9,4c));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo HtmlNodeText_obj_sMemberStorageInfo[] = {
+	{::hx::fsString,(int)offsetof(HtmlNodeText_obj,text),HX_("text",ad,cc,f9,4c)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *HtmlNodeText_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String HtmlNodeText_obj_sMemberFields[] = {
+	HX_("text",ad,cc,f9,4c),
+	HX_("toText",c8,37,b3,82),
+	::String(null()) };
+
+::hx::Class HtmlNodeText_obj::__mClass;
+
+void HtmlNodeText_obj::__register()
+{
+	HtmlNodeText_obj _hx_dummy;
+	HtmlNodeText_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("htmlparser.HtmlNodeText",de,16,b9,ea);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(HtmlNodeText_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< HtmlNodeText_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = HtmlNodeText_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = HtmlNodeText_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace htmlparser
diff --git a/Sources/c_snikket/src/htmlparser/HtmlParser.cpp b/Sources/c_snikket/src/htmlparser/HtmlParser.cpp
new file mode 100644
index 0000000..cbe42cb
--- /dev/null
+++ b/Sources/c_snikket/src/htmlparser/HtmlParser.cpp
@@ -0,0 +1,1128 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_EReg
+#include <EReg.h>
+#endif
+#ifndef INCLUDED_Reflect
+#include <Reflect.h>
+#endif
+#ifndef INCLUDED_htmlparser_HtmlAttribute
+#include <htmlparser/HtmlAttribute.h>
+#endif
+#ifndef INCLUDED_htmlparser_HtmlNode
+#include <htmlparser/HtmlNode.h>
+#endif
+#ifndef INCLUDED_htmlparser_HtmlNodeElement
+#include <htmlparser/HtmlNodeElement.h>
+#endif
+#ifndef INCLUDED_htmlparser_HtmlNodeText
+#include <htmlparser/HtmlNodeText.h>
+#endif
+#ifndef INCLUDED_htmlparser_HtmlParser
+#include <htmlparser/HtmlParser.h>
+#endif
+#ifndef INCLUDED_htmlparser_HtmlParserException
+#include <htmlparser/HtmlParserException.h>
+#endif
+#ifndef INCLUDED_htmlparser_HtmlTools
+#include <htmlparser/HtmlTools.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_8ccefc64b7335ec2_34_new,"htmlparser.HtmlParser","new",0x51fba620,"htmlparser.HtmlParser.new","htmlparser/HtmlParser.hx",34,0x7063d0af)
+HX_LOCAL_STACK_FRAME(_hx_pos_8ccefc64b7335ec2_37_parse,"htmlparser.HtmlParser","parse",0xa8ee55f3,"htmlparser.HtmlParser.parse","htmlparser/HtmlParser.hx",37,0x7063d0af)
+HX_LOCAL_STACK_FRAME(_hx_pos_8ccefc64b7335ec2_94_processMatches,"htmlparser.HtmlParser","processMatches",0xa35b0084,"htmlparser.HtmlParser.processMatches","htmlparser/HtmlParser.hx",94,0x7063d0af)
+HX_LOCAL_STACK_FRAME(_hx_pos_8ccefc64b7335ec2_168_parseElement,"htmlparser.HtmlParser","parseElement",0x4f3e7509,"htmlparser.HtmlParser.parseElement","htmlparser/HtmlParser.hx",168,0x7063d0af)
+HX_LOCAL_STACK_FRAME(_hx_pos_8ccefc64b7335ec2_200_isSelfClosingTag,"htmlparser.HtmlParser","isSelfClosingTag",0x64def8db,"htmlparser.HtmlParser.isSelfClosingTag","htmlparser/HtmlParser.hx",200,0x7063d0af)
+HX_LOCAL_STACK_FRAME(_hx_pos_8ccefc64b7335ec2_202_newElement,"htmlparser.HtmlParser","newElement",0x6359347c,"htmlparser.HtmlParser.newElement","htmlparser/HtmlParser.hx",202,0x7063d0af)
+HX_LOCAL_STACK_FRAME(_hx_pos_8ccefc64b7335ec2_239_getPosition,"htmlparser.HtmlParser","getPosition",0xd301f91f,"htmlparser.HtmlParser.getPosition","htmlparser/HtmlParser.hx",239,0x7063d0af)
+HX_LOCAL_STACK_FRAME(_hx_pos_8ccefc64b7335ec2_32_run,"htmlparser.HtmlParser","run",0x51febd0b,"htmlparser.HtmlParser.run","htmlparser/HtmlParser.hx",32,0x7063d0af)
+HX_LOCAL_STACK_FRAME(_hx_pos_8ccefc64b7335ec2_205_parseAttrs,"htmlparser.HtmlParser","parseAttrs",0x70c7172f,"htmlparser.HtmlParser.parseAttrs","htmlparser/HtmlParser.hx",205,0x7063d0af)
+HX_LOCAL_STACK_FRAME(_hx_pos_8ccefc64b7335ec2_9_boot,"htmlparser.HtmlParser","boot",0x624eb672,"htmlparser.HtmlParser.boot","htmlparser/HtmlParser.hx",9,0x7063d0af)
+HX_LOCAL_STACK_FRAME(_hx_pos_8ccefc64b7335ec2_11_boot,"htmlparser.HtmlParser","boot",0x624eb672,"htmlparser.HtmlParser.boot","htmlparser/HtmlParser.hx",11,0x7063d0af)
+HX_LOCAL_STACK_FRAME(_hx_pos_8ccefc64b7335ec2_12_boot,"htmlparser.HtmlParser","boot",0x624eb672,"htmlparser.HtmlParser.boot","htmlparser/HtmlParser.hx",12,0x7063d0af)
+HX_LOCAL_STACK_FRAME(_hx_pos_8ccefc64b7335ec2_14_boot,"htmlparser.HtmlParser","boot",0x624eb672,"htmlparser.HtmlParser.boot","htmlparser/HtmlParser.hx",14,0x7063d0af)
+HX_LOCAL_STACK_FRAME(_hx_pos_8ccefc64b7335ec2_15_boot,"htmlparser.HtmlParser","boot",0x624eb672,"htmlparser.HtmlParser.boot","htmlparser/HtmlParser.hx",15,0x7063d0af)
+HX_LOCAL_STACK_FRAME(_hx_pos_8ccefc64b7335ec2_16_boot,"htmlparser.HtmlParser","boot",0x624eb672,"htmlparser.HtmlParser.boot","htmlparser/HtmlParser.hx",16,0x7063d0af)
+HX_LOCAL_STACK_FRAME(_hx_pos_8ccefc64b7335ec2_17_boot,"htmlparser.HtmlParser","boot",0x624eb672,"htmlparser.HtmlParser.boot","htmlparser/HtmlParser.hx",17,0x7063d0af)
+HX_LOCAL_STACK_FRAME(_hx_pos_8ccefc64b7335ec2_18_boot,"htmlparser.HtmlParser","boot",0x624eb672,"htmlparser.HtmlParser.boot","htmlparser/HtmlParser.hx",18,0x7063d0af)
+HX_LOCAL_STACK_FRAME(_hx_pos_8ccefc64b7335ec2_19_boot,"htmlparser.HtmlParser","boot",0x624eb672,"htmlparser.HtmlParser.boot","htmlparser/HtmlParser.hx",19,0x7063d0af)
+HX_LOCAL_STACK_FRAME(_hx_pos_8ccefc64b7335ec2_20_boot,"htmlparser.HtmlParser","boot",0x624eb672,"htmlparser.HtmlParser.boot","htmlparser/HtmlParser.hx",20,0x7063d0af)
+HX_LOCAL_STACK_FRAME(_hx_pos_8ccefc64b7335ec2_21_boot,"htmlparser.HtmlParser","boot",0x624eb672,"htmlparser.HtmlParser.boot","htmlparser/HtmlParser.hx",21,0x7063d0af)
+HX_LOCAL_STACK_FRAME(_hx_pos_8ccefc64b7335ec2_23_boot,"htmlparser.HtmlParser","boot",0x624eb672,"htmlparser.HtmlParser.boot","htmlparser/HtmlParser.hx",23,0x7063d0af)
+HX_LOCAL_STACK_FRAME(_hx_pos_8ccefc64b7335ec2_25_boot,"htmlparser.HtmlParser","boot",0x624eb672,"htmlparser.HtmlParser.boot","htmlparser/HtmlParser.hx",25,0x7063d0af)
+namespace htmlparser{
+
+void HtmlParser_obj::__construct(){
+            	HX_STACKFRAME(&_hx_pos_8ccefc64b7335ec2_34_new)
+            	}
+
+Dynamic HtmlParser_obj::__CreateEmpty() { return new HtmlParser_obj; }
+
+void *HtmlParser_obj::_hx_vtable = 0;
+
+Dynamic HtmlParser_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< HtmlParser_obj > _hx_result = new HtmlParser_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool HtmlParser_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x0d37c69c;
+}
+
+::Array< ::Dynamic> HtmlParser_obj::parse(::String str,::hx::Null< bool >  __o_tolerant){
+            		bool tolerant = __o_tolerant.Default(false);
+            	HX_GC_STACKFRAME(&_hx_pos_8ccefc64b7335ec2_37_parse)
+HXLINE(  38)		this->tolerant = tolerant;
+HXLINE(  40)		this->matches = ::Array_obj< ::Dynamic>::__new(0);
+HXLINE(  41)		int pos = 0;
+HXDLIN(  41)		while(true){
+HXLINE(  41)			bool _hx_tmp;
+HXDLIN(  41)			if ((pos < str.length)) {
+HXLINE(  41)				_hx_tmp = ::htmlparser::HtmlParser_obj::reMain->matchSub(str,pos,null());
+            			}
+            			else {
+HXLINE(  41)				_hx_tmp = false;
+            			}
+HXDLIN(  41)			if (!(_hx_tmp)) {
+HXLINE(  41)				goto _hx_goto_1;
+            			}
+HXLINE(  43)			 ::Dynamic p = ::htmlparser::HtmlParser_obj::reMain->matchedPos();
+HXLINE(  44)			 ::EReg re = ::htmlparser::HtmlParser_obj::reMain;
+HXDLIN(  44)			::String cdata;
+HXDLIN(  44)			try {
+            				HX_STACK_CATCHABLE( ::Dynamic, 0);
+HXLINE(  44)				cdata = re->matched(1);
+            			} catch( ::Dynamic _hx_e) {
+            				if (_hx_e.IsClass<  ::Dynamic >() ){
+            					HX_STACK_BEGIN_CATCH
+            					 ::Dynamic _g = _hx_e;
+HXLINE( 268)					{
+HXLINE( 268)						null();
+            					}
+HXLINE(  44)					cdata = null();
+            				}
+            				else {
+            					HX_STACK_DO_THROW(_hx_e);
+            				}
+            			}
+HXLINE(  45)			bool _hx_tmp1;
+HXDLIN(  45)			if (::hx::IsNotNull( cdata )) {
+HXLINE(  45)				_hx_tmp1 = (cdata == HX_("",00,00,00,00));
+            			}
+            			else {
+HXLINE(  45)				_hx_tmp1 = true;
+            			}
+HXDLIN(  45)			if (_hx_tmp1) {
+HXLINE(  49)				::String r = ::htmlparser::HtmlParser_obj::reMain->matched(0);
+HXLINE(  50)				int p1 = ( (int)(p->__Field(HX_("pos",94,5d,55,00),::hx::paccDynamic)) );
+HXLINE(  52)				 ::EReg re1 = ::htmlparser::HtmlParser_obj::reMain;
+HXDLIN(  52)				::String r1;
+HXDLIN(  52)				try {
+            					HX_STACK_CATCHABLE( ::Dynamic, 0);
+HXLINE(  52)					r1 = re1->matched(2);
+            				} catch( ::Dynamic _hx_e) {
+            					if (_hx_e.IsClass<  ::Dynamic >() ){
+            						HX_STACK_BEGIN_CATCH
+            						 ::Dynamic _g1 = _hx_e;
+HXLINE( 268)						{
+HXLINE( 268)							null();
+            						}
+HXLINE(  52)						r1 = null();
+            					}
+            					else {
+            						HX_STACK_DO_THROW(_hx_e);
+            					}
+            				}
+HXLINE(  53)				 ::EReg re2 = ::htmlparser::HtmlParser_obj::reMain;
+HXDLIN(  53)				::String r2;
+HXDLIN(  53)				try {
+            					HX_STACK_CATCHABLE( ::Dynamic, 0);
+HXLINE(  53)					r2 = re2->matched(3);
+            				} catch( ::Dynamic _hx_e) {
+            					if (_hx_e.IsClass<  ::Dynamic >() ){
+            						HX_STACK_BEGIN_CATCH
+            						 ::Dynamic _g2 = _hx_e;
+HXLINE( 268)						{
+HXLINE( 268)							null();
+            						}
+HXLINE(  53)						r2 = null();
+            					}
+            					else {
+            						HX_STACK_DO_THROW(_hx_e);
+            					}
+            				}
+HXLINE(  54)				 ::EReg re3 = ::htmlparser::HtmlParser_obj::reMain;
+HXDLIN(  54)				::String r3;
+HXDLIN(  54)				try {
+            					HX_STACK_CATCHABLE( ::Dynamic, 0);
+HXLINE(  54)					r3 = re3->matched(4);
+            				} catch( ::Dynamic _hx_e) {
+            					if (_hx_e.IsClass<  ::Dynamic >() ){
+            						HX_STACK_BEGIN_CATCH
+            						 ::Dynamic _g3 = _hx_e;
+HXLINE( 268)						{
+HXLINE( 268)							null();
+            						}
+HXLINE(  54)						r3 = null();
+            					}
+            					else {
+            						HX_STACK_DO_THROW(_hx_e);
+            					}
+            				}
+HXLINE(  55)				 ::EReg re4 = ::htmlparser::HtmlParser_obj::reMain;
+HXDLIN(  55)				::String r4;
+HXDLIN(  55)				try {
+            					HX_STACK_CATCHABLE( ::Dynamic, 0);
+HXLINE(  55)					r4 = re4->matched(5);
+            				} catch( ::Dynamic _hx_e) {
+            					if (_hx_e.IsClass<  ::Dynamic >() ){
+            						HX_STACK_BEGIN_CATCH
+            						 ::Dynamic _g4 = _hx_e;
+HXLINE( 268)						{
+HXLINE( 268)							null();
+            						}
+HXLINE(  55)						r4 = null();
+            					}
+            					else {
+            						HX_STACK_DO_THROW(_hx_e);
+            					}
+            				}
+HXLINE(  56)				 ::EReg re5 = ::htmlparser::HtmlParser_obj::reMain;
+HXDLIN(  56)				::String r5;
+HXDLIN(  56)				try {
+            					HX_STACK_CATCHABLE( ::Dynamic, 0);
+HXLINE(  56)					r5 = re5->matched(6);
+            				} catch( ::Dynamic _hx_e) {
+            					if (_hx_e.IsClass<  ::Dynamic >() ){
+            						HX_STACK_BEGIN_CATCH
+            						 ::Dynamic _g5 = _hx_e;
+HXLINE( 268)						{
+HXLINE( 268)							null();
+            						}
+HXLINE(  56)						r5 = null();
+            					}
+            					else {
+            						HX_STACK_DO_THROW(_hx_e);
+            					}
+            				}
+HXLINE(  57)				 ::EReg re6 = ::htmlparser::HtmlParser_obj::reMain;
+HXDLIN(  57)				::String r6;
+HXDLIN(  57)				try {
+            					HX_STACK_CATCHABLE( ::Dynamic, 0);
+HXLINE(  57)					r6 = re6->matched(7);
+            				} catch( ::Dynamic _hx_e) {
+            					if (_hx_e.IsClass<  ::Dynamic >() ){
+            						HX_STACK_BEGIN_CATCH
+            						 ::Dynamic _g6 = _hx_e;
+HXLINE( 268)						{
+HXLINE( 268)							null();
+            						}
+HXLINE(  57)						r6 = null();
+            					}
+            					else {
+            						HX_STACK_DO_THROW(_hx_e);
+            					}
+            				}
+HXLINE(  58)				 ::EReg re7 = ::htmlparser::HtmlParser_obj::reMain;
+HXDLIN(  58)				::String r7;
+HXDLIN(  58)				try {
+            					HX_STACK_CATCHABLE( ::Dynamic, 0);
+HXLINE(  58)					r7 = re7->matched(8);
+            				} catch( ::Dynamic _hx_e) {
+            					if (_hx_e.IsClass<  ::Dynamic >() ){
+            						HX_STACK_BEGIN_CATCH
+            						 ::Dynamic _g7 = _hx_e;
+HXLINE( 268)						{
+HXLINE( 268)							null();
+            						}
+HXLINE(  58)						r7 = null();
+            					}
+            					else {
+            						HX_STACK_DO_THROW(_hx_e);
+            					}
+            				}
+HXLINE(  59)				 ::EReg re8 = ::htmlparser::HtmlParser_obj::reMain;
+HXDLIN(  59)				::String r8;
+HXDLIN(  59)				try {
+            					HX_STACK_CATCHABLE( ::Dynamic, 0);
+HXLINE(  59)					r8 = re8->matched(9);
+            				} catch( ::Dynamic _hx_e) {
+            					if (_hx_e.IsClass<  ::Dynamic >() ){
+            						HX_STACK_BEGIN_CATCH
+            						 ::Dynamic _g8 = _hx_e;
+HXLINE( 268)						{
+HXLINE( 268)							null();
+            						}
+HXLINE(  59)						r8 = null();
+            					}
+            					else {
+            						HX_STACK_DO_THROW(_hx_e);
+            					}
+            				}
+HXLINE(  60)				 ::EReg re9 = ::htmlparser::HtmlParser_obj::reMain;
+HXDLIN(  60)				::String r9;
+HXDLIN(  60)				try {
+            					HX_STACK_CATCHABLE( ::Dynamic, 0);
+HXLINE(  60)					r9 = re9->matched(10);
+            				} catch( ::Dynamic _hx_e) {
+            					if (_hx_e.IsClass<  ::Dynamic >() ){
+            						HX_STACK_BEGIN_CATCH
+            						 ::Dynamic _g9 = _hx_e;
+HXLINE( 268)						{
+HXLINE( 268)							null();
+            						}
+HXLINE(  60)						r9 = null();
+            					}
+            					else {
+            						HX_STACK_DO_THROW(_hx_e);
+            					}
+            				}
+HXLINE(  61)				 ::EReg re10 = ::htmlparser::HtmlParser_obj::reMain;
+HXDLIN(  61)				::String r10;
+HXDLIN(  61)				try {
+            					HX_STACK_CATCHABLE( ::Dynamic, 0);
+HXLINE(  61)					r10 = re10->matched(11);
+            				} catch( ::Dynamic _hx_e) {
+            					if (_hx_e.IsClass<  ::Dynamic >() ){
+            						HX_STACK_BEGIN_CATCH
+            						 ::Dynamic _g10 = _hx_e;
+HXLINE( 268)						{
+HXLINE( 268)							null();
+            						}
+HXLINE(  61)						r10 = null();
+            					}
+            					else {
+            						HX_STACK_DO_THROW(_hx_e);
+            					}
+            				}
+HXLINE(  62)				 ::EReg re11 = ::htmlparser::HtmlParser_obj::reMain;
+HXDLIN(  62)				::String r11;
+HXDLIN(  62)				try {
+            					HX_STACK_CATCHABLE( ::Dynamic, 0);
+HXLINE(  62)					r11 = re11->matched(12);
+            				} catch( ::Dynamic _hx_e) {
+            					if (_hx_e.IsClass<  ::Dynamic >() ){
+            						HX_STACK_BEGIN_CATCH
+            						 ::Dynamic _g11 = _hx_e;
+HXLINE( 268)						{
+HXLINE( 268)							null();
+            						}
+HXLINE(  62)						r11 = null();
+            					}
+            					else {
+            						HX_STACK_DO_THROW(_hx_e);
+            					}
+            				}
+HXLINE(  63)				 ::EReg re12 = ::htmlparser::HtmlParser_obj::reMain;
+HXDLIN(  63)				::String r12;
+HXDLIN(  63)				try {
+            					HX_STACK_CATCHABLE( ::Dynamic, 0);
+HXLINE(  63)					r12 = re12->matched(13);
+            				} catch( ::Dynamic _hx_e) {
+            					if (_hx_e.IsClass<  ::Dynamic >() ){
+            						HX_STACK_BEGIN_CATCH
+            						 ::Dynamic _g12 = _hx_e;
+HXLINE( 268)						{
+HXLINE( 268)							null();
+            						}
+HXLINE(  63)						r12 = null();
+            					}
+            					else {
+            						HX_STACK_DO_THROW(_hx_e);
+            					}
+            				}
+HXLINE(  64)				 ::EReg re13 = ::htmlparser::HtmlParser_obj::reMain;
+HXDLIN(  64)				::String r13;
+HXDLIN(  64)				try {
+            					HX_STACK_CATCHABLE( ::Dynamic, 0);
+HXLINE(  64)					r13 = re13->matched(14);
+            				} catch( ::Dynamic _hx_e) {
+            					if (_hx_e.IsClass<  ::Dynamic >() ){
+            						HX_STACK_BEGIN_CATCH
+            						 ::Dynamic _g13 = _hx_e;
+HXLINE( 268)						{
+HXLINE( 268)							null();
+            						}
+HXLINE(  64)						r13 = null();
+            					}
+            					else {
+            						HX_STACK_DO_THROW(_hx_e);
+            					}
+            				}
+HXLINE(  47)				 ::Dynamic r14 =  ::Dynamic(::hx::Anon_obj::Create(17)
+            					->setFixed(0,HX_("comment",5f,7a,70,81),r13)
+            					->setFixed(1,HX_("style",31,a5,1d,84),r4)
+            					->setFixed(2,HX_("styleAttrs",31,c7,d9,a6),r5)
+            					->setFixed(3,HX_("tagClose",fe,66,d0,b6),r12)
+            					->setFixed(4,HX_("styleText",7e,8a,c9,e2),r6)
+            					->setFixed(5,HX_("scriptAttrs",17,c8,c2,f2),r2)
+            					->setFixed(6,HX_("all",21,f9,49,00),r)
+            					->setFixed(7,HX_("tagOpen",44,bf,2a,23),r8)
+            					->setFixed(8,HX_("attrs",22,6e,e3,26),r9)
+            					->setFixed(9,HX_("allPos",f3,c6,84,3f),p1)
+            					->setFixed(10,HX_("elem",8f,d8,14,43),r7)
+            					->setFixed(11,HX_("scriptText",58,a8,da,45),r3)
+            					->setFixed(12,HX_("script",0b,4e,60,47),r1)
+            					->setFixed(13,HX_("close",b8,17,63,48),r11)
+            					->setFixed(14,HX_("tagOpenLC",bb,5a,cc,52),null())
+            					->setFixed(15,HX_("tagCloseLC",f5,e4,f6,58),null())
+            					->setFixed(16,HX_("tagEnd",a1,d5,8d,7f),r10));
+HXLINE(  70)				if (::hx::IsNotNull( r14->__Field(HX_("tagOpen",44,bf,2a,23),::hx::paccDynamic) )) {
+HXLINE(  70)					r14->__SetField(HX_("tagOpenLC",bb,5a,cc,52),( (::String)(r14->__Field(HX_("tagOpen",44,bf,2a,23),::hx::paccDynamic)) ).toLowerCase(),::hx::paccDynamic);
+            				}
+HXLINE(  71)				if (::hx::IsNotNull( r14->__Field(HX_("tagClose",fe,66,d0,b6),::hx::paccDynamic) )) {
+HXLINE(  71)					r14->__SetField(HX_("tagCloseLC",f5,e4,f6,58),( (::String)(r14->__Field(HX_("tagClose",fe,66,d0,b6),::hx::paccDynamic)) ).toLowerCase(),::hx::paccDynamic);
+            				}
+HXLINE(  73)				this->matches->push(r14);
+            			}
+HXLINE(  75)			pos = ( (int)((p->__Field(HX_("pos",94,5d,55,00),::hx::paccDynamic) + p->__Field(HX_("len",d5,4b,52,00),::hx::paccDynamic))) );
+            		}
+            		_hx_goto_1:;
+HXLINE(  78)		if ((this->matches->length > 0)) {
+HXLINE(  80)			this->str = str;
+HXLINE(  81)			this->i = 0;
+HXLINE(  82)			::Array< ::Dynamic> nodes = ( (::Array< ::Dynamic>)(this->processMatches(::Array_obj< ::String >::__new(0))->__Field(HX_("nodes",31,b8,be,9f),::hx::paccDynamic)) );
+HXLINE(  83)			if ((this->i < this->matches->length)) {
+HXLINE(  85)				HX_STACK_DO_THROW( ::htmlparser::HtmlParserException_obj::__alloc( HX_CTX ,HX_("Not all nodes processed.",9b,bd,31,84),this->getPosition(this->i)));
+            			}
+HXLINE(  87)			return nodes;
+            		}
+HXLINE(  90)		if ((str.length > 0)) {
+HXLINE(  90)			return ::Array_obj< ::Dynamic>::__new(1)->init(0, ::htmlparser::HtmlNodeText_obj::__alloc( HX_CTX ,str));
+            		}
+            		else {
+HXLINE(  90)			return ::Array_obj< ::Dynamic>::__new(0);
+            		}
+HXDLIN(  90)		return null();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(HtmlParser_obj,parse,return )
+
+ ::Dynamic HtmlParser_obj::processMatches(::Array< ::String > openedTagsLC){
+            	HX_GC_STACKFRAME(&_hx_pos_8ccefc64b7335ec2_94_processMatches)
+HXLINE(  95)		::Array< ::Dynamic> nodes = ::Array_obj< ::Dynamic>::__new();
+HXLINE(  97)		int prevEnd;
+HXDLIN(  97)		if ((this->i > 0)) {
+HXLINE(  97)			prevEnd = ( (int)((this->matches->__get((this->i - 1))->__Field(HX_("allPos",f3,c6,84,3f),::hx::paccDynamic) + ( (::String)(this->matches->__get((this->i - 1))->__Field(HX_("all",21,f9,49,00),::hx::paccDynamic)) ).length)) );
+            		}
+            		else {
+HXLINE(  97)			prevEnd = 0;
+            		}
+HXLINE(  98)		int curStart = ( (int)(this->matches->__get(this->i)->__Field(HX_("allPos",f3,c6,84,3f),::hx::paccDynamic)) );
+HXLINE( 100)		if ((prevEnd < curStart)) {
+HXLINE( 102)			nodes->push( ::htmlparser::HtmlNodeText_obj::__alloc( HX_CTX ,this->str.substr(prevEnd,(curStart - prevEnd))));
+            		}
+HXLINE( 105)		while((this->i < this->matches->length)){
+HXLINE( 107)			 ::Dynamic m = this->matches->__get(this->i);
+HXLINE( 109)			bool _hx_tmp;
+HXDLIN( 109)			if (::hx::IsNotNull( m->__Field(HX_("elem",8f,d8,14,43),::hx::paccDynamic) )) {
+HXLINE( 109)				_hx_tmp = ::hx::IsNotEq( m->__Field(HX_("elem",8f,d8,14,43),::hx::paccDynamic),HX_("",00,00,00,00) );
+            			}
+            			else {
+HXLINE( 109)				_hx_tmp = false;
+            			}
+HXDLIN( 109)			if (_hx_tmp) {
+HXLINE( 111)				 ::Dynamic ee = this->parseElement(openedTagsLC);
+HXLINE( 112)				nodes->push( ::Dynamic(ee->__Field(HX_("element",bc,ae,54,06),::hx::paccDynamic)));
+HXLINE( 113)				if (::hx::IsNotEq( ee->__Field(HX_("closeTagLC",79,c4,c8,d5),::hx::paccDynamic),HX_("",00,00,00,00) )) {
+HXLINE( 113)					return  ::Dynamic(::hx::Anon_obj::Create(2)
+            						->setFixed(0,HX_("nodes",31,b8,be,9f),nodes)
+            						->setFixed(1,HX_("closeTagLC",79,c4,c8,d5), ::Dynamic(ee->__Field(HX_("closeTagLC",79,c4,c8,d5),::hx::paccDynamic))));
+            				}
+            			}
+            			else {
+HXLINE( 116)				bool _hx_tmp1;
+HXDLIN( 116)				if (::hx::IsNotNull( m->__Field(HX_("script",0b,4e,60,47),::hx::paccDynamic) )) {
+HXLINE( 116)					_hx_tmp1 = ::hx::IsNotEq( m->__Field(HX_("script",0b,4e,60,47),::hx::paccDynamic),HX_("",00,00,00,00) );
+            				}
+            				else {
+HXLINE( 116)					_hx_tmp1 = false;
+            				}
+HXDLIN( 116)				if (_hx_tmp1) {
+HXLINE( 118)					 ::htmlparser::HtmlNodeElement scriptNode = this->newElement(HX_("script",0b,4e,60,47),::htmlparser::HtmlParser_obj::parseAttrs(( (::String)(m->__Field(HX_("scriptAttrs",17,c8,c2,f2),::hx::paccDynamic)) )));
+HXLINE( 119)					scriptNode->addChild( ::htmlparser::HtmlNodeText_obj::__alloc( HX_CTX ,( (::String)(m->__Field(HX_("scriptText",58,a8,da,45),::hx::paccDynamic)) )),null());
+HXLINE( 120)					nodes->push(scriptNode);
+            				}
+            				else {
+HXLINE( 123)					bool _hx_tmp2;
+HXDLIN( 123)					if (::hx::IsNotNull( m->__Field(HX_("style",31,a5,1d,84),::hx::paccDynamic) )) {
+HXLINE( 123)						_hx_tmp2 = ::hx::IsNotEq( m->__Field(HX_("style",31,a5,1d,84),::hx::paccDynamic),HX_("",00,00,00,00) );
+            					}
+            					else {
+HXLINE( 123)						_hx_tmp2 = false;
+            					}
+HXDLIN( 123)					if (_hx_tmp2) {
+HXLINE( 125)						 ::htmlparser::HtmlNodeElement styleNode = this->newElement(HX_("style",31,a5,1d,84),::htmlparser::HtmlParser_obj::parseAttrs(( (::String)(m->__Field(HX_("styleAttrs",31,c7,d9,a6),::hx::paccDynamic)) )));
+HXLINE( 126)						styleNode->addChild( ::htmlparser::HtmlNodeText_obj::__alloc( HX_CTX ,( (::String)(m->__Field(HX_("styleText",7e,8a,c9,e2),::hx::paccDynamic)) )),null());
+HXLINE( 127)						nodes->push(styleNode);
+            					}
+            					else {
+HXLINE( 130)						bool _hx_tmp3;
+HXDLIN( 130)						if (::hx::IsNotNull( m->__Field(HX_("close",b8,17,63,48),::hx::paccDynamic) )) {
+HXLINE( 130)							_hx_tmp3 = ::hx::IsNotEq( m->__Field(HX_("close",b8,17,63,48),::hx::paccDynamic),HX_("",00,00,00,00) );
+            						}
+            						else {
+HXLINE( 130)							_hx_tmp3 = false;
+            						}
+HXDLIN( 130)						if (_hx_tmp3) {
+HXLINE( 132)							if (::hx::IsEq( m->__Field(HX_("tagCloseLC",f5,e4,f6,58),::hx::paccDynamic),openedTagsLC->__get((openedTagsLC->length - 1)) )) {
+HXLINE( 132)								goto _hx_goto_3;
+            							}
+HXLINE( 133)							if (this->tolerant) {
+HXLINE( 135)								if ((openedTagsLC->lastIndexOf( ::Dynamic(m->__Field(HX_("tagCloseLC",f5,e4,f6,58),::hx::paccDynamic)),null()) >= 0)) {
+HXLINE( 135)									goto _hx_goto_3;
+            								}
+            							}
+            							else {
+HXLINE( 139)								::String _hx_tmp4 = ( (::String)(((((HX_("Closed tag <",a2,4b,47,5b) + m->__Field(HX_("tagClose",fe,66,d0,b6),::hx::paccDynamic)) + HX_("> don't match to open tag <",b8,7f,a8,03)) + openedTagsLC->__get((openedTagsLC->length - 1))) + HX_(">.",30,36,00,00))) );
+HXDLIN( 139)								HX_STACK_DO_THROW( ::htmlparser::HtmlParserException_obj::__alloc( HX_CTX ,_hx_tmp4,this->getPosition(this->i)));
+            							}
+            						}
+            						else {
+HXLINE( 143)							bool _hx_tmp5;
+HXDLIN( 143)							if (::hx::IsNotNull( m->__Field(HX_("comment",5f,7a,70,81),::hx::paccDynamic) )) {
+HXLINE( 143)								_hx_tmp5 = ::hx::IsNotEq( m->__Field(HX_("comment",5f,7a,70,81),::hx::paccDynamic),HX_("",00,00,00,00) );
+            							}
+            							else {
+HXLINE( 143)								_hx_tmp5 = false;
+            							}
+HXDLIN( 143)							if (_hx_tmp5) {
+HXLINE( 145)								nodes->push( ::htmlparser::HtmlNodeText_obj::__alloc( HX_CTX ,( (::String)(m->__Field(HX_("comment",5f,7a,70,81),::hx::paccDynamic)) )));
+            							}
+            							else {
+HXLINE( 149)								HX_STACK_DO_THROW( ::htmlparser::HtmlParserException_obj::__alloc( HX_CTX ,HX_("Unexpected XML node.",d4,3d,c2,6a),this->getPosition(this->i)));
+            							}
+            						}
+            					}
+            				}
+            			}
+HXLINE( 152)			bool _hx_tmp6;
+HXDLIN( 152)			if (this->tolerant) {
+HXLINE( 152)				_hx_tmp6 = (this->i >= this->matches->length);
+            			}
+            			else {
+HXLINE( 152)				_hx_tmp6 = false;
+            			}
+HXDLIN( 152)			if (_hx_tmp6) {
+HXLINE( 152)				goto _hx_goto_3;
+            			}
+HXLINE( 154)			int curEnd = ( (int)((this->matches->__get(this->i)->__Field(HX_("allPos",f3,c6,84,3f),::hx::paccDynamic) + ( (::String)(this->matches->__get(this->i)->__Field(HX_("all",21,f9,49,00),::hx::paccDynamic)) ).length)) );
+HXLINE( 155)			int nextStart;
+HXDLIN( 155)			if (((this->i + 1) < this->matches->length)) {
+HXLINE( 155)				nextStart = ( (int)(this->matches->__get((this->i + 1))->__Field(HX_("allPos",f3,c6,84,3f),::hx::paccDynamic)) );
+            			}
+            			else {
+HXLINE( 155)				nextStart = this->str.length;
+            			}
+HXLINE( 156)			if ((curEnd < nextStart)) {
+HXLINE( 158)				nodes->push( ::htmlparser::HtmlNodeText_obj::__alloc( HX_CTX ,this->str.substr(curEnd,(nextStart - curEnd))));
+            			}
+HXLINE( 161)			this->i++;
+            		}
+            		_hx_goto_3:;
+HXLINE( 164)		return  ::Dynamic(::hx::Anon_obj::Create(2)
+            			->setFixed(0,HX_("nodes",31,b8,be,9f),nodes)
+            			->setFixed(1,HX_("closeTagLC",79,c4,c8,d5),HX_("",00,00,00,00)));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(HtmlParser_obj,processMatches,return )
+
+ ::Dynamic HtmlParser_obj::parseElement(::Array< ::String > openedTagsLC){
+            	HX_GC_STACKFRAME(&_hx_pos_8ccefc64b7335ec2_168_parseElement)
+HXLINE( 169)		::String tag = ( (::String)(this->matches->__get(this->i)->__Field(HX_("tagOpen",44,bf,2a,23),::hx::paccDynamic)) );
+HXLINE( 170)		::String tagLC = ( (::String)(this->matches->__get(this->i)->__Field(HX_("tagOpenLC",bb,5a,cc,52),::hx::paccDynamic)) );
+HXLINE( 171)		::String attrs = ( (::String)(this->matches->__get(this->i)->__Field(HX_("attrs",22,6e,e3,26),::hx::paccDynamic)) );
+HXLINE( 172)		bool isWithClose;
+HXDLIN( 172)		bool isWithClose1;
+HXDLIN( 172)		if (::hx::IsNotNull( this->matches->__get(this->i)->__Field(HX_("tagEnd",a1,d5,8d,7f),::hx::paccDynamic) )) {
+HXLINE( 172)			isWithClose1 = ::hx::IsNotEq( this->matches->__get(this->i)->__Field(HX_("tagEnd",a1,d5,8d,7f),::hx::paccDynamic),HX_("",00,00,00,00) );
+            		}
+            		else {
+HXLINE( 172)			isWithClose1 = false;
+            		}
+HXDLIN( 172)		if (!(isWithClose1)) {
+HXLINE( 172)			isWithClose = this->isSelfClosingTag(tagLC);
+            		}
+            		else {
+HXLINE( 172)			isWithClose = true;
+            		}
+HXLINE( 174)		 ::htmlparser::HtmlNodeElement elem = this->newElement(tag,::htmlparser::HtmlParser_obj::parseAttrs(attrs));
+HXLINE( 175)		::String closeTagLC = HX_("",00,00,00,00);
+HXLINE( 176)		if (!(isWithClose)) {
+HXLINE( 178)			this->i++;
+HXLINE( 180)			openedTagsLC->push(tagLC);
+HXLINE( 181)			 ::Dynamic m = this->processMatches(openedTagsLC);
+HXLINE( 182)			{
+HXLINE( 182)				int _g = 0;
+HXDLIN( 182)				::Array< ::Dynamic> _g1 = ( (::Array< ::Dynamic>)(m->__Field(HX_("nodes",31,b8,be,9f),::hx::paccDynamic)) );
+HXDLIN( 182)				while((_g < _g1->length)){
+HXLINE( 182)					 ::htmlparser::HtmlNode node = _g1->__get(_g).StaticCast<  ::htmlparser::HtmlNode >();
+HXDLIN( 182)					_g = (_g + 1);
+HXDLIN( 182)					elem->addChild(node,null());
+            				}
+            			}
+HXLINE( 183)			openedTagsLC->pop();
+HXLINE( 185)			if (::hx::IsNotEq( m->__Field(HX_("closeTagLC",79,c4,c8,d5),::hx::paccDynamic),tagLC )) {
+HXLINE( 185)				closeTagLC = ( (::String)(m->__Field(HX_("closeTagLC",79,c4,c8,d5),::hx::paccDynamic)) );
+            			}
+            			else {
+HXLINE( 185)				closeTagLC = HX_("",00,00,00,00);
+            			}
+HXLINE( 187)			bool _hx_tmp;
+HXDLIN( 187)			if ((this->i >= this->matches->length)) {
+HXLINE( 187)				_hx_tmp = !(this->tolerant);
+            			}
+            			else {
+HXLINE( 187)				_hx_tmp = true;
+            			}
+HXDLIN( 187)			if (_hx_tmp) {
+HXLINE( 189)				bool _hx_tmp1;
+HXDLIN( 189)				bool _hx_tmp2;
+HXDLIN( 189)				if (::hx::IsNotNull( this->matches->__get(this->i)->__Field(HX_("close",b8,17,63,48),::hx::paccDynamic) )) {
+HXLINE( 189)					_hx_tmp2 = ::hx::IsEq( this->matches->__get(this->i)->__Field(HX_("close",b8,17,63,48),::hx::paccDynamic),HX_("",00,00,00,00) );
+            				}
+            				else {
+HXLINE( 189)					_hx_tmp2 = true;
+            				}
+HXDLIN( 189)				if (!(_hx_tmp2)) {
+HXLINE( 189)					_hx_tmp1 = ::hx::IsNotEq( this->matches->__get(this->i)->__Field(HX_("tagCloseLC",f5,e4,f6,58),::hx::paccDynamic),tagLC );
+            				}
+            				else {
+HXLINE( 189)					_hx_tmp1 = true;
+            				}
+HXDLIN( 189)				if (_hx_tmp1) {
+HXLINE( 191)					if (!(this->tolerant)) {
+HXLINE( 191)						HX_STACK_DO_THROW( ::htmlparser::HtmlParserException_obj::__alloc( HX_CTX ,((HX_("Tag <",d6,b0,14,9e) + tag) + HX_("> not closed.",13,ce,3c,11)),this->getPosition(this->i)));
+            					}
+            					else {
+HXLINE( 192)						closeTagLC = ( (::String)(this->matches->__get(this->i)->__Field(HX_("tagCloseLC",f5,e4,f6,58),::hx::paccDynamic)) );
+            					}
+            				}
+            			}
+            		}
+HXLINE( 197)		return  ::Dynamic(::hx::Anon_obj::Create(2)
+            			->setFixed(0,HX_("closeTagLC",79,c4,c8,d5),closeTagLC)
+            			->setFixed(1,HX_("element",bc,ae,54,06),elem));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(HtmlParser_obj,parseElement,return )
+
+bool HtmlParser_obj::isSelfClosingTag(::String tag){
+            	HX_STACKFRAME(&_hx_pos_8ccefc64b7335ec2_200_isSelfClosingTag)
+HXDLIN( 200)		return ::Reflect_obj::hasField(::htmlparser::HtmlParser_obj::SELF_CLOSING_TAGS_HTML,tag);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(HtmlParser_obj,isSelfClosingTag,return )
+
+ ::htmlparser::HtmlNodeElement HtmlParser_obj::newElement(::String name,::Array< ::Dynamic> attributes){
+            	HX_GC_STACKFRAME(&_hx_pos_8ccefc64b7335ec2_202_newElement)
+HXDLIN( 202)		return  ::htmlparser::HtmlNodeElement_obj::__alloc( HX_CTX ,name,attributes);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(HtmlParser_obj,newElement,return )
+
+ ::Dynamic HtmlParser_obj::getPosition(int matchIndex){
+            	HX_STACKFRAME(&_hx_pos_8ccefc64b7335ec2_239_getPosition)
+HXLINE( 240)		 ::Dynamic m = this->matches->__get(matchIndex);
+HXLINE( 241)		int line = 1;
+HXLINE( 242)		int lastNewLinePos = -1;
+HXLINE( 243)		int i = 0;
+HXDLIN( 243)		while(::hx::IsLess( i,m->__Field(HX_("allPos",f3,c6,84,3f),::hx::paccDynamic) )){
+HXLINE( 245)			::String chars;
+HXDLIN( 245)			if (((i + 1) < this->str.length)) {
+HXLINE( 245)				chars = this->str.substring(i,(i + 2));
+            			}
+            			else {
+HXLINE( 245)				chars = this->str.charAt(i);
+            			}
+HXLINE( 246)			if ((chars == HX_("\r\n",5d,0b,00,00))) {
+HXLINE( 248)				i = (i + 2);
+HXLINE( 249)				lastNewLinePos = i;
+HXLINE( 250)				line = (line + 1);
+            			}
+            			else {
+HXLINE( 253)				bool _hx_tmp;
+HXDLIN( 253)				if ((chars.charAt(0) != HX_("\n",0a,00,00,00))) {
+HXLINE( 253)					_hx_tmp = (chars.charAt(0) == HX_("\r",0d,00,00,00));
+            				}
+            				else {
+HXLINE( 253)					_hx_tmp = true;
+            				}
+HXDLIN( 253)				if (_hx_tmp) {
+HXLINE( 255)					i = (i + 1);
+HXLINE( 256)					lastNewLinePos = i;
+HXLINE( 257)					line = (line + 1);
+            				}
+            				else {
+HXLINE( 261)					i = (i + 1);
+            				}
+            			}
+            		}
+HXLINE( 265)		return  ::Dynamic(::hx::Anon_obj::Create(3)
+            			->setFixed(0,HX_("length",e6,94,07,9f),( (::String)(m->__Field(HX_("all",21,f9,49,00),::hx::paccDynamic)) ).length)
+            			->setFixed(1,HX_("column",d6,4e,8b,c6),(( (int)(m->__Field(HX_("allPos",f3,c6,84,3f),::hx::paccDynamic)) ) - lastNewLinePos))
+            			->setFixed(2,HX_("line",f4,17,b3,47),line));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(HtmlParser_obj,getPosition,return )
+
+ ::Dynamic HtmlParser_obj::SELF_CLOSING_TAGS_HTML;
+
+::String HtmlParser_obj::reID;
+
+::String HtmlParser_obj::reNamespacedID;
+
+::String HtmlParser_obj::reCDATA;
+
+::String HtmlParser_obj::reScript;
+
+::String HtmlParser_obj::reStyle;
+
+::String HtmlParser_obj::reElementOpen;
+
+::String HtmlParser_obj::reAttr;
+
+::String HtmlParser_obj::reElementEnd;
+
+::String HtmlParser_obj::reElementClose;
+
+::String HtmlParser_obj::reComment;
+
+ ::EReg HtmlParser_obj::reMain;
+
+ ::EReg HtmlParser_obj::reParseAttrs;
+
+::Array< ::Dynamic> HtmlParser_obj::run(::String str,::hx::Null< bool >  __o_tolerant){
+            		bool tolerant = __o_tolerant.Default(false);
+            	HX_GC_STACKFRAME(&_hx_pos_8ccefc64b7335ec2_32_run)
+HXDLIN(  32)		return  ::htmlparser::HtmlParser_obj::__alloc( HX_CTX )->parse(str,tolerant);
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(HtmlParser_obj,run,return )
+
+::Array< ::Dynamic> HtmlParser_obj::parseAttrs(::String str){
+            	HX_GC_STACKFRAME(&_hx_pos_8ccefc64b7335ec2_205_parseAttrs)
+HXLINE( 206)		::Array< ::Dynamic> attributes = ::Array_obj< ::Dynamic>::__new();
+HXLINE( 208)		int pos = 0;
+HXDLIN( 208)		while(true){
+HXLINE( 208)			bool _hx_tmp;
+HXDLIN( 208)			if ((pos < str.length)) {
+HXLINE( 208)				_hx_tmp = ::htmlparser::HtmlParser_obj::reParseAttrs->matchSub(str,pos,null());
+            			}
+            			else {
+HXLINE( 208)				_hx_tmp = false;
+            			}
+HXDLIN( 208)			if (!(_hx_tmp)) {
+HXLINE( 208)				goto _hx_goto_12;
+            			}
+HXLINE( 210)			::String name = ::htmlparser::HtmlParser_obj::reParseAttrs->matched(1);
+HXLINE( 211)			::String value = ::htmlparser::HtmlParser_obj::reParseAttrs->matched(2);
+HXLINE( 213)			::String quote = null();
+HXLINE( 214)			::String unescaped = null();
+HXLINE( 215)			if (::hx::IsNotNull( value )) {
+HXLINE( 217)				quote = value.substr(0,1);
+HXLINE( 218)				bool _hx_tmp1;
+HXDLIN( 218)				if ((quote != HX_("\"",22,00,00,00))) {
+HXLINE( 218)					_hx_tmp1 = (quote == HX_("'",27,00,00,00));
+            				}
+            				else {
+HXLINE( 218)					_hx_tmp1 = true;
+            				}
+HXDLIN( 218)				if (_hx_tmp1) {
+HXLINE( 220)					value = value.substr(1,(value.length - 2));
+            				}
+            				else {
+HXLINE( 224)					quote = HX_("",00,00,00,00);
+            				}
+HXLINE( 226)				unescaped = ::htmlparser::HtmlTools_obj::unescape(value);
+            			}
+HXLINE( 229)			attributes->push( ::htmlparser::HtmlAttribute_obj::__alloc( HX_CTX ,name,unescaped,quote));
+HXLINE( 231)			 ::Dynamic p = ::htmlparser::HtmlParser_obj::reParseAttrs->matchedPos();
+HXLINE( 232)			pos = ( (int)((p->__Field(HX_("pos",94,5d,55,00),::hx::paccDynamic) + p->__Field(HX_("len",d5,4b,52,00),::hx::paccDynamic))) );
+            		}
+            		_hx_goto_12:;
+HXLINE( 235)		return attributes;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(HtmlParser_obj,parseAttrs,return )
+
+
+::hx::ObjectPtr< HtmlParser_obj > HtmlParser_obj::__new() {
+	::hx::ObjectPtr< HtmlParser_obj > __this = new HtmlParser_obj();
+	__this->__construct();
+	return __this;
+}
+
+::hx::ObjectPtr< HtmlParser_obj > HtmlParser_obj::__alloc(::hx::Ctx *_hx_ctx) {
+	HtmlParser_obj *__this = (HtmlParser_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(HtmlParser_obj), true, "htmlparser.HtmlParser"));
+	*(void **)__this = HtmlParser_obj::_hx_vtable;
+	__this->__construct();
+	return __this;
+}
+
+HtmlParser_obj::HtmlParser_obj()
+{
+}
+
+void HtmlParser_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(HtmlParser);
+	HX_MARK_MEMBER_NAME(tolerant,"tolerant");
+	HX_MARK_MEMBER_NAME(matches,"matches");
+	HX_MARK_MEMBER_NAME(str,"str");
+	HX_MARK_MEMBER_NAME(i,"i");
+	HX_MARK_END_CLASS();
+}
+
+void HtmlParser_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(tolerant,"tolerant");
+	HX_VISIT_MEMBER_NAME(matches,"matches");
+	HX_VISIT_MEMBER_NAME(str,"str");
+	HX_VISIT_MEMBER_NAME(i,"i");
+}
+
+::hx::Val HtmlParser_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 1:
+		if (HX_FIELD_EQ(inName,"i") ) { return ::hx::Val( i ); }
+		break;
+	case 3:
+		if (HX_FIELD_EQ(inName,"str") ) { return ::hx::Val( str ); }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"parse") ) { return ::hx::Val( parse_dyn() ); }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"matches") ) { return ::hx::Val( matches ); }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"tolerant") ) { return ::hx::Val( tolerant ); }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"newElement") ) { return ::hx::Val( newElement_dyn() ); }
+		break;
+	case 11:
+		if (HX_FIELD_EQ(inName,"getPosition") ) { return ::hx::Val( getPosition_dyn() ); }
+		break;
+	case 12:
+		if (HX_FIELD_EQ(inName,"parseElement") ) { return ::hx::Val( parseElement_dyn() ); }
+		break;
+	case 14:
+		if (HX_FIELD_EQ(inName,"processMatches") ) { return ::hx::Val( processMatches_dyn() ); }
+		break;
+	case 16:
+		if (HX_FIELD_EQ(inName,"isSelfClosingTag") ) { return ::hx::Val( isSelfClosingTag_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+bool HtmlParser_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"run") ) { outValue = run_dyn(); return true; }
+		break;
+	case 4:
+		if (HX_FIELD_EQ(inName,"reID") ) { outValue = ( reID ); return true; }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"reAttr") ) { outValue = ( reAttr ); return true; }
+		if (HX_FIELD_EQ(inName,"reMain") ) { outValue = ( reMain ); return true; }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"reCDATA") ) { outValue = ( reCDATA ); return true; }
+		if (HX_FIELD_EQ(inName,"reStyle") ) { outValue = ( reStyle ); return true; }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"reScript") ) { outValue = ( reScript ); return true; }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"reComment") ) { outValue = ( reComment ); return true; }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"parseAttrs") ) { outValue = parseAttrs_dyn(); return true; }
+		break;
+	case 12:
+		if (HX_FIELD_EQ(inName,"reElementEnd") ) { outValue = ( reElementEnd ); return true; }
+		if (HX_FIELD_EQ(inName,"reParseAttrs") ) { outValue = ( reParseAttrs ); return true; }
+		break;
+	case 13:
+		if (HX_FIELD_EQ(inName,"reElementOpen") ) { outValue = ( reElementOpen ); return true; }
+		break;
+	case 14:
+		if (HX_FIELD_EQ(inName,"reNamespacedID") ) { outValue = ( reNamespacedID ); return true; }
+		if (HX_FIELD_EQ(inName,"reElementClose") ) { outValue = ( reElementClose ); return true; }
+		break;
+	case 22:
+		if (HX_FIELD_EQ(inName,"SELF_CLOSING_TAGS_HTML") ) { outValue = ( SELF_CLOSING_TAGS_HTML ); return true; }
+	}
+	return false;
+}
+
+::hx::Val HtmlParser_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 1:
+		if (HX_FIELD_EQ(inName,"i") ) { i=inValue.Cast< int >(); return inValue; }
+		break;
+	case 3:
+		if (HX_FIELD_EQ(inName,"str") ) { str=inValue.Cast< ::String >(); return inValue; }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"matches") ) { matches=inValue.Cast< ::Array< ::Dynamic> >(); return inValue; }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"tolerant") ) { tolerant=inValue.Cast< bool >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+bool HtmlParser_obj::__SetStatic(const ::String &inName,Dynamic &ioValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"reID") ) { reID=ioValue.Cast< ::String >(); return true; }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"reAttr") ) { reAttr=ioValue.Cast< ::String >(); return true; }
+		if (HX_FIELD_EQ(inName,"reMain") ) { reMain=ioValue.Cast<  ::EReg >(); return true; }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"reCDATA") ) { reCDATA=ioValue.Cast< ::String >(); return true; }
+		if (HX_FIELD_EQ(inName,"reStyle") ) { reStyle=ioValue.Cast< ::String >(); return true; }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"reScript") ) { reScript=ioValue.Cast< ::String >(); return true; }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"reComment") ) { reComment=ioValue.Cast< ::String >(); return true; }
+		break;
+	case 12:
+		if (HX_FIELD_EQ(inName,"reElementEnd") ) { reElementEnd=ioValue.Cast< ::String >(); return true; }
+		if (HX_FIELD_EQ(inName,"reParseAttrs") ) { reParseAttrs=ioValue.Cast<  ::EReg >(); return true; }
+		break;
+	case 13:
+		if (HX_FIELD_EQ(inName,"reElementOpen") ) { reElementOpen=ioValue.Cast< ::String >(); return true; }
+		break;
+	case 14:
+		if (HX_FIELD_EQ(inName,"reNamespacedID") ) { reNamespacedID=ioValue.Cast< ::String >(); return true; }
+		if (HX_FIELD_EQ(inName,"reElementClose") ) { reElementClose=ioValue.Cast< ::String >(); return true; }
+		break;
+	case 22:
+		if (HX_FIELD_EQ(inName,"SELF_CLOSING_TAGS_HTML") ) { SELF_CLOSING_TAGS_HTML=ioValue.Cast<  ::Dynamic >(); return true; }
+	}
+	return false;
+}
+
+void HtmlParser_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("tolerant",69,10,52,94));
+	outFields->push(HX_("matches",f3,3c,7c,89));
+	outFields->push(HX_("str",b1,a8,57,00));
+	outFields->push(HX_("i",69,00,00,00));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo HtmlParser_obj_sMemberStorageInfo[] = {
+	{::hx::fsBool,(int)offsetof(HtmlParser_obj,tolerant),HX_("tolerant",69,10,52,94)},
+	{::hx::fsObject /* ::Array< ::Dynamic> */ ,(int)offsetof(HtmlParser_obj,matches),HX_("matches",f3,3c,7c,89)},
+	{::hx::fsString,(int)offsetof(HtmlParser_obj,str),HX_("str",b1,a8,57,00)},
+	{::hx::fsInt,(int)offsetof(HtmlParser_obj,i),HX_("i",69,00,00,00)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo HtmlParser_obj_sStaticStorageInfo[] = {
+	{::hx::fsObject /*  ::Dynamic */ ,(void *) &HtmlParser_obj::SELF_CLOSING_TAGS_HTML,HX_("SELF_CLOSING_TAGS_HTML",f4,7f,9d,00)},
+	{::hx::fsString,(void *) &HtmlParser_obj::reID,HX_("reID",4e,36,a7,4b)},
+	{::hx::fsString,(void *) &HtmlParser_obj::reNamespacedID,HX_("reNamespacedID",d7,79,13,1b)},
+	{::hx::fsString,(void *) &HtmlParser_obj::reCDATA,HX_("reCDATA",5a,4f,97,a7)},
+	{::hx::fsString,(void *) &HtmlParser_obj::reScript,HX_("reScript",1e,6e,63,5c)},
+	{::hx::fsString,(void *) &HtmlParser_obj::reStyle,HX_("reStyle",7e,68,e5,fd)},
+	{::hx::fsString,(void *) &HtmlParser_obj::reElementOpen,HX_("reElementOpen",b3,a7,96,d1)},
+	{::hx::fsString,(void *) &HtmlParser_obj::reAttr,HX_("reAttr",84,02,77,e7)},
+	{::hx::fsString,(void *) &HtmlParser_obj::reElementEnd,HX_("reElementEnd",12,10,75,3b)},
+	{::hx::fsString,(void *) &HtmlParser_obj::reElementClose,HX_("reElementClose",af,df,cf,a6)},
+	{::hx::fsString,(void *) &HtmlParser_obj::reComment,HX_("reComment",ec,6a,29,cf)},
+	{::hx::fsObject /*  ::EReg */ ,(void *) &HtmlParser_obj::reMain,HX_("reMain",8c,1d,57,ef)},
+	{::hx::fsObject /*  ::EReg */ ,(void *) &HtmlParser_obj::reParseAttrs,HX_("reParseAttrs",82,da,74,66)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+#endif
+
+static ::String HtmlParser_obj_sMemberFields[] = {
+	HX_("tolerant",69,10,52,94),
+	HX_("matches",f3,3c,7c,89),
+	HX_("str",b1,a8,57,00),
+	HX_("i",69,00,00,00),
+	HX_("parse",33,90,55,bd),
+	HX_("processMatches",44,7e,da,3b),
+	HX_("parseElement",c9,02,2f,60),
+	HX_("isSelfClosingTag",9b,66,89,ba),
+	HX_("newElement",3c,d2,56,43),
+	HX_("getPosition",5f,63,ee,f0),
+	::String(null()) };
+
+static void HtmlParser_obj_sMarkStatics(HX_MARK_PARAMS) {
+	HX_MARK_MEMBER_NAME(HtmlParser_obj::SELF_CLOSING_TAGS_HTML,"SELF_CLOSING_TAGS_HTML");
+	HX_MARK_MEMBER_NAME(HtmlParser_obj::reID,"reID");
+	HX_MARK_MEMBER_NAME(HtmlParser_obj::reNamespacedID,"reNamespacedID");
+	HX_MARK_MEMBER_NAME(HtmlParser_obj::reCDATA,"reCDATA");
+	HX_MARK_MEMBER_NAME(HtmlParser_obj::reScript,"reScript");
+	HX_MARK_MEMBER_NAME(HtmlParser_obj::reStyle,"reStyle");
+	HX_MARK_MEMBER_NAME(HtmlParser_obj::reElementOpen,"reElementOpen");
+	HX_MARK_MEMBER_NAME(HtmlParser_obj::reAttr,"reAttr");
+	HX_MARK_MEMBER_NAME(HtmlParser_obj::reElementEnd,"reElementEnd");
+	HX_MARK_MEMBER_NAME(HtmlParser_obj::reElementClose,"reElementClose");
+	HX_MARK_MEMBER_NAME(HtmlParser_obj::reComment,"reComment");
+	HX_MARK_MEMBER_NAME(HtmlParser_obj::reMain,"reMain");
+	HX_MARK_MEMBER_NAME(HtmlParser_obj::reParseAttrs,"reParseAttrs");
+};
+
+#ifdef HXCPP_VISIT_ALLOCS
+static void HtmlParser_obj_sVisitStatics(HX_VISIT_PARAMS) {
+	HX_VISIT_MEMBER_NAME(HtmlParser_obj::SELF_CLOSING_TAGS_HTML,"SELF_CLOSING_TAGS_HTML");
+	HX_VISIT_MEMBER_NAME(HtmlParser_obj::reID,"reID");
+	HX_VISIT_MEMBER_NAME(HtmlParser_obj::reNamespacedID,"reNamespacedID");
+	HX_VISIT_MEMBER_NAME(HtmlParser_obj::reCDATA,"reCDATA");
+	HX_VISIT_MEMBER_NAME(HtmlParser_obj::reScript,"reScript");
+	HX_VISIT_MEMBER_NAME(HtmlParser_obj::reStyle,"reStyle");
+	HX_VISIT_MEMBER_NAME(HtmlParser_obj::reElementOpen,"reElementOpen");
+	HX_VISIT_MEMBER_NAME(HtmlParser_obj::reAttr,"reAttr");
+	HX_VISIT_MEMBER_NAME(HtmlParser_obj::reElementEnd,"reElementEnd");
+	HX_VISIT_MEMBER_NAME(HtmlParser_obj::reElementClose,"reElementClose");
+	HX_VISIT_MEMBER_NAME(HtmlParser_obj::reComment,"reComment");
+	HX_VISIT_MEMBER_NAME(HtmlParser_obj::reMain,"reMain");
+	HX_VISIT_MEMBER_NAME(HtmlParser_obj::reParseAttrs,"reParseAttrs");
+};
+
+#endif
+
+::hx::Class HtmlParser_obj::__mClass;
+
+static ::String HtmlParser_obj_sStaticFields[] = {
+	HX_("SELF_CLOSING_TAGS_HTML",f4,7f,9d,00),
+	HX_("reID",4e,36,a7,4b),
+	HX_("reNamespacedID",d7,79,13,1b),
+	HX_("reCDATA",5a,4f,97,a7),
+	HX_("reScript",1e,6e,63,5c),
+	HX_("reStyle",7e,68,e5,fd),
+	HX_("reElementOpen",b3,a7,96,d1),
+	HX_("reAttr",84,02,77,e7),
+	HX_("reElementEnd",12,10,75,3b),
+	HX_("reElementClose",af,df,cf,a6),
+	HX_("reComment",ec,6a,29,cf),
+	HX_("reMain",8c,1d,57,ef),
+	HX_("reParseAttrs",82,da,74,66),
+	HX_("run",4b,e7,56,00),
+	HX_("parseAttrs",ef,b4,c4,50),
+	::String(null())
+};
+
+void HtmlParser_obj::__register()
+{
+	HtmlParser_obj _hx_dummy;
+	HtmlParser_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("htmlparser.HtmlParser",2e,56,ee,b1);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &HtmlParser_obj::__GetStatic;
+	__mClass->mSetStaticField = &HtmlParser_obj::__SetStatic;
+	__mClass->mMarkFunc = HtmlParser_obj_sMarkStatics;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(HtmlParser_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(HtmlParser_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< HtmlParser_obj >;
+#ifdef HXCPP_VISIT_ALLOCS
+	__mClass->mVisitFunc = HtmlParser_obj_sVisitStatics;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = HtmlParser_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = HtmlParser_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+void HtmlParser_obj::__boot()
+{
+{
+            	HX_STACKFRAME(&_hx_pos_8ccefc64b7335ec2_9_boot)
+HXDLIN(   9)		SELF_CLOSING_TAGS_HTML =  ::Dynamic(::hx::Anon_obj::Create(11)
+            			->setFixed(0,HX_("spacer",ec,a0,54,b8),1)
+            			->setFixed(1,HX_("param",8d,80,55,bd),1)
+            			->setFixed(2,HX_("input",0a,c4,1d,be),1)
+            			->setFixed(3,HX_("br",d0,55,00,00),1)
+            			->setFixed(4,HX_("hr",0a,5b,00,00),1)
+            			->setFixed(5,HX_("img",03,0c,50,00),1)
+            			->setFixed(6,HX_("source",db,b0,31,32),1)
+            			->setFixed(7,HX_("base",11,e8,10,41),1)
+            			->setFixed(8,HX_("link",fa,17,b3,47),1)
+            			->setFixed(9,HX_("meta",c5,4a,59,48),1)
+            			->setFixed(10,HX_("embed",d9,8d,cf,6f),1));
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_8ccefc64b7335ec2_11_boot)
+HXDLIN(  11)		reID = HX_("[a-z](?:-?[_a-z0-9])*",e1,82,9a,3a);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_8ccefc64b7335ec2_12_boot)
+HXDLIN(  12)		reNamespacedID = (((::htmlparser::HtmlParser_obj::reID + HX_("(?::",97,89,a0,1a)) + ::htmlparser::HtmlParser_obj::reID) + HX_(")?",f6,23,00,00));
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_8ccefc64b7335ec2_14_boot)
+HXDLIN(  14)		reCDATA = HX_("[<]!\\[CDATA\\[[\\s\\S]*?\\]\\][>]",a7,ae,9c,cf);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_8ccefc64b7335ec2_15_boot)
+HXDLIN(  15)		reScript = HX_("[<]\\s*script\\s*([^>]*)>([\\s\\S]*?)<\\s*/\\s*script\\s*>",6f,5f,7c,b6);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_8ccefc64b7335ec2_16_boot)
+HXDLIN(  16)		reStyle = HX_("<\\s*style\\s*([^>]*)>([\\s\\S]*?)<\\s*/\\s*style\\s*>",5b,c4,8b,bb);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_8ccefc64b7335ec2_17_boot)
+HXDLIN(  17)		reElementOpen = ((HX_("<\\s*(",51,d7,31,c9) + ::htmlparser::HtmlParser_obj::reNamespacedID) + HX_(")",29,00,00,00));
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_8ccefc64b7335ec2_18_boot)
+HXDLIN(  18)		reAttr = (::htmlparser::HtmlParser_obj::reNamespacedID + HX_("(?:\\s*=\\s*(?:'[^']*?'|\"[^\"]*?\"|[-_a-z0-9]+))?",f8,b4,8a,50));
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_8ccefc64b7335ec2_19_boot)
+HXDLIN(  19)		reElementEnd = HX_("(/)?\\s*>",68,02,5a,7a);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_8ccefc64b7335ec2_20_boot)
+HXDLIN(  20)		reElementClose = ((HX_("<\\s*/\\s*(",6d,6c,d3,c4) + ::htmlparser::HtmlParser_obj::reNamespacedID) + HX_(")\\s*>",d4,d1,94,d8));
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_8ccefc64b7335ec2_21_boot)
+HXDLIN(  21)		reComment = HX_("<!--[\\s\\S]*?-->",30,12,75,12);
+            	}
+{
+            	HX_GC_STACKFRAME(&_hx_pos_8ccefc64b7335ec2_23_boot)
+HXDLIN(  23)		reMain =  ::EReg_obj::__alloc( HX_CTX ,((((((((((((((((HX_("(",28,00,00,00) + ::htmlparser::HtmlParser_obj::reCDATA) + HX_(")|(",95,88,1f,00)) + ::htmlparser::HtmlParser_obj::reScript) + HX_(")|(",95,88,1f,00)) + ::htmlparser::HtmlParser_obj::reStyle) + HX_(")|(",95,88,1f,00)) + ::htmlparser::HtmlParser_obj::reElementOpen) + HX_("((?:\\s+",79,1c,7c,ea)) + ::htmlparser::HtmlParser_obj::reAttr) + HX_(")*)\\s*",8b,1b,d6,ae)) + ::htmlparser::HtmlParser_obj::reElementEnd) + HX_(")|(",95,88,1f,00)) + ::htmlparser::HtmlParser_obj::reElementClose) + HX_(")|(",95,88,1f,00)) + ::htmlparser::HtmlParser_obj::reComment) + HX_(")",29,00,00,00)),HX_("ig",de,5b,00,00));
+            	}
+{
+            	HX_GC_STACKFRAME(&_hx_pos_8ccefc64b7335ec2_25_boot)
+HXDLIN(  25)		reParseAttrs =  ::EReg_obj::__alloc( HX_CTX ,((HX_("(",28,00,00,00) + ::htmlparser::HtmlParser_obj::reNamespacedID) + HX_(")(?:\\s*=\\s*('[^']*'|\"[^\"]*\"|[-_a-z0-9]+))?",92,0f,f7,ad)),HX_("ig",de,5b,00,00));
+            	}
+}
+
+} // end namespace htmlparser
diff --git a/Sources/c_snikket/src/htmlparser/HtmlParserException.cpp b/Sources/c_snikket/src/htmlparser/HtmlParserException.cpp
new file mode 100644
index 0000000..566fcce
--- /dev/null
+++ b/Sources/c_snikket/src/htmlparser/HtmlParserException.cpp
@@ -0,0 +1,154 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_htmlparser_HtmlParserException
+#include <htmlparser/HtmlParserException.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_8ec4e8a8c4e51446_12_new,"htmlparser.HtmlParserException","new",0xd1aeb9b3,"htmlparser.HtmlParserException.new","htmlparser/HtmlParserException.hx",12,0x545e05de)
+HX_LOCAL_STACK_FRAME(_hx_pos_8ec4e8a8c4e51446_20_toString,"htmlparser.HtmlParserException","toString",0x97863a79,"htmlparser.HtmlParserException.toString","htmlparser/HtmlParserException.hx",20,0x545e05de)
+namespace htmlparser{
+
+void HtmlParserException_obj::__construct(::String message, ::Dynamic pos){
+            	HX_STACKFRAME(&_hx_pos_8ec4e8a8c4e51446_12_new)
+HXLINE(  13)		this->message = message;
+HXLINE(  15)		this->line = ( (int)(pos->__Field(HX_("line",f4,17,b3,47),::hx::paccDynamic)) );
+HXLINE(  16)		this->column = ( (int)(pos->__Field(HX_("column",d6,4e,8b,c6),::hx::paccDynamic)) );
+HXLINE(  17)		this->length = ( (int)(pos->__Field(HX_("length",e6,94,07,9f),::hx::paccDynamic)) );
+            	}
+
+Dynamic HtmlParserException_obj::__CreateEmpty() { return new HtmlParserException_obj; }
+
+void *HtmlParserException_obj::_hx_vtable = 0;
+
+Dynamic HtmlParserException_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< HtmlParserException_obj > _hx_result = new HtmlParserException_obj();
+	_hx_result->__construct(inArgs[0],inArgs[1]);
+	return _hx_result;
+}
+
+bool HtmlParserException_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x0872044b;
+}
+
+::String HtmlParserException_obj::toString(){
+            	HX_STACKFRAME(&_hx_pos_8ec4e8a8c4e51446_20_toString)
+HXDLIN(  20)		return (((((HX_("Parse error at ",28,15,14,1d) + this->line) + HX_(":",3a,00,00,00)) + this->column) + HX_(". ",32,28,00,00)) + this->message);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(HtmlParserException_obj,toString,return )
+
+
+HtmlParserException_obj::HtmlParserException_obj()
+{
+}
+
+void HtmlParserException_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(HtmlParserException);
+	HX_MARK_MEMBER_NAME(message,"message");
+	HX_MARK_MEMBER_NAME(line,"line");
+	HX_MARK_MEMBER_NAME(column,"column");
+	HX_MARK_MEMBER_NAME(length,"length");
+	HX_MARK_END_CLASS();
+}
+
+void HtmlParserException_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(message,"message");
+	HX_VISIT_MEMBER_NAME(line,"line");
+	HX_VISIT_MEMBER_NAME(column,"column");
+	HX_VISIT_MEMBER_NAME(length,"length");
+}
+
+::hx::Val HtmlParserException_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"line") ) { return ::hx::Val( line ); }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"column") ) { return ::hx::Val( column ); }
+		if (HX_FIELD_EQ(inName,"length") ) { return ::hx::Val( length ); }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"message") ) { return ::hx::Val( message ); }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"toString") ) { return ::hx::Val( toString_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val HtmlParserException_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"line") ) { line=inValue.Cast< int >(); return inValue; }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"column") ) { column=inValue.Cast< int >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"length") ) { length=inValue.Cast< int >(); return inValue; }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"message") ) { message=inValue.Cast< ::String >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void HtmlParserException_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("message",c7,35,11,9a));
+	outFields->push(HX_("line",f4,17,b3,47));
+	outFields->push(HX_("column",d6,4e,8b,c6));
+	outFields->push(HX_("length",e6,94,07,9f));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo HtmlParserException_obj_sMemberStorageInfo[] = {
+	{::hx::fsString,(int)offsetof(HtmlParserException_obj,message),HX_("message",c7,35,11,9a)},
+	{::hx::fsInt,(int)offsetof(HtmlParserException_obj,line),HX_("line",f4,17,b3,47)},
+	{::hx::fsInt,(int)offsetof(HtmlParserException_obj,column),HX_("column",d6,4e,8b,c6)},
+	{::hx::fsInt,(int)offsetof(HtmlParserException_obj,length),HX_("length",e6,94,07,9f)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *HtmlParserException_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String HtmlParserException_obj_sMemberFields[] = {
+	HX_("message",c7,35,11,9a),
+	HX_("line",f4,17,b3,47),
+	HX_("column",d6,4e,8b,c6),
+	HX_("length",e6,94,07,9f),
+	HX_("toString",ac,d0,6e,38),
+	::String(null()) };
+
+::hx::Class HtmlParserException_obj::__mClass;
+
+void HtmlParserException_obj::__register()
+{
+	HtmlParserException_obj _hx_dummy;
+	HtmlParserException_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("htmlparser.HtmlParserException",41,64,65,1d);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(HtmlParserException_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< HtmlParserException_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = HtmlParserException_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = HtmlParserException_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace htmlparser
diff --git a/Sources/c_snikket/src/htmlparser/HtmlTools.cpp b/Sources/c_snikket/src/htmlparser/HtmlTools.cpp
new file mode 100644
index 0000000..7dbbc62
--- /dev/null
+++ b/Sources/c_snikket/src/htmlparser/HtmlTools.cpp
@@ -0,0 +1,288 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_EReg
+#include <EReg.h>
+#endif
+#ifndef INCLUDED_Std
+#include <Std.h>
+#endif
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+#ifndef INCLUDED_haxe_ds_StringMap
+#include <haxe/ds/StringMap.h>
+#endif
+#ifndef INCLUDED_htmlparser_HtmlTools
+#include <htmlparser/HtmlTools.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_afb72cddd227e1ec_9_get_htmlUnescapeMap,"htmlparser.HtmlTools","get_htmlUnescapeMap",0x8f1cd9cc,"htmlparser.HtmlTools.get_htmlUnescapeMap","htmlparser/HtmlTools.hx",9,0x09b71c13)
+HX_LOCAL_STACK_FRAME(_hx_pos_afb72cddd227e1ec_135_unescape,"htmlparser.HtmlTools","unescape",0x3992439c,"htmlparser.HtmlTools.unescape","htmlparser/HtmlTools.hx",135,0x09b71c13)
+HX_LOCAL_STACK_FRAME(_hx_pos_afb72cddd227e1ec_134_unescape,"htmlparser.HtmlTools","unescape",0x3992439c,"htmlparser.HtmlTools.unescape","htmlparser/HtmlTools.hx",134,0x09b71c13)
+namespace htmlparser{
+
+void HtmlTools_obj::__construct() { }
+
+Dynamic HtmlTools_obj::__CreateEmpty() { return new HtmlTools_obj; }
+
+void *HtmlTools_obj::_hx_vtable = 0;
+
+Dynamic HtmlTools_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< HtmlTools_obj > _hx_result = new HtmlTools_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool HtmlTools_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x319122e2;
+}
+
+ ::haxe::ds::StringMap HtmlTools_obj::htmlUnescapeMap;
+
+ ::haxe::ds::StringMap HtmlTools_obj::get_htmlUnescapeMap(){
+            	HX_GC_STACKFRAME(&_hx_pos_afb72cddd227e1ec_9_get_htmlUnescapeMap)
+HXLINE(  10)		if (::hx::IsNull( ::htmlparser::HtmlTools_obj::htmlUnescapeMap )) {
+HXLINE(  13)			 ::haxe::ds::StringMap _g =  ::haxe::ds::StringMap_obj::__alloc( HX_CTX );
+HXDLIN(  13)			_g->set(HX_("nbsp",d1,39,00,49),HX_(" ",20,00,00,00));
+HXDLIN(  13)			_g->set(HX_("amp",04,fa,49,00),HX_("&",26,00,00,00));
+HXDLIN(  13)			_g->set(HX_("lt",88,5e,00,00),HX_("<",3c,00,00,00));
+HXDLIN(  13)			_g->set(HX_("gt",2d,5a,00,00),HX_(">",3e,00,00,00));
+HXDLIN(  13)			_g->set(HX_("quot",09,45,0a,4b),HX_("\"",22,00,00,00));
+HXDLIN(  13)			_g->set(HX_("apos",d3,0f,73,40),HX_("'",27,00,00,00));
+HXDLIN(  13)			_g->set(HX_("euro",2d,b8,1b,43),HX_W(u"\u20ac",ef4c,00ab));
+HXDLIN(  13)			_g->set(HX_("iexcl",c5,da,30,b8),HX_W(u"\u00a1",a99f,0000));
+HXDLIN(  13)			_g->set(HX_("cent",68,23,bd,41),HX_W(u"\u00a2",a9a0,0000));
+HXDLIN(  13)			_g->set(HX_("pound",4c,cf,98,c6),HX_W(u"\u00a3",a9a1,0000));
+HXDLIN(  13)			_g->set(HX_("curren",db,c3,e7,3e),HX_W(u"\u00a4",a9a2,0000));
+HXDLIN(  13)			_g->set(HX_("yen",22,29,5c,00),HX_W(u"\u00a5",a9a3,0000));
+HXDLIN(  13)			_g->set(HX_("brvbar",ed,5c,f1,20),HX_W(u"\u00a6",a9a4,0000));
+HXDLIN(  13)			_g->set(HX_("sect",c3,83,50,4c),HX_W(u"\u00a7",a9a5,0000));
+HXDLIN(  13)			_g->set(HX_("uml",14,27,59,00),HX_W(u"\u00a8",a9a6,0000));
+HXDLIN(  13)			_g->set(HX_("copy",b5,bb,c4,41),HX_W(u"\u00a9",a9a7,0000));
+HXDLIN(  13)			_g->set(HX_("ordf",65,87,b5,49),HX_W(u"\u00aa",a9a8,0000));
+HXDLIN(  13)			_g->set(HX_("not",13,d9,53,00),HX_W(u"\u00ac",a9aa,0000));
+HXDLIN(  13)			_g->set(HX_("shy",44,9e,57,00),HX_W(u"\u00ad",a9ab,0000));
+HXDLIN(  13)			_g->set(HX_("reg",54,d9,56,00),HX_W(u"\u00ae",a9ac,0000));
+HXDLIN(  13)			_g->set(HX_("macr",03,33,56,48),HX_W(u"\u00af",a9ad,0000));
+HXDLIN(  13)			_g->set(HX_("deg",c6,39,4c,00),HX_W(u"\u00b0",a9ae,0000));
+HXDLIN(  13)			_g->set(HX_("plusmn",3b,a9,ec,44),HX_W(u"\u00b1",a9af,0000));
+HXDLIN(  13)			_g->set(HX_("sup2",e4,b2,5c,4c),HX_W(u"\u00b2",a9b0,0000));
+HXDLIN(  13)			_g->set(HX_("sup3",e5,b2,5c,4c),HX_W(u"\u00b3",a9b1,0000));
+HXDLIN(  13)			_g->set(HX_("acute",84,91,a7,1b),HX_W(u"\u00b4",a9b2,0000));
+HXDLIN(  13)			_g->set(HX_("micro",04,25,60,08),HX_W(u"\u00b5",a9b3,0000));
+HXDLIN(  13)			_g->set(HX_("para",e0,e3,51,4a),HX_W(u"\u00b6",a9b4,0000));
+HXDLIN(  13)			_g->set(HX_("middot",01,d6,5e,4c),HX_W(u"\u00b7",a9b5,0000));
+HXDLIN(  13)			_g->set(HX_("cedil",e5,37,ba,43),HX_W(u"\u00b8",a9b6,0000));
+HXDLIN(  13)			_g->set(HX_("sup1",e3,b2,5c,4c),HX_W(u"\u00b9",a9b7,0000));
+HXDLIN(  13)			_g->set(HX_("ordm",6c,87,b5,49),HX_W(u"\u00ba",a9b8,0000));
+HXDLIN(  13)			_g->set(HX_("raquo",bc,f8,21,e4),HX_W(u"\u00bb",a9b9,0000));
+HXDLIN(  13)			_g->set(HX_("frac14",91,eb,7d,ac),HX_W(u"\u00bc",a9ba,0000));
+HXDLIN(  13)			_g->set(HX_("frac12",8f,eb,7d,ac),HX_W(u"\u00bd",a9bb,0000));
+HXDLIN(  13)			_g->set(HX_("frac34",4f,ed,7d,ac),HX_W(u"\u00be",a9bc,0000));
+HXDLIN(  13)			_g->set(HX_("iquest",d9,6e,63,59),HX_W(u"\u00bf",a9bd,0000));
+HXDLIN(  13)			_g->set(HX_("Agrave",a4,88,1c,97),HX_W(u"\u00c0",aa5d,0000));
+HXDLIN(  13)			_g->set(HX_("Aacute",a3,05,da,18),HX_W(u"\u00c1",aa5e,0000));
+HXDLIN(  13)			_g->set(HX_("Acirc",98,e4,cb,ae),HX_W(u"\u00c2",aa5f,0000));
+HXDLIN(  13)			_g->set(HX_("Atilde",b7,70,67,0d),HX_W(u"\u00c3",aa60,0000));
+HXDLIN(  13)			_g->set(HX_("Auml",73,05,50,2b),HX_W(u"\u00c4",aa61,0000));
+HXDLIN(  13)			_g->set(HX_("Aring",71,14,b6,b8),HX_W(u"\u00c5",aa62,0000));
+HXDLIN(  13)			_g->set(HX_("AElig",e6,bc,f9,9a),HX_W(u"\u00c6",aa63,0000));
+HXDLIN(  13)			_g->set(HX_("Ccedil",c2,64,a3,0d),HX_W(u"\u00c7",aa64,0000));
+HXDLIN(  13)			_g->set(HX_("Egrave",20,fa,89,30),HX_W(u"\u00c8",aa65,0000));
+HXDLIN(  13)			_g->set(HX_("Eacute",1f,77,47,b2),HX_W(u"\u00c9",aa66,0000));
+HXDLIN(  13)			_g->set(HX_("Ecirc",9c,36,66,fc),HX_W(u"\u00ca",aa67,0000));
+HXDLIN(  13)			_g->set(HX_("Euml",ef,df,f4,2d),HX_W(u"\u00cb",aa68,0000));
+HXDLIN(  13)			_g->set(HX_("Igrave",9c,6b,f7,c9),HX_W(u"\u00cc",aa69,0000));
+HXDLIN(  13)			_g->set(HX_("Iacute",9b,e8,b4,4b),HX_W(u"\u00cd",aa6a,0000));
+HXDLIN(  13)			_g->set(HX_("Icirc",a0,88,00,4a),HX_W(u"\u00ce",aa6b,0000));
+HXDLIN(  13)			_g->set(HX_("Iuml",6b,ba,99,30),HX_W(u"\u00cf",aa6c,0000));
+HXDLIN(  13)			_g->set(HX_("ETH",f9,a4,34,00),HX_W(u"\u00d0",aa6d,0000));
+HXDLIN(  13)			_g->set(HX_("Ntilde",8a,21,0b,40),HX_W(u"\u00d1",aa6e,0000));
+HXDLIN(  13)			_g->set(HX_("Ograve",d6,95,1b,30),HX_W(u"\u00d2",aa6f,0000));
+HXDLIN(  13)			_g->set(HX_("Oacute",d5,12,d9,b1),HX_W(u"\u00d3",aa70,0000));
+HXDLIN(  13)			_g->set(HX_("Ocirc",a6,03,68,be),HX_W(u"\u00d4",aa71,0000));
+HXDLIN(  13)			_g->set(HX_("Otilde",e9,7d,66,a6),HX_W(u"\u00d5",aa72,0000));
+HXDLIN(  13)			_g->set(HX_("Ouml",25,02,91,34),HX_W(u"\u00d6",aa73,0000));
+HXDLIN(  13)			_g->set(HX_("times",c6,bf,35,10),HX_W(u"\u00d7",aa74,0000));
+HXDLIN(  13)			_g->set(HX_("Oslash",8e,41,f3,14),HX_W(u"\u00d8",aa75,0000));
+HXDLIN(  13)			_g->set(HX_("Ugrave",10,c0,3f,96),HX_W(u"\u00d9",aa76,0000));
+HXDLIN(  13)			_g->set(HX_("Uacute",0f,3d,fd,17),HX_W(u"\u00da",aa77,0000));
+HXDLIN(  13)			_g->set(HX_("Ucirc",ac,7e,cf,32),HX_W(u"\u00db",aa78,0000));
+HXDLIN(  13)			_g->set(HX_("Uuml",df,49,88,38),HX_W(u"\u00dc",aa79,0000));
+HXDLIN(  13)			_g->set(HX_("Yacute",8b,ae,6a,b1),HX_W(u"\u00dd",aa7a,0000));
+HXDLIN(  13)			_g->set(HX_("THORN",d7,50,7c,8d),HX_W(u"\u00de",aa7b,0000));
+HXDLIN(  13)			_g->set(HX_("szlig",03,0d,0b,88),HX_W(u"\u00df",aa7c,0000));
+HXDLIN(  13)			_g->set(HX_("agrave",84,14,88,62),HX_W(u"\u00e0",aa7d,0000));
+HXDLIN(  13)			_g->set(HX_("aacute",83,91,45,e4),HX_W(u"\u00e1",aa7e,0000));
+HXDLIN(  13)			_g->set(HX_("acirc",b8,74,9e,1b),HX_W(u"\u00e2",aa7f,0000));
+HXDLIN(  13)			_g->set(HX_("atilde",97,fc,d2,d8),HX_W(u"\u00e3",aa80,0000));
+HXDLIN(  13)			_g->set(HX_("auml",53,d9,76,40),HX_W(u"\u00e4",aa81,0000));
+HXDLIN(  13)			_g->set(HX_("aring",91,a4,88,25),HX_W(u"\u00e5",aa82,0000));
+HXDLIN(  13)			_g->set(HX_("aelig",e6,20,f3,1c),HX_W(u"\u00e6",aa83,0000));
+HXDLIN(  13)			_g->set(HX_("ccedil",a2,f0,0e,d9),HX_W(u"\u00e7",aa84,0000));
+HXDLIN(  13)			_g->set(HX_("egrave",00,86,f5,fb),HX_W(u"\u00e8",aa85,0000));
+HXDLIN(  13)			_g->set(HX_("eacute",ff,02,b3,7d),HX_W(u"\u00e9",aa86,0000));
+HXDLIN(  13)			_g->set(HX_("ecirc",bc,c6,38,69),HX_W(u"\u00ea",aa87,0000));
+HXDLIN(  13)			_g->set(HX_("euml",cf,b3,1b,43),HX_W(u"\u00eb",aa88,0000));
+HXDLIN(  13)			_g->set(HX_("igrave",7c,f7,62,95),HX_W(u"\u00ec",aa89,0000));
+HXDLIN(  13)			_g->set(HX_("iacute",7b,74,20,17),HX_W(u"\u00ed",aa8a,0000));
+HXDLIN(  13)			_g->set(HX_("icirc",c0,18,d3,b6),HX_W(u"\u00ee",aa8b,0000));
+HXDLIN(  13)			_g->set(HX_("iuml",4b,8e,c0,45),HX_W(u"\u00ef",aa8c,0000));
+HXDLIN(  13)			_g->set(HX_("eth",19,09,4d,00),HX_W(u"\u00f0",aa8d,0000));
+HXDLIN(  13)			_g->set(HX_("ntilde",6a,ad,76,0b),HX_W(u"\u00f1",aa8e,0000));
+HXDLIN(  13)			_g->set(HX_("ograve",b6,21,87,fb),HX_W(u"\u00f2",aa8f,0000));
+HXDLIN(  13)			_g->set(HX_("oacute",b5,9e,44,7d),HX_W(u"\u00f3",aa90,0000));
+HXDLIN(  13)			_g->set(HX_("ocirc",c6,93,3a,2b),HX_W(u"\u00f4",aa91,0000));
+HXDLIN(  13)			_g->set(HX_("otilde",c9,09,d2,71),HX_W(u"\u00f5",aa92,0000));
+HXDLIN(  13)			_g->set(HX_("ouml",05,d6,b7,49),HX_W(u"\u00f6",aa93,0000));
+HXDLIN(  13)			_g->set(HX_("divide",79,2f,12,bf),HX_W(u"\u00f7",aa94,0000));
+HXDLIN(  13)			_g->set(HX_("oslash",6e,cd,5e,e0),HX_W(u"\u00f8",aa95,0000));
+HXDLIN(  13)			_g->set(HX_("ugrave",f0,4b,ab,61),HX_W(u"\u00f9",aa96,0000));
+HXDLIN(  13)			_g->set(HX_("uacute",ef,c8,68,e3),HX_W(u"\u00fa",aa97,0000));
+HXDLIN(  13)			_g->set(HX_("ucirc",cc,0e,a2,9f),HX_W(u"\u00fb",aa98,0000));
+HXDLIN(  13)			_g->set(HX_("uuml",bf,1d,af,4d),HX_W(u"\u00fc",aa99,0000));
+HXDLIN(  13)			_g->set(HX_("yacute",6b,3a,d6,7c),HX_W(u"\u00fd",aa9a,0000));
+HXDLIN(  13)			_g->set(HX_("thorn",f7,18,8e,0f),HX_W(u"\u00fe",aa9b,0000));
+HXLINE(  12)			::htmlparser::HtmlTools_obj::htmlUnescapeMap = _g;
+            		}
+HXLINE( 116)		return ::htmlparser::HtmlTools_obj::htmlUnescapeMap;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC0(HtmlTools_obj,get_htmlUnescapeMap,return )
+
+::String HtmlTools_obj::unescape(::String text){
+            		HX_BEGIN_LOCAL_FUNC_S0(::hx::LocalFunc,_hx_Closure_0) HXARGC(1)
+            		::String _hx_run( ::EReg re){
+            			HX_GC_STACKFRAME(&_hx_pos_afb72cddd227e1ec_135_unescape)
+HXLINE( 136)			::String s = re->matched(0);
+HXLINE( 137)			if ((s.charAt(0) == HX_("&",26,00,00,00))) {
+HXLINE( 139)				if ((s.charAt(1) == HX_("#",23,00,00,00))) {
+HXLINE( 141)					::String numbers = s.substring(2,(s.length - 1));
+HXLINE( 142)					if ((numbers.charAt(0) == HX_("x",78,00,00,00))) {
+HXLINE( 142)						numbers = (HX_("0",30,00,00,00) + numbers);
+            					}
+HXLINE( 143)					 ::Dynamic code = ::Std_obj::parseInt(numbers);
+HXLINE( 144)					bool _hx_tmp;
+HXDLIN( 144)					if (::hx::IsNotNull( code )) {
+HXLINE( 144)						_hx_tmp = ::hx::IsNotEq( code,0 );
+            					}
+            					else {
+HXLINE( 144)						_hx_tmp = false;
+            					}
+HXDLIN( 144)					if (_hx_tmp) {
+HXLINE( 144)						return ::String::fromCharCode(( (int)(code) ));
+            					}
+            					else {
+HXLINE( 144)						return s;
+            					}
+            				}
+            				else {
+HXLINE( 148)					::Dynamic this1 = ::htmlparser::HtmlTools_obj::get_htmlUnescapeMap();
+HXDLIN( 148)					::String r = ( ( ::haxe::ds::StringMap)(this1) )->get_string(s.substring(1,(s.length - 1)));
+HXLINE( 149)					if (::hx::IsNotNull( r )) {
+HXLINE( 149)						return r;
+            					}
+            					else {
+HXLINE( 149)						return s;
+            					}
+            				}
+            			}
+HXLINE( 152)			return re->matched(1);
+            		}
+            		HX_END_LOCAL_FUNC1(return)
+
+            	HX_GC_STACKFRAME(&_hx_pos_afb72cddd227e1ec_134_unescape)
+HXDLIN( 134)		return  ::EReg_obj::__alloc( HX_CTX ,HX_("[<]!\\[CDATA\\[((?:.|[\r\n])*?)\\]\\][>]|&[^;]+;",d6,26,fb,65),HX_("g",67,00,00,00))->map(text, ::Dynamic(new _hx_Closure_0()));
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(HtmlTools_obj,unescape,return )
+
+
+HtmlTools_obj::HtmlTools_obj()
+{
+}
+
+bool HtmlTools_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 8:
+		if (HX_FIELD_EQ(inName,"unescape") ) { outValue = unescape_dyn(); return true; }
+		break;
+	case 15:
+		if (HX_FIELD_EQ(inName,"htmlUnescapeMap") ) { outValue = ( inCallProp == ::hx::paccAlways ? get_htmlUnescapeMap() : htmlUnescapeMap ); return true; }
+		break;
+	case 19:
+		if (HX_FIELD_EQ(inName,"get_htmlUnescapeMap") ) { outValue = get_htmlUnescapeMap_dyn(); return true; }
+	}
+	return false;
+}
+
+bool HtmlTools_obj::__SetStatic(const ::String &inName,Dynamic &ioValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 15:
+		if (HX_FIELD_EQ(inName,"htmlUnescapeMap") ) { htmlUnescapeMap=ioValue.Cast<  ::haxe::ds::StringMap >(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *HtmlTools_obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo HtmlTools_obj_sStaticStorageInfo[] = {
+	{::hx::fsObject /*  ::haxe::ds::StringMap */ ,(void *) &HtmlTools_obj::htmlUnescapeMap,HX_("htmlUnescapeMap",77,60,84,1e)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+#endif
+
+static void HtmlTools_obj_sMarkStatics(HX_MARK_PARAMS) {
+	HX_MARK_MEMBER_NAME(HtmlTools_obj::htmlUnescapeMap,"htmlUnescapeMap");
+};
+
+#ifdef HXCPP_VISIT_ALLOCS
+static void HtmlTools_obj_sVisitStatics(HX_VISIT_PARAMS) {
+	HX_VISIT_MEMBER_NAME(HtmlTools_obj::htmlUnescapeMap,"htmlUnescapeMap");
+};
+
+#endif
+
+::hx::Class HtmlTools_obj::__mClass;
+
+static ::String HtmlTools_obj_sStaticFields[] = {
+	HX_("htmlUnescapeMap",77,60,84,1e),
+	HX_("get_htmlUnescapeMap",8e,2f,8f,a9),
+	HX_("unescape",9a,72,21,dd),
+	::String(null())
+};
+
+void HtmlTools_obj::__register()
+{
+	HtmlTools_obj _hx_dummy;
+	HtmlTools_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("htmlparser.HtmlTools",ac,b7,89,3f);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &HtmlTools_obj::__GetStatic;
+	__mClass->mSetStaticField = &HtmlTools_obj::__SetStatic;
+	__mClass->mMarkFunc = HtmlTools_obj_sMarkStatics;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(HtmlTools_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< HtmlTools_obj >;
+#ifdef HXCPP_VISIT_ALLOCS
+	__mClass->mVisitFunc = HtmlTools_obj_sVisitStatics;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = HtmlTools_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = HtmlTools_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace htmlparser
diff --git a/Sources/c_snikket/src/httpstatus/_HttpStatusMessage/HttpStatusMessage_Impl_.cpp b/Sources/c_snikket/src/httpstatus/_HttpStatusMessage/HttpStatusMessage_Impl_.cpp
new file mode 100644
index 0000000..d8254d2
--- /dev/null
+++ b/Sources/c_snikket/src/httpstatus/_HttpStatusMessage/HttpStatusMessage_Impl_.cpp
@@ -0,0 +1,336 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_httpstatus__HttpStatusMessage_HttpStatusMessage_Impl_
+#include <httpstatus/_HttpStatusMessage/HttpStatusMessage_Impl_.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_29343a8e513e00a9_9_fromCode,"httpstatus._HttpStatusMessage.HttpStatusMessage_Impl_","fromCode",0x5ecb8a04,"httpstatus._HttpStatusMessage.HttpStatusMessage_Impl_.fromCode","httpstatus/HttpStatusMessage.hx",9,0x8734b7a6)
+namespace httpstatus{
+namespace _HttpStatusMessage{
+
+void HttpStatusMessage_Impl__obj::__construct() { }
+
+Dynamic HttpStatusMessage_Impl__obj::__CreateEmpty() { return new HttpStatusMessage_Impl__obj; }
+
+void *HttpStatusMessage_Impl__obj::_hx_vtable = 0;
+
+Dynamic HttpStatusMessage_Impl__obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< HttpStatusMessage_Impl__obj > _hx_result = new HttpStatusMessage_Impl__obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool HttpStatusMessage_Impl__obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x0de4d9f9;
+}
+
+::String HttpStatusMessage_Impl__obj::fromCode(int statusCode){
+            	HX_STACKFRAME(&_hx_pos_29343a8e513e00a9_9_fromCode)
+HXDLIN(   9)		switch((int)(statusCode)){
+            			case (int)100: {
+HXLINE(  10)				return HX_("Continue",87,9c,7a,0b);
+            			}
+            			break;
+            			case (int)101: {
+HXLINE(  11)				return HX_("Switching Protocols",a9,d3,99,92);
+            			}
+            			break;
+            			case (int)102: {
+HXLINE(  12)				return HX_("Processing",f3,5d,e6,cd);
+            			}
+            			break;
+            			case (int)200: {
+HXLINE(  13)				return HX_("OK",1c,45,00,00);
+            			}
+            			break;
+            			case (int)201: {
+HXLINE(  14)				return HX_("Created",c8,dd,bb,de);
+            			}
+            			break;
+            			case (int)202: {
+HXLINE(  15)				return HX_("Accepted",87,79,c9,a1);
+            			}
+            			break;
+            			case (int)203: {
+HXLINE(  16)				return HX_("Non-Authoritative Information",bb,a3,63,e2);
+            			}
+            			break;
+            			case (int)204: {
+HXLINE(  17)				return HX_("No Content",5a,06,74,1a);
+            			}
+            			break;
+            			case (int)205: {
+HXLINE(  18)				return HX_("Reset Content",a8,79,f4,ab);
+            			}
+            			break;
+            			case (int)206: {
+HXLINE(  19)				return HX_("Partial Content",5a,c1,24,ef);
+            			}
+            			break;
+            			case (int)207: {
+HXLINE(  20)				return HX_("Multi-Status",06,2e,90,60);
+            			}
+            			break;
+            			case (int)208: {
+HXLINE(  21)				return HX_("Already Reported",db,97,92,dc);
+            			}
+            			break;
+            			case (int)226: {
+HXLINE(  22)				return HX_("IM Used",19,f4,72,4a);
+            			}
+            			break;
+            			case (int)300: {
+HXLINE(  23)				return HX_("Multiple Choices",e2,6f,07,3b);
+            			}
+            			break;
+            			case (int)301: {
+HXLINE(  24)				return HX_("Moved Permanently",8e,8c,fc,4c);
+            			}
+            			break;
+            			case (int)302: {
+HXLINE(  25)				return HX_("Found",22,72,c4,97);
+            			}
+            			break;
+            			case (int)303: {
+HXLINE(  26)				return HX_("See Other",43,4e,33,f2);
+            			}
+            			break;
+            			case (int)304: {
+HXLINE(  27)				return HX_("Not Modified",36,f0,28,59);
+            			}
+            			break;
+            			case (int)305: {
+HXLINE(  28)				return HX_("Use Proxy",95,e5,f1,4a);
+            			}
+            			break;
+            			case (int)306: {
+HXLINE(  29)				return HX_("Switch Proxy",42,6f,c6,d6);
+            			}
+            			break;
+            			case (int)307: {
+HXLINE(  30)				return HX_("Temporary Redirect",cb,73,f1,2d);
+            			}
+            			break;
+            			case (int)308: {
+HXLINE(  31)				return HX_("Permanent Redirect",8e,d3,f2,8e);
+            			}
+            			break;
+            			case (int)400: {
+HXLINE(  32)				return HX_("Bad Request",b4,61,00,b4);
+            			}
+            			break;
+            			case (int)401: {
+HXLINE(  33)				return HX_("Unauthorized",54,5a,51,93);
+            			}
+            			break;
+            			case (int)402: {
+HXLINE(  34)				return HX_("Payment Required",f9,4d,5e,c5);
+            			}
+            			break;
+            			case (int)403: {
+HXLINE(  35)				return HX_("Forbidden",d9,e8,e2,e5);
+            			}
+            			break;
+            			case (int)404: {
+HXLINE(  36)				return HX_("Not Found",35,47,57,4d);
+            			}
+            			break;
+            			case (int)405: {
+HXLINE(  37)				return HX_("Method Not Allowed",3c,b5,d0,70);
+            			}
+            			break;
+            			case (int)406: {
+HXLINE(  38)				return HX_("Not Acceptable",cf,0e,6b,35);
+            			}
+            			break;
+            			case (int)407: {
+HXLINE(  39)				return HX_("Proxy Authentication Required",35,f1,30,06);
+            			}
+            			break;
+            			case (int)408: {
+HXLINE(  40)				return HX_("Request Timeout",90,d4,9d,f8);
+            			}
+            			break;
+            			case (int)409: {
+HXLINE(  41)				return HX_("Conflict",72,46,d6,fd);
+            			}
+            			break;
+            			case (int)410: {
+HXLINE(  42)				return HX_("Gone",7f,c0,42,2f);
+            			}
+            			break;
+            			case (int)411: {
+HXLINE(  43)				return HX_("Length Required",d9,13,1b,e3);
+            			}
+            			break;
+            			case (int)412: {
+HXLINE(  44)				return HX_("Precondition Failed",c5,ef,a0,89);
+            			}
+            			break;
+            			case (int)413: {
+HXLINE(  45)				return HX_("Payload Too Large",bd,55,e7,53);
+            			}
+            			break;
+            			case (int)414: {
+HXLINE(  46)				return HX_("URI Too Long",1c,6e,93,1c);
+            			}
+            			break;
+            			case (int)415: {
+HXLINE(  47)				return HX_("Unsupported Media Type",61,45,31,c9);
+            			}
+            			break;
+            			case (int)416: {
+HXLINE(  48)				return HX_("Range Not Satisfiable",9d,7a,7b,53);
+            			}
+            			break;
+            			case (int)417: {
+HXLINE(  49)				return HX_("Expectation Failed",61,e3,49,ae);
+            			}
+            			break;
+            			case (int)418: {
+HXLINE(  50)				return HX_("I'm a teapot",f5,5a,78,47);
+            			}
+            			break;
+            			case (int)421: {
+HXLINE(  51)				return HX_("Misdirected Request",4e,3a,3b,51);
+            			}
+            			break;
+            			case (int)422: {
+HXLINE(  52)				return HX_("Unprocessable Entity",b3,bb,45,9b);
+            			}
+            			break;
+            			case (int)423: {
+HXLINE(  53)				return HX_("Locked",2a,79,5b,8e);
+            			}
+            			break;
+            			case (int)424: {
+HXLINE(  54)				return HX_("Failed Dependency",4e,8c,3e,61);
+            			}
+            			break;
+            			case (int)426: {
+HXLINE(  55)				return HX_("Upgrade Required",a3,21,95,bc);
+            			}
+            			break;
+            			case (int)428: {
+HXLINE(  56)				return HX_("Precondition Required",67,4d,69,a0);
+            			}
+            			break;
+            			case (int)429: {
+HXLINE(  57)				return HX_("Too Many Requests",39,d7,77,53);
+            			}
+            			break;
+            			case (int)431: {
+HXLINE(  58)				return HX_("Request Header Fields Too Large",8a,a4,23,6a);
+            			}
+            			break;
+            			case (int)451: {
+HXLINE(  59)				return HX_("Unavailable For Legal Reasons",a1,79,b9,fc);
+            			}
+            			break;
+            			case (int)500: {
+HXLINE(  60)				return HX_("Internal Server Error",4e,49,be,d4);
+            			}
+            			break;
+            			case (int)501: {
+HXLINE(  61)				return HX_("Not Implemented",f5,b5,64,18);
+            			}
+            			break;
+            			case (int)502: {
+HXLINE(  62)				return HX_("Bad Gateway",69,c2,d4,00);
+            			}
+            			break;
+            			case (int)503: {
+HXLINE(  63)				return HX_("Service Unavailable",a5,bb,e8,07);
+            			}
+            			break;
+            			case (int)504: {
+HXLINE(  64)				return HX_("Gateway Timeout",45,72,81,e5);
+            			}
+            			break;
+            			case (int)505: {
+HXLINE(  65)				return HX_("HTTP Version Not Supported",e1,52,c5,3e);
+            			}
+            			break;
+            			case (int)506: {
+HXLINE(  66)				return HX_("Variant Also Negotiates",f3,a2,fb,f7);
+            			}
+            			break;
+            			case (int)507: {
+HXLINE(  67)				return HX_("Insufficient Storage",1e,5a,8e,43);
+            			}
+            			break;
+            			case (int)508: {
+HXLINE(  68)				return HX_("Loop Detected",be,f6,5c,fa);
+            			}
+            			break;
+            			case (int)510: {
+HXLINE(  69)				return HX_("Not Extended",a6,e9,37,23);
+            			}
+            			break;
+            			case (int)511: {
+HXLINE(  70)				return HX_("Network Authentication Required",75,3f,0a,86);
+            			}
+            			break;
+            			default:{
+HXLINE(  71)				return HX_("Unknown Status",48,89,45,e6);
+            			}
+            		}
+HXLINE(   9)		return null();
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(HttpStatusMessage_Impl__obj,fromCode,return )
+
+
+HttpStatusMessage_Impl__obj::HttpStatusMessage_Impl__obj()
+{
+}
+
+bool HttpStatusMessage_Impl__obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 8:
+		if (HX_FIELD_EQ(inName,"fromCode") ) { outValue = fromCode_dyn(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *HttpStatusMessage_Impl__obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo *HttpStatusMessage_Impl__obj_sStaticStorageInfo = 0;
+#endif
+
+::hx::Class HttpStatusMessage_Impl__obj::__mClass;
+
+static ::String HttpStatusMessage_Impl__obj_sStaticFields[] = {
+	HX_("fromCode",b7,7f,90,9f),
+	::String(null())
+};
+
+void HttpStatusMessage_Impl__obj::__register()
+{
+	HttpStatusMessage_Impl__obj _hx_dummy;
+	HttpStatusMessage_Impl__obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("httpstatus._HttpStatusMessage.HttpStatusMessage_Impl_",c1,d3,37,02);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &HttpStatusMessage_Impl__obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(HttpStatusMessage_Impl__obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< HttpStatusMessage_Impl__obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = HttpStatusMessage_Impl__obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = HttpStatusMessage_Impl__obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace httpstatus
+} // end namespace _HttpStatusMessage
diff --git a/Sources/c_snikket/src/hx/Anon.cpp b/Sources/c_snikket/src/hx/Anon.cpp
new file mode 100644
index 0000000..6374367
--- /dev/null
+++ b/Sources/c_snikket/src/hx/Anon.cpp
@@ -0,0 +1,449 @@
+#include <hxcpp.h>
+#undef RegisterClass
+namespace hx
+{
+
+Dynamic FieldMapCreate() { return Dynamic(); }
+
+bool FieldMapGet(FieldMap *inMap, const String &inName, Dynamic &outValue)
+{
+   if (!inMap || !inMap->mPtr)
+      return false;
+
+   if (!__string_hash_exists(*inMap,inName))
+      return false;
+   outValue = __string_hash_get(*inMap, inName);
+   return true;
+}
+
+
+bool FieldMapGet(FieldMap *inMap, int inId, Dynamic &outValue)
+{
+   if (!inMap || !inMap->mPtr)
+      return false;
+
+   const String &key = __hxcpp_field_from_id(inId);
+   if (!__string_hash_exists(*inMap,key))
+      return false;
+   outValue = __string_hash_get(*inMap, key);
+   return true;
+}
+
+
+
+
+bool FieldMapHas(FieldMap *inMap, const String &inName)
+{
+   return inMap && inMap->mPtr &&  __string_hash_exists(*inMap,inName);
+}
+
+
+#ifdef HXCPP_GC_GENERATIONAL
+void FieldMapSet(hx::Object *inThis,FieldMap *inMap, const String &inName, const Dynamic &inValue)
+{
+   __string_hash_set(inThis,*inMap, inName, inValue,true);
+}
+#else
+void FieldMapSet(FieldMap *inMap, const String &inName, const Dynamic &inValue)
+{
+   __string_hash_set(*inMap, inName, inValue,true);
+}
+#endif
+
+
+void FieldMapAppendFields(FieldMap *inMap,Array<String> &outFields)
+{
+   Array<String> keys = __string_hash_keys(*inMap);
+   if (outFields->length==0)
+      outFields = keys;
+   else
+      outFields = outFields->concat(keys);
+}
+
+
+// -- Anon_obj -------------------------------------------------
+
+
+
+Anon_obj::Anon_obj(int inElements)
+{
+   mFixedFields = inElements;
+   //mFields = hx::FieldMapCreate();
+}
+
+void Anon_obj::__Mark(hx::MarkContext *__inCtx)
+{
+   if (mFixedFields)
+   {
+      VariantKey *fixed = getFixed();
+      for(int i=0;i<mFixedFields;i++)
+         HX_MARK_MEMBER(fixed[i].value);
+   }
+   HX_MARK_MEMBER(mFields);
+}
+
+#ifdef HXCPP_VISIT_ALLOCS
+void Anon_obj::__Visit(hx::VisitContext *__inCtx)
+{
+   if (mFixedFields)
+   {
+      VariantKey *fixed = getFixed();
+      for(int i=0;i<mFixedFields;i++)
+         HX_VISIT_MEMBER(fixed[i].value);
+   }
+   HX_VISIT_MEMBER(mFields);
+}
+#endif
+
+inline int Anon_obj::findFixed(const ::String &inKey, bool inSkip5)
+{
+   if (!mFixedFields || !inKey.isAsciiEncoded() )
+      return -1;
+   VariantKey *fixed = getFixed();
+
+   if (!inSkip5)
+      if (inKey.__s[HX_GC_CONST_ALLOC_MARK_OFFSET]  & HX_GC_CONST_ALLOC_MARK_BIT)
+      {
+         for(int i=0;i<mFixedFields;i++)
+         {
+            if (fixed[i].key.__s == inKey.__s)
+            return i;
+         }
+      }
+
+
+   int sought = inKey.hash();
+
+   if (!inSkip5)
+   {
+      if (mFixedFields<5)
+      {
+         for(int i=0;i<mFixedFields;i++)
+            if (fixed[i].hash==sought && (
+                   (fixed[i].key.length == inKey.length && !memcmp(fixed[i].key.raw_ptr(),inKey.raw_ptr(), inKey.length))))
+               return i;
+         return -1;
+      }
+   }
+
+   // Find node with same hash...
+   /* hash example
+      [0] = -3  <- min
+      [1] = -1
+      [2] = -1   (sought -1)
+      [3] =  4
+      [4] =  4  <- max
+   */
+
+   int min = inSkip5 ? 5 : 0;
+   if (fixed[min].hash>sought)
+      return -1;
+   if (fixed[min].hash!=sought)
+   {
+      int max = mFixedFields;
+      if (fixed[max-1].hash<sought)
+         return -1;
+
+      while(max>min+1)
+      {
+         int mid = (max+min)>>1;
+         if (fixed[mid].hash <= sought)
+            min = mid;
+         else
+            max = mid;
+      }
+   }
+
+   while(fixed[min].hash==sought)
+   {
+      // Might be multiple?
+      if ( fixed[min].key.length == inKey.length && !memcmp(fixed[min].key.raw_ptr(),inKey.raw_ptr(), inKey.length))
+         return min;
+
+      min++;
+      if (min>=mFixedFields)
+         break;
+   }
+
+   return -1;
+}
+
+hx::Val Anon_obj::__Field(const String &inName, hx::PropertyAccess inCallProp)
+{
+
+   #ifdef HX_SMART_STRINGS
+   if (inName.isAsciiEncodedQ())
+   #endif
+   if (mFixedFields>0)
+   {
+      VariantKey *fixed = getFixed();
+      if (inName.__s[HX_GC_CONST_ALLOC_MARK_OFFSET]  & HX_GC_CONST_ALLOC_MARK_BIT)
+      {
+         for(int i=0;i<mFixedFields;i++)
+         {
+            if (fixed[i].key.__s == inName.__s)
+               return fixed[i].value;
+         }
+      }
+
+      int hash = inName.hash();
+      if (fixed->hash==hash && HX_QSTR_EQ_AE(fixed->key,inName))
+         return fixed->value;
+      if (mFixedFields>1)
+      {
+         fixed++;
+         if (fixed->hash==hash && HX_QSTR_EQ_AE(fixed->key,inName))
+           return fixed->value;
+         if (mFixedFields>2)
+         {
+            fixed++;
+            if (fixed->hash==hash && HX_QSTR_EQ_AE(fixed->key,inName))
+              return fixed->value;
+            if (mFixedFields>3)
+            {
+               fixed++;
+               if (fixed->hash==hash && HX_QSTR_EQ_AE(fixed->key,inName))
+                 return fixed->value;
+               if (mFixedFields>4)
+               {
+                  fixed++;
+                  if (fixed->hash==hash && HX_QSTR_EQ_AE(fixed->key,inName))
+                     return fixed->value;
+
+                  int fixed = findFixed(inName,true);
+                  if (fixed>=0)
+                     return getFixed()[fixed].value;
+               }
+            }
+         }
+      }
+   }
+
+
+   if (!mFields.mPtr)
+      return hx::Val();
+
+   return __string_hash_get(mFields,inName);
+}
+
+bool Anon_obj::__HasField(const String &inName)
+{
+   if (findFixed(inName)>=0)
+      return true;
+   if (!mFields.mPtr)
+      return false;
+   return __string_hash_exists(mFields,inName);
+}
+
+bool Anon_obj::__Remove(String inKey)
+{
+   int slot = findFixed(inKey);
+   if (slot>=0)
+   {
+      VariantKey *fixed = getFixed();
+      while(slot<mFixedFields)
+      {
+         fixed[slot] = fixed[slot+1];
+         slot++;
+      }
+      mFixedFields--;
+      return true;
+   }
+
+   if (!mFields.mPtr)
+      return false;
+   return __string_hash_remove(mFields,inKey);
+}
+
+
+hx::Val Anon_obj::__SetField(const String &inName,const hx::Val &inValue, hx::PropertyAccess inCallProp)
+{
+   int slot = findFixed(inName);
+   if (slot>=0)
+   {
+      #ifdef HXCPP_GC_GENERATIONAL
+      VariantKey *fixed = getFixed() + slot;
+      fixed->value=inValue;
+      if (fixed->value.type <= cpp::Variant::typeString)
+         HX_OBJ_WB_GET(this, fixed->value.valObject);
+      #else
+      getFixed()[slot].value=inValue;
+      #endif
+      return inValue;
+   }
+
+   // TODO - fixed
+   if (!mFields.mPtr)
+   {
+      mFields = hx::FieldMapCreate();
+      HX_OBJ_WB_GET(this, mFields.mPtr);
+   }
+
+   __string_hash_set(HX_MAP_THIS_ mFields,inName,inValue,true);
+   return inValue;
+}
+
+Anon_obj *Anon_obj::Add(const String &inName,const Dynamic &inValue,bool inSetThisPointer)
+{
+   // TODO - fixed
+   if (!mFields.mPtr)
+   {
+      mFields = hx::FieldMapCreate();
+      HX_OBJ_WB_GET(this, mFields.mPtr);
+   }
+
+   __string_hash_set(HX_MAP_THIS_ mFields,inName,inValue,true);
+   if (inSetThisPointer && inValue.GetPtr())
+      inValue.GetPtr()->__SetThis(this);
+   return this;
+}
+
+static int _hx_toString_depth = 0;
+String Anon_obj::toString()
+{
+   if (!mFields.mPtr && !mFixedFields)
+      return HX_CSTRING("{ }");
+
+   if (_hx_toString_depth >= 5)
+      return HX_CSTRING("...");
+
+   _hx_toString_depth++;
+
+   try
+   {
+      int fixedToString = findFixed(HX_CSTRING("toString"));
+      if (fixedToString>=0)
+      {
+         Dynamic func = getFixed()[fixedToString].value;
+         if (func!=null())
+         {
+            String res = func();
+            _hx_toString_depth--;
+            return res;
+         }
+      }
+
+      Dynamic func;
+      if (FieldMapGet(&mFields, HX_CSTRING("toString"), func))
+      {
+         String res = func();
+         _hx_toString_depth--;
+         return res;
+      }
+
+      if (mFixedFields)
+      {
+         Array<String> array = Array<String>(0,mFixedFields*4+4);
+         array->push(HX_CSTRING("{ "));
+
+         if (mFields.mPtr)
+         {
+            String val = __string_hash_to_string_raw(mFields);
+            if (val.raw_ptr())
+               array->push(val);
+         }
+
+         VariantKey *fixed = getFixed();
+         for(int i=0;i<mFixedFields;i++)
+         {
+            if (array->length>1)
+              array->push(HX_CSTRING(", "));
+
+            array->push(fixed[i].key);
+            array->push(HX_CSTRING(" => "));
+            array->push(fixed[i].value);
+         }
+         array->push(HX_CSTRING(" }"));
+         _hx_toString_depth--;
+         return array->join(HX_CSTRING(""));
+      }
+
+      String ret = __string_hash_to_string(mFields);
+      _hx_toString_depth--;
+      return ret;
+   } catch (...)
+   {
+      _hx_toString_depth--;
+      throw;
+   }
+}
+
+void Anon_obj::__GetFields(Array<String> &outFields)
+{
+   if (mFields.mPtr)
+      outFields = __string_hash_keys(mFields);
+   if (mFixedFields>0)
+   {
+      VariantKey *fixed = getFixed();
+      for(int i=0;i<mFixedFields;i++)
+         outFields->push( fixed[i].key );
+   }
+}
+
+
+String Anon_obj::__ToString() const { return HX_CSTRING("Anon"); }
+
+Dynamic Anon_obj::__Create(DynamicArray inArgs) { return Anon(new (0) Anon_obj); }
+
+hx::Class Anon_obj::__mClass;
+
+
+void Anon_obj::__boot()
+{
+   Static(__mClass) = hx::_hx_RegisterClass(HX_CSTRING("__Anon"),TCanCast<Anon_obj>,sNone,sNone,0,0,0,0);
+}
+
+
+
+Anon SourceInfo(String inFile, int inLine, String inClass, String inMethod)
+{
+   Anon result = Anon_obj::Create();
+   result->Add(HX_CSTRING("fileName"),inFile);
+   result->Add(HX_CSTRING("lineNumber"),inLine);
+   result->Add(HX_CSTRING("className"),inClass);
+   result->Add(HX_CSTRING("methodName"),inMethod);
+   return result;
+}
+
+String StringFromAnonFields(hx::Object *inPtr)
+{
+   Array<String> fields = Array_obj<String>::__new();
+   inPtr->__GetFields(fields);
+
+   int n = fields->length;
+   Array<String> array = Array<String>(0,n*4+4);
+   array->push(HX_CSTRING("{ "));
+   for(int i=0;i<n;i++)
+   {
+      if (array->length>1)
+         array->push(HX_CSTRING(", "));
+
+      array->push(fields[i]);
+      array->push(HX_CSTRING(" => "));
+      array->push( inPtr->__Field( fields[i], HX_PROP_DYNAMIC) );
+   }
+   array->push(HX_CSTRING(" }"));
+   return array->join(HX_CSTRING(""));
+}
+
+
+
+
+}
+
+bool __hxcpp_anon_remove(Dynamic inObj,String inKey)
+{
+   hx::Anon_obj *anon = dynamic_cast<hx::Anon_obj *>(inObj.mPtr);
+   if (anon)
+   {
+      bool removed = anon->__Remove(inKey);
+      if (removed)
+         return true;
+   }
+   Dynamic *map = inObj->__GetFieldMap();
+   if (map)
+      return __string_hash_remove(*map,inKey);
+   return false;
+}
+
+
diff --git a/Sources/c_snikket/src/hx/Boot.cpp b/Sources/c_snikket/src/hx/Boot.cpp
new file mode 100644
index 0000000..5378960
--- /dev/null
+++ b/Sources/c_snikket/src/hx/Boot.cpp
@@ -0,0 +1,35 @@
+#include <hxcpp.h>
+#include <hxMath.h>
+
+#ifdef HX_WINRT
+#include<Roapi.h>
+#endif
+namespace hx
+{
+
+void Boot()
+{
+   //__hxcpp_enable(false);
+   #ifdef HX_WINRT
+   HRESULT hr = ::RoInitialize(  RO_INIT_MULTITHREADED );
+   #endif
+
+	#ifdef GPH
+	 setvbuf( stdout , 0 , _IONBF , 0 );
+	 setvbuf( stderr , 0 , _IONBF , 0 );
+	#endif
+
+   __hxcpp_stdlibs_boot();
+   Object::__boot();
+	Dynamic::__boot();
+	hx::Class_obj::__boot();
+	String::__boot();
+	Anon_obj::__boot();
+	ArrayBase::__boot();
+	EnumBase_obj::__boot();
+   Math_obj::__boot();
+}
+
+}
+
+
diff --git a/Sources/c_snikket/src/hx/CFFI.cpp b/Sources/c_snikket/src/hx/CFFI.cpp
new file mode 100644
index 0000000..c299571
--- /dev/null
+++ b/Sources/c_snikket/src/hx/CFFI.cpp
@@ -0,0 +1,1013 @@
+#include <hxcpp.h>
+#include <stdio.h>
+#include <hx/Memory.h>
+#include <hx/OS.h>
+
+#define IGNORE_CFFI_API_H
+
+#include <hx/CFFI.h>
+#include <map>
+#include <string>
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4190 )
+#endif
+
+
+// Class for boxing external handles
+
+namespace hx
+{
+
+class Abstract_obj : public Object
+{
+public:
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdAbstract };
+
+   Abstract_obj(int inType,void *inData)
+   {
+      mType = inType;
+      mHandle = inData;
+      mFinalizer = 0;
+      mMarkSize = 0;
+   }
+
+   Abstract_obj(int inType,int inSize, finalizer inFinalizer)
+   {
+      mType = inType;
+      mFinalizer = 0;
+      mMarkSize = 0;
+      mHandle = 0;
+      if (inSize)
+      {
+         mMarkSize = inSize;
+         mHandle = HxAlloc(inSize);
+         memset(mHandle,0,mMarkSize);
+      }
+
+      SetFinalizer(inFinalizer);
+   }
+
+
+   virtual int __GetType() const { return mType; }
+   virtual hx::ObjectPtr<hx::Class_obj> __GetClass() const { return 0; }
+   virtual bool __IsClass(hx::Class inClass ) const { return false; }
+
+   virtual void *__GetHandle() const
+   {
+      return mHandle;
+   }
+
+   void __Mark(hx::MarkContext *__inCtx)
+   {
+      HX_MARK_MEMBER(_hxcpp_toString);
+      if (mMarkSize>=sizeof(void *) && mHandle)
+      {
+         hx::MarkConservative((int *)mHandle, ((int *)mHandle) + (mMarkSize/sizeof(int)), __inCtx );
+      }
+   }
+
+   #ifdef HXCPP_VISIT_ALLOCS
+   void __Visit(hx::VisitContext *__inCtx)
+   {
+      HX_VISIT_MEMBER(_hxcpp_toString);
+      if (mFinalizer)
+         mFinalizer->Visit(__inCtx);
+   }
+   #endif
+
+   void SetFinalizer(finalizer inFinalizer)
+   {
+      if (!inFinalizer)
+      {
+         if (mFinalizer)
+            mFinalizer->Detach();
+         mFinalizer = 0;
+      }
+      else
+      {
+         if (!mFinalizer)
+            mFinalizer = new hx::InternalFinalizer(this);
+         mFinalizer->mFinalizer = inFinalizer;
+      }
+   }
+   void Clear()
+   {
+      SetFinalizer(0);
+      mType = 0;
+      if (mMarkSize && mHandle)
+         HxFree(mHandle);
+      mHandle = 0;
+   }
+
+   String toString()
+   {
+      if (_hxcpp_toString.mPtr)
+         return _hxcpp_toString( Dynamic(this) );
+
+      char buffer[40];
+      snprintf(buffer,sizeof(buffer),"0x%p", mHandle);
+
+      return HX_CSTRING("Abstract(") +
+             __hxcpp_get_kind(this) +
+             HX_CSTRING(":") +
+             String::create(buffer,strlen(buffer)) +
+             HX_CSTRING(")");
+   }
+
+   hx::Val __Field(const String &inString, hx::PropertyAccess inCallProp)
+   {
+      if (inString==HX_CSTRING("_hxcpp_toString")) return _hxcpp_toString;
+      if (inString==HX_CSTRING("_hxcpp_kind")) return __hxcpp_get_kind(this);
+      return hx::Object::__Field(inString, inCallProp);
+   }
+
+   hx::Val __SetField(const String &inName,const hx::Val &inValue, hx::PropertyAccess inCallProp)
+   {
+      if (inName==HX_CSTRING("_hxcpp_toString"))
+      {
+         _hxcpp_toString = inValue;
+         return inValue;
+      }
+      return hx::Object::__SetField(inName, inValue,inCallProp);
+   }
+
+
+   Dynamic _hxcpp_toString;
+   hx::InternalFinalizer *mFinalizer;
+   void *mHandle;
+   int mType;
+   int mMarkSize;
+};
+
+typedef ObjectPtr<Abstract_obj> Abstract;
+
+} // end namespace hx
+
+vkind k_int32 = (vkind)vtAbstractBase;
+vkind k_hash = (vkind)(vtAbstractBase + 1);
+vkind k_cpp_pointer = (vkind)(vtAbstractBase + 2);
+vkind k_cpp_struct = (vkind)(vtAbstractBase + 3);
+vkind k_cpp_objc = (vkind)(vtAbstractBase + 4);
+static int sgKinds = (int)(vtAbstractBase + 5);
+
+typedef std::map<std::string,int> KindMap;
+typedef std::map<int,std::string> ReverseKindMap;
+static KindMap sgKindMap;
+static ReverseKindMap sgReverseKindMap;
+
+
+int hxcpp_alloc_kind()
+{
+   return ++sgKinds;
+}
+
+
+void hxcpp_kind_share(int &ioKind,const char *inName)
+{
+   int &kind = sgKindMap[inName];
+   if (kind==0)
+      kind = hxcpp_alloc_kind();
+   ioKind = kind;
+   sgReverseKindMap[kind] = inName;
+}
+
+String __hxcpp_get_kind(Dynamic inObject)
+{
+   int type = inObject->__GetType();
+   if (type<vtAbstractBase)
+      return null();
+   if (type==(int)(size_t)k_cpp_pointer)
+      return HX_CSTRING("cpp.Pointer");
+   ReverseKindMap::const_iterator it = sgReverseKindMap.find(type);
+   if (it==sgReverseKindMap.end())
+      return null();
+   return String::create(it->second.c_str(), it->second.size());
+}
+
+
+//#define THROWS throw(Dynamic)
+#define THROWS
+
+
+extern "C" {
+
+
+/*
+ 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.
+
+ For the static link case, these functions are linked directly.
+*/
+
+void hx_error() THROWS
+{
+   hx::Throw( HX_CSTRING("ERROR") );
+}
+
+
+void val_throw(hx::Object * arg1) THROWS
+{
+   if (arg1==0)
+      hx::Throw( null() );
+   hx::Throw( arg1 );
+}
+
+
+void hx_fail(const char * inMessage,const char * inFile,int inLine)
+{
+   if (inFile!=0 && inLine!=0)
+      hx::Throw( HX_CSTRING("Failure ") + String(inMessage) + HX_CSTRING(" @ ") +
+                    String(inFile) + HX_CSTRING(":") + Dynamic(inLine) );
+   else
+      hx::Throw( HX_CSTRING("Failure ") + String(inMessage) );
+}
+
+
+
+// Determine hx::Object * type
+int val_type(hx::Object * arg1)
+{
+   if (arg1==0)
+      return valtNull;
+   return arg1->__GetType();
+}
+
+\
+vkind val_kind(hx::Object * arg1) THROWS
+{
+   if (arg1==0)
+      hx::Throw( HX_CSTRING("Value has no 'kind'") );
+   int type = arg1->__GetType();
+   if (type<valtAbstractBase)
+      hx::Throw( HX_CSTRING("Value has no 'kind'") );
+   return (vkind)(intptr_t)(type);
+}
+
+
+void * val_to_kind(hx::Object * arg1,vkind arg2)
+{
+   if (arg1==0)
+      return 0;
+   if ((int)(intptr_t)arg2 == arg1->__GetType())
+      return arg1->__GetHandle();
+   return 0;
+}
+
+
+// don't check the 'kind' ...
+void * val_data(hx::Object * arg1)
+{
+   if (arg1==0)
+      return 0;
+   return arg1->__GetHandle();
+}
+
+
+int val_fun_nargs(hx::Object * arg1)
+{
+   if (arg1==0)
+      return faNotFunction;
+   return arg1->__ArgCount();
+}
+
+
+
+
+// Extract hx::Object * type
+bool val_bool(hx::Object * arg1)
+{
+   if (arg1==0) return false;
+   return arg1->__ToInt()!=0;
+}
+
+
+int val_int(hx::Object * arg1)
+{
+   if (arg1==0) return 0;
+   return arg1->__ToInt();
+}
+
+
+double val_float(hx::Object * arg1)
+{
+   if (arg1==0) return 0.0;
+   return arg1->__ToDouble();
+}
+
+
+double val_number(hx::Object * arg1)
+{
+   if (arg1==0) return 0.0;
+   return arg1->__ToDouble();
+}
+
+
+
+// Create hx::Object * type
+
+hx::Object * alloc_null() { return 0; }
+hx::Object * alloc_bool(bool arg1) { return Dynamic(arg1).GetPtr(); }
+hx::Object * alloc_int(int arg1) { return Dynamic(arg1).GetPtr(); }
+hx::Object * alloc_float(double arg1) { return Dynamic(arg1).GetPtr(); }
+hx::Object * alloc_empty_object() { return new hx::Anon_obj(); }
+
+
+hx::Object * alloc_abstract(vkind arg1,void * arg2)
+{
+   int type = (int)(intptr_t)arg1;
+   return new hx::Abstract_obj(type,arg2);
+}
+
+hx::Object *create_abstract(vkind inKind,int inMemSize, hx::finalizer inFree )
+{
+   int type = (int)(intptr_t)inKind;
+
+   return new hx::Abstract_obj(type,inMemSize,inFree);
+}
+
+
+void free_abstract(hx::Object *obj)
+{
+   if (obj)
+   {
+      hx::Abstract_obj *abstract = dynamic_cast<hx::Abstract_obj *>(obj);
+      if (abstract)
+         abstract->Clear();
+   }
+}
+
+hx::Object * alloc_best_int(int arg1) { return Dynamic(arg1).GetPtr(); }
+hx::Object * alloc_int32(int arg1) { return Dynamic(arg1).GetPtr(); }
+
+
+
+// String access
+int val_strlen(hx::Object * arg1)
+{
+   if (arg1==0) return 0;
+   return arg1->toString().length;
+}
+
+
+const wchar_t * val_wstring(hx::Object * arg1)
+{
+   if (arg1==0) return L"";
+   return arg1->toString().__WCStr();
+}
+
+
+const char * val_string(hx::Object * arg1)
+{
+   if (arg1==0) return "";
+   return arg1->__CStr();
+}
+
+
+hx::Object * alloc_string(const char * arg1)
+{
+   return Dynamic( String::create(arg1) ).GetPtr();
+}
+
+hx::StringEncoding hxs_encoding(const String &str)
+{
+   #ifdef HX_SMART_STRINGS
+   if (str.isUTF16Encoded())
+      return hx::StringUtf16;
+   else
+      return hx::StringAscii;
+   #else
+   return hx::StringUtf8;
+   #endif
+}
+
+
+wchar_t * val_dup_wstring(value inVal)
+{
+   hx::Object *obj = (hx::Object *)inVal;
+   if (!obj)
+      return 0;
+   String  s = obj->toString();
+   if (!s.raw_ptr())
+      return 0;
+   #ifdef HX_SMART_STRINGS
+   if ( sizeof(wchar_t)==2 && s.isUTF16Encoded())
+   {
+      wchar_t *result = (wchar_t *)hx::NewGCBytes(0,(s.length+1)*2);
+      memcpy(result, s.wchar_str(), s.length*2 );
+      result[s.length]=0;
+      return result;
+   }
+   #endif
+   return (wchar_t *)s.wchar_str();
+}
+
+char * val_dup_string(value inVal)
+{
+   hx::Object *obj = (hx::Object *)inVal;
+   if (!obj) return 0;
+   String  s = obj->toString();
+   if (!s.raw_ptr())
+      return 0;
+   #ifdef HX_SMART_STRINGS
+   if (s.isUTF16Encoded())
+      return (char *)s.utf8_str();
+   #endif
+
+   char *result = (char *)hx::NewGCBytes(0,s.length+1);
+   memcpy(result, s.raw_ptr(), s.length);
+   result[s.length] = 0;
+   return result;
+}
+
+
+char *alloc_string_data(const char *inData, int inLength)
+{
+   char *result = (char *)hx::NewGCBytes(0,inLength+1);
+   if (inData)
+   {
+      memcpy(result, inData, inLength);
+      result[inLength] = 0;
+   }
+   return result;
+}
+
+hx::Object *alloc_string_len(const char *inStr,int inLen)
+{
+   return Dynamic( String::create(inStr,inLen) ).GetPtr();
+}
+
+hx::Object *alloc_wstring_len(const wchar_t *inStr,int inLen)
+{
+   String str = String::create(inStr,inLen);
+   return Dynamic(str).GetPtr();
+}
+
+// Array access - generic
+int val_array_size(hx::Object * arg1)
+{
+   if (arg1==0) return 0;
+   return arg1->__length();
+}
+
+
+hx::Object * val_array_i(hx::Object * arg1,int arg2)
+{
+   if (arg1==0) return 0;
+   return arg1->__GetItem(arg2).GetPtr();
+}
+
+void val_array_set_i(hx::Object * arg1,int arg2,hx::Object *inVal)
+{
+   if (arg1==0) return;
+   arg1->__SetItem(arg2, Dynamic(inVal) );
+}
+
+void val_array_set_size(hx::Object * arg1,int inLen)
+{
+   hx::ArrayBase *base = dynamic_cast<hx::ArrayBase *>(arg1);
+   if (base)
+   {
+      base->__SetSize(inLen);
+   }
+   else
+   {
+      cpp::VirtualArray_obj *va = dynamic_cast<cpp::VirtualArray_obj *>(arg1);
+      if (va)
+         va->__SetSize(inLen);
+   }
+}
+
+void val_array_push(hx::Object * arg1,hx::Object *inValue)
+{
+   hx::ArrayBase *base = dynamic_cast<hx::ArrayBase *>(arg1);
+   if (base==0) return;
+   base->__push(inValue);
+}
+
+
+hx::Object * alloc_array(int arg1)
+{
+   Array<Dynamic> array(arg1,arg1);
+   return array.GetPtr();
+}
+
+
+
+// Array access - fast if possible - may return null
+// Resizing the array may invalidate the pointer
+bool * val_array_bool(hx::Object * arg1)
+{
+   hx::ArrayCommon *common = dynamic_cast< hx::ArrayCommon * >(arg1);
+   if (!common) return 0;
+   arg1 = common->__GetRealObject();
+   Array_obj<bool> *a = dynamic_cast< Array_obj<bool> * >(arg1);
+   if (a==0)
+      return 0;
+   return (bool *)a->GetBase();
+}
+
+
+int * val_array_int(hx::Object * arg1)
+{
+   hx::ArrayCommon *common = dynamic_cast< hx::ArrayCommon * >(arg1);
+   if (!common) return 0;
+   arg1 = common->__GetRealObject();
+   Array_obj<int> *a = dynamic_cast< Array_obj<int> * >(arg1);
+   if (a==0)
+      return 0;
+   return (int *)a->GetBase();
+}
+
+
+double * val_array_double(hx::Object * arg1)
+{
+   hx::ArrayCommon *common = dynamic_cast< hx::ArrayCommon * >(arg1);
+   if (!common) return 0;
+   arg1 = common->__GetRealObject();
+   Array_obj<double> *a = dynamic_cast< Array_obj<double> * >(arg1);
+   if (a==0)
+      return 0;
+   return (double *)a->GetBase();
+}
+
+
+float * val_array_float(hx::Object * arg1)
+{
+   hx::ArrayCommon *common = dynamic_cast< hx::ArrayCommon * >(arg1);
+   if (!common) return 0;
+   arg1 = common->__GetRealObject();
+   Array_obj<float> *a = dynamic_cast< Array_obj<float> * >(arg1);
+   if (a==0)
+      return 0;
+   return (float *)a->GetBase();
+}
+
+value * val_array_value(hx::Object * arg1)
+{
+   return 0;
+}
+
+
+
+
+typedef Array_obj<unsigned char> *ByteArray;
+
+// Byte arrays
+// The byte array may be a string or a Array<bytes> depending on implementation
+buffer val_to_buffer(hx::Object * arg1)
+{
+   ByteArray b = dynamic_cast< ByteArray >(arg1);
+   return (buffer)b;
+}
+
+bool val_is_buffer(value inVal) { return val_to_buffer((hx::Object *)inVal)!=0; }
+
+
+
+buffer alloc_buffer(const char *inStr)
+{
+   int len = inStr ? strlen(inStr) : 0;
+   ByteArray b = new Array_obj<unsigned char>(len,len);
+   if (len)
+      memcpy(b->GetBase(),inStr,len);
+   return (buffer)b;
+}
+
+
+buffer alloc_buffer_len(int inLen)
+{
+   ByteArray b = new Array_obj<unsigned char>(inLen,inLen);
+   return (buffer)b;
+}
+
+
+value buffer_val(buffer b)
+{
+   return (value)b;
+}
+
+
+value buffer_to_string(buffer inBuffer)
+{
+   ByteArray b = (ByteArray) inBuffer;
+   String str(b->GetBase(),b->length);
+   Dynamic d(str);
+   return (value)d.GetPtr();
+}
+
+
+void buffer_append(buffer inBuffer,const char *inStr)
+{
+   ByteArray b = (ByteArray)inBuffer;
+   int olen = b->length;
+   int len = strlen(inStr);
+   b->__SetSize(olen+len);
+   memcpy(b->GetBase()+olen,inStr,len);
+
+}
+
+
+int buffer_size(buffer inBuffer)
+{
+   ByteArray b = (ByteArray)inBuffer;
+   return b->length;
+}
+
+
+void buffer_set_size(buffer inBuffer,int inLen)
+{
+   ByteArray b = (ByteArray)inBuffer;
+   b->__SetSize(inLen);
+}
+
+
+void buffer_append_sub(buffer inBuffer,const char *inStr,int inLen)
+{
+   ByteArray b = (ByteArray)inBuffer;
+   int olen = b->length;
+   b->__SetSize(olen+inLen);
+   memcpy(b->GetBase()+olen,inStr,inLen);
+}
+
+
+void buffer_append_char(buffer inBuffer,int inChar)
+{
+   ByteArray b = (ByteArray)inBuffer;
+   b->Add(inChar);
+}
+
+
+char * buffer_data(buffer inBuffer)
+{
+   ByteArray b = (ByteArray)inBuffer;
+   return b->GetBase();
+}
+
+
+// Append value to buffer
+void val_buffer(buffer inBuffer,value inValue)
+{
+   hx::Object *obj = (hx::Object *)inValue;
+   if (obj)
+   {
+       buffer_append(inBuffer, obj->toString().__CStr());
+   }
+   else
+   {
+      buffer_append_sub(inBuffer,"null",4);
+   }
+}
+
+
+
+
+
+
+// Call Function 
+hx::Object * val_call0(hx::Object * arg1) THROWS
+{
+   if (!arg1) Dynamic::ThrowBadFunctionError();
+   return arg1->__run().GetPtr();
+}
+
+hx::Object * val_call0_traceexcept(hx::Object * arg1) THROWS
+{
+   try
+   {
+   if (!arg1) Dynamic::ThrowBadFunctionError();
+   return arg1->__run().GetPtr();
+   }
+   catch(Dynamic e)
+   {
+      String s = e;
+      fprintf(stderr,"Fatal Error : %s\n",s.__CStr());
+      exit(1);
+   }
+   return 0;
+}
+
+
+hx::Object * val_call1(hx::Object * arg1,hx::Object * arg2) THROWS
+{
+   if (!arg1) Dynamic::ThrowBadFunctionError();
+   return arg1->__run(arg2).GetPtr();
+}
+
+
+hx::Object * val_call2(hx::Object * arg1,hx::Object * arg2,hx::Object * arg3) THROWS
+{
+   if (!arg1) Dynamic::ThrowBadFunctionError();
+   return arg1->__run(arg2,arg3).GetPtr();
+}
+
+
+hx::Object * val_call3(hx::Object * arg1,hx::Object * arg2,hx::Object * arg3,hx::Object * arg4) THROWS
+{
+   if (!arg1) Dynamic::ThrowBadFunctionError();
+   return arg1->__run(arg2,arg3,arg4).GetPtr();
+}
+
+
+hx::Object * val_callN(hx::Object * arg1,hx::Object ** arg2, int nCount) THROWS
+{
+   if (!arg1) Dynamic::ThrowBadFunctionError();
+   Array<Dynamic> args = Array_obj<Dynamic>::__new(0, nCount);
+   while (nCount--)
+     args << *arg2++;
+   return arg1->__Run( args ).GetPtr();
+}
+
+
+// Call object field
+hx::Object * val_ocall0(hx::Object * arg1,int arg2) THROWS
+{
+   if (!arg1) hx::Throw(HX_INVALID_OBJECT);
+   return arg1->__IField(arg2)->__run().GetPtr();
+}
+
+
+hx::Object * val_ocall1(hx::Object * arg1,int arg2,hx::Object * arg3) THROWS
+{
+   if (!arg1) hx::Throw(HX_INVALID_OBJECT);
+   return arg1->__IField(arg2)->__run(arg3).GetPtr();
+}
+
+
+hx::Object * val_ocall2(hx::Object * arg1,int arg2,hx::Object * arg3,hx::Object * arg4) THROWS
+{
+   if (!arg1) hx::Throw(HX_INVALID_OBJECT);
+   return arg1->__IField(arg2)->__run(arg3,arg4).GetPtr();
+}
+
+
+hx::Object * val_ocall3(hx::Object * arg1,int arg2,hx::Object * arg3,hx::Object * arg4,hx::Object * arg5) THROWS
+{
+   if (!arg1) hx::Throw(HX_INVALID_OBJECT);
+   return arg1->__IField(arg2)->__run(arg3,arg4,arg5).GetPtr();
+}
+
+
+hx::Object * val_ocallN(hx::Object * arg1,int arg2,hx::Object * arg3) THROWS
+{
+   if (!arg1) hx::Throw(HX_INVALID_OBJECT);
+   return arg1->__IField(arg2)->__run(Dynamic(arg3)).GetPtr();
+}
+
+
+
+// Objects access
+int val_id(const char * arg1)
+{
+   return __hxcpp_field_to_id(arg1);
+}
+
+
+void alloc_field(hx::Object * arg1,int arg2,hx::Object * arg3) THROWS
+{
+   //hx::InternalCollect();
+   if (!arg1) hx::Throw(HX_INVALID_OBJECT);
+   arg1->__SetField(__hxcpp_field_from_id(arg2),arg3, HX_PROP_DYNAMIC );
+}
+void hxcpp_alloc_field(hx::Object * arg1,int arg2,hx::Object * arg3)
+{
+   return alloc_field(arg1,arg2,arg3);
+}
+
+void alloc_field_numeric(hx::Object * arg1,int arg2,double arg3) THROWS
+{
+   //hx::InternalCollect();
+   if (!arg1) hx::Throw(HX_INVALID_OBJECT);
+   arg1->__SetField(__hxcpp_field_from_id(arg2),arg3, HX_PROP_DYNAMIC );
+}
+void hxcpp_alloc_field_numeric(hx::Object * arg1,int arg2,double arg3)
+{
+   return alloc_field_numeric(arg1,arg2,arg3);
+}
+
+
+
+hx::Object * val_field(hx::Object * arg1,int arg2) THROWS
+{
+   if (!arg1) hx::Throw(HX_INVALID_OBJECT);
+   return arg1->__IField(arg2).GetPtr();
+}
+
+double val_field_numeric(hx::Object * arg1,int arg2) THROWS
+{
+   if (!arg1) hx::Throw(HX_INVALID_OBJECT);
+   return arg1->__INumField(arg2);
+}
+
+value val_field_name(field inField)
+{
+   return (value)Dynamic(__hxcpp_field_from_id(inField)).mPtr;
+}
+
+
+void val_iter_field_vals(hx::Object *inObj, __hx_field_iter inFunc ,void *inCookie)
+{
+   if (inObj)
+   {
+      Array<String> fields = Array_obj<String>::__new(0,0);
+
+      inObj->__GetFields(fields);
+
+      for(int i=0;i<fields->length;i++)
+      {
+         inFunc((value)Dynamic(inObj->__Field(fields[i], HX_PROP_NEVER )).mPtr, __hxcpp_field_to_id(fields[i].__CStr()), inCookie);
+      }
+   }
+}
+
+
+void val_iter_fields(hx::Object *inObj, __hx_field_iter inFunc ,void *inCookie)
+{
+   if (inObj)
+   {
+      Array<String> fields = Array_obj<String>::__new(0,0);
+
+      inObj->__GetFields(fields);
+
+      for(int i=0;i<fields->length;i++)
+      {
+         inFunc((value)inObj, __hxcpp_field_to_id(fields[i].__CStr()), inCookie);
+      }
+   }
+}
+
+
+
+   // Abstract types
+vkind alloc_kind()
+{
+   return (vkind)(intptr_t)hxcpp_alloc_kind();
+}
+
+void kind_share(vkind *inKind,const char *inName)
+{
+   int k = (int)(intptr_t)*inKind;
+   hxcpp_kind_share(k,inName);
+   *inKind = (vkind)(intptr_t)k;
+}
+
+
+
+// Garbage Collection
+void * hx_alloc(int arg1)
+{
+   return hx::NewGCBytes(0,arg1);
+}
+
+
+void * alloc_private(int arg1)
+{
+   return hx::NewGCPrivate(0,arg1);
+}
+
+hx::Object * alloc_raw_string(int length)
+{
+   return Dynamic( String( (HX_CHAR *) alloc_private(length+1), length) ).GetPtr();
+}
+
+void  val_gc(hx::Object * arg1,hx::finalizer arg2) THROWS
+{
+   hx::Abstract_obj *abstract = dynamic_cast<hx::Abstract_obj *>(arg1);
+   if (!abstract)
+   {
+      hx::GCSetFinalizer(arg1,arg2);
+      //hx::Throw(HX_CSTRING("Finalizer not on abstract object"));
+   }
+   else
+      abstract->SetFinalizer(arg2);
+}
+
+void  val_gc_ptr(void * arg1,hxPtrFinalizer arg2) THROWS
+{
+   hx::Throw(HX_CSTRING("Finalizer not supported here"));
+}
+
+void  val_gc_add_root(hx::Object **inRoot)
+{
+   hx::GCAddRoot(inRoot);
+}
+
+
+void  val_gc_remove_root(hx::Object **inRoot)
+{
+   hx::GCRemoveRoot(inRoot);
+}
+
+void  gc_set_top_of_stack(int *inTopOfStack,bool inForce)
+{
+   hx::SetTopOfStack(inTopOfStack,inForce);
+}
+
+
+void gc_change_managed_memory(int inDelta, const char *inWhy)
+{
+   hx::GCChangeManagedMemory(inDelta, inWhy);
+}
+
+
+value *alloc_root()
+{
+   hx::Object ** result = new hx::Object *();
+   hx::GCAddRoot(result);
+   return (value *)result;
+}
+
+void free_root(value *inValue)
+{
+   hx::Object **root = (hx::Object **) inValue;
+   hx::GCRemoveRoot(root);
+   delete root;
+}
+
+
+// Used for finding functions in static libraries
+int hx_register_prim( const char * arg1, void* arg2)
+{
+   __hxcpp_register_prim(arg1,arg2);
+   return 0;
+}
+
+void gc_enter_blocking()
+{
+   hx::EnterGCFreeZone();
+}
+
+void gc_exit_blocking()
+{
+   hx::ExitGCFreeZone();
+}
+
+
+bool gc_try_blocking()
+{
+   return hx::TryGCFreeZone();
+}
+
+bool gc_try_unblocking()
+{
+   return hx::TryExitGCFreeZone();
+}
+
+
+void gc_safe_point()
+{
+   if (hx::gPauseForCollect)
+      hx::PauseForCollect();
+}
+
+gcroot create_root(value) { return 0; }
+value query_root(gcroot) { return 0; }
+void destroy_root(gcroot) { }
+
+
+String alloc_hxs_wchar(const wchar_t *ptr,int size)
+{
+   return String::create(ptr,size);
+}
+
+String alloc_hxs_utf16(const char16_t *ptr,int size)
+{
+   return String::create(ptr,size);
+}
+
+String alloc_hxs_utf8(const char *ptr,int size)
+{
+   return String::create(ptr,size);
+}
+
+const char * hxs_utf8(const String &string,hx::IStringAlloc *alloc)
+{
+   return string.utf8_str(alloc);
+}
+
+const wchar_t * hxs_wchar(const String &string,hx::IStringAlloc *alloc)
+{
+   return string.wchar_str(alloc);
+}
+
+const char16_t * hxs_utf16(const String &string,hx::IStringAlloc *alloc)
+{
+   return string.wc_str(alloc);
+}
+
+
+#ifndef HXCPP_STATIC_CFFI
+EXPORT
+#endif
+void * hx_cffi(const char *inName)
+{
+   #define HXCPP_PRIME
+   #define DEFFUNC(name,r,b,c) if ( !strcmp(inName,#name) ) return (void *)name;
+
+   #include <hx/CFFIAPI.h>
+
+   return 0;
+}
+
+}
diff --git a/Sources/c_snikket/src/hx/Class.cpp b/Sources/c_snikket/src/hx/Class.cpp
new file mode 100644
index 0000000..554775a
--- /dev/null
+++ b/Sources/c_snikket/src/hx/Class.cpp
@@ -0,0 +1,373 @@
+#include <hxcpp.h>
+#include <map>
+
+#ifdef ANDROID
+#include <android/log.h>
+#endif
+
+
+namespace hx
+{
+
+typedef std::map<String,Class> ClassMap;
+static ClassMap *sClassMap = 0;
+
+Class _hx_RegisterClass(const String &inClassName, CanCastFunc inCanCast,
+                    String inStatics[], String inMembers[],
+                    ConstructEmptyFunc inConstructEmpty, ConstructArgsFunc inConstructArgs,
+                    Class *inSuperClass, ConstructEnumFunc inConstructEnum,
+                    MarkFunc inMarkFunc
+                    #ifdef HXCPP_VISIT_ALLOCS
+                    ,VisitFunc inVisitFunc
+                    #endif
+                    #ifdef HXCPP_SCRIPTABLE
+                    ,const hx::StorageInfo *inStorageInfo
+                    ,const hx::StaticInfo *inStaticInfo
+                    #endif
+                    )
+{
+   if (sClassMap==0)
+      sClassMap = new ClassMap;
+
+   Class_obj *obj = new Class_obj(inClassName, inStatics, inMembers,
+                                  inConstructEmpty, inConstructArgs, inSuperClass,
+                                  inConstructEnum, inCanCast, inMarkFunc
+                                  #ifdef HXCPP_VISIT_ALLOCS
+                                  ,inVisitFunc
+                                  #endif
+                                  #ifdef HXCPP_SCRIPTABLE
+                                  ,inStorageInfo
+                                  ,inStaticInfo
+                                  #endif
+                                  );
+   Class c(obj);
+   (*sClassMap)[inClassName] = c;
+   return c;
+}
+
+void _hx_RegisterClass(const String &inClassName, Class inClass)
+{
+   if (sClassMap==0)
+      sClassMap = new ClassMap;
+   (*sClassMap)[inClassName] = inClass;
+}
+
+
+
+// -------- Class ---------------------------------------
+
+
+Class_obj::Class_obj(const String &inClassName,String inStatics[], String inMembers[],
+             ConstructEmptyFunc inConstructEmpty, ConstructArgsFunc inConstructArgs,
+             Class *inSuperClass,ConstructEnumFunc inConstructEnum,
+             CanCastFunc inCanCast, MarkFunc inFunc
+             #ifdef HXCPP_VISIT_ALLOCS
+             ,VisitFunc inVisitFunc
+             #endif
+             #ifdef HXCPP_SCRIPTABLE
+             ,const hx::StorageInfo *inStorageInfo
+             ,const hx::StaticInfo *inStaticInfo
+             #endif
+             )
+{
+   mName = inClassName.makePermanent();
+   mSuper = inSuperClass;
+   mConstructEmpty = inConstructEmpty;
+   mConstructArgs = inConstructArgs;
+   mConstructEnum = inConstructEnum;
+   mMarkFunc = inFunc;
+   #ifdef HXCPP_VISIT_ALLOCS
+   mVisitFunc = inVisitFunc;
+   #endif
+
+   #ifdef HXCPP_SCRIPTABLE
+   mMemberStorageInfo = inStorageInfo;
+   mStaticStorageInfo = inStaticInfo;
+   #endif
+
+   mStatics = dupFunctions(inStatics);
+   mMembers = dupFunctions(inMembers);
+   mCanCast = inCanCast;
+}
+
+bool Class_obj::GetNoStaticField(const String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp)
+{
+   return false;
+}
+bool Class_obj::SetNoStaticField(const String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp)
+{
+   return false;
+}
+
+
+
+::Array< ::String > Class_obj::dupFunctions(String inFuncs[])
+{
+   if (!inFuncs)
+      return null();
+
+   int count = 0;
+   for(String *s = inFuncs; s->length; s++)
+      count++;
+
+   Array<String> result = Array_obj<String>::__newConstWrapper(&inFuncs[0],count);
+
+   return result;
+}
+
+void Class_obj::registerScriptable(bool inOverwrite)
+{
+   if (!inOverwrite && sClassMap->find(mName)!=sClassMap->end())
+      return;
+   (*sClassMap)[ mName ] = this;
+}
+
+Class Class_obj::GetSuper()
+{
+   if (!mSuper)
+      return null();
+	if (mSuper==&hx::Object::__SGetClass())
+		return null();
+   return *mSuper;
+}
+
+
+Class Class_obj__mClass;
+
+Class  Class_obj::__GetClass() const { return Class_obj__mClass; }
+Class &Class_obj::__SGetClass() { return Class_obj__mClass; }
+
+void Class_obj::__boot()
+{
+Static(Class_obj__mClass) = hx::_hx_RegisterClass(HX_CSTRING("Class"),TCanCast<Class_obj>,sNone,sNone, 0,0 , 0, 0 );
+}
+
+
+void Class_obj::MarkStatics(hx::MarkContext *__inCtx)
+{
+   HX_MARK_MEMBER(__meta__);
+   if (mMarkFunc)
+       mMarkFunc(__inCtx);
+}
+#ifdef HXCPP_VISIT_ALLOCS
+void Class_obj::VisitStatics(hx::VisitContext *__inCtx)
+{
+   HX_VISIT_MEMBER(__meta__);
+   if (mVisitFunc)
+       mVisitFunc(__inCtx);
+}
+#endif
+
+Class Class_obj::Resolve(String inName)
+{
+   ClassMap::const_iterator i = sClassMap->find(inName);
+   if (i==sClassMap->end())
+   {
+      // Class class...
+      if (inName==HX_CSTRING("Enum"))
+         return Class_obj__mClass;
+      return null();
+   }
+   return i->second;
+}
+
+Dynamic Class_obj::ConstructEmpty()
+{
+   return mConstructEmpty();
+}
+
+Dynamic Class_obj::ConstructArgs(DynamicArray inArgs)
+{
+   return mConstructArgs(inArgs);
+}
+
+Dynamic Class_obj::ConstructEnum(String inName,DynamicArray inArgs)
+{
+   if (mConstructEnum==0)
+      return null();
+   return mConstructEnum(inName,inArgs);
+}
+
+
+
+String Class_obj::__ToString() const { return mName; }
+
+
+Array<String> Class_obj::GetInstanceFields()
+{
+   Array<String> result = mSuper && (*mSuper).mPtr != this ? (*mSuper)->GetInstanceFields() : Array<String>(0,0);
+   if (mMembers.mPtr)
+      for(int m=0;m<mMembers->size();m++)
+      {
+         const String &mem = mMembers[m];
+         if (result->Find(mem)==-1)
+            result.Add(mem);
+      }
+   return result;
+}
+
+Array<String> Class_obj::GetClassFields()
+{
+   Array<String> result = mStatics.mPtr ? mStatics->copy() : new Array_obj<String>(0,0);
+   if (__rtti__.raw_ptr())
+      result->push( HX_CSTRING("__rtti") );
+   return result;
+}
+
+bool Class_obj::__HasField(const String &inString)
+{
+   if (__rtti__.raw_ptr() && inString==HX_CSTRING("__rtti"))
+      return true;
+
+   if (mStatics.mPtr)
+      for(int s=0;s<mStatics->size();s++)
+         if (mStatics[s]==inString)
+            return true;
+   return false;
+}
+
+hx::Val Class_obj::__Field(const String &inString, hx::PropertyAccess inCallProp)
+{
+   if (inString==HX_CSTRING("__meta__"))
+      return __meta__;
+   if (inString==HX_CSTRING("__rtti"))
+      return __rtti__;
+
+   if (mGetStaticField)
+   {
+      Dynamic result;
+      if (mGetStaticField(inString,result,inCallProp))
+         return result;
+ 
+      // Throw ?
+      return null();
+   }
+
+   // Not the most efficient way of doing this!
+   if (!mConstructEmpty)
+      return null();
+   Dynamic instance = mConstructEmpty();
+   return instance->__Field(inString, inCallProp);
+}
+
+hx::Val Class_obj::__SetField(const String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp)
+{
+
+   if (mSetStaticField)
+   {
+      Dynamic result = inValue;
+      if (mSetStaticField(inString,result,inCallProp))
+         return result;
+ 
+      // Throw ?
+      return inValue;
+   }
+
+
+
+
+   // Not the most efficient way of doing this!
+   if (!mConstructEmpty)
+      return null();
+   Dynamic instance = mConstructEmpty();
+   return instance->__SetField(inString,inValue, inCallProp);
+}
+
+bool Class_obj::__IsEnum()
+{
+   return mConstructEnum || this==GetVoidClass().GetPtr() || this==GetBoolClass().GetPtr();
+}
+
+#ifdef HXCPP_SCRIPTABLE
+const hx::StorageInfo* Class_obj::GetMemberStorage(String inName)
+{
+   if (mMemberStorageInfo)
+   {
+      for(const StorageInfo *s = mMemberStorageInfo; s->offset; s++)
+      {
+         if (s->name == inName)
+            return s;
+      }
+   }
+   if (mSuper)
+      return (*mSuper)->GetMemberStorage(inName);
+   return 0;
+}
+
+
+const hx::StaticInfo* Class_obj::GetStaticStorage(String inName)
+{
+   if (mStaticStorageInfo)
+   {
+      for(const StaticInfo *s = mStaticStorageInfo; s->address; s++)
+      {
+         if (s->name == inName)
+            return s;
+      }
+   }
+   return 0;
+}
+
+
+#endif
+
+
+
+void MarkClassStatics(hx::MarkContext *__inCtx)
+{
+   #ifdef HXCPP_DEBUG
+   MarkPushClass("MarkClassStatics",__inCtx);
+   #endif
+   ClassMap::iterator end = sClassMap->end();
+   for(ClassMap::iterator i = sClassMap->begin(); i!=end; ++i)
+   {
+      Class c = i->second;
+      if (c->__meta__.mPtr || c->mMarkFunc)
+      {
+         #ifdef HXCPP_DEBUG
+         hx::MarkPushClass(i->first.raw_ptr(),__inCtx);
+         hx::MarkSetMember("statics",__inCtx);
+         #endif
+      
+         c->MarkStatics(__inCtx);
+
+         #ifdef HXCPP_DEBUG
+         hx::MarkPopClass(__inCtx);
+         #endif
+      }
+   }
+   #ifdef HXCPP_DEBUG
+   MarkPopClass(__inCtx);
+   #endif
+}
+
+#ifdef HXCPP_VISIT_ALLOCS
+
+void VisitClassStatics(hx::VisitContext *__inCtx)
+{
+   HX_VISIT_MEMBER(Class_obj__mClass);
+   ClassMap::iterator end = sClassMap->end();
+   for(ClassMap::iterator i = sClassMap->begin(); i!=end; ++i)
+         i->second->VisitStatics(__inCtx);
+}
+
+#endif
+
+
+} // End namespace hx
+
+Array<String> __hxcpp_get_class_list()
+{
+   Array<String> result = Array_obj<String>::__new();
+   if (hx::sClassMap)
+   {
+      for(hx::ClassMap::iterator i=hx::sClassMap->begin(); i!=hx::sClassMap->end(); ++i)
+      {
+         if (i->second.mPtr)
+            result->push( i->first );
+      }
+   }
+   return result;
+}
+
+
diff --git a/Sources/c_snikket/src/hx/Date.cpp b/Sources/c_snikket/src/hx/Date.cpp
new file mode 100644
index 0000000..cdc665b
--- /dev/null
+++ b/Sources/c_snikket/src/hx/Date.cpp
@@ -0,0 +1,428 @@
+#include <hxcpp.h>
+
+#include <time.h>
+
+#ifdef HX_WINDOWS
+   #include <windows.h>
+#else
+   #include <stdint.h>
+   #if defined(__unix__) || defined(__APPLE__)
+      #include <unistd.h>
+      #include <stdio.h>
+      #if (_POSIX_VERSION >= 1)
+         #define USE_TIME_R
+      #endif
+      #if (_POSIX_VERSION >= 199309L)
+         #include <sys/time.h>
+         #define USE_CLOCK_GETTIME
+         #define USE_GETTIMEOFDAY
+      #endif
+   #endif
+   #if defined(__ORBIS__)
+      // fill in for a missing localtime_r with localtime_s
+      #define localtime_r localtime_s
+      #define gmtime_r gmtime_s
+   #endif
+#endif
+
+#ifdef HX_MACOS
+#include <mach/mach_time.h>
+#include <mach-o/dyld.h>
+#include <CoreServices/CoreServices.h>
+#endif
+
+#if defined(IPHONE) || defined(APPLETV)
+#include <QuartzCore/QuartzCore.h>
+#endif
+
+
+//#include <hxMacros.h>
+
+static double t0 = 0;
+double __hxcpp_time_stamp()
+{
+#ifdef HX_WINDOWS
+   static __int64 t0=0;
+   static double period=0;
+   __int64 now;
+
+   if (QueryPerformanceCounter((LARGE_INTEGER*)&now))
+   {
+      if (t0==0)
+      {
+         t0 = now;
+         __int64 freq;
+         QueryPerformanceFrequency((LARGE_INTEGER*)&freq);
+         if (freq!=0)
+            period = 1.0/freq;
+      }
+      if (period!=0)
+         return (now-t0)*period;
+   }
+
+   return (double)clock() / ( (double)CLOCKS_PER_SEC);
+#elif defined(HX_MACOS)
+   static double time_scale = 0.0;
+   if (time_scale==0.0)
+   {
+      mach_timebase_info_data_t info;
+      mach_timebase_info(&info);
+      time_scale = 1e-9 * (double)info.numer / info.denom;
+   }
+   double r =  mach_absolute_time() * time_scale;
+   return mach_absolute_time() * time_scale;
+#else
+   #if defined(IPHONE) || defined(APPLETV)
+      double t = CACurrentMediaTime();
+   #elif defined(USE_GETTIMEOFDAY)
+      struct timeval tv;
+      if( gettimeofday(&tv,NULL) )
+         return 0;
+      double t =  ( tv.tv_sec + ((double)tv.tv_usec) / 1000000.0 );
+   #elif defined(USE_CLOCK_GETTIME)
+      struct timespec ts;
+      clock_gettime(CLOCK_MONOTONIC, &ts);
+      double t =  ( ts.tv_sec + ((double)ts.tv_nsec)*1e-9  );
+   #else
+      double t = (double)clock() * (1.0 / CLOCKS_PER_SEC);
+   #endif
+   if (t0==0) t0 = t;
+   return t-t0;
+#endif
+}
+
+/*
+ * for the provided Epoch time, fills the passed struct tm with date_time representation in local time zone
+ */
+void __internal_localtime(double inSeconds, struct tm* time)
+{
+   time_t t = (time_t) inSeconds;
+   #ifdef USE_TIME_R
+   localtime_r(&t, time);
+   #else
+   struct tm *result = localtime(&t);
+   if (result)
+      *time = *result;
+   else
+      memset(time, 0, sizeof(*time) );
+   #endif
+}
+
+/*
+ * for the provided Epoch time, fills the passed struct tm with with date_time representation in UTC
+ */
+void __internal_gmtime(double inSeconds, struct tm* time)
+{
+   time_t t = (time_t) inSeconds;
+   #ifdef USE_TIME_R
+   gmtime_r(&t, time);
+   #else
+   *time = *gmtime(&t);
+   #endif
+}
+
+/*
+ * input: takes Y-M-D h:m:s.ms (considers that date parts are in local date_time representation)
+ * output: returns UTC time stamp (Epoch), in seconds
+ */
+double __hxcpp_new_date(int inYear,int inMonth,int inDay,int inHour, int inMin, int inSeconds, int inMilliseconds)
+{
+   struct tm time;
+
+   time.tm_isdst = -1;
+   time.tm_year = inYear - 1900;
+   time.tm_mon = inMonth;
+   time.tm_mday = inDay;
+   time.tm_hour = inHour;
+   time.tm_min = inMin;
+   time.tm_sec = inSeconds;
+
+   return (mktime(&time) + ((double) inMilliseconds * 0.001));
+}
+
+// Used by DateTools.makeUtc
+double __hxcpp_utc_date(int inYear,int inMonth,int inDay,int inHour, int inMin, int inSeconds)
+{
+   int diff;
+   time_t a, b;
+   struct tm time, *temp;
+ 
+   time.tm_year = inYear;
+   time.tm_isdst = -1;
+   time.tm_year = inYear - 1900;
+   time.tm_mon = inMonth;
+   time.tm_mday = inDay;
+   time.tm_hour = inHour;
+   time.tm_min = inMin;
+   time.tm_sec = inSeconds;
+   
+   a =  mktime(&time); //timestamp based on local interpretation of date parts
+   temp = gmtime(&a); //get utc date parts corresponding to this timestamp
+   temp->tm_isdst=-1; //reset dst flag for use in mktime
+   b = mktime(temp); //get timestamp for local interpretation of utc date parts
+   diff= a - b; //find difference in timestamp values .
+   
+   return a+diff; 
+}
+
+/*
+ * returns hh value (in hh:mm:ss) of date_time representation in local time zone
+ */
+int __hxcpp_get_hours(double inSeconds)
+{
+   struct tm time;
+   __internal_localtime( inSeconds, &time);
+   return time.tm_hour;
+}
+
+/*
+ * returns mm value (in hh:mm:ss) of date_time representation in local time zone
+ */
+int __hxcpp_get_minutes(double inSeconds)
+{
+   struct tm time;
+   __internal_localtime( inSeconds, &time);
+   return time.tm_min;
+}
+
+/*
+ * returns ss value (in hh:mm:ss) of date_time representation in local time zone
+ */
+int __hxcpp_get_seconds(double inSeconds)
+{
+   struct tm time;
+   __internal_localtime( inSeconds, &time);
+   return time.tm_sec;
+}
+
+/*
+ * returns YYYY value (in YYYY-MM-DD) of date_time representation in local time zone
+ */
+int __hxcpp_get_year(double inSeconds)
+{
+   struct tm time;
+   __internal_localtime( inSeconds, &time);
+   return (time.tm_year + 1900);
+}
+
+/*
+ * returns MM value (in YYYY-MM-DD) of date_time representation in local time zone
+ */
+int __hxcpp_get_month(double inSeconds)
+{
+   struct tm time;
+   __internal_localtime( inSeconds, &time);
+   return time.tm_mon;
+}
+
+/*
+ * returns DD value (in YYYY-MM-DD) of date_time representation in local time zone
+ */
+int __hxcpp_get_date(double inSeconds)
+{
+   struct tm time;
+   __internal_localtime( inSeconds, &time);
+   return time.tm_mday;
+}
+
+/*
+ * returns week day (as int, Sun=0...Sat=6) of date_time representation in local time zone
+ */
+int __hxcpp_get_day(double inSeconds)
+{
+   struct tm time;
+   __internal_localtime( inSeconds, &time);
+   return time.tm_wday;
+}
+
+/*
+ * returns hh value (in hh:mm:ss) of date_time representation in UTC
+ */
+int __hxcpp_get_utc_hours(double inSeconds)
+{
+   struct tm time;
+   __internal_gmtime( inSeconds, &time);
+   return time.tm_hour;
+}
+
+/*
+ * returns mm value (in hh:mm:ss) of date_time representation in UTC
+ */
+int __hxcpp_get_utc_minutes(double inSeconds)
+{
+   struct tm time;
+   __internal_gmtime( inSeconds, &time);
+   return time.tm_min;
+}
+
+/*
+ * returns ss value (in hh:mm:ss) of date_time representation in UTC
+ */
+int __hxcpp_get_utc_seconds(double inSeconds)
+{
+   struct tm time;
+   __internal_gmtime( inSeconds, &time);
+   return time.tm_sec;
+}
+
+/*
+ * returns YYYY value (in YYYY-MM-DD) of date_time representation in UTC
+ */
+int __hxcpp_get_utc_year(double inSeconds)
+{
+   struct tm time;
+   __internal_gmtime( inSeconds, &time);
+   return (time.tm_year + 1900);
+}
+
+/*
+ * returns MM value (in YYYY-MM-DD) of date_time representation in UTC
+ */
+int __hxcpp_get_utc_month(double inSeconds)
+{
+   struct tm time;
+   __internal_gmtime( inSeconds, &time);
+   return time.tm_mon;
+}
+
+/*
+ * returns DD value (in YYYY-MM-DD) of date_time representation in UTC
+ */
+int __hxcpp_get_utc_date(double inSeconds)
+{
+   struct tm time;
+   __internal_gmtime( inSeconds, &time);
+   return time.tm_mday;
+}
+
+/*
+ * returns week day (as int, Sun=0...Sat=6) of date_time representation in UTC
+ */
+int __hxcpp_get_utc_day(double inSeconds)
+{
+   struct tm time;
+   __internal_gmtime( inSeconds, &time);
+   return time.tm_wday;
+}
+
+/*
+ * similar to __hxcpp_new_date but, takes no date parts as input because, it assumes NOW date_time
+ */
+double __hxcpp_date_now()
+{
+   #ifdef HX_WINDOWS
+   typedef unsigned __int64 uint64_t;
+   static const uint64_t EPOCH = ((uint64_t) 116444736000000000ULL);
+
+   SYSTEMTIME  system_time;
+   FILETIME    file_time;
+   ULARGE_INTEGER ularge;
+
+   GetSystemTime( &system_time );
+   SystemTimeToFileTime( &system_time, &file_time );
+
+   ularge.LowPart = file_time.dwLowDateTime;
+   ularge.HighPart = file_time.dwHighDateTime;
+
+   return (double)( (long) ((ularge.QuadPart - EPOCH) / 10000000L) ) +
+          system_time.wMilliseconds*0.001;
+   #elif defined(USE_GETTIMEOFDAY)
+   struct timeval tv;
+   gettimeofday(&tv, 0);
+   return (tv.tv_sec + (((double) tv.tv_usec) / (1000 * 1000)));
+   #else
+   // per-second time resolution. not ideal, but OK given the docs for Date.now
+   time_t t;
+   struct tm ti;
+   time(&t);
+   __internal_localtime((double)t, &ti);
+   return mktime(&ti);
+   #endif
+}
+
+/*
+ * for the input Epoch time, returns whether the corresponding local time would be in DST
+ * 1 : yes, in DST ; 0 : no, not in DST
+ */
+int __hxcpp_is_dst(double inSeconds)
+{
+   struct tm time;
+   __internal_localtime( inSeconds, &time);
+   return time.tm_isdst;
+}
+
+/*
+ * for the input Epoch time, returns the correct timezone offset of local time zone;
+ * return value is in seconds e.g. -28800 (that would be -8 hrs)
+ */
+double __hxcpp_timezone_offset(double inSeconds)
+{
+   struct tm localTime;
+   __internal_localtime( inSeconds, &localTime);
+
+   #if defined(HX_WINDOWS) || defined(__SNC__) || defined(__ORBIS__)
+   struct tm gmTime;
+   __internal_gmtime(inSeconds, &gmTime );
+
+   return mktime(&localTime) - mktime(&gmTime);
+   #else
+   return localTime.tm_gmtoff;
+   #endif
+}
+
+String __internal_to_string(struct tm time)
+{
+   // YYYY-MM-DD hh:mm:ss
+
+   char buf[100];
+   strftime(buf,100, "%Y-%m-%d %H:%M:%S", &time);
+   return String::create(buf);
+}
+
+/*
+ * string form of a given Epoch time, without milliseconds,
+ * as in format [YYYY-MM-DD hh:mm:ss +hhmm] ex: [1997-07-16 19:20:30 +0100].
+ */
+String __hxcpp_to_utc_string(double inSeconds)
+{
+   struct tm time;
+   __internal_gmtime( inSeconds, &time);
+   return __internal_to_string( time);
+}
+
+/*
+ * string form of a given Epoch time, without milliseconds and timezone offset,
+ * as in  format [YYYY-MM-DD hh:mm:ss] ex: [1997-07-16 19:20:30].
+ */
+String __hxcpp_to_string(double inSeconds)
+{
+   struct tm time;
+   __internal_localtime( inSeconds, &time);
+   return __internal_to_string( time);
+}
+
+/*
+ * input: takes Y-M-D h:m:s.ms (considers that date parts are in UTC date_time representation)
+ * output: returns UTC time stamp (Epoch), in seconds
+ */
+double __hxcpp_from_utc(int inYear,int inMonth,int inDay,int inHour, int inMin, int inSeconds, int inMilliseconds)
+{
+   struct tm time;
+
+   time.tm_isdst = -1;
+   time.tm_year  = inYear - 1900;
+   time.tm_mon   = inMonth;
+   time.tm_mday  = inDay;
+   time.tm_hour  = inHour;
+   time.tm_min   = inMin;
+   time.tm_sec   = inSeconds;
+
+   time_t z = mktime(&time);
+   time_t t = z + __hxcpp_timezone_offset(z);
+
+   struct tm local_tm;
+   __internal_localtime( t, &local_tm);
+
+   return (mktime(&local_tm) + ((double) inMilliseconds * 0.001));
+}
+
diff --git a/Sources/c_snikket/src/hx/Debug.cpp b/Sources/c_snikket/src/hx/Debug.cpp
new file mode 100644
index 0000000..25c7d4d
--- /dev/null
+++ b/Sources/c_snikket/src/hx/Debug.cpp
@@ -0,0 +1,573 @@
+#include <hxcpp.h>
+#include <list>
+#include <map>
+#include <vector>
+#include <string>
+#include <hx/Debug.h>
+#include <hx/Thread.h>
+#include <hx/Telemetry.h>
+#include <hx/Unordered.h>
+#include <hx/OS.h>
+
+
+#if defined(HXCPP_CATCH_SEGV) && !defined(_MSC_VER)
+#include <signal.h>
+#endif
+
+
+
+#ifdef HX_WINRT
+#define DBGLOG WINRT_LOG
+#elif defined(ANDROID)
+#include <android/log.h>
+#define DBGLOG(...) __android_log_print(ANDROID_LOG_INFO, "HXCPP", __VA_ARGS__)
+#else
+#include <stdio.h>
+#define DBGLOG printf
+#endif
+
+#if _MSC_VER
+#ifndef snprintf
+#define snprintf _snprintf
+#endif
+#endif
+
+#ifndef __has_builtin
+#define __has_builtin(x) 0
+#endif
+
+
+
+
+namespace hx
+{
+
+const char* EXTERN_CLASS_NAME = "extern";
+
+#ifdef HXCPP_STACK_IDS
+static HxMutex sStackMapMutex;
+typedef UnorderedMap<int, StackContext *> StackMap;
+static StackMap sStackMap;
+#endif
+
+// User settable String->Void
+//  String  : message
+//  You can 'throw' to prevent default action
+static Dynamic sCriticalErrorHandler;
+
+
+static void setStaticHandler(Dynamic &inStore, Dynamic inValue)
+{
+   if ( inStore==null() != inValue==null())
+   {
+      if ( inValue!=null() )
+         GCAddRoot(&inStore.mPtr);
+      else
+         GCRemoveRoot(&inStore.mPtr);
+   }
+   inStore = inValue;
+}
+
+
+
+static void CriticalErrorHandler(String inErr, bool allowFixup)
+{
+#ifdef HXCPP_DEBUGGER
+   if (allowFixup && __hxcpp_dbg_fix_critical_error(inErr))
+      return;
+#endif
+
+#ifdef HXCPP_STACK_TRACE
+   hx::StackContext *ctx = hx::StackContext::getCurrent();
+   ctx->beginCatch(true);
+#endif
+
+   if (sCriticalErrorHandler!=null())
+      sCriticalErrorHandler(inErr);
+
+#ifdef HXCPP_STACK_TRACE
+   ctx->dumpExceptionStack();
+#endif
+
+    DBGLOG("Critical Error: %s\n", inErr.utf8_str());
+
+#if defined(HX_WINDOWS) && !defined(HX_WINRT)
+    MessageBoxA(0, inErr.utf8_str(), "Critical Error - program must terminate",
+        MB_ICONEXCLAMATION|MB_OK);
+#endif
+
+    // Good when using gdb, and to collect a core ...
+    #if __has_builtin(__builtin_trap)
+    __builtin_trap();
+    #else
+    (* (int *) 0) = 0;
+    #endif
+
+    // Just in case that didn't do it ...
+    exit(1);
+}
+
+void CriticalError(const String &inErr, bool inAllowFixup)
+{
+    CriticalErrorHandler(inErr, inAllowFixup);
+}
+
+
+#ifdef HXCPP_CATCH_SEGV
+class hxSehException : public hx::Object
+{
+public:
+   int code;
+
+   inline void *operator new( size_t inSize )
+   {
+      return hx::InternalCreateConstBuffer(0,(int)inSize);
+   }
+   void operator delete( void *) { }
+
+   hxSehException(int inCode) : code(inCode) { }
+
+   String __ToString() const { return  HX_CSTRING("hxSehException"); }
+
+   int __GetType() const { return vtObject; }
+};
+
+static hx::Object *sException = new hxSehException(1);
+
+#ifdef _MSC_VER
+void __cdecl hxSignalFunction(unsigned int, struct _EXCEPTION_POINTERS* )
+{
+   hx::Throw(sException);
+}
+#else
+void hxSignalFunction(int)
+{
+   hx::Throw(sException);
+}
+#endif
+
+#endif
+
+
+String FormatStack(const char *file, const char *clazz, const char *func, int line, bool display)
+{
+   // Not sure if the following is even possible but the old debugger did it so ...
+   char buf[1024];
+   if (!file || file[0]=='?')
+   {
+       if (display)
+          snprintf(buf, sizeof(buf), "%s::%s", clazz, func);
+       else
+          snprintf(buf, sizeof(buf), "%s::%s::%d", clazz, func,line);
+   }
+   else
+   {
+      // Old-style combined file::class...
+      if (!clazz || !clazz[0])
+      {
+          if (line>0 || !display)
+             snprintf(buf, sizeof(buf), display ? "%s %s line %d" : "%s::%s::%d", func, file, line);
+          else
+             snprintf(buf, sizeof(buf), "%s %s", func, file);
+      }
+      else
+      {
+          if (line>0 || !display)
+             snprintf(buf, sizeof(buf), display ? "%s::%s %s line %d" : "%s::%s::%s::%d", clazz, func, file, line);
+          else
+             snprintf(buf, sizeof(buf), "%s::%s %s", clazz, func, file);
+      }
+   }
+   return ::String(buf);
+}
+
+
+
+
+
+
+StackContext::StackContext()
+{
+   #ifdef HXCPP_STACK_TRACE
+   mIsUnwindingException = false;
+   #endif
+
+   #if HXCPP_TELEMETRY
+   mTelemetry = tlmCreate(this);
+   #endif
+
+   #ifdef HXCPP_DEBUGGER
+   mDebugger = 0;
+   #endif
+
+   #ifdef HXCPP_PROFILER
+   mProfiler = 0;
+   #endif
+
+   #ifdef HXCPP_SCRIPTABLE
+   stack = new unsigned char[128*1024];
+   pointer = &stack[0];
+   push((hx::Object *)0);
+   frame = pointer;
+   exception = 0;
+   breakContReturn = 0;
+   #endif
+
+   #ifdef HXCPP_COMBINE_STRINGS
+   stringSet = 0;
+   #endif
+}
+
+StackContext::~StackContext()
+{
+   #ifdef HXCPP_DEBUGGER
+   if (mDebugger)
+      dbgCtxDestroy(mDebugger);
+   #endif
+
+   #ifdef HXCPP_TELEMETRY
+   if (mTelemetry)
+      tlmDestroy(mTelemetry);
+   #endif
+
+   #ifdef HXCPP_PROFILER
+   if (mProfiler)
+      profDestroy(mProfiler);
+   #endif
+
+   #ifdef HXCPP_SCRIPTABLE
+   delete [] stack;
+   #endif
+}
+
+void StackContext::onThreadAttach()
+{
+   #ifdef HXCPP_STACK_IDS
+   mThreadId = __hxcpp_GetCurrentThreadNumber();
+
+   sStackMapMutex.Lock();
+   sStackMap[mThreadId] = this;
+   sStackMapMutex.Unlock();
+   #endif
+
+   #ifdef HXCPP_DEBUGGER
+   if (!mDebugger)
+      mDebugger = dbgCtxCreate(this);
+   if (mDebugger)
+      dbgCtxAttach(mDebugger,this);
+   #endif
+
+   #ifdef HXCPP_TELEMETRY
+   if (mTelemetry)
+      tlmAttach(mTelemetry,this);
+   #endif
+
+   #ifdef HXCPP_PROFILER
+   if (mProfiler)
+      profAttach(mProfiler,this);
+   #endif
+
+   #ifdef HXCPP_CATCH_SEGV
+      #ifdef _MSC_VER
+      mOldSignalFunc = _set_se_translator( hxSignalFunction );
+      #else
+      mOldSignalFunc = signal( SIGSEGV, hxSignalFunction );
+      #endif
+   #endif
+}
+
+void StackContext::onThreadDetach()
+{
+   #ifdef HXCPP_CATCH_SEGV
+      #ifdef _MSC_VER
+      _set_se_translator( mOldSignalFunc );
+      #else
+      signal( SIGSEGV, mOldSignalFunc );
+      #endif
+   #endif
+
+   #ifdef HXCPP_DEBUGGER
+   if (mDebugger)
+      dbgCtxDetach(mDebugger);
+   #endif
+
+   #ifdef HXCPP_TELEMETRY
+   if (mTelemetry)
+      tlmDetach(mTelemetry);
+   #endif
+
+   #ifdef HXCPP_PROFILER
+   if (mProfiler)
+      profDetach(mProfiler,this);
+   #endif
+
+   #ifdef HXCPP_STACK_IDS
+   sStackMapMutex.Lock();
+   sStackMap.erase(mThreadId);
+   sStackMapMutex.Unlock();
+   mThreadId = 0;
+   #endif
+
+   #ifdef HXCPP_COMBINE_STRINGS
+   stringSet = 0;
+   #endif
+}
+
+#ifdef HXCPP_STACK_IDS
+void StackContext::getAllStackIds( QuickVec<int> &outIds )
+{
+   outIds.clear();
+   sStackMapMutex.Lock();
+   for(StackMap::iterator i=sStackMap.begin(); i!=sStackMap.end(); ++i)
+      outIds.push(i->first);
+   sStackMapMutex.Unlock();
+}
+
+StackContext *StackContext::getStackForId(int id)
+{
+   sStackMapMutex.Lock();
+   StackContext *result = sStackMap[id];
+   sStackMapMutex.Unlock();
+   return result;
+}
+#endif
+
+
+#ifdef HXCPP_STACK_TRACE // {
+
+void StackContext::tracePosition( )
+{
+   StackFrame *frame = mStackFrames[mStackFrames.size()-1];
+   #ifdef HXCPP_STACK_LINE
+   DBGLOG("%s::%s : %d\n", frame->position->className, frame->position->functionName, frame->lineNumber);
+   #else
+   DBGLOG("%s::%s\n", frame->position->className, frame->position->functionName);
+   #endif
+}
+
+void StackContext::getCurrentCallStackAsStrings(Array<String> result, bool skipLast)
+{
+   int n = mStackFrames.size() - (skipLast ? 1 : 0);
+
+   for (int i = 0; i < n; i++)
+   {
+       // Reverse call stack to match exception stack
+       StackFrame *frame = mStackFrames[n-1-i];
+       result->push(frame->toString());
+   }
+}
+
+void StackContext::getCurrentExceptionStackAsStrings(Array<String> result)
+{
+   int size = mExceptionStack.size();
+
+   for (int i = 0; i < size; i++)
+   {
+      result->push(mExceptionStack[i].toString());
+   }
+}
+
+void StackContext::beginCatch(bool inAll)
+{
+   if (inAll)
+   {
+      mExceptionStack.clear();
+      // Copy remaineder of stack frames to exception stack...
+      // This will use the default operator=, which will copy the pointers.
+      // This is what we want, since the pointers are pointers to constant data
+      for(int i=mStackFrames.size()-1;i>=0;--i)
+         mExceptionStack.push( *mStackFrames[i] );
+   }
+   // Lock-in the excpetion stack
+   mIsUnwindingException = false;
+}
+
+
+
+// Called when a throw occurs
+void StackContext::setLastException()
+{
+   mExceptionStack.clear();
+   mIsUnwindingException = true;
+}
+
+
+// Called when a throw occurs
+void StackContext::pushLastException()
+{
+   mIsUnwindingException = true;
+}
+
+
+
+void StackContext::dumpExceptionStack()
+{
+   #ifdef ANDROID
+   #define EXCEPTION_PRINT(...) \
+        __android_log_print(ANDROID_LOG_ERROR, "HXCPP", __VA_ARGS__)
+   #else
+   #define EXCEPTION_PRINT(...) \
+           printf(__VA_ARGS__)
+   #endif
+
+   int size = mExceptionStack.size();
+   for(int i = size - 1; i >= 0; i--)
+   {
+      EXCEPTION_PRINT("Called from %s\n", mExceptionStack[i].toDisplay().utf8_str());
+   }
+}
+
+
+// ---- StackFrame -------
+
+
+::String StackFrame::toDisplay()
+{
+   #ifndef HXCPP_STACK_LINE
+   int lineNumber=0;
+   #endif
+   return FormatStack(position->fileName, position->className, position->functionName, lineNumber,true);
+}
+
+
+::String StackFrame::toString()
+{
+   #ifndef HXCPP_STACK_LINE
+   int lineNumber=0;
+   #endif
+
+   return FormatStack(position->fileName, position->className, position->functionName, lineNumber,false);
+}
+
+
+
+
+ExceptionStackFrame::ExceptionStackFrame(const StackFrame &inFrame)
+{
+   // It is safe to use the pointer in 331+
+   position = inFrame.position;
+
+   #ifdef HXCPP_STACK_LINE
+   line = inFrame.lineNumber;
+   #endif
+}
+
+::String ExceptionStackFrame::format(bool inForDisplay)
+{
+   #ifndef HXCPP_STACK_LINE
+   int line=0;
+   #endif
+
+   const char *fileName = position->fileName;
+   const char *className = position->className;
+   const char *functionName = position->functionName;
+
+   return FormatStack(fileName, className, functionName, line, inForDisplay);
+}
+
+::String ExceptionStackFrame::toDisplay() { return format(true); }
+::String ExceptionStackFrame::toString() { return format(false); }
+
+
+#endif // } HXCPP_STACK_TRACE
+
+
+HXCPP_EXTERN_CLASS_ATTRIBUTES void NullReference(const char *type, bool allowFixup)
+{
+#ifdef HXCPP_DEBUGGER
+   String err(HX_CSTRING("Null ") + String(type) + HX_CSTRING(" Reference"));
+   if (__hxcpp_dbg_fix_critical_error(err))
+      return;
+#endif
+
+   __hxcpp_dbg_checkedThrow(HX_CSTRING("Null Object Reference"));
+}
+
+
+} // end namspace hx
+
+#ifndef HXCPP_DEBUGGER
+void __hxcpp_execution_trace(int inLevel) { }
+#endif
+
+
+void __hx_dump_stack()
+{
+#ifdef HXCPP_STACK_TRACE
+   hx::StackContext *ctx = hx::StackContext::getCurrent();
+   ctx->beginCatch(false);
+   ctx->dumpExceptionStack();
+#endif
+}
+
+
+void __hx_stack_set_last_exception()
+{
+#ifdef HXCPP_STACK_TRACE
+   hx::StackContext *ctx = hx::StackContext::getCurrent();
+   ctx->setLastException();
+#endif
+}
+
+
+void __hx_stack_push_last_exception()
+{
+#ifdef HXCPP_STACK_TRACE
+   hx::StackContext *ctx = hx::StackContext::getCurrent();
+   ctx->pushLastException();
+#endif
+}
+
+
+void __hxcpp_stack_begin_catch()
+{
+#ifdef HXCPP_STACK_TRACE
+   hx::StackContext *ctx = hx::StackContext::getCurrent();
+   ctx->beginCatch(false);
+#endif
+}
+
+
+Array<String> __hxcpp_get_call_stack(bool inSkipLast)
+{
+    Array<String> result = Array_obj<String>::__new();
+
+#ifdef HXCPP_STACK_TRACE
+   hx::StackContext *ctx = hx::StackContext::getCurrent();
+   ctx->getCurrentCallStackAsStrings(result,inSkipLast);
+#endif
+   return result;
+}
+
+
+Array<String> __hxcpp_get_exception_stack()
+{
+    Array<String> result = Array_obj<String>::__new();
+
+#ifdef HXCPP_STACK_TRACE
+   hx::StackContext *ctx = hx::StackContext::getCurrent();
+   ctx->getCurrentExceptionStackAsStrings(result);
+#endif
+
+    return result;
+}
+
+void __hxcpp_set_critical_error_handler(Dynamic inHandler)
+{
+   hx::setStaticHandler(hx::sCriticalErrorHandler,inHandler);
+}
+
+#ifndef HXCPP_DEBUGGER
+void __hxcpp_set_debugger_info(const char **inAllClasses, const char **inFullPaths) { }
+#endif
+
+
+#ifndef HXCPP_PROFILER
+void __hxcpp_start_profiler(::String inDumpFile)
+{
+   DBGLOG("Warning - profiler has no effect without HXCPP_PROFILER\n");
+}
+void __hxcpp_stop_profiler() { }
+#endif
+
+
diff --git a/Sources/c_snikket/src/hx/Hash.cpp b/Sources/c_snikket/src/hx/Hash.cpp
new file mode 100644
index 0000000..61a6f6f
--- /dev/null
+++ b/Sources/c_snikket/src/hx/Hash.cpp
@@ -0,0 +1,1242 @@
+#include <hxcpp.h>
+#include "Hash.h"
+
+
+using namespace hx;
+
+
+// --- HashRoot ---------------------------------------------------
+
+int __root_hash_size(Dynamic &rtHash)
+{
+   HashRoot *hash = static_cast<HashRoot *>(rtHash.GetPtr());
+   if(!hash)
+      return 0;
+   return hash->getSize();
+}
+
+
+// --- IntHash ----------------------------------------------------
+
+namespace
+{
+typedef hx::HashBase<int>                   IntHashBase;
+typedef hx::Hash< TIntElement<Dynamic> >    IntHashObject;
+typedef hx::Hash< TIntElement<int> >        IntHashInt;
+typedef hx::Hash< TIntElement<Float> >      IntHashFloat;
+typedef hx::Hash< TIntElement<String> >     IntHashString;
+typedef hx::Hash< TIntElement<cpp::Int64> > IntHashInt64;
+}
+
+void __int_hash_set(HX_MAP_THIS_ARG,int inKey,const Dynamic &value)
+{
+   IntHashBase *hash = static_cast<IntHashBase *>(ioHash.GetPtr());
+   if (!hash)
+   {
+      if (value==null())
+      {
+         hash = new IntHashObject();
+      }
+      else
+      {
+         hxObjectType type = (hxObjectType)value->__GetType();
+         switch (type)
+         {
+            case vtInt   : hash = new IntHashInt(); break;
+            case vtFloat : hash = new IntHashFloat(); break;
+            case vtString: hash = new IntHashString(); break;
+            case vtInt64 : hash = new IntHashInt64(); break;
+            default      : hash = new IntHashObject(); break;
+         }
+      }
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+   else if (hash->store!=hashObject)
+   {
+      HashStore want = hashObject;
+      if (value!=null())
+      {
+         hxObjectType type = (hxObjectType)value->__GetType();
+         if (type==vtInt)
+         {
+            if (hash->store==hashFloat)
+               want = hashFloat;
+            else if (hash->store==hashInt)
+               want = hashInt;
+            else if (hash->store==hashInt64)
+               want = hashInt64;
+         }
+         else if (type==vtFloat)
+         {
+            if (hash->store==hashInt || hash->store==hashFloat)
+               want = hashFloat;
+         }
+         else if (type==vtString)
+         {
+            if (hash->store==hashString)
+               want = hashString;
+         }
+         else if (type==vtInt64)
+         {
+            if (hash->store==hashInt || hash->store==hashInt64)
+               want = hashInt64;
+         }
+      }
+      if (hash->store!=want)
+      {
+         hash = hash->convertStore(want);
+         ioHash = hash;
+         HX_OBJ_WB_GET(owner,hash);
+      }
+   }
+
+   hash->set(inKey,value);
+}
+
+void __int_hash_set_int(HX_MAP_THIS_ARG,int inKey,int inValue)
+{
+   IntHashBase *hash = static_cast<IntHashBase *>(ioHash.GetPtr());
+   if (!hash)
+   {
+      hash = new IntHashInt();
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+   else if (hash->store==hashString)
+   {
+      hash = hash->convertStore(hashObject);
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+
+   hash->set(inKey,inValue);
+}
+
+
+void __int_hash_set_float(HX_MAP_THIS_ARG,int inKey,Float inValue)
+{
+   IntHashBase *hash = static_cast<IntHashBase *>(ioHash.GetPtr());
+   if (!hash)
+   {
+      hash = new IntHashFloat();
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+   else if (hash->store==hashString || hash->store==hashInt64)
+   {
+      hash = hash->convertStore(hashObject);
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+   else if (hash->store==hashInt)
+   {
+      hash = hash->convertStore(hashFloat);
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+
+   hash->set(inKey,inValue);
+}
+
+
+
+void __int_hash_set_string(HX_MAP_THIS_ARG,int inKey, ::String inValue)
+{
+   IntHashBase *hash = static_cast<IntHashBase *>(ioHash.GetPtr());
+   if (!hash)
+   {
+      hash = new IntHashString();
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+   else if (hash->store==hashInt || hash->store==hashFloat || hash->store==hashInt64)
+   {
+      hash = hash->convertStore(hashObject);
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+
+   hash->set(inKey,inValue);
+}
+
+void __int_hash_set_int64(HX_MAP_THIS_ARG, int inKey, cpp::Int64 inValue)
+{
+   IntHashBase *hash = static_cast<IntHashBase*>(ioHash.GetPtr());
+   if (!hash)
+   {
+      hash = new IntHashInt64();
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+   else if (hash->store==hashInt)
+   {
+      hash = hash->convertStore(hashInt64);
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+   else if (hash->store==hashString || hash->store==hashFloat)
+   {
+      hash = hash->convertStore(hashObject);
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+
+   hash->set(inKey, inValue);
+}
+
+Dynamic  __int_hash_get(Dynamic inHash,int inKey)
+{
+   IntHashBase *hash = static_cast<IntHashBase *>(inHash.GetPtr());
+   if (!hash)
+      return null();
+
+   Dynamic result = null();
+   hash->query(inKey,result);
+   return result;
+}
+
+int  __int_hash_get_int(Dynamic inHash,int inKey)
+{
+   IntHashBase *hash = static_cast<IntHashBase *>(inHash.GetPtr());
+   if (!hash)
+      return 0;
+
+   int result = 0;
+   hash->query(inKey,result);
+   return result;
+}
+
+
+Float  __int_hash_get_float(Dynamic inHash,int inKey)
+{
+   IntHashBase *hash = static_cast<IntHashBase *>(inHash.GetPtr());
+   if (!hash)
+      return 0;
+
+   Float result = 0;
+   hash->query(inKey,result);
+   return result;
+}
+
+String  __int_hash_get_string(Dynamic inHash,int inKey)
+{
+   IntHashBase *hash = static_cast<IntHashBase *>(inHash.GetPtr());
+   if (!hash)
+      return String();
+
+   String result;
+   hash->query(inKey,result);
+   return result;
+}
+
+cpp::Int64 __int_hash_get_int64(Dynamic inHash, int inKey)
+{
+   IntHashBase *hash = static_cast<IntHashBase*>(inHash.GetPtr());
+   if (!hash)
+      return 0;
+
+   cpp::Int64 result = 0;
+   hash->query(inKey, result);
+   return result;
+}
+
+
+bool  __int_hash_exists(Dynamic &ioHash,int inKey)
+{
+   IntHashBase *hash = static_cast<IntHashBase *>(ioHash.GetPtr());
+   if (!hash)
+      return false;
+   return hash->exists(inKey);
+}
+
+bool  __int_hash_remove(Dynamic &ioHash,int inKey)
+{
+   IntHashBase *hash = static_cast<IntHashBase *>(ioHash.GetPtr());
+   if (!hash)
+      return false;
+   return hash->remove(inKey);
+}
+
+Array<int> __int_hash_keys(Dynamic &ioHash)
+{
+   IntHashBase *hash = static_cast<IntHashBase *>(ioHash.GetPtr());
+   if (!hash)
+      return Array_obj<int>::__new();
+   return hash->keys();
+}
+
+Dynamic __int_hash_values(Dynamic &ioHash)
+{
+   IntHashBase *hash = static_cast<IntHashBase *>(ioHash.GetPtr());
+   if (!hash)
+      return Array_obj<Dynamic>::__new();
+   return hash->values();
+}
+
+
+String __int_hash_to_string(Dynamic &ioHash)
+{
+   IntHashBase *hash = static_cast<IntHashBase *>(ioHash.GetPtr());
+   if (hash)
+      return hash->toString();
+   #if (HXCPP_API_LEVEL >= 430)
+   return HX_CSTRING("[]");
+   #else
+   return HX_CSTRING("{}");
+   #endif
+}
+
+void __int_hash_clear(Dynamic &ioHash)
+{
+   IntHashBase *hash = static_cast<IntHashBase *>(ioHash.GetPtr());
+   if (hash)
+      hash->clear();
+}
+
+// --- Int64Hash -----------------------------------------------------
+
+
+namespace
+{
+typedef hx::HashBase<cpp::Int64>              Int64HashBase;
+typedef hx::Hash< TInt64Element<Dynamic> >    Int64HashObject;
+typedef hx::Hash< TInt64Element<int> >        Int64HashInt;
+typedef hx::Hash< TInt64Element<Float> >      Int64HashFloat;
+typedef hx::Hash< TInt64Element<String> >     Int64HashString;
+typedef hx::Hash< TInt64Element<cpp::Int64> > Int64HashInt64;
+}
+
+void __int64_hash_set(HX_MAP_THIS_ARG, cpp::Int64 inKey, const Dynamic &value)
+{
+   Int64HashBase *hash = static_cast<Int64HashBase *>(ioHash.GetPtr());
+   if (!hash)
+   {
+      if (value==null())
+      {
+         hash = new Int64HashObject();
+      }
+      else
+      {
+         hxObjectType type = (hxObjectType)value->__GetType();
+         switch (type)
+         {
+            case vtInt: hash = new Int64HashInt(); break;
+            case vtFloat: hash = new Int64HashFloat(); break;
+            case vtString: hash = new Int64HashString(); break;
+            case vtInt64: hash = new Int64HashInt64(); break;
+            default: hash = new Int64HashObject(); break;
+         }
+      }
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner, hash);
+   }
+   else if (hash->store != hashObject)
+   {
+      HashStore want = hashObject;
+      if (value!=null())
+      {
+         hxObjectType type = (hxObjectType)value->__GetType();
+         if (type==vtInt)
+         {
+            if (hash->store==hashFloat)
+               want = hashFloat;
+            else if (hash->store==hashInt)
+               want = hashInt;
+            else if (hash->store==hashInt64)
+               want = hashInt64;
+         }
+         else if (type==vtFloat)
+         {
+            if (hash->store==hashInt || hash->store==hashFloat)
+               want = hashFloat;
+         }
+         else if (type==vtString)
+         {
+            if (hash->store==hashString)
+               want = hashString;
+         }
+      }
+      if (hash->store!=want)
+      {
+         hash = hash->convertStore(want);
+         ioHash = hash;
+         HX_OBJ_WB_GET(owner, hash);
+      }
+   }
+
+   hash->set(inKey, value);
+}
+
+void __int64_hash_set_int(HX_MAP_THIS_ARG, cpp::Int64 inKey, int inValue)
+{
+   Int64HashBase *hash = static_cast<Int64HashBase *>(ioHash.GetPtr());
+   if (!hash)
+   {
+      hash = new Int64HashInt();
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner, hash);
+   }
+   else if (hash->store==hashString)
+   {
+      hash = hash->convertStore(hashObject);
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner, hash);
+   }
+
+   hash->set(inKey, inValue);
+}
+
+void __int64_hash_set_float(HX_MAP_THIS_ARG, cpp::Int64 inKey, Float inValue)
+{
+   Int64HashBase *hash = static_cast<Int64HashBase *>(ioHash.GetPtr());
+   if (!hash)
+   {
+      hash = new Int64HashFloat();
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner, hash);
+   }
+   else if (hash->store==hashString || hash->store==hashInt64)
+   {
+      hash = hash->convertStore(hashObject);
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner, hash);
+   }
+   else if (hash->store==hashInt)
+   {
+      hash = hash->convertStore(hashFloat);
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner, hash);
+   }
+
+   hash->set(inKey, inValue);
+}
+
+void __int64_hash_set_string(HX_MAP_THIS_ARG, cpp::Int64 inKey, ::String inValue)
+{
+   Int64HashBase *hash = static_cast<Int64HashBase *>(ioHash.GetPtr());
+   if (!hash)
+   {
+      hash = new Int64HashString();
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner, hash);
+   }
+   else if (hash->store==hashInt || hash->store==hashFloat || hash->store==hashInt64)
+   {
+      hash = hash->convertStore(hashObject);
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner, hash);
+   }
+
+   hash->set(inKey, inValue);
+}
+
+void __int64_hash_set_int64(HX_MAP_THIS_ARG, cpp::Int64 inKey, cpp::Int64 inValue)
+{
+   Int64HashBase *hash = static_cast<Int64HashBase *>(ioHash.GetPtr());
+   if (!hash)
+   {
+      hash = new Int64HashInt64();
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner, hash);
+   }
+   else if (hash->store==hashInt)
+   {
+      hash = hash->convertStore(hashInt64);
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner, hash);
+   }
+   else if (hash->store==hashString || hash->store==hashFloat)
+   {
+      hash = hash->convertStore(hashObject);
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner, hash);
+   }
+
+   hash->set(inKey, inValue);
+}
+
+Dynamic __int64_hash_get(Dynamic inHash, cpp::Int64 inKey)
+{
+   Int64HashBase *hash = static_cast<Int64HashBase *>(inHash.GetPtr());
+   if (!hash)
+      return null();
+
+   Dynamic result = null();
+   hash->query(inKey, result);
+   return result;
+}
+
+int __int64_hash_get_int(Dynamic inHash, cpp::Int64 inKey)
+{
+   Int64HashBase *hash = static_cast<Int64HashBase *>(inHash.GetPtr());
+   if (!hash)
+      return 0;
+
+   int result = 0;
+   hash->query(inKey, result);
+   return result;
+}
+
+Float __int64_hash_get_float(Dynamic inHash, cpp::Int64 inKey)
+{
+   Int64HashBase *hash = static_cast<Int64HashBase *>(inHash.GetPtr());
+   if (!hash)
+      return 0;
+
+   Float result = 0;
+   hash->query(inKey, result);
+   return result;
+}
+
+String __int64_hash_get_string(Dynamic inHash, cpp::Int64 inKey)
+{
+   Int64HashBase *hash = static_cast<Int64HashBase *>(inHash.GetPtr());
+   if (!hash)
+      return String();
+
+   String result;
+   hash->query(inKey, result);
+   return result;
+}
+
+cpp::Int64 __int64_hash_get_int64(Dynamic inHash, cpp::Int64 inKey)
+{
+   Int64HashBase *hash = static_cast<Int64HashBase *>(inHash.GetPtr());
+   if (!hash)
+      return 0;
+
+   cpp::Int64 result = 0;
+   hash->query(inKey, result);
+   return result;
+}
+
+bool __int64_hash_exists(Dynamic &inHash, cpp::Int64 inKey)
+{
+   Int64HashBase *hash = static_cast<Int64HashBase *>(inHash.GetPtr());
+   if (!hash)
+      return false;
+
+   return hash->exists(inKey);
+}
+
+bool __int64_hash_remove(Dynamic &ioHash, cpp::Int64 inKey)
+{
+   Int64HashBase *hash = static_cast<Int64HashBase *>(ioHash.GetPtr());
+   if (!hash)
+      return false;
+
+   return hash->remove(inKey);
+}
+
+Array<cpp::Int64> __int64_hash_keys(Dynamic &ioHash)
+{
+   Int64HashBase *hash = static_cast<Int64HashBase *>(ioHash.GetPtr());
+   if (!hash)
+      return Array_obj<cpp::Int64>::__new();
+
+   return hash->keys();
+}
+
+Dynamic __int64_hash_values(Dynamic &ioHash)
+{
+   Int64HashBase *hash = static_cast<Int64HashBase *>(ioHash.GetPtr());
+   if (!hash)
+      return Array_obj<Dynamic>::__new();
+
+   return hash->values();
+}
+
+String __int64_hash_to_string(Dynamic &ioHash)
+{
+   Int64HashBase *hash = static_cast<Int64HashBase *>(ioHash.GetPtr());
+   if (!hash)
+      return HX_CSTRING("{}");
+
+   return hash->toString();
+}
+
+void __int64_hash_clear(Dynamic &ioHash)
+{
+   Int64HashBase *hash = static_cast<Int64HashBase *>(ioHash.GetPtr());
+   if (hash)
+      hash->clear();
+}
+
+// --- StringHash ----------------------------------------------------
+
+
+namespace
+{
+typedef hx::HashBase<String>                    StringHashBase;
+typedef hx::Hash< TStringElement<Dynamic> >     StringHashObject;
+typedef hx::Hash< TStringElement<int> >         StringHashInt;
+typedef hx::Hash< TStringElement<Float> >       StringHashFloat;
+typedef hx::Hash< TStringElement<String> >      StringHashString;
+typedef hx::Hash< TStringElement<cpp::Int64> >  StringHashInt64;
+}
+
+
+void __string_hash_set(HX_MAP_THIS_ARG,String inKey,const Dynamic &value, bool inForceDynamic)
+{
+   StringHashBase *hash = static_cast<StringHashBase *>(ioHash.GetPtr());
+   if (!hash)
+   {
+      if (inForceDynamic || value==null() )
+      {
+         hash = new StringHashObject();
+      }
+      else
+      {
+         hxObjectType type = (hxObjectType)value->__GetType();
+         switch (type)
+         {
+            case vtInt   : hash = new StringHashInt(); break;
+            case vtFloat : hash = new StringHashFloat(); break;
+            case vtString: hash = new StringHashString(); break;
+            case vtInt64 : hash = new StringHashInt64(); break;
+            default      : hash = new StringHashObject(); break;
+         }
+      }
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+   else if (hash->store!=hashObject)
+   {
+      HashStore want = hashObject;
+      if (value!=null())
+      {
+         hxObjectType type = (hxObjectType)value->__GetType();
+         if (type==vtInt)
+         {
+            if (hash->store==hashFloat)
+               want = hashFloat;
+            else if (hash->store==hashInt)
+               want = hashInt;
+            else if (hash->store==hashInt64)
+               want = hashInt64;
+         }
+         else if (type==vtFloat)
+         {
+            if (hash->store==hashInt || hash->store==hashFloat)
+               want = hashFloat;
+         }
+         else if (type==vtString)
+         {
+            if (hash->store==hashString)
+               want = hashString;
+         }
+         else if (type==vtInt64)
+         {
+            if (hash->store==hashInt || hash->store==hashInt64)
+               want = hashInt64;
+         }
+      }
+      if (hash->store!=want)
+      {
+         hash = hash->convertStore(want);
+         ioHash = hash;
+         HX_OBJ_WB_GET(owner,hash);
+      }
+   }
+
+   hash->set(inKey,value);
+}
+
+void __string_hash_set_int(HX_MAP_THIS_ARG,String inKey,int inValue)
+{
+   StringHashBase *hash = static_cast<StringHashBase *>(ioHash.GetPtr());
+   if (!hash)
+   {
+      hash = new StringHashInt();
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+   else if (hash->store==hashString)
+   {
+      hash = hash->convertStore(hashObject);
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+
+   hash->set(inKey,inValue);
+}
+
+
+void __string_hash_set_float(HX_MAP_THIS_ARG,String inKey,Float inValue)
+{
+   StringHashBase *hash = static_cast<StringHashBase *>(ioHash.GetPtr());
+   if (!hash)
+   {
+      hash = new StringHashFloat();
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+   else if (hash->store==hashString || hash->store==hashInt64)
+   {
+      hash = hash->convertStore(hashObject);
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+   else if (hash->store==hashInt)
+   {
+      hash = hash->convertStore(hashFloat);
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+
+   hash->set(inKey,inValue);
+}
+
+
+
+void __string_hash_set_string(HX_MAP_THIS_ARG,String inKey, ::String inValue)
+{
+   StringHashBase *hash = static_cast<StringHashBase *>(ioHash.GetPtr());
+   if (!hash)
+   {
+      hash = new StringHashString();
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+   else if (hash->store==hashInt || hash->store==hashFloat || hash->store==hashInt64)
+   {
+      hash = hash->convertStore(hashObject);
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+
+   hash->set(inKey,inValue);
+}
+
+void __string_hash_set_int64(HX_MAP_THIS_ARG, String inKey, cpp::Int64 inValue)
+{
+   StringHashBase *hash = static_cast<StringHashBase *>(ioHash.GetPtr());
+   if (!hash)
+   {
+      hash = new StringHashInt64();
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+   else if (hash->store==hashInt)
+   {
+      hash = hash->convertStore(hashInt64);
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+   else if (hash->store==hashString || hash->store==hashFloat)
+   {
+      hash = hash->convertStore(hashObject);
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+
+   hash->set(inKey, inValue);
+}
+
+::String __string_hash_map_substr(HX_MAP_THIS_ARG,String inKey, int inStart, int inLength)
+{
+   StringHashBase *sash = static_cast<StringHashBase *>(ioHash.GetPtr());
+   if (!sash)
+   {
+      sash = new StringHashInt();
+      ioHash = sash;
+      HX_OBJ_WB_GET(owner,sash);
+   }
+   else if (sash->store!=hashInt)
+   {
+      sash = sash->convertStore(hashInt);
+      ioHash = sash;
+      HX_OBJ_WB_GET(owner,sash);
+   }
+
+   StringHashInt *shi = static_cast<StringHashInt *>(sash);
+
+
+   struct Finder
+   {
+      ::String bigString;
+      int len;
+      int offset;
+
+      Finder(const String &inBigStr, int inStart, int inLength) : bigString(inBigStr), offset(inStart), len(inLength) { }
+
+      bool operator==(const String &inKey) const
+      {
+         if (inKey.length!=len)
+            return false;
+         #ifdef HX_SMART_STRINGS
+         if (inKey.isUTF16Encoded())
+         {
+            // Has no wide chars, so can't match
+            if (!bigString.isUTF16Encoded())
+               return false;
+            return !memcmp(inKey.__w, bigString.__w+offset, sizeof(char16_t)*len);
+         }
+         else if (bigString.isUTF16Encoded())
+         {
+            const char *k = inKey.__s;
+            const char16_t *v = bigString.__w + offset;
+            for(int i=0;i<len;i++)
+               if (k[i] != v[i])
+                  return false;
+            return true;
+         }
+         // fallthough...
+         #endif
+         return !memcmp(inKey.__s, bigString.__s+offset, len);
+      }
+   };
+   Finder finder(inKey, inStart, inLength);
+
+   unsigned int code = inKey.calcSubHash(inStart,inLength);
+   String found;
+   if (shi->findEquivalentKey(found,code,finder))
+      return found;
+   String k = inKey.substr(inStart, inLength);
+   shi->set(k,1);
+   return k;
+}
+
+
+Dynamic  __string_hash_get(Dynamic inHash,String inKey)
+{
+   StringHashBase *hash = static_cast<StringHashBase *>(inHash.GetPtr());
+   if (!hash)
+      return null();
+
+   Dynamic result = null();
+   hash->query(inKey,result);
+   return result;
+}
+
+int  __string_hash_get_int(Dynamic inHash,String inKey)
+{
+   StringHashBase *hash = static_cast<StringHashBase *>(inHash.GetPtr());
+   if (!hash)
+      return null();
+
+   int result = 0;
+   hash->query(inKey,result);
+   return result;
+}
+
+
+Float  __string_hash_get_float(Dynamic inHash,String inKey)
+{
+   StringHashBase *hash = static_cast<StringHashBase *>(inHash.GetPtr());
+   if (!hash)
+      return null();
+
+   Float result = 0;
+   hash->query(inKey,result);
+   return result;
+}
+
+String  __string_hash_get_string(Dynamic inHash,String inKey)
+{
+   StringHashBase *hash = static_cast<StringHashBase *>(inHash.GetPtr());
+   if (!hash)
+      return null();
+
+   String result;
+   hash->query(inKey,result);
+   return result;
+}
+
+cpp::Int64 __string_hash_get_int64(Dynamic inHash,String inKey)
+{
+   StringHashBase *hash = static_cast<StringHashBase *>(inHash.GetPtr());
+   if (!hash)
+      return null();
+
+   cpp::Int64 result = 0;
+   hash->query(inKey,result);
+   return result;
+}
+
+bool  __string_hash_exists(Dynamic &ioHash,String inKey)
+{
+   StringHashBase *hash = static_cast<StringHashBase *>(ioHash.GetPtr());
+   if (!hash)
+      return false;
+   return hash->exists(inKey);
+}
+
+bool  __string_hash_remove(Dynamic &ioHash,String inKey)
+{
+   StringHashBase *hash = static_cast<StringHashBase *>(ioHash.GetPtr());
+   if (!hash)
+      return false;
+   return hash->remove(inKey);
+}
+
+Array<String> __string_hash_keys(Dynamic &ioHash)
+{
+   StringHashBase *hash = static_cast<StringHashBase *>(ioHash.GetPtr());
+   if (!hash)
+      return Array_obj<String>::__new();
+   return hash->keys();
+}
+
+Dynamic __string_hash_values(Dynamic &ioHash)
+{
+   StringHashBase *hash = static_cast<StringHashBase *>(ioHash.GetPtr());
+   if (!hash)
+      return Array_obj<Dynamic>::__new();
+   return hash->values();
+}
+
+String __string_hash_to_string(Dynamic &ioHash)
+{
+   StringHashBase *hash = static_cast<StringHashBase *>(ioHash.GetPtr());
+   if (hash)
+      return hash->toString();
+   #if (HXCPP_API_LEVEL >= 430)
+   return HX_CSTRING("[]");
+   #else
+   return HX_CSTRING("{}");
+   #endif
+}
+
+String __string_hash_to_string_raw(Dynamic &ioHash)
+{
+   StringHashBase *hash = static_cast<StringHashBase *>(ioHash.GetPtr());
+   if (hash)
+      return hash->toStringRaw();
+   return null();
+}
+
+void __string_hash_clear(Dynamic &ioHash)
+{
+   StringHashBase *hash = static_cast<StringHashBase *>(ioHash.GetPtr());
+   if (hash)
+      hash->clear();
+}
+
+
+
+// --- ObjectHash ----------------------------------------------------
+
+
+namespace
+{
+typedef hx::HashBase<Dynamic>                DynamicHashBase;
+
+typedef hx::Hash< TDynamicElement<Dynamic,false> > DynamicHashObject;
+typedef hx::Hash< TDynamicElement<int,false> >    DynamicHashInt;
+typedef hx::Hash< TDynamicElement<Float,false> >   DynamicHashFloat;
+typedef hx::Hash< TDynamicElement<String,false> >  DynamicHashString;
+typedef hx::Hash< TDynamicElement<cpp::Int64,false> >  DynamicHashInt64;
+
+typedef hx::Hash< TDynamicElement<Dynamic,true> > WeakDynamicHashObject;
+typedef hx::Hash< TDynamicElement<int,true> >    WeakDynamicHashInt;
+typedef hx::Hash< TDynamicElement<Float,true> >   WeakDynamicHashFloat;
+typedef hx::Hash< TDynamicElement<String,true> >  WeakDynamicHashString;
+typedef hx::Hash< TDynamicElement<cpp::Int64,true> >  WeakDynamicHashInt64;
+
+#define toRealObject(x)
+}
+
+
+void __object_hash_set(HX_MAP_THIS_ARG,Dynamic inKey,const Dynamic &value,bool inWeakKeys)
+{
+   toRealObject(inKey);
+   DynamicHashBase *hash = static_cast<DynamicHashBase *>(ioHash.GetPtr());
+   if (!hash)
+   {
+      if (value==null())
+      {
+         hash = inWeakKeys ? (DynamicHashBase *)new WeakDynamicHashObject() :
+                             (DynamicHashBase *)new DynamicHashObject();
+      }
+      else
+      {
+         hxObjectType type = (hxObjectType)value->__GetType();
+         switch (type)
+         {
+            case vtInt:
+               hash = inWeakKeys ? (DynamicHashBase *)new WeakDynamicHashInt() :
+                                   (DynamicHashBase *)new DynamicHashInt();
+               break;
+            case vtFloat:
+               hash = inWeakKeys ? (DynamicHashBase *)new WeakDynamicHashFloat() :
+                                   (DynamicHashBase *)new DynamicHashFloat();
+               break;
+            case vtString:
+               hash = inWeakKeys ? (DynamicHashBase *)new WeakDynamicHashString() :
+                                   (DynamicHashBase *)new DynamicHashString();
+               break;
+            case vtInt64:
+               hash = inWeakKeys ? (DynamicHashBase *)new WeakDynamicHashInt64() :
+                                   (DynamicHashBase *)new DynamicHashInt64();
+               break;
+            default:
+               hash = inWeakKeys ? (DynamicHashBase *)new WeakDynamicHashObject() :
+                                   (DynamicHashBase *)new DynamicHashObject();
+               break;
+         }
+      }
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+   else if (hash->store!=hashObject)
+   {
+      HashStore want = hashObject;
+      if (value!=null())
+      {
+         hxObjectType type = (hxObjectType)value->__GetType();
+         if (type==vtInt)
+         {
+            if (hash->store==hashFloat)
+               want = hashFloat;
+            else if (hash->store==hashInt)
+               want = hashInt;
+            else if (hash->store==hashInt64)
+               want = hashInt64;
+         }
+         else if (type==vtFloat)
+         {
+            if (hash->store==hashInt || hash->store==hashFloat)
+               want = hashFloat;
+         }
+         else if (type==vtString)
+         {
+            if (hash->store==hashString)
+               want = hashString;
+         }
+         else if (type==vtInt64)
+         {
+            if (hash->store==hashInt || hash->store==hashInt64)
+               want = hashInt64;
+         }
+      }
+      if (hash->store!=want)
+      {
+         hash = hash->convertStore(want);
+         ioHash = hash;
+         HX_OBJ_WB_GET(owner,hash);
+      }
+   }
+
+   hash->set(inKey,value);
+}
+
+void __object_hash_set_int(HX_MAP_THIS_ARG,Dynamic inKey,int inValue,bool inWeakKeys)
+{
+   toRealObject(inKey);
+   DynamicHashBase *hash = static_cast<DynamicHashBase *>(ioHash.GetPtr());
+   if (!hash)
+   {
+      hash = inWeakKeys ? (DynamicHashBase *)new WeakDynamicHashInt() :
+                          (DynamicHashBase *)new DynamicHashInt();
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+   else if (hash->store==hashString)
+   {
+      hash = hash->convertStore(hashObject);
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+
+   hash->set(inKey,inValue);
+}
+
+
+void __object_hash_set_float(HX_MAP_THIS_ARG,Dynamic inKey,Float inValue,bool inWeakKeys)
+{
+   toRealObject(inKey);
+   DynamicHashBase *hash = static_cast<DynamicHashBase *>(ioHash.GetPtr());
+   if (!hash)
+   {
+      hash = inWeakKeys ?  (DynamicHashBase *)new WeakDynamicHashFloat() :
+                           (DynamicHashBase *)new DynamicHashFloat();
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+   else if (hash->store==hashString)
+   {
+      hash = hash->convertStore(hashObject);
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+   else if (hash->store==hashInt || hash->store==hashInt64)
+   {
+      hash = hash->convertStore(hashFloat);
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+
+   hash->set(inKey,inValue);
+}
+
+
+
+void __object_hash_set_string(HX_MAP_THIS_ARG,Dynamic inKey, ::String inValue,bool inWeakKeys)
+{
+   toRealObject(inKey);
+   DynamicHashBase *hash = static_cast<DynamicHashBase *>(ioHash.GetPtr());
+   if (!hash)
+   {
+      hash = inWeakKeys ? (DynamicHashBase *)new WeakDynamicHashString() :
+                          (DynamicHashBase *)new DynamicHashString();
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+   else if (hash->store==hashInt || hash->store==hashFloat || hash->store==hashInt64)
+   {
+      hash = hash->convertStore(hashObject);
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+
+   hash->set(inKey,inValue);
+}
+
+void __object_hash_set_int64(HX_MAP_THIS_ARG,Dynamic inKey, cpp::Int64 inValue,bool inWeakKeys)
+{
+   toRealObject(inKey);
+   DynamicHashBase *hash = static_cast<DynamicHashBase *>(ioHash.GetPtr());
+   if (!hash)
+   {
+      hash = inWeakKeys ?  (DynamicHashBase *)new WeakDynamicHashInt64() :
+                           (DynamicHashBase *)new DynamicHashInt64();
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+   else if (hash->store==hashString || hash->store==hashFloat)
+   {
+      hash = hash->convertStore(hashObject);
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+   else if (hash->store==hashInt)
+   {
+      hash = hash->convertStore(hashInt64);
+      ioHash = hash;
+      HX_OBJ_WB_GET(owner,hash);
+   }
+
+   hash->set(inKey,inValue);
+}
+
+Dynamic  __object_hash_get(Dynamic inHash,Dynamic inKey)
+{
+   toRealObject(inKey);
+   DynamicHashBase *hash = static_cast<DynamicHashBase *>(inHash.GetPtr());
+   if (!hash)
+      return null();
+
+   Dynamic result = null();
+   hash->query(inKey,result);
+   return result;
+}
+
+
+int  __object_hash_get_int(Dynamic inHash,Dynamic inKey)
+{
+   toRealObject(inKey);
+   DynamicHashBase *hash = static_cast<DynamicHashBase *>(inHash.GetPtr());
+   if (!hash)
+      return null();
+
+   int result = 0;
+   hash->query(inKey,result);
+   return result;
+}
+
+
+Float  __object_hash_get_float(Dynamic inHash,Dynamic inKey)
+{
+   toRealObject(inKey);
+   DynamicHashBase *hash = static_cast<DynamicHashBase *>(inHash.GetPtr());
+   if (!hash)
+      return null();
+
+   Float result = 0;
+   hash->query(inKey,result);
+   return result;
+}
+
+
+String  __object_hash_get_string(Dynamic inHash,Dynamic inKey)
+{
+   toRealObject(inKey);
+   DynamicHashBase *hash = static_cast<DynamicHashBase *>(inHash.GetPtr());
+   if (!hash)
+      return null();
+
+   String result;
+   hash->query(inKey,result);
+   return result;
+}
+
+
+cpp::Int64 __object_hash_get_int64(Dynamic inHash,Dynamic inKey)
+{
+   toRealObject(inKey);
+   DynamicHashBase *hash = static_cast<DynamicHashBase *>(inHash.GetPtr());
+   if (!hash)
+      return null();
+
+   cpp::Int64 result = 0;
+   hash->query(inKey,result);
+   return result;
+}
+
+
+
+bool  __object_hash_exists(Dynamic &ioHash,Dynamic inKey)
+{
+   toRealObject(inKey);
+   DynamicHashBase *hash = static_cast<DynamicHashBase *>(ioHash.GetPtr());
+   if (!hash)
+      return false;
+   return hash->exists(inKey);
+}
+
+bool  __object_hash_remove(Dynamic &ioHash,Dynamic inKey)
+{
+   toRealObject(inKey);
+   DynamicHashBase *hash = static_cast<DynamicHashBase *>(ioHash.GetPtr());
+   if (!hash)
+      return false;
+   return hash->remove(inKey);
+}
+
+Array<Dynamic> __object_hash_keys(Dynamic &ioHash)
+{
+   DynamicHashBase *hash = static_cast<DynamicHashBase *>(ioHash.GetPtr());
+   if (!hash)
+      return Array_obj<String>::__new();
+   return hash->keys();
+}
+
+Dynamic __object_hash_values(Dynamic &ioHash)
+{
+   DynamicHashBase *hash = static_cast<DynamicHashBase *>(ioHash.GetPtr());
+   if (!hash)
+      return Array_obj<Dynamic>::__new();
+   return hash->values();
+}
+
+String __object_hash_to_string(Dynamic &ioHash)
+{
+   DynamicHashBase *hash = static_cast<DynamicHashBase *>(ioHash.GetPtr());
+   if (hash)
+      return hash->toString();
+   #if (HXCPP_API_LEVEL >= 430)
+   return HX_CSTRING("[]");
+   #else
+   return HX_CSTRING("{}");
+   #endif
+}
+
+void __object_hash_clear(Dynamic &ioHash)
+{
+   DynamicHashBase *hash = static_cast<DynamicHashBase *>(ioHash.GetPtr());
+   if (hash)
+      hash->clear();
+}
+
diff --git a/Sources/c_snikket/src/hx/Hash.h b/Sources/c_snikket/src/hx/Hash.h
new file mode 100644
index 0000000..0fde32d
--- /dev/null
+++ b/Sources/c_snikket/src/hx/Hash.h
@@ -0,0 +1,827 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef HXCPP_TELEMETRY
+extern void __hxt_new_hash(void* obj, int size);
+#endif
+
+namespace hx
+{
+
+
+inline unsigned int HashCalcHash(int inKey) { return inKey; }
+inline unsigned int HashCalcHash(cpp::Int64 inKey) { return (unsigned int)((inKey >> 32) ^ inKey); }
+inline unsigned int HashCalcHash(const String &inKey) { return inKey.hash(); }
+inline unsigned int HashCalcHash(const Dynamic &inKey)
+{
+   return __hxcpp_obj_hash(inKey);
+}
+
+inline void HashClear(int &ioValue) { }
+inline void HashClear(Dynamic &ioValue) { ioValue=null(); }
+inline void HashClear(String &ioValue) { ioValue=String(); }
+inline void HashClear(Float &ioValue) {  }
+inline void HashClear(cpp::Int64 &ioValue) { }
+
+template<typename T>
+struct NeedsMarking { enum { Yes = 0 }; };
+template<> struct NeedsMarking<Dynamic> { enum { Yes = 1 }; };
+template<> struct NeedsMarking<String> { enum { Yes = 1 }; };
+
+// An int element has key = hash
+template<typename VALUE>
+struct TIntElement
+{
+   typedef int   Key;
+   typedef VALUE Value;
+
+   enum { IgnoreHash = 1 };
+   enum { WeakKeys = 0 };
+   enum { ManageKeys = 0 };
+
+   typedef TIntElement<int>        IntValue;
+   typedef TIntElement<Float>      FloatValue;
+   typedef TIntElement<Dynamic>    DynamicValue;
+   typedef TIntElement<String>     StringValue;
+   typedef TIntElement<cpp::Int64> Int64Value;
+
+public:
+   inline void  setKey(int inKey, unsigned int )
+   {
+      key = inKey;
+   }
+   inline unsigned int getHash()   { return key; }
+
+   Value               value;
+   Key                 key;
+   TIntElement<VALUE>  *next;
+};
+
+//
+template<typename VALUE>
+struct TInt64Element
+{
+   typedef cpp::Int64 Key;
+   typedef VALUE Value;
+
+   enum { IgnoreHash = 0 };
+   enum { WeakKeys = 0 };
+   enum { ManageKeys = 1 };
+
+   typedef TInt64Element<int>        IntValue;
+   typedef TInt64Element<Float>      FloatValue;
+   typedef TInt64Element<Dynamic>    DynamicValue;
+   typedef TInt64Element<String>     StringValue;
+   typedef TInt64Element<cpp::Int64> Int64Value;
+
+public:
+   inline void setKey(cpp::Int64 inKey, unsigned int inHash)
+   {
+      key = inKey;
+      hash = inHash;
+   }
+   inline unsigned int getHash() { return hash; }
+
+   Value                value;
+   Key                  key;
+   unsigned int         hash;
+   TInt64Element<VALUE> *next;
+};
+
+// An string element gets hash from string or calculates it
+template<typename VALUE>
+struct TStringElement
+{
+   typedef String Key;
+   typedef VALUE  Value;
+
+   enum { IgnoreHash = 0 };
+   enum { WeakKeys = 0 };
+   enum { ManageKeys = 1 };
+
+   typedef TStringElement<int>        IntValue;
+   typedef TStringElement<Float>      FloatValue;
+   typedef TStringElement<Dynamic>    DynamicValue;
+   typedef TStringElement<String>     StringValue;
+   typedef TStringElement<cpp::Int64> Int64Value;
+
+
+public:
+   inline void  setKey(String inKey, unsigned int inHash)
+   {
+      key = inKey;
+      hash = inHash;
+   }
+   inline unsigned int getHash() { return hash; }
+
+   Value                  value;
+   Key                    key;
+   unsigned int           hash;
+   TStringElement<VALUE>  *next;
+};
+
+
+struct TWeakStringSet
+{
+   typedef null Value;
+   typedef String Key;
+
+   enum { IgnoreHash = 0 };
+   enum { WeakKeys = 1 };
+   enum { ManageKeys = 1 };
+
+   typedef TWeakStringSet  IntValue;
+   typedef TWeakStringSet  FloatValue;
+   typedef TWeakStringSet  DynamicValue;
+   typedef TWeakStringSet  StringValue;
+   typedef TWeakStringSet  Int64Value;
+
+
+public:
+   inline void  setKey(String inKey, unsigned int inHash)
+   {
+      key = inKey;
+      hash = inHash;
+   }
+   inline unsigned int getHash() { return hash; }
+
+   Key                key;
+   unsigned int       hash;
+   Value              value;
+   TWeakStringSet     *next;
+};
+
+
+struct TNonGcStringSet
+{
+   typedef null Value;
+   typedef String Key;
+
+   enum { IgnoreHash = 0 };
+   enum { WeakKeys = 1 };
+   enum { ManageKeys = 0 };
+
+   typedef TNonGcStringSet  IntValue;
+   typedef TNonGcStringSet  FloatValue;
+   typedef TNonGcStringSet  DynamicValue;
+   typedef TNonGcStringSet  StringValue;
+   typedef TNonGcStringSet  Int64Value;
+
+
+public:
+   inline void  setKey(String inKey, unsigned int inHash)
+   {
+      key = inKey;
+      hash = inHash;
+   }
+   inline unsigned int getHash() { return hash; }
+
+   Key                key;
+   unsigned int       hash;
+   Value              value;
+   TNonGcStringSet    *next;
+};
+
+
+
+
+// An Dyanamic element must use the GC code to get a hash
+template<typename VALUE,bool WEAK>
+struct TDynamicElement
+{
+   typedef Dynamic Key;
+   typedef VALUE   Value;
+
+   enum { IgnoreHash = 0 };
+   enum { WeakKeys = WEAK };
+   enum { ManageKeys = 1 };
+
+   typedef TDynamicElement<int,WEAK>        IntValue;
+   typedef TDynamicElement<Float,WEAK>      FloatValue;
+   typedef TDynamicElement<Dynamic,WEAK>    DynamicValue;
+   typedef TDynamicElement<String,WEAK>     StringValue;
+   typedef TDynamicElement<cpp::Int64,WEAK> Int64Value;
+
+public:
+   inline void  setKey(Dynamic inKey, unsigned int inHash)
+   {
+      key = inKey;
+      hash = inHash;
+   }
+   inline unsigned int getHash() { return hash; }
+
+   Value                        value;
+   Key                          key;
+   unsigned int                 hash;
+   TDynamicElement<VALUE,WEAK>  *next;
+};
+
+
+
+
+enum HashStore
+{
+   hashInt,
+   hashFloat,
+   hashString,
+   hashObject,
+   hashNull,
+   hashInt64
+};
+template<typename T> struct StoreOf{ enum {store=hashObject}; };
+template<> struct StoreOf<int> { enum {store=hashInt}; };
+template<> struct StoreOf< ::String> { enum {store=hashString}; };
+template<> struct StoreOf<Float> { enum {store=hashFloat}; };
+template<> struct StoreOf<null> { enum {store=hashNull}; };
+template<> struct StoreOf<cpp::Int64> { enum {store=hashInt64}; };
+
+namespace
+{
+inline void CopyValue(Dynamic &outValue, const Dynamic &inValue) { outValue = inValue; }
+inline void CopyValue(String &outValue, const String &inValue) { outValue = inValue; }
+inline void CopyValue(String &outValue, Float inValue) {  }
+inline void CopyValue(String &outValue, const Dynamic &inValue) { outValue = inValue; }
+inline void CopyValue(int &outValue, int inValue) { outValue = inValue; }
+inline void CopyValue(int &outValue, cpp::Int64 inValue) { }
+inline void CopyValue(int &outValue, Float inValue) { outValue = inValue; }
+inline void CopyValue(int &outValue, const Dynamic &inValue) { outValue = inValue; }
+inline void CopyValue(int &outValue, const String &inValue) {  }
+inline void CopyValue(Float &outValue, Float inValue) { outValue = inValue; }
+inline void CopyValue(Float &outValue, const Dynamic &inValue) { outValue = inValue; }
+inline void CopyValue(Float &outValue, const String &inValue) {  }
+inline void CopyValue(cpp::Int64 &outValue, cpp::Int64 inValue) { outValue = inValue; }
+inline void CopyValue(cpp::Int64 &outValue, int inValue) { outValue = inValue; }
+inline void CopyValue(cpp::Int64 &outValue, Float inValue) { }
+inline void CopyValue(cpp::Int64 &outValue, const Dynamic &inValue) { outValue = inValue; }
+inline void CopyValue(cpp::Int64 &outValue, const String &inValue) {  }
+inline void CopyValue(null &, const null &) {  }
+template<typename T> inline void CopyValue(T &outValue, const null &) {  }
+template<typename T> inline void CopyValue(null &, const T &) {  }
+}
+
+
+struct HashRoot : public Object
+{
+   HashStore store;
+   int       size;
+   int       mask;
+   int       bucketCount;
+
+    HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdHash };
+
+   virtual void updateAfterGc() = 0;
+
+   inline int getSize() { return size; }
+};
+
+template<typename KEY>
+struct HashBase : public HashRoot
+{
+   HashBase(int inStore)
+   {
+      store = (HashStore)inStore;
+      size = 0;
+      mask = 0;
+      bucketCount = 0;
+   }
+
+
+   virtual bool query(KEY inKey,int &outValue) = 0;
+   virtual bool query(KEY inKey,::String &outValue) = 0;
+   virtual bool query(KEY inKey,Float &outValue) = 0;
+   virtual bool query(KEY inKey,Dynamic &outValue) = 0;
+   virtual bool query(KEY inKey,cpp::Int64 &outValue) = 0;
+
+   virtual void set(KEY inKey, const int &inValue) = 0;
+   virtual void set(KEY inKey, const ::String &inValue) = 0;
+   virtual void set(KEY inKey, const Float &inValue) = 0;
+   virtual void set(KEY inKey, const Dynamic &inValue) = 0;
+   virtual void set(KEY inKey, const cpp::Int64 &inValue) = 0;
+
+   virtual void clear() = 0;
+
+   virtual HashBase<KEY> *convertStore(HashStore inStore) = 0;
+
+   virtual bool remove(KEY inKey) = 0;
+   virtual bool exists(KEY inKey) = 0;
+   virtual Array<KEY> keys() = 0;
+   virtual Dynamic values() = 0;
+
+   virtual ::String toStringRaw() { return toString(); }
+};
+
+extern void RegisterWeakHash(HashBase<Dynamic> *);
+extern void RegisterWeakHash(HashBase< ::String> *);
+
+inline void RegisterWeakHash(HashBase<int> *) { };
+inline void RegisterWeakHash(HashBase<cpp::Int64> *) { };
+
+
+template<typename T>
+struct ArrayValueOf{ typedef T Value; };
+template<> struct ArrayValueOf<null> { typedef Dynamic Value; };
+
+template<typename ELEMENT>
+struct Hash : public HashBase< typename ELEMENT::Key >
+{
+   using HashRoot::size;
+   using HashRoot::mask;
+   using HashRoot::bucketCount;
+   using HashRoot::getSize;
+
+   typedef typename ELEMENT::Key   Key;
+   typedef typename ELEMENT::Value Value;
+   typedef typename ArrayValueOf<Value>::Value ArrayValue;
+
+   typedef ELEMENT Element;
+   enum { IgnoreHash = Element::IgnoreHash };
+
+
+   ELEMENT **bucket;
+
+
+   Hash() : HashBase<Key>( StoreOf<Value>::store )
+   {
+      bucket = 0;
+      if (ELEMENT::WeakKeys && Element::ManageKeys)
+         RegisterWeakHash(this);
+   }
+
+   template<typename T>
+   bool TIsWeakRefValid(T &) { return true; }
+   bool TIsWeakRefValid(Dynamic &key) { return IsWeakRefValid(key.mPtr); }
+   bool TIsWeakRefValid(String &key) { return IsWeakRefValid(key.raw_ptr()); }
+
+
+   void updateAfterGc()
+   {
+      if (Element::WeakKeys && Element::ManageKeys)
+      {
+         for(int b=0;b<bucketCount;b++)
+         {
+            Element **headPtr = &bucket[b];
+            while(*headPtr)
+            {
+               Element &el = **headPtr;
+               if (!TIsWeakRefValid(el.key))
+               {
+                  *headPtr = el.next;
+                  size--;
+               }
+               else
+                  headPtr = &el.next;
+            }
+         }
+      }
+   }
+
+   void rebucket(int inNewCount)
+   {
+#ifdef HXCPP_TELEMETRY
+      bool is_new = bucket==0;
+#endif
+      mask = inNewCount-1;
+      //printf("expand %d -> %d\n",bucketCount, inNewCount);
+      bucket = (Element **)InternalRealloc(bucketCount*sizeof(ELEMENT *), bucket,inNewCount*sizeof(ELEMENT *));
+      HX_OBJ_WB_GET(this, bucket);
+      //for(int b=bucketCount;b<inNewCount;b++)
+      //   bucket[b] = 0;
+
+#ifdef HXCPP_TELEMETRY
+      if (is_new) __hxt_new_hash(bucket, inNewCount*sizeof(ELEMENT *));
+#endif
+
+
+      for(int b=0;b<bucketCount;b++)
+      {
+         Element **head = &bucket[b];
+         while(*head)
+         {
+            Element &e = **head;
+            int newBucket = e.getHash()&mask;
+            if ( newBucket != b )
+            {
+               *head = e.next;
+               e.next = bucket[newBucket];
+               bucket[newBucket] = &e;
+            }
+            else
+               head = &e.next;
+         }
+      }
+
+      bucketCount = inNewCount;
+   }
+
+   void reserve(int inSize)
+   {
+      if (inSize<8)
+          inSize = 8;
+
+      expandBuckets(inSize);
+   }
+
+   void compact()
+   {
+      int origSize = bucketCount;
+      int newSize = bucketCount>>1;
+      // printf("compact -> %d\n", newSize);
+      mask = newSize-1;
+      for(int b=newSize; b<bucketCount; b++)
+      {
+         Element *head = bucket[b];
+         if (head)
+         {
+            Element *oldHead = bucket[b-newSize];
+            bucket[b-newSize] = head;
+
+            if (oldHead)
+            {
+               // Append to last element
+               Element **lastPtr = &(head->next);
+               while(*lastPtr)
+                  lastPtr = & (*lastPtr)->next;
+               *lastPtr = oldHead;
+            }
+            bucket[b] = 0;
+         }
+      }
+      bucketCount = newSize;
+      bucket = (Element **)InternalRealloc(origSize*sizeof(ELEMENT *),bucket, sizeof(ELEMENT *)*bucketCount );
+      HX_OBJ_WB_GET(this, bucket);
+   }
+
+   bool remove(Key inKey)
+   {
+      if (!bucket)
+         return false;
+      unsigned int hash = HashCalcHash(inKey);
+      Element **head = bucket + (hash&mask);
+      while(*head)
+      {
+         Element &el = **head;
+         if ( (IgnoreHash || el.getHash()==hash) && el.key==inKey)
+         {
+            *head = el.next;
+            size--;
+            if (bucketCount>8 && size < (bucketCount>>1) )
+               compact();
+            return true;
+         }
+         head = &el.next;
+      }
+      return false;
+   }
+
+   ELEMENT *allocElement()
+   {
+      ELEMENT *result = (ELEMENT *)InternalNew( sizeof(ELEMENT), false );
+      size++;
+      expandBuckets(size);
+      return result;
+   }
+
+   inline void expandBuckets(int inSize)
+   {
+      // Trades memory vs bucket occupancy - more memory is used for elements anyhow, so not too critical
+      enum { LOG_ELEMS_PER_BUCKET = 1 };
+      if ( inSize > (bucketCount<<LOG_ELEMS_PER_BUCKET) )
+      {
+         int newCount = bucketCount;
+         if (newCount==0)
+            newCount = 2;
+         else
+            while( inSize > (newCount<<LOG_ELEMS_PER_BUCKET) )
+               newCount<<=1;
+         if (newCount!=bucketCount)
+            rebucket(newCount);
+      }
+   }
+
+   Element *find(int inHash, Key inKey)
+   {
+      if (!bucket) return 0;
+      Element *head = bucket[inHash & mask];
+      while(head)
+      {
+         if ( (IgnoreHash || head->getHash()==inHash) && head->key==inKey)
+            return head;
+         head = head->next;
+      }
+      return 0;
+   }
+
+   bool exists(Key inKey) { return find( HashCalcHash(inKey), inKey ); }
+
+
+   HashBase<Key> *convertStore(HashStore inStore)
+   {
+      switch(inStore)
+      {
+         case hashInt:
+            return TConvertStore< typename ELEMENT::IntValue >();
+         case hashFloat:
+            return TConvertStore< typename ELEMENT::FloatValue >();
+         case hashString:
+            return TConvertStore< typename ELEMENT::StringValue >();
+         case hashObject:
+            return TConvertStore< typename ELEMENT::DynamicValue >();
+         case hashInt64:
+            return TConvertStore< typename ELEMENT::Int64Value >();
+         case hashNull:
+             ;
+      }
+      return 0;
+   }
+
+
+   template<typename OUT_VALUE>
+   bool TQuery(Key inKey,OUT_VALUE &outValue)
+   {
+      Element *result = find( HashCalcHash(inKey), inKey );
+      if (!result)
+         return false;
+      CopyValue(outValue,result->value);
+      return true;
+   }
+
+   bool query(Key inKey,int &outValue) { return TQuery(inKey,outValue); }
+   bool query(Key inKey,::String &outValue) { return TQuery(inKey,outValue); }
+   bool query(Key inKey,Float &outValue) { return TQuery(inKey,outValue); }
+   bool query(Key inKey,Dynamic &outValue) { return TQuery(inKey,outValue); }
+   bool query(Key inKey,cpp::Int64 &outValue) { return TQuery(inKey, outValue); }
+
+
+   Value get(Key inKey)
+   {
+      Element *result = find( HashCalcHash(inKey), inKey );
+      if (result)
+         return result->value;
+      return 0;
+   }
+
+
+   template<typename Finder>
+   bool findEquivalentKey(Key &outKey, int inHash, const Finder &inFinder)
+   {
+      if (!bucket) return false;
+      Element *head = bucket[inHash & mask];
+      while(head)
+      {
+         if ( (IgnoreHash || head->getHash()==inHash) && inFinder==head->key)
+         {
+            outKey = head->key;
+            return true;
+         }
+         head = head->next;
+      }
+      return false;
+   }
+
+   static inline bool IsNursery(const void *inPtr)
+   {
+      return inPtr && !(((unsigned char *)inPtr)[ HX_ENDIAN_MARK_ID_BYTE]);
+   }
+
+   template<typename SET>
+   void TSet(Key inKey, const SET &inValue)
+   {
+      unsigned int hash = HashCalcHash(inKey);
+      Element *el = find(hash,inKey);
+      if (el)
+      {
+         CopyValue(el->value,inValue);
+         if (hx::ContainsPointers<Value>())
+            HX_OBJ_WB_GET(this,hx::PointerOf(el->value));
+         return;
+      }
+      el = allocElement();
+      el->setKey(inKey,hash);
+      CopyValue(el->value,inValue);
+      el->next = bucket[hash&mask];
+      bucket[hash&mask] = el;
+
+      #ifdef HXCPP_GC_GENERATIONAL
+      unsigned char &mark =  ((unsigned char *)(this))[ HX_ENDIAN_MARK_ID_BYTE];
+      if (mark == hx::gByteMarkID)
+      {
+         // Look for nursery objects...
+         if ( IsNursery(el) || IsNursery(hx::PointerOf(el->key)) ||
+             (hx::ContainsPointers<Value>() && IsNursery(hx::PointerOf(el->value)) ) )
+         {
+            mark|=HX_GC_REMEMBERED;
+            (HX_CTX_GET)->pushReferrer(this);
+         }
+      }
+      #endif
+   }
+
+   void set(Key inKey, const int &inValue) { TSet(inKey, inValue); }
+   void set(Key inKey, const ::String &inValue)  { TSet(inKey, inValue); }
+   void set(Key inKey, const Float &inValue)  { TSet(inKey, inValue); }
+   void set(Key inKey, const Dynamic &inValue)  { TSet(inKey, inValue); }
+   void set(Key inKey, const null &inValue)  { TSet(inKey, inValue);  }
+   void set(Key inKey, const cpp::Int64 &inValue) { TSet(inKey, inValue); }
+
+   void clear()
+   {
+      bucket = 0;
+      size = 0;
+      mask = 0;
+      bucketCount = 0;
+   }
+
+
+   template<typename F>
+   void iterate(F &inFunc)
+   {
+      for(int b=0;b<bucketCount;b++)
+      {
+         Element *el = bucket[b];
+         while(el)
+         {
+            inFunc(el);
+            el = el->next;
+         }
+      }
+   }
+
+   // Convert
+   template<typename NEW>
+   struct Converter
+   {
+      NEW *result;
+
+      Converter(NEW *inResult) : result(inResult) { }
+
+      void operator()(typename Hash::Element *elem)
+      {
+         result->set(elem->key,elem->value);
+      }
+   };
+
+
+   template<typename NEW_ELEM>
+   HashBase<Key> *TConvertStore()
+   {
+      Hash<NEW_ELEM> *result = new Hash<NEW_ELEM>();
+
+      result->reserve(getSize()*3/2);
+
+      Converter< Hash<NEW_ELEM> > converter(result);
+
+      iterate(converter);
+
+      return result;
+   }
+
+
+
+   // Keys ...
+   struct KeyBuilder
+   {
+      Array<Key> array;
+
+      KeyBuilder(int inReserve = 0)
+      {
+         array = Array<Key>(0,inReserve);
+      }
+      void operator()(typename Hash::Element *elem)
+      {
+         array->push(elem->key);
+      }
+   };
+   Array<Key> keys()
+   {
+      KeyBuilder builder(getSize());
+      iterate(builder);
+      return builder.array;;
+   }
+
+
+   // Values...
+   struct ValueBuilder
+   {
+      Array<ArrayValue> array;
+      ValueBuilder(int inReserve = 0)
+      {
+         array = Array<ArrayValue>(0,inReserve);
+      }
+
+      void operator()(typename Hash::Element *elem)
+      {
+         array->push(elem->value);
+      }
+   };
+   Dynamic values()
+   {
+      ValueBuilder builder(getSize());
+      iterate(builder);
+      return builder.array;;
+   }
+
+
+   // Strings ...
+   struct StringBuilder
+   {
+      Array<String> array;
+      bool raw;
+
+      StringBuilder(int inReserve = 0,bool inRaw=false)
+      {
+         raw = inRaw;
+         array = Array<String>(0,inReserve*4+1);
+         if (!raw) {
+            #if (HXCPP_API_LEVEL >= 430)
+            array->push(HX_CSTRING("["));
+            #else
+            array->push(HX_CSTRING("{ "));
+            #endif
+         }
+      }
+      void operator()(typename Hash::Element *elem)
+      {
+         if (array->length>1)
+            array->push(HX_CSTRING(", "));
+         array->push(String(elem->key));
+         array->push(HX_CSTRING(" => "));
+         array->push(String(elem->value));
+      }
+      ::String toString()
+      {
+         if (!raw) {
+            #if (HXCPP_API_LEVEL >= 430)
+            array->push(HX_CSTRING("]"));
+            #else
+            array->push(HX_CSTRING(" }"));
+            #endif
+         }
+         return array->length==0 ? String() : array->join(HX_CSTRING(""));
+      }
+   };
+
+   String toString()
+   {
+      StringBuilder builder(getSize());
+      iterate(builder);
+      return builder.toString();
+   }
+
+
+   String toStringRaw()
+   {
+      StringBuilder builder(getSize(),true);
+      iterate(builder);
+      return builder.toString();
+   }
+
+
+   // Mark ...
+   struct HashMarker
+   {
+      hx::MarkContext *__inCtx;
+      HashMarker(hx::MarkContext *ctx) : __inCtx(ctx) { }
+      void operator()(typename Hash::Element *inElem)
+      {
+         HX_MARK_ARRAY(inElem);
+         if (!Hash::Element::WeakKeys)
+         {
+            HX_MARK_MEMBER(inElem->key);
+         }
+         HX_MARK_MEMBER(inElem->value);
+      }
+   };
+
+   void __Mark(hx::MarkContext *__inCtx)
+   {
+      HX_MARK_ARRAY(bucket);
+
+      HashMarker marker(__inCtx);
+      iterate(marker);
+   }
+
+#ifdef HXCPP_VISIT_ALLOCS
+
+   void __Visit(hx::VisitContext *__inCtx)
+   {
+      //printf(" visit hash %p\n", this);
+      HX_VISIT_ARRAY(bucket);
+      for(int b=0;b<bucketCount;b++)
+      {
+         HX_VISIT_ARRAY(bucket[b]);
+         Element *el = bucket[b];
+         while(el)
+         {
+            HX_VISIT_MEMBER(el->key);
+            HX_VISIT_MEMBER(el->value);
+            HX_VISIT_ARRAY(el->next);
+            el = el->next;
+         }
+      }
+   }
+#endif
+};
+
+
+} // end namespace hx
+
diff --git a/Sources/c_snikket/src/hx/Lib.cpp b/Sources/c_snikket/src/hx/Lib.cpp
new file mode 100644
index 0000000..3a1d3f2
--- /dev/null
+++ b/Sources/c_snikket/src/hx/Lib.cpp
@@ -0,0 +1,807 @@
+#include <hxcpp.h>
+
+#include <stdio.h>
+#include <string>
+#include <map>
+#include <vector>
+#include <stdlib.h>
+
+#ifdef ANDROID
+#include <android/log.h>
+#include <unistd.h>
+#endif
+
+#if (defined (IPHONE) || defined(EMSCRIPTEN) || defined(STATIC_LINK) || defined(APPLETV) ) && \
+	!defined(HXCPP_DLL_IMPORT) && (!defined(HXCPP_DLL_EXPORT) || defined(HXCPP_SCRIPTABLE) )
+#define HXCPP_NO_DYNAMIC_LOADING
+#elif !defined(ANDROID) && !defined(HX_WINRT) && !defined(IPHONE) && !defined(EMSCRIPTEN) && \
+	!defined(STATIC_LINK) && !defined(APPLETV)
+#define HXCPP_TRY_HAXELIB
+#endif
+
+#ifdef HXCPP_TRY_HAXELIB
+#include <sys/types.h>
+#include <sys/stat.h>
+#endif
+#if defined(BLACKBERRY)
+using namespace std;
+#endif
+#ifdef HXCPP_LOAD_DEBUG
+bool gLoadDebug = true;
+#else
+bool gLoadDebug = false;
+#endif
+
+#ifdef HXCPP_NO_DYNAMIC_LOADING
+
+typedef void *Module;
+Module hxLoadLibrary(const String &) { return 0; }
+void hxFreeLibrary(Module) { }
+
+#elif defined _WIN32
+
+#include <windows.h>
+typedef HMODULE Module;
+
+#ifdef HX_WINRT
+Module hxLoadLibrary(String inLib) { return LoadPackagedLibrary(inLib.__WCStr(),0); }
+#else // Windows, not WinRT
+Module hxLoadLibrary(String inLib)
+{
+   HMODULE result = LoadLibraryW(inLib.__WCStr());
+   if (gLoadDebug)
+   {
+      if (result)
+         printf("Loaded module : %S.\n", inLib.__WCStr());
+   }
+   return result;
+}
+#endif
+
+void *hxFindSymbol(Module inModule, const char *inSymbol) { return (void *)GetProcAddress(inModule,inSymbol); }
+
+void hxFreeLibrary(Module inModule) { FreeLibrary(inModule); }
+
+#else
+
+typedef void *Module;
+
+#include <dlfcn.h>
+typedef void *Module;
+Module hxLoadLibrary(String inLib)
+{
+   int flags = RTLD_GLOBAL;
+   #if defined(HXCPP_RTLD_LAZY) || defined(IPHONE) || defined(EMSCRIPTEN) || defined(STATIC_LINK) || defined(APPLETV)
+   flags |= RTLD_LAZY;
+   #else
+   flags |= RTLD_NOW;
+   #endif
+   
+   Module result = dlopen(inLib.__CStr(), flags);
+   if (gLoadDebug)
+   {
+#ifdef HX_WINRT
+      if (result)
+         WINRT_LOG("Loaded : %s.\n", inLib.__CStr());
+      else
+         WINRT_LOG("Error loading library: (%s) %s\n", inLib.__CStr(), dlerror());
+#else
+      if (result)
+         printf("Loaded : %s.\n", inLib.__CStr());
+      else
+         printf("Error loading library: (%s) %s\n", inLib.__CStr(), dlerror());
+#endif
+   }
+   return result;
+}
+void *hxFindSymbol(Module inModule, const char *inSymbol) { return dlsym(inModule,inSymbol); }
+
+void hxFreeLibrary(Module inModule) { dlclose(inModule); }
+
+#endif
+
+typedef std::map<std::string,Module> LoadedModule;
+
+static LoadedModule sgLoadedModule;
+typedef std::vector<Module> ModuleList;
+static ModuleList sgOrderedModules;
+
+typedef hx::Object * (*prim_0)();
+typedef hx::Object * (*prim_1)(hx::Object *);
+typedef hx::Object * (*prim_2)(hx::Object *,hx::Object *);
+typedef hx::Object * (*prim_3)(hx::Object *,hx::Object *,hx::Object *);
+typedef hx::Object * (*prim_4)(hx::Object *,hx::Object *,hx::Object *,hx::Object *);
+typedef hx::Object * (*prim_5)(hx::Object *,hx::Object *,hx::Object *,hx::Object *,hx::Object *);
+typedef hx::Object * (*prim_mult)(hx::Object **inArray,int inArgs);
+
+typedef void *(*FundFunc)(); 
+
+
+class ExternalPrimitive : public hx::Object
+{
+public:
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdExternalPrimitive };
+
+   inline void *operator new( size_t inSize )
+     { return hx::InternalCreateConstBuffer(0,(int)inSize); }
+   void operator delete( void *) { }
+
+   ExternalPrimitive(void *inProc,int inArgCount,const String &inName) :
+       mProc(inProc), mArgCount(inArgCount), mName(inName.makePermanent())
+   {
+     functionName = ("extern::cffi "+mName).makePermanent().raw_ptr();
+   }
+
+   virtual int __GetType() const { return vtFunction; }
+   String __ToString() const { return mName; }
+
+   Dynamic __run()
+   {
+      HX_STACK_FRAME(hx::EXTERN_CLASS_NAME, "cffi",0, functionName, __FILE__, __LINE__,0);
+      if (mArgCount!=0) throw HX_INVALID_ARG_COUNT;
+      if (mProc==0) hx::Throw( HX_NULL_FUNCTION_POINTER );
+      return ((prim_0)mProc)();
+   }
+   Dynamic __run(D a)
+   {
+      HX_STACK_FRAME(hx::EXTERN_CLASS_NAME, "cffi",0,  functionName, __FILE__, __LINE__,0);
+      if (mArgCount!=1) throw HX_INVALID_ARG_COUNT;
+      if (mProc==0) hx::Throw( HX_NULL_FUNCTION_POINTER );
+      return ((prim_1)mProc)(a.GetPtr());
+   }
+   Dynamic __run(D a,D b)
+   {
+      HX_STACK_FRAME(hx::EXTERN_CLASS_NAME, "cffi",0,  functionName, __FILE__, __LINE__,0);
+      if (mArgCount!=2) throw HX_INVALID_ARG_COUNT;
+      if (mProc==0) hx::Throw( HX_NULL_FUNCTION_POINTER );
+      return ((prim_2)mProc)(a.GetPtr(),b.GetPtr());
+   }
+   Dynamic __run(D a,D b,D c)
+   {
+      HX_STACK_FRAME(hx::EXTERN_CLASS_NAME, "cffi",0,  functionName, __FILE__, __LINE__,0);
+      if (mArgCount!=3) throw HX_INVALID_ARG_COUNT;
+      if (mProc==0) hx::Throw( HX_NULL_FUNCTION_POINTER );
+      return ((prim_3)mProc)(a.GetPtr(),b.GetPtr(),c.GetPtr());
+   }
+   Dynamic __run(D a,D b,D c,D d)
+   {
+      HX_STACK_FRAME(hx::EXTERN_CLASS_NAME, "cffi",0,  functionName, __FILE__, __LINE__,0);
+      if (mArgCount!=4) throw HX_INVALID_ARG_COUNT;
+      if (mProc==0) hx::Throw( HX_NULL_FUNCTION_POINTER );
+      return ((prim_4)mProc)(a.GetPtr(),b.GetPtr(),c.GetPtr(),d.GetPtr());
+   }
+   Dynamic __run(D a,D b,D c,D d,D e)
+   {
+      HX_STACK_FRAME(hx::EXTERN_CLASS_NAME, "cffi",0,  functionName, __FILE__, __LINE__,0);
+      if (mArgCount!=5) throw HX_INVALID_ARG_COUNT;
+      if (mProc==0) hx::Throw( HX_NULL_FUNCTION_POINTER );
+      return ((prim_5)mProc)(a.GetPtr(),b.GetPtr(),c.GetPtr(),d.GetPtr(),e.GetPtr());
+   }
+
+   Dynamic __Run(const Array<Dynamic> &inArgs)
+   {
+      HX_STACK_FRAME(hx::EXTERN_CLASS_NAME, "cffi",0,  functionName, __FILE__, __LINE__,0);
+      if (mArgCount!=-1 && mArgCount!=inArgs->length)
+         throw HX_INVALID_ARG_COUNT;
+      if (mProc==0) hx::Throw( HX_NULL_FUNCTION_POINTER );
+      return ((prim_mult)mProc)( (hx::Object **)inArgs->GetBase(), inArgs->length );
+   }
+
+   int __Compare(const hx::Object *inRHS) const
+   {
+      const ExternalPrimitive *other = dynamic_cast<const ExternalPrimitive *>(inRHS);
+      if (!other)
+         return -1;
+      return mProc==other->mProc;
+   }
+
+
+   void        *mProc;
+   int         mArgCount;
+   String      mName;
+   const char* functionName;
+};
+
+
+namespace
+{
+typedef std::map<String,ExternalPrimitive *> LoadedMap;
+LoadedMap sLoadedMap;
+}
+
+
+typedef void (*SetLoaderProcFunc)(void *(*)(const char *));
+typedef void *(*GetNekoEntryFunc)();
+typedef void (*NekoEntryFunc)();
+
+
+#ifdef HXCPP_TRY_HAXELIB
+
+static String GetFileContents(String inFile)
+{
+#ifndef _MSC_VER
+   FILE *file = fopen(inFile.__CStr(),"rb");
+#else
+   FILE *file = _wfopen(inFile.__WCStr(),L"rb");
+#endif
+   if (!file)
+   {
+      // printf("Could not open %S\n", inFile.__s);
+      return null();
+   }
+
+   char buf[2049];
+   int bytes = fread(buf,1,2048,file);
+   fclose(file);
+   if (bytes<1)
+      return null();
+   buf[bytes]='\0';
+   return String::create(buf);
+}
+
+static String GetEnv(const char *inPath)
+{
+   const char *env  = getenv(inPath);
+   String result(env,env?strlen(env):0);
+   return result;
+}
+
+static String FindHaxelib(String inLib)
+{
+   bool loadDebug = getenv("HXCPP_LOAD_DEBUG");
+
+   // printf("FindHaxelib %S\n", inLib.__s);
+
+   String haxepath;
+   hx::strbuf convertBuf;
+   hx::strbuf convertBuf1;
+
+   struct stat s;
+   if ( (stat(".haxelib",&s)==0 && (s.st_mode & S_IFDIR) ) )
+      haxepath = HX_CSTRING(".haxelib");
+   if (loadDebug)
+      printf( haxepath.length ? "Found local .haxelib\n" : "No local .haxelib\n");
+
+   if (haxepath.length==0)
+   {
+      haxepath = GetEnv("HAXELIB_PATH");
+      if (loadDebug)
+         printf("HAXELIB_PATH env:%s\n", haxepath.out_str(&convertBuf));
+   }
+
+   if (haxepath.length==0)
+   {
+       #ifdef _WIN32
+       String home = GetEnv("HOMEDRIVE") + GetEnv("HOMEPATH") + HX_CSTRING("/.haxelib");
+       #else
+       String home = GetEnv("HOME") + HX_CSTRING("/.haxelib");
+       #endif
+       haxepath = GetFileContents(home);
+       if (loadDebug)
+          printf("HAXEPATH home:%s\n", haxepath.out_str(&convertBuf));
+   }
+
+   if (haxepath.length==0)
+   {
+      haxepath = GetEnv("HAXEPATH");
+      if (loadDebug)
+         printf("HAXEPATH env:%s\n", haxepath.out_str(&convertBuf));
+      if (haxepath.length>0)
+      {
+         haxepath += HX_CSTRING("/lib");
+      }
+   }
+
+   if (loadDebug)
+      printf("HAXEPATH dir:%s\n", haxepath.out_str(&convertBuf));
+
+   if (haxepath.length==0)
+   {
+       haxepath = GetFileContents(HX_CSTRING("/etc/.haxepath"));
+       if (loadDebug) printf("HAXEPATH etc:%s\n", haxepath.out_str(&convertBuf));
+   }
+
+   if (haxepath.length==0)
+   {
+      #ifdef _WIN32
+      haxepath = HX_CSTRING("C:\\HaxeToolkit\\haxe\\lib");
+      #else
+      haxepath = HX_CSTRING("/usr/lib/haxe/lib");
+      #endif
+       if (loadDebug) printf("HAXEPATH default:%s\n", haxepath.out_str(&convertBuf));
+   }
+
+   String dir = haxepath + HX_CSTRING("/") + inLib + HX_CSTRING("/");
+
+
+   String dev = dir + HX_CSTRING(".dev");
+   String path = GetFileContents(dev);
+   if (loadDebug) printf("Read dev location from file :%s, got %s\n", dev.out_str(&convertBuf), path.out_str(&convertBuf1));
+   if (path.length==0)
+   {
+      path = GetFileContents(dir + HX_CSTRING(".current"));
+      if (path.length==0)
+         return null();
+      // Replace "." with "," ...
+      String with_commas;
+      for(int i=0;i<path.length;i++)
+         if (path.getChar(i)=='.')
+            with_commas += HX_CSTRING(",");
+         else
+            with_commas += path.substr(i,1);
+
+      path = dir + with_commas + HX_CSTRING("/");
+   }
+
+   return path;
+}
+
+#endif // HXCPP_TRY_HAXELIB
+
+
+typedef std::map<std::string,void *> RegistrationMap;
+RegistrationMap *sgRegisteredPrims=0;
+
+
+
+static std::vector<String> sgLibPath;
+
+static bool sgLibPathIsInit = false;
+
+String __hxcpp_get_bin_dir()
+{
+   return
+#if defined(HX_WINRT)
+  #ifdef HXCPP_M64
+    HX_CSTRING("WinRT64");
+  #else
+    HX_CSTRING("WinRT");
+  #endif
+#elif defined(_WIN32)
+  #ifdef HXCPP_M64
+    HX_CSTRING("Windows64");
+  #else
+    HX_CSTRING("Windows");
+  #endif
+// Unix...
+#elif defined(__APPLE__)
+  #ifdef HXCPP_ARM64
+    HX_CSTRING("MacArm64");
+  #elif defined(HXCPP_M64)
+    HX_CSTRING("Mac64");
+  #else
+    HX_CSTRING("Mac");
+  #endif
+#elif defined (ANDROID)
+    HX_CSTRING("Android");
+#elif defined(WEBOS)
+    HX_CSTRING("webOS");
+#elif defined(BLACKBERRY)
+    HX_CSTRING("BlackBerry");
+#elif defined(RASPBERRYPI)
+    HX_CSTRING("RPi");
+#elif defined(EMSCRIPTEN)
+    HX_CSTRING("Emscripten");
+#elif defined(TIZEN)
+    HX_CSTRING("Tizen");
+#elif defined(IPHONESIM)
+    HX_CSTRING("IPhoneSim");
+#elif defined(IPHONEOS)
+    HX_CSTRING("IPhoneOs");
+#elif defined(APPLETVSIM)
+    HX_CSTRING("AppleTVSim");
+#elif defined(APPLETVOS)
+    HX_CSTRING("AppleTVOS");
+#else
+  #ifdef HXCPP_M64
+    HX_CSTRING("Linux64");
+  #else
+    HX_CSTRING("Linux");
+  #endif
+#endif
+}
+
+String __hxcpp_get_dll_extension()
+{
+   return
+#if defined(_WIN32) || defined(HX_WINRT)
+    HX_CSTRING(".dll");
+#elif defined(IPHONEOS)
+    HX_CSTRING(".ios.dylib");
+#elif defined(IPHONESIM)
+    HX_CSTRING(".sim.dylib");
+#elif defined(APPLETVOS)
+    HX_CSTRING(".tvos.dylib");
+#elif defined(APPLETVSIM)
+    HX_CSTRING(".sim.dylib");
+#elif defined(__APPLE__)
+    HX_CSTRING(".dylib");
+#elif defined(ANDROID) || defined(GPH) || defined(WEBOS)  || defined(BLACKBERRY) || defined(EMSCRIPTEN) || defined(TIZEN)
+    HX_CSTRING(".so");
+#else
+    HX_CSTRING(".dso");
+#endif
+}
+
+void __hxcpp_push_dll_path(String inPath)
+{
+   int last = inPath.length-1;
+   int lastCode = (last>0) ? inPath.cca(last) : -1;
+
+   if ( lastCode!='\\' && lastCode!='/')
+      sgLibPath.push_back( (inPath + HX_CSTRING("/")).makePermanent() );
+   else
+      sgLibPath.push_back( inPath.makePermanent() );
+}
+
+
+
+#ifdef HXCPP_NO_DYNAMIC_LOADING
+
+Dynamic __loadprim(String inLib, String inPrim,int inArgCount)
+{
+   String full_name = inPrim;
+   switch(inArgCount)
+   {
+      case 0: full_name += HX_CSTRING("__0"); break;
+      case 1: full_name += HX_CSTRING("__1"); break;
+      case 2: full_name += HX_CSTRING("__2"); break;
+      case 3: full_name += HX_CSTRING("__3"); break;
+      case 4: full_name += HX_CSTRING("__4"); break;
+      case 5: full_name += HX_CSTRING("__5"); break;
+      default:
+          full_name += HX_CSTRING("__MULT");
+   }
+
+   String libString = inLib + HX_CSTRING("_") + full_name;
+   ExternalPrimitive *prim = sLoadedMap[libString];
+   if (prim)
+      return Dynamic(prim);
+
+   if (sgRegisteredPrims)
+   {
+      void *registered = (*sgRegisteredPrims)[full_name.__CStr()];
+      // Try with lib name ...
+      if (!registered)
+      {
+         registered = (*sgRegisteredPrims)[libString.__CStr()];
+         if (registered)
+            full_name = libString;
+      }
+
+      if (registered)
+      {
+         libString = libString.makePermanent();
+         prim = new ExternalPrimitive(registered,inArgCount,libString);
+         sLoadedMap[libString] = prim;
+         return Dynamic(prim);
+      }
+   }
+
+   printf("Primitive not found : %s\n", full_name.__CStr() );
+   return null();
+}
+
+void *__hxcpp_get_proc_address(String inLib, String inPrim,bool ,bool inQuietFail)
+{
+   if (sgRegisteredPrims)
+      return (*sgRegisteredPrims)[inPrim.__CStr()];
+
+   if (!inQuietFail)
+      printf("Primitive not found : %s\n", inPrim.__CStr() );
+   return 0;
+}
+
+int __hxcpp_unload_all_libraries() { return 0; }
+
+
+#else
+
+
+extern "C" void *hx_cffi(const char *inName);
+
+
+void *__hxcpp_get_proc_address(String inLib, String full_name,bool inNdllProc,bool inQuietFail)
+{
+   if (inLib.length==0)
+   {
+      if (sgRegisteredPrims)
+      {
+         void *registered = (*sgRegisteredPrims)[full_name.__CStr()];
+         if (registered)
+            return registered;
+      }
+      if (!inQuietFail)
+      {
+         #ifdef ANDROID
+         __android_log_print(ANDROID_LOG_ERROR, "loader", "Could not find primitive %s in static link", full_name.__CStr());
+         #else
+         fprintf(stderr,"Could not find primitive %s in static link.\n", full_name.__CStr());
+         #endif
+      }
+      return nullptr;
+   }
+
+   String bin = __hxcpp_get_bin_dir();
+   String deviceExt = __hxcpp_get_dll_extension();
+
+
+   #ifdef HX_ANDROID
+   String module_name = HX_CSTRING("lib") + inLib;
+   #else
+   String module_name = inLib;
+   #endif
+
+   #if defined(HX_WINRT) && defined(HXCPP_DEBUG)
+   gLoadDebug = true;
+   #elif defined(IPHONE) || defined(APPLETV)
+   gLoadDebug = true;
+   setenv("DYLD_PRINT_APIS","1",true);
+
+   #elif !defined(HX_WINRT)
+   gLoadDebug = gLoadDebug || getenv("HXCPP_LOAD_DEBUG");
+   #endif
+
+   if (!sgLibPathIsInit)
+   {
+      sgLibPathIsInit = true;
+      #ifndef HX_WINRT 
+      sgLibPath.push_back( HX_CSTRING("./") );
+      #endif
+      #ifdef HX_MACOS
+      sgLibPath.push_back( HX_CSTRING("@executable_path/") );
+      #endif
+      sgLibPath.push_back( HX_CSTRING("") );
+
+      #ifdef HXCPP_TRY_HAXELIB
+      String hxcpp = GetEnv("HXCPP");
+      if (hxcpp.length==0)
+         hxcpp = FindHaxelib( HX_CSTRING("hxcpp") );
+      if (hxcpp.length!=0)
+         __hxcpp_push_dll_path(hxcpp+HX_CSTRING("/bin/") + bin + HX_CSTRING("/"));
+      #endif
+   }
+
+   hx::strbuf convertBuf;
+
+
+   Module module = sgLoadedModule[module_name.utf8_str()];
+
+   bool new_module = module==0;
+
+   if (!module && sgRegisteredPrims)
+   {
+      void *registered = (*sgRegisteredPrims)[full_name.__CStr()];
+      // Try with lib name ...
+      if (!registered)
+      {
+         String libString = inLib + HX_CSTRING("_") + full_name;
+         registered = (*sgRegisteredPrims)[libString.__CStr()];
+      }
+
+      if (registered)
+         return registered;
+   }
+
+   if (!module && gLoadDebug)
+   {
+      #ifdef HX_WINRT
+      WINRT_LOG("Searching for %s...\n", inLib.out_str(&convertBuf));
+      #elif defined(ANDROID)
+       __android_log_print(ANDROID_LOG_INFO, "loader", "Searching for %s...", module_name.out_str(&convertBuf));
+      #else
+      printf("Searching for %s...\n", inLib.out_str(&convertBuf));
+      #endif
+   }
+
+   String haxelibPath;
+
+#ifdef HX_WINRT
+   for(int e=0; module==0 && e<1; e++) //only accept DLL
+#else
+   for(int e=0; module==0 && e<3; e++)
+#endif
+   {
+      String extension = e==0 ? deviceExt : e==1 ? HX_CSTRING(".ndll") : HX_CSTRING("");
+
+      for(int path=0;path<sgLibPath.size();path++)
+      {
+         #ifdef HX_WINRT
+         String testPath = module_name + extension;
+         #else
+         String testPath =  sgLibPath[path] +  module_name + extension;
+         #endif
+         if (gLoadDebug)
+         {
+            #ifdef HX_WINRT
+            WINRT_LOG(" try %s...\n", testPath.out_str(&convertBuf));
+            #elif !defined(ANDROID)
+            printf(" try %s...\n", testPath.out_str(&convertBuf));
+            #else
+            __android_log_print(ANDROID_LOG_INFO, "loader", "Try %s", testPath.out_str(&convertBuf));
+            #endif
+         }
+         module = hxLoadLibrary(testPath);
+         if (module)
+         {
+            if (gLoadDebug)
+            {
+               #ifdef HX_WINRT
+               WINRT_LOG("Found %s\n", testPath.out_str(&convertBuf));
+               #elif !defined(ANDROID)
+               printf("Found %s\n", testPath.out_str(&convertBuf));
+               #else
+               __android_log_print(ANDROID_LOG_INFO, "loader", "Found %s", testPath.out_str(&convertBuf));
+               #endif
+            }
+            break;
+         }
+      }
+
+      #ifdef HXCPP_TRY_HAXELIB
+      if (!module)
+      {
+         if (e==0)
+            haxelibPath = FindHaxelib(inLib);
+
+         if (haxelibPath.length!=0)
+         {
+            String testPath  = haxelibPath + HX_CSTRING("/ndll/") + bin + HX_CSTRING("/") + inLib + extension;
+            if (gLoadDebug)
+               printf(" try %s...\n", testPath.out_str(&convertBuf));
+            module = hxLoadLibrary(testPath);
+            if (module && gLoadDebug)
+            {
+               printf("Found %s\n", testPath.out_str(&convertBuf));
+            }
+
+
+            #if defined(HX_MACOS) && defined(HXCPP_ARM64)
+            if (!module)
+            {
+               // Fat binary?
+               String testPath  = haxelibPath + HX_CSTRING("/ndll/Mac64/") + inLib + extension;
+               if (gLoadDebug)
+                  printf(" try %s...\n", testPath.out_str(&convertBuf));
+               module = hxLoadLibrary(testPath);
+               if (module && gLoadDebug)
+               {
+                  printf("Found %s\n", testPath.out_str(&convertBuf));
+               }
+            }
+            #endif
+         }
+      }
+      #endif
+   }
+
+   if (!module)
+   {
+      hx::Throw(HX_CSTRING("Could not load module ") + inLib + HX_CSTRING("@") + full_name);
+   }
+
+
+   if (new_module)
+   {
+      sgLoadedModule[module_name.utf8_str()] = module;
+
+      sgOrderedModules.push_back(module);
+
+      SetLoaderProcFunc set_loader = (SetLoaderProcFunc)hxFindSymbol(module,"hx_set_loader");
+      if (set_loader)
+         set_loader(hx_cffi);
+
+      GetNekoEntryFunc func = (GetNekoEntryFunc)hxFindSymbol(module,"__neko_entry_point");
+      if (func)
+      {
+         NekoEntryFunc entry = (NekoEntryFunc)func();
+         if (entry)
+            entry();
+      }
+   }
+
+   FundFunc proc_query = (FundFunc)hxFindSymbol(module,full_name.__CStr());
+   if (!proc_query)
+       proc_query = (FundFunc)hxFindSymbol(module, (inLib + HX_CSTRING("_") + full_name).__CStr());
+
+   if (!proc_query && !inQuietFail)
+   {
+      #ifdef ANDROID
+       __android_log_print(ANDROID_LOG_ERROR, "loader", "Could not find primitive %s in %p",
+        full_name.__CStr(), module);
+      #else
+      fprintf(stderr,"Could not find primitive %s.\n", full_name.__CStr());
+      #endif
+      return 0;
+   }
+
+   if (!inNdllProc)
+      return (void *)proc_query;
+
+   void *proc = proc_query();
+   if (!proc && !inQuietFail)
+   {
+      #ifdef ANDROID
+      __android_log_print(ANDROID_LOG_ERROR, "loader", "Could not identify primitive %s in %s",
+        full_name.__CStr(), inLib.__CStr() );
+      #else
+      fprintf(stderr,"Could not identify primitive %s in %s\n", full_name.__CStr(),inLib.__CStr());
+      #endif
+   }
+
+   return proc;
+}
+
+int __hxcpp_unload_all_libraries()
+{
+   int unloaded = 0;
+   while(sgOrderedModules.size())
+   {
+      Module module = sgOrderedModules.back();
+      sgOrderedModules.pop_back();
+      hxFreeLibrary(module);
+      unloaded++;
+   }
+   return unloaded;
+}
+
+
+
+Dynamic __loadprim(String inLib, String inPrim,int inArgCount)
+{
+   String full_name = inPrim;
+   switch(inArgCount)
+   {
+      case 0: full_name += HX_CSTRING("__0"); break;
+      case 1: full_name += HX_CSTRING("__1"); break;
+      case 2: full_name += HX_CSTRING("__2"); break;
+      case 3: full_name += HX_CSTRING("__3"); break;
+      case 4: full_name += HX_CSTRING("__4"); break;
+      case 5: full_name += HX_CSTRING("__5"); break;
+      default:
+          full_name += HX_CSTRING("__MULT");
+   }
+
+   String primName = inLib+HX_CSTRING("@")+full_name;
+   ExternalPrimitive *saved = sLoadedMap[primName];
+   if (saved)
+      return Dynamic(saved);
+
+   void *proc = __hxcpp_get_proc_address(inLib,full_name,true);
+   if (proc)
+   {
+      primName = primName.makePermanent();
+
+      saved = new ExternalPrimitive(proc,inArgCount,primName);
+      sLoadedMap[primName] = saved;
+      return Dynamic(saved);
+   }
+   return null();
+}
+
+#endif // not HXCPP_NO_DYNAMIC_LOADING
+
+void __hxcpp_run_dll(String inLib, String inFunc)
+{
+   typedef void (*VoidVoid)();
+
+   void *result = __hxcpp_get_proc_address(inLib,inFunc,false);
+   if (result)
+      ((VoidVoid)result)();
+}
+
+// This can be used to find symbols in static libraries
+
+int __hxcpp_register_prim(const char *inName,void *inProc)
+{
+   if (sgRegisteredPrims==0)
+      sgRegisteredPrims = new RegistrationMap();
+   void * &proc = (*sgRegisteredPrims)[inName];
+   if (proc)
+   {
+      printf("Warning : duplicate symbol %s\n", inName);
+   }
+   proc = inProc;
+   return 0;
+}
+
diff --git a/Sources/c_snikket/src/hx/Object.cpp b/Sources/c_snikket/src/hx/Object.cpp
new file mode 100644
index 0000000..64050b5
--- /dev/null
+++ b/Sources/c_snikket/src/hx/Object.cpp
@@ -0,0 +1,205 @@
+#include <hxcpp.h>
+
+#include <stdio.h>
+#include <hxMath.h>
+//#include <hxMacros.h>
+#include <cpp/CppInt32__.h>
+#include <map>
+
+
+#ifdef _WIN32
+
+#include <windows.h>
+// Stoopid windows ...
+#ifdef RegisterClass
+#undef RegisterClass
+#endif
+#ifdef abs
+#undef abs
+#endif
+
+#else
+
+#include <wchar.h>
+#ifndef EMSCRIPTEN
+typedef  int64_t  __int64;
+#endif
+
+#endif
+
+#ifdef HXCPP_SCRIPTABLE
+#include <hx/Scriptable.h>
+#endif
+
+
+// --- hxObject -----------------------------------------
+
+namespace hx
+{
+
+String sNone[] = { String(null()) };
+
+bool Object::_hx_isInstanceOf(int inClassId)
+{
+   return inClassId == hx::Object::_hx_ClassId;
+}
+
+Dynamic Object::__IField(int inFieldID)
+{
+   return __Field( __hxcpp_field_from_id(inFieldID), HX_PROP_DYNAMIC );
+}
+
+double Object::__INumField(int inFieldID)
+{
+   return __Field( __hxcpp_field_from_id(inFieldID), HX_PROP_DYNAMIC );
+}
+
+Dynamic *Object::__GetFieldMap() { return 0; }
+
+
+int Object::__Compare(const Object *inRHS) const
+{
+   hx::Object *real = const_cast<Object *>(this);
+   return real < inRHS ? -1 : real==inRHS ? 0 : 1;
+}
+
+
+hx::Val Object::__Field(const String &inString, hx::PropertyAccess inCallProp)
+{
+   #if 0
+   // Will be true for 'Implements dynamic'
+   if (inCallProp && __GetFieldMap())
+   {
+      Dynamic resolve = __Field(HX_CSTRING("resolve"), false);
+      if (resolve.mPtr)
+         return resolve(inString);
+   }
+   #endif
+   return null();
+}
+
+bool Object::__HasField(const String &inString)
+{
+   return false;
+}
+Dynamic Object::__Run(const Array<Dynamic> &inArgs) { return 0; }
+Dynamic Object::__GetItem(int inIndex) const { return null(); }
+Dynamic Object::__SetItem(int inIndex,Dynamic) { return null();  }
+
+
+void Object::__SetThis(Dynamic inThis) { }
+
+hx::Class Object__mClass;
+
+bool AlwaysCast(Object *inPtr) { return inPtr!=0; }
+
+#if !defined(HXCPP_SCRIPTABLE)
+// Other implementation is in Cppia.cpp
+void *hx::Object::_hx_getInterface(int inId)
+{
+   return 0;
+}
+#endif
+
+
+
+#ifdef HXCPP_SCRIPTABLE
+
+class Object__scriptable : public hx::Object {
+   typedef Object__scriptable __ME;
+   void __construct() { }
+   typedef hx::Object super;
+   typedef hx::Object __superString;
+   HX_DEFINE_SCRIPTABLE(HX_ARR_LIST0);
+   HX_DEFINE_SCRIPTABLE_DYNAMIC;
+};
+
+hx::ScriptFunction Object::__script_construct;
+
+static void CPPIA_CALL __s_toString(hx::CppiaCtx *ctx) {
+   ctx->returnString((ctx->getThis())->toString());
+}
+static hx::ScriptNamedFunction __scriptableFunctions[] = {
+  hx::ScriptNamedFunction("toString",__s_toString,"s"),
+  hx::ScriptNamedFunction(0,0,0) };
+
+#endif
+
+void Object::__boot()
+{
+   Static(Object__mClass) = hx::_hx_RegisterClass(HX_CSTRING("Dynamic"),AlwaysCast,sNone,sNone,0,0, 0, 0 );
+
+   #ifdef HXCPP_SCRIPTABLE
+   hx::ScriptableRegisterClass( HX_CSTRING("hx.Object"), (int)sizeof(hx::Object__scriptable), __scriptableFunctions, Object__scriptable::__script_create, Object::__script_construct );
+   #endif
+}
+
+
+hx::Class &Object::__SGetClass() { return Object__mClass; }
+
+hx::Class Object::__GetClass() const { return Object__mClass; }
+
+hx::FieldRef Object::__FieldRef(const String &inString) { return hx::FieldRef(this,inString); }
+
+String Object::__ToString() const { return HX_CSTRING("Object"); }
+
+const char * Object::__CStr() const { return __ToString().__CStr(); }
+
+
+hx::Val Object::__SetField(const String &inField,const hx::Val &inValue, hx::PropertyAccess inCallProp)
+{
+   hx::Throw( HX_CSTRING("Invalid field:") + inField );
+   return null();
+}
+
+Dynamic Object::__run()
+{
+   return __Run(Array_obj<Dynamic>::__new());
+}
+
+Dynamic Object::__run(D a)
+{
+   return __Run( Array_obj<Dynamic>::__new(0,1) << a );
+}
+
+Dynamic Object::__run(D a,D b)
+{
+   return __Run( Array_obj<Dynamic>::__new(0,2) << a << b );
+}
+
+Dynamic Object::__run(D a,D b,D c)
+{
+   return __Run( Array_obj<Dynamic>::__new(0,3) << a << b << c);
+}
+Dynamic Object::__run(D a,D b,D c,D d)
+{
+   return __Run( Array_obj<Dynamic>::__new(0,4) << a << b << c << d);
+}
+Dynamic Object::__run(D a,D b,D c,D d,D e)
+{
+   return __Run( Array_obj<Dynamic>::__new(0,5) << a << b << c << d << e);
+}
+
+void Object::__GetFields(Array<String> &outFields)
+{
+}
+
+
+String Object::toString()
+{
+   Dynamic *m = __GetFieldMap();
+   if (m)
+   {
+      Dynamic func;
+      if (FieldMapGet(m,HX_CSTRING("toString"),func))
+         return func();
+   }
+   return __ToString();
+}
+
+
+} // end namespace hx
+
+
+
+
diff --git a/Sources/c_snikket/src/hx/StdLibs.cpp b/Sources/c_snikket/src/hx/StdLibs.cpp
new file mode 100644
index 0000000..f4c4890
--- /dev/null
+++ b/Sources/c_snikket/src/hx/StdLibs.cpp
@@ -0,0 +1,833 @@
+#include <hxcpp.h>
+#include <hxMath.h>
+#include <hx/Memory.h>
+#include <hx/Thread.h>
+
+#ifdef HX_WINDOWS
+#include <windows.h>
+#include <io.h>
+#elif defined(__unix__) || defined(__APPLE__)
+#include <sys/time.h>
+#ifndef EMSCRIPTEN
+typedef int64_t __int64;
+#endif
+#endif
+
+#ifdef ANDROID
+#include <android/log.h>
+#endif
+#ifdef WEBOS
+#include <syslog.h>
+#endif
+#ifdef TIZEN
+#include <dlog.h>
+#endif
+#if defined(BLACKBERRY) || defined(GCW0)
+#include <unistd.h>
+#endif
+#include <string>
+#include <map>
+#include <stdio.h>
+#include <time.h>
+#include <clocale>
+
+
+#ifdef HX_ANDROID
+#define rand() lrand48()
+#define srand(x) srand48(x)
+#endif
+
+#ifdef HX_WINRT
+#define PRINTF WINRT_PRINTF
+#elif defined(TIZEN)
+#define PRINTF(fmt, ...) dlog_dprint(DLOG_INFO, "trace", fmt, __VA_ARGS__);
+#elif defined(HX_ANDROID) && !defined(HXCPP_EXE_LINK)
+#define PRINTF(fmt, ...) __android_log_print(ANDROID_LOG_INFO, "trace", fmt, __VA_ARGS__);
+#elif defined(WEBOS)
+#define PRINTF(fmt, ...) syslog(LOG_INFO, "trace", fmt, __VA_ARGS__);
+#else
+#define PRINTF printf
+#endif
+
+void __hx_stack_set_last_exception();
+void __hx_stack_push_last_exception();
+
+int _hxcpp_argc = 0;
+char **_hxcpp_argv = 0;
+
+namespace hx
+{
+
+Dynamic Throw(Dynamic inDynamic)
+{
+   #ifdef HXCPP_STACK_TRACE
+   __hx_stack_set_last_exception();
+   #endif
+   throw inDynamic;
+   return null();
+}
+
+
+Dynamic Rethrow(Dynamic inDynamic)
+{
+   #ifdef HXCPP_STACK_TRACE
+   __hx_stack_push_last_exception();
+   #endif
+   throw inDynamic;
+   return null();
+}
+
+
+null NullArithmetic(const char *inErr)
+{
+	Throw( String::create(inErr) );
+	return null();
+}
+
+}
+
+// -------- Resources ---------------------------------------
+
+namespace hx
+{
+
+//typedef std::map<std::wstring,Resource> ResourceSet;
+//static ResourceSet sgResources;
+
+Resource *sgResources = 0;
+Resource *sgSecondResources = 0;
+
+void RegisterResources(Resource *inResources)
+{
+   if (sgResources)
+      sgSecondResources = inResources;
+   else
+      sgResources = inResources;
+}
+
+}
+
+using namespace hx;
+
+Array<String> __hxcpp_resource_names()
+{
+   Array<String> result(0,0);
+
+   if (sgResources)
+      for(Resource *reso  = sgResources; reso->mData; reso++)
+         result->push( reso->mName );
+
+   if (sgSecondResources)
+      for(Resource *reso  = sgSecondResources; reso->mData; reso++)
+         result->push( reso->mName );
+
+   return result;
+}
+
+String __hxcpp_resource_string(String inName)
+{
+   if (sgResources)
+      for(Resource *reso  = sgResources; reso->mData; reso++)
+      {
+         if (reso->mName == inName)
+         #if (HXCPP_API_LEVEL > 0)
+         {
+            #ifdef HX_SMART_STRINGS
+            const unsigned char *p = reso->mData;
+            for(int i=0;i<reso->mDataLength;i++)
+               if (p[i]>127)
+                  return String::create((const char *)p, reso->mDataLength);
+            #endif
+            return String((const char *) reso->mData, reso->mDataLength );
+         }
+         #else
+            return String::create((const char *) reso->mData, reso->mDataLength );
+         #endif
+      }
+
+   if (sgSecondResources)
+   {
+      for(Resource *reso  = sgSecondResources; reso->mData; reso++)
+         if (reso->mName == inName)
+         {
+            #ifdef HX_SMART_STRINGS
+            const unsigned char *p = reso->mData;
+            for(int i=0;i<reso->mDataLength;i++)
+               if (p[i]>127)
+                  return _hx_utf8_to_utf16(p, reso->mDataLength,false);
+            #endif
+            return String((const char *) reso->mData, reso->mDataLength );
+
+            return String((const char *) reso->mData, reso->mDataLength );
+         }
+   }
+   return null();
+}
+
+Array<unsigned char> __hxcpp_resource_bytes(String inName)
+{
+   if (sgResources)
+      for(Resource *reso  = sgResources; reso->mData; reso++)
+      {
+         if (reso->mName == inName)
+         {
+            int len = reso->mDataLength;
+            Array<unsigned char> result( len, 0);
+            memcpy( result->GetBase() , reso->mData, len );
+            return result;
+         }
+      }
+   if (sgSecondResources)
+      for(Resource *reso  = sgSecondResources; reso->mData; reso++)
+      {
+         if (reso->mName == inName)
+         {
+            int len = reso->mDataLength;
+            Array<unsigned char> result( len, 0);
+            memcpy( result->GetBase() , reso->mData, len );
+            return result;
+         }
+      }
+
+   return null();
+}
+
+// -- hx::Native -------
+
+extern "C" void __hxcpp_lib_main();
+namespace hx
+{
+   static std::string initReturnBuffer;
+   const char *Init(bool stayAttached)
+   {
+      try
+      {
+         __hxcpp_lib_main();
+         if (!stayAttached)
+            SetTopOfStack(0,true);
+         return 0;
+      }
+      catch(Dynamic e)
+      {
+         HX_TOP_OF_STACK
+         if (!stayAttached)
+         {
+            initReturnBuffer = e->toString().utf8_str();
+            SetTopOfStack(0,true);
+            return initReturnBuffer.c_str();
+         }
+         return e->toString().utf8_str();
+      }
+   }
+}
+
+// --- System ---------------------------------------------------------------------
+
+// --- Maths ---------------------------------------------------------
+static double rand_scale = 1.0 / (1<<16) / (1<<16);
+double __hxcpp_drand()
+{
+   unsigned int lo = rand() & 0xfff;
+   unsigned int mid = rand() & 0xfff;
+   unsigned int hi = rand() & 0xff;
+   double result = (lo | (mid<<12) | (hi<<24) ) * rand_scale;
+   return result;
+}
+
+int __hxcpp_irand(int inMax)
+{
+   unsigned int lo = rand() & 0xfff;
+   unsigned int mid = rand() & 0xfff;
+   unsigned int hi = rand() & 0xff;
+   return (lo | (mid<<12) | (hi<<24) ) % inMax;
+}
+
+void __hxcpp_stdlibs_boot()
+{
+   #if defined(_MSC_VER) && !defined(HX_WINRT)
+   HMODULE kernel32 = LoadLibraryA("kernel32");
+   if (kernel32)
+   {
+      typedef BOOL (WINAPI *AttachConsoleFunc)(DWORD);
+      typedef HWND (WINAPI *GetConsoleWindowFunc)(void);
+      AttachConsoleFunc attach = (AttachConsoleFunc)GetProcAddress(kernel32,"AttachConsole");
+      GetConsoleWindowFunc getConsole = (GetConsoleWindowFunc)GetProcAddress(kernel32,"GetConsoleWindow");
+      if (attach && getConsole)
+      {
+         if (!attach( /*ATTACH_PARENT_PROCESS*/ (DWORD)-1 ))
+         {
+            //printf("Could not attach to parent console : %d\n",GetLastError());
+         }
+         else if (getConsole())
+         {
+            if (_fileno(stdout) < 0 || _get_osfhandle(fileno(stdout)) < 0)
+               freopen("CONOUT$", "w", stdout);
+            if (_fileno(stderr) < 0 || _get_osfhandle(fileno(stderr)) < 0)
+               freopen("CONOUT$", "w", stderr);
+            if (_fileno(stdin) < 0 || _get_osfhandle(fileno(stdin)) < 0)
+               freopen("CONIN$", "r", stdin);
+         }
+      }
+   }
+   //_setmode(_fileno(stdout), 0x00040000); // _O_U8TEXT
+   //_setmode(_fileno(stderr), 0x00040000); // _O_U8TEXT
+   //_setmode(_fileno(stdin), 0x00040000); // _O_U8TEXT
+   #endif
+
+   // This is necessary for UTF-8 output to work correctly.
+   setlocale(LC_ALL, "");
+   setlocale(LC_NUMERIC, "C");
+
+   // I think this does more harm than good.
+   //  It does not cause fread to return immediately - as perhaps desired.
+   //  But it does cause some new-line characters to be lost.
+   //setbuf(stdin, 0);
+   setvbuf(stdout, NULL, _IOLBF, BUFSIZ);
+   setbuf(stderr, 0);
+}
+
+void __trace(Dynamic inObj, Dynamic info)
+{
+   String text;
+   if (inObj != null())
+      text = inObj->toString();
+
+
+   hx::strbuf convertBuf;
+   if (info==null())
+   {
+      PRINTF("?? %s\n", text.raw_ptr() ? text.out_str(&convertBuf) : "null");
+   }
+   else
+   {
+      const char *filename = Dynamic((info)->__Field(HX_CSTRING("fileName"), HX_PROP_DYNAMIC))->toString().utf8_str(0,false);
+      int line = Dynamic((info)->__Field( HX_CSTRING("lineNumber") , HX_PROP_DYNAMIC))->__ToInt();
+
+      hx::strbuf convertBuf;
+      //PRINTF("%s:%d: %s\n", filename, line, text.raw_ptr() ? text.out_str(&convertBuf) : "null");
+      PRINTF("%s:%d: %s\n", filename, line, text.raw_ptr() ? text.out_str(&convertBuf) : "null");
+   }
+   fflush(stdout);
+}
+
+void __hxcpp_exit(int inExitCode)
+{
+   exit(inExitCode);
+}
+
+double  __time_stamp()
+{
+#ifdef HX_WINDOWS
+   static __int64 t0=0;
+   static double period=0;
+   __int64 now;
+
+   if (QueryPerformanceCounter((LARGE_INTEGER*)&now))
+   {
+      if (t0==0)
+      {
+         t0 = now;
+         __int64 freq;
+         QueryPerformanceFrequency((LARGE_INTEGER*)&freq);
+         if (freq!=0)
+            period = 1.0/freq;
+      }
+      if (period!=0)
+         return (now-t0)*period;
+   }
+   return (double)clock() / ( (double)CLOCKS_PER_SEC);
+#elif defined(__unix__) || defined(__APPLE__)
+   static double t0 = 0;
+   struct timeval tv;
+   if( gettimeofday(&tv,0) )
+      throw Dynamic("Could not get time");
+   double t =  ( tv.tv_sec + ((double)tv.tv_usec) / 1000000.0 );
+   if (t0==0) t0 = t;
+   return t-t0;
+#else
+   return (double)clock() / ( (double)CLOCKS_PER_SEC);
+#endif
+}
+
+#if defined(HX_WINDOWS) && !defined(HX_WINRT)
+
+/*
+ISWHITE and ParseCommandLine are based on the implementation of the
+.NET Core runtime, CoreCLR, which is licensed under the MIT license:
+Copyright (c) Microsoft. All rights reserved.
+See LICENSE file in the CoreCLR project root for full license information.
+
+The original source code of ParseCommandLine can be found in
+https://github.com/dotnet/coreclr/blob/master/src/vm/util.cpp
+*/
+
+#define ISWHITE(x) ((x)==(' ') || (x)==('\t') || (x)==('\n') || (x)==('\r') )
+
+static void ParseCommandLine(LPWSTR psrc, Array<String> &out)
+{
+    unsigned int argcount = 1;       // discovery of arg0 is unconditional, below
+
+    bool    fInQuotes;
+    int     iSlash;
+
+    /* A quoted program name is handled here. The handling is much
+       simpler than for other arguments. Basically, whatever lies
+       between the leading double-quote and next one, or a terminal null
+       character is simply accepted. Fancier handling is not required
+       because the program name must be a legal NTFS/HPFS file name.
+       Note that the double-quote characters are not copied, nor do they
+       contribute to numchars.
+
+       This "simplification" is necessary for compatibility reasons even
+       though it leads to mishandling of certain cases.  For example,
+       "c:\tests\"test.exe will result in an arg0 of c:\tests\ and an
+       arg1 of test.exe.  In any rational world this is incorrect, but
+       we need to preserve compatibility.
+    */
+
+    LPWSTR pStart = psrc;
+    bool skipQuote = false;
+
+    // Pairs of double-quotes vanish...
+    while(psrc[0]=='\"' && psrc[1]=='\"')
+       psrc += 2;
+
+    if (*psrc == '\"')
+    {
+        // scan from just past the first double-quote through the next
+        // double-quote, or up to a null, whichever comes first
+        psrc++;
+        while ((*psrc!= '\"') && (*psrc != '\0'))
+        {
+           psrc++;
+           // Pairs of double-quotes vanish...
+           while(psrc[0]=='\"' && psrc[1]=='\"')
+              psrc += 2;
+        }
+
+        skipQuote = true;
+    }
+    else
+    {
+        /* Not a quoted program name */
+
+        while (!ISWHITE(*psrc) && *psrc != '\0')
+            psrc++;
+    }
+
+    // We have now identified arg0 as pStart (or pStart+1 if we have a leading
+    // quote) through psrc-1 inclusive
+    if (skipQuote)
+        pStart++;
+    String arg0("");
+    while (pStart < psrc)
+    {
+        arg0 += String::fromCharCode(*pStart);
+        pStart++;
+    }
+    // out.Add(arg0); // the command isn't part of Sys.args()
+
+    // if we stopped on a double-quote when arg0 is quoted, skip over it
+    if (skipQuote && *psrc == '\"')
+        psrc++;
+
+    while ( *psrc != '\0')
+    {
+LEADINGWHITE:
+
+        // The outofarg state.
+        while (ISWHITE(*psrc))
+            psrc++;
+
+        if (*psrc == '\0')
+            break;
+        else
+        if (*psrc == '#')
+        {
+            while (*psrc != '\0' && *psrc != '\n')
+                psrc++;     // skip to end of line
+
+            goto LEADINGWHITE;
+        }
+
+        argcount++;
+        fInQuotes = FALSE;
+
+        String arg("");
+
+        while ((!ISWHITE(*psrc) || fInQuotes) && *psrc != '\0')
+        {
+            switch (*psrc)
+            {
+            case '\\':
+                iSlash = 0;
+                while (*psrc == '\\')
+                {
+                    iSlash++;
+                    psrc++;
+                }
+
+                if (*psrc == '\"')
+                {
+                    for ( ; iSlash >= 2; iSlash -= 2)
+                    {
+                        arg += String("\\");
+                    }
+
+                    if (iSlash & 1)
+                    {
+                        arg += String::fromCharCode(*psrc);
+                        psrc++;
+                    }
+                    else
+                    {
+                        fInQuotes = !fInQuotes;
+                        psrc++;
+                    }
+                }
+                else
+                    for ( ; iSlash > 0; iSlash--)
+                    {
+                        arg += String("\\");
+                    }
+
+                break;
+
+            case '\"':
+                fInQuotes = !fInQuotes;
+                psrc++;
+                break;
+
+            default:
+                arg += String::fromCharCode(*psrc);
+                psrc++;
+            }
+        }
+
+        out.Add(arg);
+        arg = String("");
+    }
+}
+#endif
+
+
+#ifdef __APPLE__
+ #if !defined(IPHONE) && !defined(APPLETV) && !defined(HX_APPLEWATCH)
+   extern "C" {
+   extern int *_NSGetArgc(void);
+   extern char ***_NSGetArgv(void);
+   }
+ #endif
+#endif
+Array<String> __get_args()
+{
+   Array<String> result(0,0);
+   if (_hxcpp_argc)
+   {
+      for(int i=1;i<_hxcpp_argc;i++)
+         result->push( String::create(_hxcpp_argv[i],strlen(_hxcpp_argv[i])) );
+      return result;
+   }
+
+   #ifdef HX_WINRT
+   // Do nothing
+   #elif defined(HX_WINDOWS)
+   LPWSTR str =  GetCommandLineW();
+   ParseCommandLine(str, result);
+   #else
+   #ifdef __APPLE__
+
+   #if !defined(IPHONE) && !defined(APPLETV) && !defined(HX_APPLEWATCH)
+   int argc = *_NSGetArgc();
+   char **argv = *_NSGetArgv();
+   for(int i=1;i<argc;i++)
+      result->push( String::create(argv[i],strlen(argv[i])) );
+   #endif
+
+   #else
+   #ifdef ANDROID
+   // TODO: Get from java
+   #elif defined(__linux__)
+   char buf[80];
+   sprintf(buf, "/proc/%d/cmdline", getpid());
+   FILE *cmd = fopen(buf,"rb");
+   bool real_arg = 0;
+   if (cmd)
+   {
+      hx::QuickVec<char> arg;
+
+      buf[0] = '\0';
+      while (fread(buf, 1, 1, cmd))
+      {
+         if ((unsigned char)buf[0] == 0) // line terminator
+         {
+            if (real_arg)
+               result->push( String::create(arg.mPtr, arg.mSize) );
+            real_arg = true;
+            arg.clear();
+         }
+         else
+            arg.push(buf[0]);
+      }
+      fclose(cmd);
+   }
+   #endif
+
+   #endif
+   #endif
+   return result;
+}
+
+
+void __hxcpp_print_string(const String &inV)
+{
+   hx::strbuf convertBuf;
+   PRINTF("%s", inV.out_str(&convertBuf) );
+}
+
+void __hxcpp_println_string(const String &inV)
+{
+   hx::strbuf convertBuf;
+   PRINTF("%s\n", inV.out_str(&convertBuf));
+   fflush(stdout);
+}
+
+
+// --- Casting/Converting ---------------------------------------------------------
+
+
+bool __instanceof(const Dynamic &inValue, const Dynamic &inType)
+{
+   if (inValue==null())
+      return false;
+   if (inType==hx::Object::__SGetClass())
+      return true;
+   hx::Class c = inType;
+   if (c==null())
+      return false;
+   return c->CanCast(inValue.GetPtr());
+}
+
+
+int __int__(double x)
+{
+   #ifndef EMSCRIPTEN
+   if (x < -0x7fffffff || x>0x7fffffff )
+   {
+      __int64 big_int = (__int64)(x);
+      return big_int & 0xffffffff;
+   }
+   else
+   #endif
+      return (int)x;
+}
+
+
+static inline bool is_hex_string(const char *c, int len)
+{
+   return (len > 2 && c[0] == '0' && (c[1] == 'x' || c[1] == 'X'))
+      || (len > 3 && (c[0] == '-' || c[0] == '+') && c[1] == '0' && (c[2] == 'x' || c[2] == 'X'));
+}
+
+Dynamic __hxcpp_parse_int(const String &inString)
+{
+   if (!inString.raw_ptr())
+      return null();
+   hx::strbuf buf;
+   const char *str = inString.utf8_str(&buf);
+
+   // On the first non space char check to see if we've got a hex string
+   while (isspace(*str)) ++str;
+   bool isHex = is_hex_string(str, strlen(str));
+   char *end = 0;
+   long result;
+   if (isHex)
+   {
+      bool neg = str[0] == '-';
+      if (neg) str++;
+      result = strtoul(str,&end,16);
+      if (neg) result = -result;
+   }
+   else 
+      result = strtol(str,&end,10);
+   #ifdef HX_WINDOWS
+   if (str==end && !isHex)
+   #else
+   if (str==end)
+   #endif
+      return null();
+   return (int)result;
+}
+
+
+double __hxcpp_parse_substr_float(const String &inString,int start, int length)
+{
+   if (start>=inString.length || length<1 || (start+length)>inString.length )
+      return Math_obj::NaN;
+
+   hx::strbuf buf;
+   const char *str = inString.ascii_substr(&buf,start,length);
+   char *end = (char *)str;
+   double result = str ? strtod(str,&end) : 0;
+
+   if (end==str)
+      return Math_obj::NaN;
+
+   return result;
+}
+
+
+double __hxcpp_parse_float(const String &inString)
+{
+   if (!inString.raw_ptr())
+      return Math_obj::NaN;
+
+   hx::strbuf buf;
+   const char *str = inString.utf8_str(&buf);
+   char *end = (char *)str;
+   double result = str ? strtod(str,&end) : 0;
+
+   if (end==str)
+      return Math_obj::NaN;
+
+   return result;
+}
+
+
+bool __hxcpp_same_closure(Dynamic &inF1,Dynamic &inF2)
+{
+   hx::Object *p1 = inF1.GetPtr();
+   hx::Object *p2 = inF2.GetPtr();
+   if (p1==0 || p2==0)
+      return false;
+   if ( (p1->__GetHandle() != p2->__GetHandle()))
+      return false;
+   return p1->__Compare(p2)==0;
+}
+
+namespace hx
+{
+
+struct VarArgFunc : public hx::Object
+{
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdClosure };
+
+   VarArgFunc(Dynamic &inFunc) : mRealFunc(inFunc) {
+     HX_OBJ_WB_NEW_MARKED_OBJECT(this)
+   }
+
+   int __GetType() const { return vtFunction; }
+   ::String __ToString() const { return mRealFunc->__ToString() ; }
+
+   void __Mark(hx::MarkContext *__inCtx) { HX_MARK_MEMBER(mRealFunc); }
+
+   #ifdef HXCPP_VISIT_ALLOCS
+   void __Visit(hx::VisitContext *__inCtx) { HX_VISIT_MEMBER(mRealFunc); }
+   #endif
+
+   void *__GetHandle() const { return mRealFunc.GetPtr(); }
+   Dynamic __Run(const Array<Dynamic> &inArgs)
+   {
+      return mRealFunc->__run(inArgs);
+   }
+
+   Dynamic mRealFunc;
+};
+
+}
+
+Dynamic __hxcpp_create_var_args(Dynamic &inArrayFunc)
+{
+   return Dynamic(new hx::VarArgFunc(inArrayFunc));
+}
+
+// --- CFFI helpers ------------------------------------------------------------------
+
+
+// Field name management
+
+
+
+static HxMutex sgFieldMapMutex;
+
+typedef std::map<std::string,int> StringToField;
+
+// These need to be pointers because of the unknown order of static object construction.
+String *sgFieldToString=0;
+int    sgFieldToStringSize=0;
+int    sgFieldToStringAlloc=0;
+StringToField *sgStringToField=0;
+
+static String sgNullString;
+
+
+const String &__hxcpp_field_from_id( int f )
+{
+   if (!sgFieldToString)
+      return sgNullString;
+
+   return sgFieldToString[f];
+}
+
+
+int  __hxcpp_field_to_id( const char *inFieldName )
+{
+   AutoLock lock(sgFieldMapMutex);
+
+   if (!sgFieldToStringAlloc)
+   {
+      sgFieldToStringAlloc = 100;
+      sgFieldToString = (String *)HxAlloc(sgFieldToStringAlloc * sizeof(String));
+
+      sgStringToField = new StringToField;
+   }
+
+   std::string f(inFieldName);
+   StringToField::iterator i = sgStringToField->find(f);
+   if (i!=sgStringToField->end())
+      return i->second;
+
+   int result = sgFieldToStringSize;
+   (*sgStringToField)[f] = result;
+   String str(inFieldName,strlen(inFieldName));
+
+   // Make into "const" string that will not get collected...
+   str = String((char *)hx::InternalCreateConstBuffer(str.raw_ptr(),(str.length+1) * sizeof(char),true), str.length );
+
+   if (sgFieldToStringAlloc<=sgFieldToStringSize+1)
+   {
+      int oldAlloc = sgFieldToStringAlloc;
+      String *oldData = sgFieldToString;
+      sgFieldToStringAlloc *= 2;
+      String *newData = (String *)malloc(sgFieldToStringAlloc*sizeof(String));
+      if (oldAlloc)
+         memcpy(newData, oldData, oldAlloc*sizeof(String));
+      // Let oldData dangle to keep it thread safe, rather than require mutex on id read.
+      sgFieldToString = newData;
+   }
+   sgFieldToString[sgFieldToStringSize++] = str;
+   return result;
+}
+
+// --- haxe.Int32 ---------------------------------------------------------------------
+void __hxcpp_check_overflow(int x)
+{
+   if( (((x) >> 30) & 1) != ((unsigned int)(x) >> 31) )
+      throw Dynamic(HX_CSTRING("Overflow ")+x);
+}
+
+// --- Memory ---------------------------------------------------------------------
+
+unsigned char *__hxcpp_memory = 0;
+
+void  __hxcpp_memory_memset(Array<unsigned char> &inBuffer ,int pos, int len, int value)
+{
+   if (pos<inBuffer->length)
+   {
+      if (pos+len>inBuffer->length)
+         len = inBuffer->length - pos;
+      if (len>0)
+         memset( inBuffer->Pointer() + pos, value, len);
+   }
+}
+
diff --git a/Sources/c_snikket/src/hx/Thread.cpp b/Sources/c_snikket/src/hx/Thread.cpp
new file mode 100644
index 0000000..e5af49d
--- /dev/null
+++ b/Sources/c_snikket/src/hx/Thread.cpp
@@ -0,0 +1,950 @@
+#include <hxcpp.h>
+
+#include <hx/Thread.h>
+#include <time.h>
+
+DECLARE_TLS_DATA(class hxThreadInfo, tlsCurrentThread);
+
+// g_threadInfoMutex allows atomic access to g_nextThreadNumber
+static HxMutex g_threadInfoMutex;
+// Thread number 0 is reserved for the main thread
+static int g_nextThreadNumber = 1;
+
+
+// How to manage hxThreadInfo references for non haxe threads (main, extenal)?
+// HXCPP_THREAD_INFO_PTHREAD - use pthread api
+// HXCPP_THREAD_INFO_LOCAL - use thread_local storage
+// HXCPP_THREAD_INFO_SINGLETON - use one structure for all threads. Not ideal.
+
+#if __cplusplus > 199711L && !defined(__BORLANDC__)
+   #define HXCPP_THREAD_INFO_LOCAL
+#elif defined (HXCPP_PTHREADS)
+   #define HXCPP_THREAD_INFO_PTHREAD
+#else
+   #define HXCPP_THREAD_INFO_SINGLETON
+#endif
+
+
+// --- Deque ----------------------------------------------------------
+
+struct Deque : public Array_obj<Dynamic>
+{
+	Deque() : Array_obj<Dynamic>(0,0) { }
+
+	static Deque *Create()
+	{
+		Deque *result = new Deque();
+		result->mFinalizer = new hx::InternalFinalizer(result,clean);
+		return result;
+	}
+	static void clean(hx::Object *inObj)
+	{
+		Deque *d = dynamic_cast<Deque *>(inObj);
+		if (d) d->Clean();
+	}
+	void Clean()
+	{
+		#ifdef HX_WINDOWS
+		mMutex.Clean();
+		#endif
+		mSemaphore.Clean();
+	}
+
+   #ifdef HXCPP_VISIT_ALLOCS
+  	void __Visit(hx::VisitContext *__inCtx)
+	{
+		Array_obj<Dynamic>::__Visit(__inCtx);
+		mFinalizer->Visit(__inCtx);
+	}
+   #endif
+
+
+	#ifndef HX_THREAD_SEMAPHORE_LOCKABLE
+	HxMutex     mMutex;
+	void PushBack(Dynamic inValue)
+	{
+		hx::EnterGCFreeZone();
+		AutoLock lock(mMutex);
+		hx::ExitGCFreeZone();
+
+		push(inValue);
+		mSemaphore.Set();
+	}
+	void PushFront(Dynamic inValue)
+	{
+		hx::EnterGCFreeZone();
+		AutoLock lock(mMutex);
+		hx::ExitGCFreeZone();
+
+		unshift(inValue);
+		mSemaphore.Set();
+	}
+
+	
+	Dynamic PopFront(bool inBlock)
+	{
+		hx::EnterGCFreeZone();
+		AutoLock lock(mMutex);
+		if (!inBlock)
+		{
+			hx::ExitGCFreeZone();
+			return shift();
+		}
+		// Ok - wait for something on stack...
+		while(!length)
+		{
+			mSemaphore.Reset();
+			lock.Unlock();
+			mSemaphore.Wait();
+			lock.Lock();
+		}
+		hx::ExitGCFreeZone();
+		if (length==1)
+			mSemaphore.Reset();
+		return shift();
+	}
+	#else
+	void PushBack(Dynamic inValue)
+	{
+		hx::EnterGCFreeZone();
+		AutoLock lock(mSemaphore);
+		hx::ExitGCFreeZone();
+		push(inValue);
+		mSemaphore.QSet();
+	}
+	void PushFront(Dynamic inValue)
+	{
+		hx::EnterGCFreeZone();
+		AutoLock lock(mSemaphore);
+		hx::ExitGCFreeZone();
+		unshift(inValue);
+		mSemaphore.QSet();
+	}
+
+	
+	Dynamic PopFront(bool inBlock)
+	{
+		hx::EnterGCFreeZone();
+		AutoLock lock(mSemaphore);
+		while(inBlock && !length)
+			mSemaphore.QWait();
+		hx::ExitGCFreeZone();
+		Dynamic result =  shift();
+		if (length)
+			mSemaphore.QSet();
+		return result;
+	}
+	#endif
+
+	hx::InternalFinalizer *mFinalizer;
+	HxSemaphore mSemaphore;
+};
+
+Dynamic __hxcpp_deque_create()
+{
+	return Deque::Create();
+}
+
+void __hxcpp_deque_add(Dynamic q,Dynamic inVal)
+{
+	Deque *d = dynamic_cast<Deque *>(q.mPtr);
+	if (!d)
+		throw HX_INVALID_OBJECT;
+	d->PushBack(inVal);
+}
+
+void __hxcpp_deque_push(Dynamic q,Dynamic inVal)
+{
+	Deque *d = dynamic_cast<Deque *>(q.mPtr);
+	if (!d)
+		throw HX_INVALID_OBJECT;
+	d->PushFront(inVal);
+}
+
+Dynamic __hxcpp_deque_pop(Dynamic q,bool block)
+{
+	Deque *d = dynamic_cast<Deque *>(q.mPtr);
+	if (!d)
+		throw HX_INVALID_OBJECT;
+	return d->PopFront(block);
+}
+
+
+
+// --- Thread ----------------------------------------------------------
+
+class hxThreadInfo : public hx::Object
+{
+public:
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdThreadInfo };
+
+	hxThreadInfo(Dynamic inFunction, int inThreadNumber)
+        : mFunction(inFunction), mThreadNumber(inThreadNumber), mTLS(0,0)
+	{
+		mSemaphore = new HxSemaphore;
+		mDeque = Deque::Create();
+      HX_OBJ_WB_NEW_MARKED_OBJECT(this);
+	}
+	hxThreadInfo()
+	{
+		mSemaphore = 0;
+		mDeque = Deque::Create();
+      HX_OBJ_WB_NEW_MARKED_OBJECT(this);
+	}
+    int GetThreadNumber() const
+    {
+        return mThreadNumber;
+    }
+	void CleanSemaphore()
+	{
+		delete mSemaphore;
+		mSemaphore = 0;
+	}
+	void Send(Dynamic inMessage)
+	{
+		mDeque->PushBack(inMessage);
+	}
+	Dynamic ReadMessage(bool inBlocked)
+	{
+		return mDeque->PopFront(inBlocked);
+	}
+	String toString()
+	{
+		return String(GetThreadNumber());
+	}
+	void SetTLS(int inID,Dynamic inVal) {
+      mTLS->__SetItem(inID,inVal);
+   }
+	Dynamic GetTLS(int inID) { return mTLS[inID]; }
+
+	void __Mark(hx::MarkContext *__inCtx)
+	{
+		HX_MARK_MEMBER(mFunction);
+		HX_MARK_MEMBER(mTLS);
+		if (mDeque)
+			HX_MARK_OBJECT(mDeque);
+	}
+   #ifdef HXCPP_VISIT_ALLOCS
+  	void __Visit(hx::VisitContext *__inCtx)
+	{
+		HX_VISIT_MEMBER(mFunction);
+		HX_VISIT_MEMBER(mTLS);
+		if (mDeque)
+			HX_VISIT_OBJECT(mDeque);
+	}
+   #endif
+
+
+	Array<Dynamic> mTLS;
+	HxSemaphore *mSemaphore;
+	Dynamic mFunction;
+    int mThreadNumber;
+	Deque   *mDeque;
+};
+
+
+THREAD_FUNC_TYPE hxThreadFunc( void *inInfo )
+{
+   // info[1] will the the "top of stack" - values under this
+   //  (ie info[0] and other stack values) will be in the GC conservative range
+	hxThreadInfo *info[2];
+   info[0] = (hxThreadInfo *)inInfo;
+   info[1] = 0;
+
+	tlsCurrentThread = info[0];
+
+	hx::SetTopOfStack((int *)&info[1], true);
+
+	// Release the creation function
+	info[0]->mSemaphore->Set();
+
+    // Call the debugger function to annouce that a thread has been created
+    //__hxcpp_dbg_threadCreatedOrTerminated(info[0]->GetThreadNumber(), true);
+
+	if ( info[0]->mFunction.GetPtr() )
+	{
+		// Try ... catch
+		info[0]->mFunction->__run();
+	}
+
+    // Call the debugger function to annouce that a thread has terminated
+    //__hxcpp_dbg_threadCreatedOrTerminated(info[0]->GetThreadNumber(), false);
+
+	hx::UnregisterCurrentThread();
+
+	tlsCurrentThread = 0;
+
+	THREAD_FUNC_RET
+}
+
+
+
+Dynamic __hxcpp_thread_create(Dynamic inStart)
+{
+    #ifdef EMSCRIPTEN
+    return hx::Throw( HX_CSTRING("Threads are not supported on Emscripten") );
+    #else
+    g_threadInfoMutex.Lock();
+    int threadNumber = g_nextThreadNumber++;
+    g_threadInfoMutex.Unlock();
+
+	hxThreadInfo *info = new hxThreadInfo(inStart, threadNumber);
+
+	hx::GCPrepareMultiThreaded();
+	hx::EnterGCFreeZone();
+
+    bool ok = HxCreateDetachedThread(hxThreadFunc, info);
+    if (ok)
+    {
+       info->mSemaphore->Wait();
+    }
+
+    hx::ExitGCFreeZone();
+    info->CleanSemaphore();
+
+    if (!ok)
+       throw Dynamic( HX_CSTRING("Could not create thread") );
+    return info;
+    #endif
+}
+
+#ifdef HXCPP_THREAD_INFO_PTHREAD
+static pthread_key_t externThreadInfoKey;;
+static pthread_once_t key_once = PTHREAD_ONCE_INIT;
+static void destroyThreadInfo(void *i)
+{
+   hx::Object **threadRoot = (hx::Object **)i;
+   hx::GCRemoveRoot(threadRoot);
+   delete threadRoot;
+}
+static void make_key()
+{
+   pthread_key_create(&externThreadInfoKey, destroyThreadInfo);
+}
+#elif defined(HXCPP_THREAD_INFO_LOCAL)
+struct ThreadInfoHolder
+{
+   hx::Object **threadRoot;
+   ThreadInfoHolder() : threadRoot(0) { }
+   ~ThreadInfoHolder()
+   {
+      if (threadRoot)
+      {
+         hx::GCRemoveRoot(threadRoot);
+         delete threadRoot;
+      }
+   }
+   void set(hx::Object **info) { threadRoot = info; }
+   hxThreadInfo *get() { return threadRoot ? (hxThreadInfo *)*threadRoot : nullptr; }
+   
+};
+static thread_local ThreadInfoHolder threadHolder;
+#else
+static hx::Object **sMainThreadInfoRoot = 0;
+#endif
+
+static hxThreadInfo *GetCurrentInfo(bool createNew = true)
+{
+	hxThreadInfo *info = tlsCurrentThread;
+	if (!info)
+   {
+      #ifdef HXCPP_THREAD_INFO_PTHREAD
+      pthread_once(&key_once, make_key);
+      hxThreadInfo **pp = (hxThreadInfo **)pthread_getspecific(externThreadInfoKey);
+      if (pp)
+         info = *pp;
+      #elif defined(HXCPP_THREAD_INFO_LOCAL)
+      info = threadHolder.get();
+      #else
+      if (sMainThreadInfoRoot)
+      info = (hxThreadInfo *)*sMainThreadInfoRoot;
+      #endif
+   }
+
+	if (!info && createNew)
+	{
+      // New, non-haxe thread - might be the first thread, or might be a new
+      //  foreign thread.
+		info = new hxThreadInfo(null(), 0);
+      hx::Object **threadRoot = new hx::Object *;
+      *threadRoot = info; 
+		hx::GCAddRoot(threadRoot);
+      #ifdef HXCPP_THREAD_INFO_PTHREAD
+      pthread_setspecific(externThreadInfoKey, threadRoot);
+      #elif defined(HXCPP_THREAD_INFO_LOCAL)
+      threadHolder.set(threadRoot);
+      #else
+      sMainThreadInfoRoot = threadRoot;
+      #endif
+	}
+	return info;
+}
+
+Dynamic __hxcpp_thread_current()
+{
+	return GetCurrentInfo();
+}
+
+void __hxcpp_thread_send(Dynamic inThread, Dynamic inMessage)
+{
+	hxThreadInfo *info = dynamic_cast<hxThreadInfo *>(inThread.mPtr);
+	if (!info)
+		throw HX_INVALID_OBJECT;
+	info->Send(inMessage);
+}
+
+Dynamic __hxcpp_thread_read_message(bool inBlocked)
+{
+	hxThreadInfo *info = GetCurrentInfo();
+	return info->ReadMessage(inBlocked);
+}
+
+bool __hxcpp_is_current_thread(hx::Object *inThread)
+{
+   hxThreadInfo *info = tlsCurrentThread;
+   return info==inThread;
+}
+
+// --- TLS ------------------------------------------------------------
+
+Dynamic __hxcpp_tls_get(int inID)
+{
+	return GetCurrentInfo()->GetTLS(inID);
+}
+
+void __hxcpp_tls_set(int inID,Dynamic inVal)
+{
+	GetCurrentInfo()->SetTLS(inID,inVal);
+}
+
+
+
+// --- Mutex ------------------------------------------------------------
+
+class hxMutex : public hx::Object
+{
+public:
+
+	hxMutex()
+	{
+		mFinalizer = new hx::InternalFinalizer(this);
+		mFinalizer->mFinalizer = clean;
+	}
+
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdMutex };
+
+   #ifdef HXCPP_VISIT_ALLOCS
+	void __Visit(hx::VisitContext *__inCtx) { mFinalizer->Visit(__inCtx); }
+   #endif
+
+	hx::InternalFinalizer *mFinalizer;
+
+	static void clean(hx::Object *inObj)
+	{
+		hxMutex *m = dynamic_cast<hxMutex *>(inObj);
+		if (m) m->mMutex.Clean();
+	}
+	bool Try()
+	{
+		return mMutex.TryLock();
+	}
+	void Acquire()
+	{
+		hx::EnterGCFreeZone();
+		mMutex.Lock();
+		hx::ExitGCFreeZone();
+	}
+	void Release()
+	{
+		mMutex.Unlock();
+	}
+
+
+   HxMutex mMutex;
+};
+
+
+
+Dynamic __hxcpp_mutex_create()
+{
+	return new hxMutex;
+}
+void __hxcpp_mutex_acquire(Dynamic inMutex)
+{
+	hxMutex *mutex = dynamic_cast<hxMutex *>(inMutex.mPtr);
+	if (!mutex)
+		throw HX_INVALID_OBJECT;
+	mutex->Acquire();
+}
+bool __hxcpp_mutex_try(Dynamic inMutex)
+{
+	hxMutex *mutex = dynamic_cast<hxMutex *>(inMutex.mPtr);
+	if (!mutex)
+		throw HX_INVALID_OBJECT;
+	return mutex->Try();
+}
+void __hxcpp_mutex_release(Dynamic inMutex)
+{
+	hxMutex *mutex = dynamic_cast<hxMutex *>(inMutex.mPtr);
+	if (!mutex)
+		throw HX_INVALID_OBJECT;
+	return mutex->Release();
+}
+
+#if defined(HX_LINUX) || defined(HX_ANDROID)
+#define POSIX_SEMAPHORE
+#include <semaphore.h>
+#endif
+
+#if defined(HX_MACOS) || defined(IPHONE) || defined(APPLETV)
+#define APPLE_SEMAPHORE
+#include <dispatch/dispatch.h>
+#endif
+
+class hxSemaphore : public hx::Object {
+public:
+  hx::InternalFinalizer *mFinalizer;
+#ifdef HX_WINDOWS
+  HANDLE sem;
+#elif defined (POSIX_SEMAPHORE)
+  sem_t sem;
+#elif defined(APPLE_SEMAPHORE)
+	dispatch_semaphore_t sem;
+#endif
+  bool valid;
+
+  hxSemaphore(int value) {
+    mFinalizer = new hx::InternalFinalizer(this);
+    mFinalizer->mFinalizer = clean;
+#ifdef HX_WINDOWS
+    sem = CreateSemaphoreW(NULL, value, 0x7FFFFFFF, NULL);
+#elif defined(POSIX_SEMAPHORE)
+    sem_init(&sem, 0, value);
+#elif defined(APPLE_SEMAPHORE)
+    sem = dispatch_semaphore_create(value);
+#endif
+    valid = true;
+  }
+
+  HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdSemaphore };
+
+#ifdef HXCPP_VISIT_ALLOCS
+  void __Visit(hx::VisitContext *__inCtx) { mFinalizer->Visit(__inCtx); }
+#endif
+
+  void Acquire() {
+#if HX_WINDOWS
+	WaitForSingleObject(sem, INFINITE);
+#elif defined(POSIX_SEMAPHORE)
+    sem_wait(&sem);
+#elif defined(APPLE_SEMAPHORE)
+    dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
+#endif
+  }
+
+  bool TryAcquire(double timeout) {
+#ifdef HX_WINDOWS
+    return WaitForSingleObject(sem, (DWORD)((FLOAT)timeout * 1000.0)) == 0;
+#elif defined(POSIX_SEMAPHORE)
+    if (timeout == 0) {
+      return sem_trywait(&sem) == 0;
+    } else {
+      struct timeval tv;
+      struct timespec t;
+      double delta = timeout;
+      int idelta = (int)delta, idelta2;
+      delta -= idelta;
+      delta *= 1.0e9;
+      gettimeofday(&tv, NULL);
+      delta += tv.tv_usec * 1000.0;
+      idelta2 = (int)(delta / 1e9);
+      delta -= idelta2 * 1e9;
+      t.tv_sec = tv.tv_sec + idelta + idelta2;
+      t.tv_nsec = (long)delta;
+      return sem_timedwait(&sem, &t) == 0;
+    }
+#elif defined(APPLE_SEMAPHORE)
+    return dispatch_semaphore_wait(
+               sem,
+               dispatch_time(DISPATCH_TIME_NOW,
+                             (int64_t)(timeout * 1000 * 1000 * 1000))) == 0;
+#else
+	return false;
+#endif
+  }
+
+  void Release() {
+#if HX_WINDOWS
+	ReleaseSemaphore(sem, 1, NULL);
+#elif defined(POSIX_SEMAPHORE)
+    sem_post(&sem);
+#elif defined(APPLE_SEMAPHORE)
+    dispatch_semaphore_signal(sem);
+#endif
+  }
+
+  static void clean(hx::Object *inObj) {
+    hxSemaphore *l = dynamic_cast<hxSemaphore *>(inObj);
+    if (l) {
+      if(l->valid) {
+#ifdef HX_WINDOWS
+		CloseHandle(l->sem);
+#elif defined(POSIX_SEMAPHORE)
+		  sem_destroy(&l->sem);
+#endif
+		  l->valid = false;
+	  }
+    }
+  }
+};
+
+Dynamic __hxcpp_semaphore_create(int value) {
+  return new hxSemaphore(value);
+}
+void __hxcpp_semaphore_acquire(Dynamic inSemaphore) {
+  hxSemaphore *semaphore = dynamic_cast<hxSemaphore *>(inSemaphore.mPtr);
+  if (!semaphore)
+    throw HX_INVALID_OBJECT;
+  semaphore->Acquire();
+}
+bool __hxcpp_semaphore_try_acquire(Dynamic inSemaphore, double timeout) {
+  hxSemaphore *semaphore = dynamic_cast<hxSemaphore *>(inSemaphore.mPtr);
+  if (!semaphore)
+    throw HX_INVALID_OBJECT;
+  return semaphore->TryAcquire(timeout);
+}
+void __hxcpp_semaphore_release(Dynamic inSemaphore) {
+  hxSemaphore *semaphore = dynamic_cast<hxSemaphore *>(inSemaphore.mPtr);
+  if (!semaphore)
+    throw HX_INVALID_OBJECT;
+  semaphore->Release();
+}
+
+class hxCondition : public hx::Object {
+public:
+#ifdef HX_WINDOWS
+#ifndef HXCPP_WINXP_COMPAT
+	CRITICAL_SECTION cs;
+	CONDITION_VARIABLE cond;
+#endif
+#else
+	pthread_cond_t *cond;
+	pthread_mutex_t *mutex;
+#endif
+  hx::InternalFinalizer *mFinalizer;
+  hxCondition() {
+    mFinalizer = new hx::InternalFinalizer(this);
+    mFinalizer->mFinalizer = clean;
+#ifdef HX_WINDOWS
+#ifndef HXCPP_WINXP_COMPAT
+    InitializeCriticalSection(&cs);
+	InitializeConditionVariable(&cond);
+#else
+	throw Dynamic(HX_CSTRING("Condition variables are not supported on Windows XP"));
+#endif
+#else
+    pthread_condattr_t cond_attr;
+    pthread_condattr_init(&cond_attr);
+    cond = new pthread_cond_t();
+    pthread_cond_init(cond, &cond_attr);
+    pthread_condattr_destroy(&cond_attr);
+    pthread_mutexattr_t mutex_attr;
+    pthread_mutexattr_init(&mutex_attr);
+    mutex = new pthread_mutex_t();
+    pthread_mutex_init(mutex, &mutex_attr);
+    pthread_mutexattr_destroy(&mutex_attr);
+#endif
+  }
+
+  HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdCondition };
+
+#ifdef HXCPP_VISIT_ALLOCS
+  void __Visit(hx::VisitContext *__inCtx) { mFinalizer->Visit(__inCtx); }
+#endif
+  static void clean(hx::Object *inObj) {
+    hxCondition *cond = dynamic_cast<hxCondition *>(inObj);
+    if (cond) {
+#ifdef HX_WINDOWS
+#ifndef HXCPP_WINXP_COMPAT
+      DeleteCriticalSection(&cond->cs);
+#endif
+#else
+      pthread_cond_destroy(cond->cond);
+      delete cond->cond;
+      pthread_mutex_destroy(cond->mutex);
+      delete cond->mutex;
+#endif
+    }
+  }
+
+  void Acquire() {
+#ifdef HX_WINDOWS
+#ifndef HXCPP_WINXP_COMPAT
+	  EnterCriticalSection(&cs);
+#endif
+#else
+	  pthread_mutex_lock(mutex);
+#endif
+  }
+
+  bool TryAcquire() {
+#ifdef HX_WINDOWS
+#ifndef HXCPP_WINXP_COMPAT
+    return (bool)TryEnterCriticalSection(&cs);
+#else
+	return false;
+#endif
+#else
+    return pthread_mutex_trylock(mutex);
+#endif
+  }
+
+  void Release() {
+#ifdef HX_WINDOWS
+#ifndef HXCPP_WINXP_COMPAT
+	  LeaveCriticalSection(&cs);
+#endif
+#else
+	  pthread_mutex_unlock(mutex);
+#endif
+  }
+
+  void Wait() {
+#ifdef HX_WINDOWS
+#ifndef HXCPP_WINXP_COMPAT
+	  SleepConditionVariableCS(&cond,&cs,INFINITE);
+#endif
+#else
+	  pthread_cond_wait(cond, mutex);
+#endif
+  }
+
+  bool TimedWait(double timeout) {
+#ifdef HX_WINDOWS
+#ifndef HXCPP_WINXP_COMPAT
+	  return (bool)SleepConditionVariableCS(&cond, &cs, (DWORD)((FLOAT)timeout * 1000.0));
+#else
+	  return false;
+#endif
+#else
+    struct timeval tv;
+    struct timespec t;
+    double delta = timeout;
+    int idelta = (int)delta, idelta2;
+    delta -= idelta;
+    delta *= 1.0e9;
+    gettimeofday(&tv, NULL);
+    delta += tv.tv_usec * 1000.0;
+    idelta2 = (int)(delta / 1e9);
+    delta -= idelta2 * 1e9;
+    t.tv_sec = tv.tv_sec + idelta + idelta2;
+    t.tv_nsec = (long)delta;
+    return pthread_cond_timedwait(cond, mutex, &t);
+#endif
+  }
+  void Signal() {
+#ifdef HX_WINDOWS
+#ifndef HXCPP_WINXP_COMPAT
+	  WakeConditionVariable(&cond);
+#endif
+#else
+	  pthread_cond_signal(cond);
+#endif
+  }
+  void Broadcast() {
+#ifdef HX_WINDOWS
+#ifndef HXCPP_WINXP_COMPAT
+	  WakeAllConditionVariable(&cond);
+#endif
+#else
+	  pthread_cond_broadcast(cond);
+#endif
+  }
+};
+
+Dynamic __hxcpp_condition_create(void) {
+  return new hxCondition;
+}
+void __hxcpp_condition_acquire(Dynamic inCond) {
+  hxCondition *cond = dynamic_cast<hxCondition *>(inCond.mPtr);
+  if (!cond)
+    throw HX_INVALID_OBJECT;
+  cond->Acquire();
+}
+bool __hxcpp_condition_try_acquire(Dynamic inCond) {
+  hxCondition *cond = dynamic_cast<hxCondition *>(inCond.mPtr);
+  if (!cond)
+    throw HX_INVALID_OBJECT;
+  return cond->TryAcquire();
+}
+void __hxcpp_condition_release(Dynamic inCond) {
+  hxCondition *cond = dynamic_cast<hxCondition *>(inCond.mPtr);
+  if (!cond)
+    throw HX_INVALID_OBJECT;
+  cond->Release();
+}
+void __hxcpp_condition_wait(Dynamic inCond) {
+  hxCondition *cond = dynamic_cast<hxCondition *>(inCond.mPtr);
+  if (!cond)
+    throw HX_INVALID_OBJECT;
+  cond->Wait();
+}
+bool __hxcpp_condition_timed_wait(Dynamic inCond, double timeout) {
+  hxCondition *cond = dynamic_cast<hxCondition *>(inCond.mPtr);
+  if (!cond)
+    throw HX_INVALID_OBJECT;
+  return cond->TimedWait(timeout);
+}
+void __hxcpp_condition_signal(Dynamic inCond) {
+  hxCondition *cond = dynamic_cast<hxCondition *>(inCond.mPtr);
+  if (!cond)
+    throw HX_INVALID_OBJECT;
+  cond->Signal();
+}
+void __hxcpp_condition_broadcast(Dynamic inCond) {
+  hxCondition *cond = dynamic_cast<hxCondition *>(inCond.mPtr);
+  if (!cond)
+    throw HX_INVALID_OBJECT;
+  cond->Broadcast();
+}
+
+// --- Lock ------------------------------------------------------------
+
+class hxLock : public hx::Object
+{
+public:
+
+	hxLock()
+	{
+		mFinalizer = new hx::InternalFinalizer(this);
+		mFinalizer->mFinalizer = clean;
+	}
+
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdLock };
+
+   #ifdef HXCPP_VISIT_ALLOCS
+	void __Visit(hx::VisitContext *__inCtx) { mFinalizer->Visit(__inCtx); }
+   #endif
+
+	hx::InternalFinalizer *mFinalizer;
+
+	#if defined(HX_WINDOWS) || defined(__SNC__)
+	double Now()
+	{
+		return (double)clock()/CLOCKS_PER_SEC;
+	}
+	#else
+	double Now()
+	{
+		struct timeval tv;
+		gettimeofday(&tv,0);
+		return tv.tv_sec + tv.tv_usec*0.000001;
+	}
+	#endif
+
+	static void clean(hx::Object *inObj)
+	{
+		hxLock *l = dynamic_cast<hxLock *>(inObj);
+		if (l)
+		{
+			l->mNotEmpty.Clean();
+			l->mAvailableLock.Clean();
+		}
+	}
+	bool Wait(double inTimeout)
+	{
+		double stop = 0;
+		if (inTimeout>=0)
+			stop = Now() + inTimeout;
+		while(1)
+		{
+			mAvailableLock.Lock();
+			if (mAvailable)
+			{
+				--mAvailable;
+		      if (mAvailable>0)
+               mNotEmpty.Set();
+				mAvailableLock.Unlock();
+				return true;
+			}
+			mAvailableLock.Unlock();
+			double wait = 0;
+			if (inTimeout>=0)
+			{
+				wait = stop-Now();
+				if (wait<=0)
+					return false;
+			}
+
+			hx::EnterGCFreeZone();
+			if (inTimeout<0)
+				mNotEmpty.Wait( );
+			else
+				mNotEmpty.WaitSeconds(wait);
+			hx::ExitGCFreeZone();
+		}
+	}
+	void Release()
+	{
+		AutoLock lock(mAvailableLock);
+		mAvailable++;
+		mNotEmpty.Set();
+	}
+
+
+	HxSemaphore mNotEmpty;
+   HxMutex     mAvailableLock;
+	int         mAvailable;
+};
+
+
+
+Dynamic __hxcpp_lock_create()
+{
+	return new hxLock;
+}
+bool __hxcpp_lock_wait(Dynamic inlock,double inTime)
+{
+	hxLock *lock = dynamic_cast<hxLock *>(inlock.mPtr);
+	if (!lock)
+		throw HX_INVALID_OBJECT;
+	return lock->Wait(inTime);
+}
+void __hxcpp_lock_release(Dynamic inlock)
+{
+	hxLock *lock = dynamic_cast<hxLock *>(inlock.mPtr);
+	if (!lock)
+		throw HX_INVALID_OBJECT;
+	lock->Release();
+}
+
+
+int __hxcpp_GetCurrentThreadNumber()
+{
+    // Can't allow GetCurrentInfo() to create the main thread's info
+    // because that can cause a call loop.
+    hxThreadInfo *threadInfo = GetCurrentInfo(false);
+    if (!threadInfo) {
+        return 0;
+    }
+    return threadInfo->GetThreadNumber();
+}
+
+// --- Atomic ---
+
+bool _hx_atomic_exchange_if(::cpp::Pointer<cpp::AtomicInt> inPtr, int test, int  newVal )
+{
+   return _hx_atomic_compare_exchange(inPtr, test, newVal) == test;
+}
+
+int _hx_atomic_inc(::cpp::Pointer<cpp::AtomicInt> inPtr )
+{
+   return _hx_atomic_add(inPtr, 1);
+}
+
+int _hx_atomic_dec(::cpp::Pointer<cpp::AtomicInt> inPtr )
+{
+   return _hx_atomic_sub(inPtr, 1);
+}
+
+
diff --git a/Sources/c_snikket/src/hx/Unicase.h b/Sources/c_snikket/src/hx/Unicase.h
new file mode 100755
index 0000000..564c0e4
--- /dev/null
+++ b/Sources/c_snikket/src/hx/Unicase.h
@@ -0,0 +1,125 @@
+#define UL_BITS 6
+#define UL_SIZE 64
+static unsigned short _E[UL_SIZE] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static unsigned short L1[UL_SIZE] = {0,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static unsigned short L3[UL_SIZE] = {224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,0,248,249,250,251,252,253,254,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static unsigned short L4[UL_SIZE] = {257,0,259,0,261,0,263,0,265,0,267,0,269,0,271,0,273,0,275,0,277,0,279,0,281,0,283,0,285,0,287,0,289,0,291,0,293,0,295,0,297,0,299,0,301,0,303,0,105,0,307,0,309,0,311,0,0,314,0,316,0,318,0,320};
+static unsigned short L5[UL_SIZE] = {0,322,0,324,0,326,0,328,0,0,331,0,333,0,335,0,337,0,339,0,341,0,343,0,345,0,347,0,349,0,351,0,353,0,355,0,357,0,359,0,361,0,363,0,365,0,367,0,369,0,371,0,373,0,375,0,255,378,0,380,0,382,0,0};
+static unsigned short L6[UL_SIZE] = {0,595,387,0,389,0,596,392,0,598,599,396,0,0,477,601,603,402,0,608,611,0,617,616,409,0,0,0,623,626,0,629,417,0,419,0,421,0,640,424,0,643,0,0,429,0,648,432,0,650,651,436,0,438,0,658,441,0,0,0,445,0,0,0};
+static unsigned short L7[UL_SIZE] = {0,0,0,0,454,454,0,457,457,0,460,460,0,462,0,464,0,466,0,468,0,470,0,472,0,474,0,476,0,0,479,0,481,0,483,0,485,0,487,0,489,0,491,0,493,0,495,0,0,499,499,0,501,0,405,447,505,0,507,0,509,0,511,0};
+static unsigned short L8[UL_SIZE] = {513,0,515,0,517,0,519,0,521,0,523,0,525,0,527,0,529,0,531,0,533,0,535,0,537,0,539,0,541,0,543,0,414,0,547,0,549,0,551,0,553,0,555,0,557,0,559,0,561,0,563,0,0,0,0,0,0,0,11365,572,0,410,11366,0};
+static unsigned short L9[UL_SIZE] = {0,578,0,384,649,652,583,0,585,0,587,0,589,0,591,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static unsigned short L13[UL_SIZE] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,881,0,883,0,0,0,887,0,0,0,0,0,0,0,0,1011};
+static unsigned short L14[UL_SIZE] = {0,0,0,0,0,0,940,0,941,942,943,0,972,0,973,974,0,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,0,963,964,965,966,967,968,969,970,971,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static unsigned short L15[UL_SIZE] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,983,0,0,0,0,0,0,0,0,985,0,987,0,989,0,991,0,993,0,995,0,997,0,999,0,1001,0,1003,0,1005,0,1007,0,0,0,0,0,952,0,0,1016,0,1010,1019,0,0,891,892,893};
+static unsigned short L16[UL_SIZE] = {1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static unsigned short L17[UL_SIZE] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1121,0,1123,0,1125,0,1127,0,1129,0,1131,0,1133,0,1135,0,1137,0,1139,0,1141,0,1143,0,1145,0,1147,0,1149,0,1151,0};
+static unsigned short L18[UL_SIZE] = {1153,0,0,0,0,0,0,0,0,0,1163,0,1165,0,1167,0,1169,0,1171,0,1173,0,1175,0,1177,0,1179,0,1181,0,1183,0,1185,0,1187,0,1189,0,1191,0,1193,0,1195,0,1197,0,1199,0,1201,0,1203,0,1205,0,1207,0,1209,0,1211,0,1213,0,1215,0};
+static unsigned short L19[UL_SIZE] = {1231,1218,0,1220,0,1222,0,1224,0,1226,0,1228,0,1230,0,0,1233,0,1235,0,1237,0,1239,0,1241,0,1243,0,1245,0,1247,0,1249,0,1251,0,1253,0,1255,0,1257,0,1259,0,1261,0,1263,0,1265,0,1267,0,1269,0,1271,0,1273,0,1275,0,1277,0,1279,0};
+static unsigned short L20[UL_SIZE] = {1281,0,1283,0,1285,0,1287,0,1289,0,1291,0,1293,0,1295,0,1297,0,1299,0,1301,0,1303,0,1305,0,1307,0,1309,0,1311,0,1313,0,1315,0,1317,0,1319,0,1321,0,1323,0,1325,0,1327,0,0,1377,1378,1379,1380,1381,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391};
+static unsigned short L21[UL_SIZE] = {1392,1393,1394,1395,1396,1397,1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1411,1412,1413,1414,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static unsigned short L66[UL_SIZE] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11520,11521,11522,11523,11524,11525,11526,11527,11528,11529,11530,11531,11532,11533,11534,11535,11536,11537,11538,11539,11540,11541,11542,11543,11544,11545,11546,11547,11548,11549,11550,11551};
+static unsigned short L67[UL_SIZE] = {11552,11553,11554,11555,11556,11557,0,11559,0,0,0,0,0,11565,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static unsigned short L78[UL_SIZE] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,43888,43889,43890,43891,43892,43893,43894,43895,43896,43897,43898,43899,43900,43901,43902,43903,43904,43905,43906,43907,43908,43909,43910,43911,43912,43913,43914,43915,43916,43917,43918,43919};
+static unsigned short L79[UL_SIZE] = {43920,43921,43922,43923,43924,43925,43926,43927,43928,43929,43930,43931,43932,43933,43934,43935,43936,43937,43938,43939,43940,43941,43942,43943,43944,43945,43946,43947,43948,43949,43950,43951,43952,43953,43954,43955,43956,43957,43958,43959,43960,43961,43962,43963,43964,43965,43966,43967,5112,5113,5114,5115,5116,5117,0,0,0,0,0,0,0,0,0,0};
+static unsigned short L120[UL_SIZE] = {7681,0,7683,0,7685,0,7687,0,7689,0,7691,0,7693,0,7695,0,7697,0,7699,0,7701,0,7703,0,7705,0,7707,0,7709,0,7711,0,7713,0,7715,0,7717,0,7719,0,7721,0,7723,0,7725,0,7727,0,7729,0,7731,0,7733,0,7735,0,7737,0,7739,0,7741,0,7743,0};
+static unsigned short L121[UL_SIZE] = {7745,0,7747,0,7749,0,7751,0,7753,0,7755,0,7757,0,7759,0,7761,0,7763,0,7765,0,7767,0,7769,0,7771,0,7773,0,7775,0,7777,0,7779,0,7781,0,7783,0,7785,0,7787,0,7789,0,7791,0,7793,0,7795,0,7797,0,7799,0,7801,0,7803,0,7805,0,7807,0};
+static unsigned short L122[UL_SIZE] = {7809,0,7811,0,7813,0,7815,0,7817,0,7819,0,7821,0,7823,0,7825,0,7827,0,7829,0,0,0,0,0,0,0,0,0,223,0,7841,0,7843,0,7845,0,7847,0,7849,0,7851,0,7853,0,7855,0,7857,0,7859,0,7861,0,7863,0,7865,0,7867,0,7869,0,7871,0};
+static unsigned short L123[UL_SIZE] = {7873,0,7875,0,7877,0,7879,0,7881,0,7883,0,7885,0,7887,0,7889,0,7891,0,7893,0,7895,0,7897,0,7899,0,7901,0,7903,0,7905,0,7907,0,7909,0,7911,0,7913,0,7915,0,7917,0,7919,0,7921,0,7923,0,7925,0,7927,0,7929,0,7931,0,7933,0,7935,0};
+static unsigned short L124[UL_SIZE] = {0,0,0,0,0,0,0,0,7936,7937,7938,7939,7940,7941,7942,7943,0,0,0,0,0,0,0,0,7952,7953,7954,7955,7956,7957,0,0,0,0,0,0,0,0,0,0,7968,7969,7970,7971,7972,7973,7974,7975,0,0,0,0,0,0,0,0,7984,7985,7986,7987,7988,7989,7990,7991};
+static unsigned short L125[UL_SIZE] = {0,0,0,0,0,0,0,0,8000,8001,8002,8003,8004,8005,0,0,0,0,0,0,0,0,0,0,0,8017,0,8019,0,8021,0,8023,0,0,0,0,0,0,0,0,8032,8033,8034,8035,8036,8037,8038,8039,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static unsigned short L126[UL_SIZE] = {0,0,0,0,0,0,0,0,8064,8065,8066,8067,8068,8069,8070,8071,0,0,0,0,0,0,0,0,8080,8081,8082,8083,8084,8085,8086,8087,0,0,0,0,0,0,0,0,8096,8097,8098,8099,8100,8101,8102,8103,0,0,0,0,0,0,0,0,8112,8113,8048,8049,8115,0,0,0};
+static unsigned short L127[UL_SIZE] = {0,0,0,0,0,0,0,0,8050,8051,8052,8053,8131,0,0,0,0,0,0,0,0,0,0,0,8144,8145,8054,8055,0,0,0,0,0,0,0,0,0,0,0,0,8160,8161,8058,8059,8165,0,0,0,0,0,0,0,0,0,0,0,8056,8057,8060,8061,8179,0,0,0};
+static unsigned short L132[UL_SIZE] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,969,0,0,0,107,229,0,0,0,0,0,0,8526,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static unsigned short L133[UL_SIZE] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8560,8561,8562,8563,8564,8565,8566,8567,8568,8569,8570,8571,8572,8573,8574,8575,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static unsigned short L134[UL_SIZE] = {0,0,0,8580,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static unsigned short L146[UL_SIZE] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9424,9425,9426,9427,9428,9429,9430,9431,9432,9433};
+static unsigned short L147[UL_SIZE] = {9434,9435,9436,9437,9438,9439,9440,9441,9442,9443,9444,9445,9446,9447,9448,9449,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static unsigned short L176[UL_SIZE] = {11312,11313,11314,11315,11316,11317,11318,11319,11320,11321,11322,11323,11324,11325,11326,11327,11328,11329,11330,11331,11332,11333,11334,11335,11336,11337,11338,11339,11340,11341,11342,11343,11344,11345,11346,11347,11348,11349,11350,11351,11352,11353,11354,11355,11356,11357,11358,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static unsigned short L177[UL_SIZE] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11361,0,619,7549,637,0,0,11368,0,11370,0,11372,0,593,625,592,594,0,11379,0,0,11382,0,0,0,0,0,0,0,0,575,576};
+static unsigned short L178[UL_SIZE] = {11393,0,11395,0,11397,0,11399,0,11401,0,11403,0,11405,0,11407,0,11409,0,11411,0,11413,0,11415,0,11417,0,11419,0,11421,0,11423,0,11425,0,11427,0,11429,0,11431,0,11433,0,11435,0,11437,0,11439,0,11441,0,11443,0,11445,0,11447,0,11449,0,11451,0,11453,0,11455,0};
+static unsigned short L179[UL_SIZE] = {11457,0,11459,0,11461,0,11463,0,11465,0,11467,0,11469,0,11471,0,11473,0,11475,0,11477,0,11479,0,11481,0,11483,0,11485,0,11487,0,11489,0,11491,0,0,0,0,0,0,0,0,11500,0,11502,0,0,0,0,11507,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static unsigned short L665[UL_SIZE] = {42561,0,42563,0,42565,0,42567,0,42569,0,42571,0,42573,0,42575,0,42577,0,42579,0,42581,0,42583,0,42585,0,42587,0,42589,0,42591,0,42593,0,42595,0,42597,0,42599,0,42601,0,42603,0,42605,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static unsigned short L666[UL_SIZE] = {42625,0,42627,0,42629,0,42631,0,42633,0,42635,0,42637,0,42639,0,42641,0,42643,0,42645,0,42647,0,42649,0,42651,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static unsigned short L668[UL_SIZE] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,42787,0,42789,0,42791,0,42793,0,42795,0,42797,0,42799,0,0,0,42803,0,42805,0,42807,0,42809,0,42811,0,42813,0,42815,0};
+static unsigned short L669[UL_SIZE] = {42817,0,42819,0,42821,0,42823,0,42825,0,42827,0,42829,0,42831,0,42833,0,42835,0,42837,0,42839,0,42841,0,42843,0,42845,0,42847,0,42849,0,42851,0,42853,0,42855,0,42857,0,42859,0,42861,0,42863,0,0,0,0,0,0,0,0,0,0,42874,0,42876,0,7545,42879,0};
+static unsigned short L670[UL_SIZE] = {42881,0,42883,0,42885,0,42887,0,0,0,0,42892,0,613,0,0,42897,0,42899,0,0,0,42903,0,42905,0,42907,0,42909,0,42911,0,42913,0,42915,0,42917,0,42919,0,42921,0,614,604,609,620,0,0,670,647,669,43859,42933,0,42935,0,0,0,0,0,0,0,0,0};
+static unsigned short L1020[UL_SIZE] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,65345,65346,65347,65348,65349,65350,65351,65352,65353,65354,65355,65356,65357,65358,65359,65360,65361,65362,65363,65364,65365,65366,65367,65368,65369,65370,0,0,0,0,0};
+static unsigned short U1[UL_SIZE] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,0,0,0,0,0};
+static unsigned short U2[UL_SIZE] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,924,0,0,0,0,0,0,0,0,0,0};
+static unsigned short U3[UL_SIZE] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,0,216,217,218,219,220,221,222,376};
+static unsigned short U4[UL_SIZE] = {0,256,0,258,0,260,0,262,0,264,0,266,0,268,0,270,0,272,0,274,0,276,0,278,0,280,0,282,0,284,0,286,0,288,0,290,0,292,0,294,0,296,0,298,0,300,0,302,0,73,0,306,0,308,0,310,0,0,313,0,315,0,317,0};
+static unsigned short U5[UL_SIZE] = {319,0,321,0,323,0,325,0,327,0,0,330,0,332,0,334,0,336,0,338,0,340,0,342,0,344,0,346,0,348,0,350,0,352,0,354,0,356,0,358,0,360,0,362,0,364,0,366,0,368,0,370,0,372,0,374,0,0,377,0,379,0,381,83};
+static unsigned short U6[UL_SIZE] = {579,0,0,386,0,388,0,0,391,0,0,0,395,0,0,0,0,0,401,0,0,502,0,0,0,408,573,0,0,0,544,0,0,416,0,418,0,420,0,0,423,0,0,0,0,428,0,0,431,0,0,0,435,0,437,0,0,440,0,0,0,444,0,503};
+static unsigned short U7[UL_SIZE] = {0,0,0,0,453,453,453,456,456,456,459,459,459,0,461,0,463,0,465,0,467,0,469,0,471,0,473,0,475,398,0,478,0,480,0,482,0,484,0,486,0,488,0,490,0,492,0,494,0,498,498,498,0,500,0,0,0,504,0,506,0,508,0,510};
+static unsigned short U8[UL_SIZE] = {0,512,0,514,0,516,0,518,0,520,0,522,0,524,0,526,0,528,0,530,0,532,0,534,0,536,0,538,0,540,0,542,0,0,0,546,0,548,0,550,0,552,0,554,0,556,0,558,0,560,0,562,0,0,0,0,0,0,0,0,571,0,0,11390};
+static unsigned short U9[UL_SIZE] = {11391,0,577,0,0,0,0,582,0,584,0,586,0,588,0,590,11375,11373,11376,385,390,0,393,394,0,399,0,400,42923,0,0,0,403,42924,0,404,0,42893,42922,0,407,406,0,11362,42925,0,0,412,0,11374,413,0,0,415,0,0,0,0,0,0,0,11364,0,0};
+static unsigned short U10[UL_SIZE] = {422,0,0,425,0,0,0,42929,430,580,433,434,581,0,0,0,0,0,439,0,0,0,0,0,0,0,0,0,0,42930,42928,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static unsigned short U13[UL_SIZE] = {0,0,0,0,0,921,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,880,0,882,0,0,0,886,0,0,0,1021,1022,1023,0,0};
+static unsigned short U14[UL_SIZE] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,902,904,905,906,0,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927};
+static unsigned short U15[UL_SIZE] = {928,929,931,931,932,933,934,935,936,937,938,939,908,910,911,0,914,920,0,0,0,934,928,975,0,984,0,986,0,988,0,990,0,992,0,994,0,996,0,998,0,1000,0,1002,0,1004,0,1006,922,929,1017,895,0,917,0,0,1015,0,0,1018,0,0,0,0};
+static unsigned short U16[UL_SIZE] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055};
+static unsigned short U17[UL_SIZE] = {1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,0,1120,0,1122,0,1124,0,1126,0,1128,0,1130,0,1132,0,1134,0,1136,0,1138,0,1140,0,1142,0,1144,0,1146,0,1148,0,1150};
+static unsigned short U18[UL_SIZE] = {0,1152,0,0,0,0,0,0,0,0,0,1162,0,1164,0,1166,0,1168,0,1170,0,1172,0,1174,0,1176,0,1178,0,1180,0,1182,0,1184,0,1186,0,1188,0,1190,0,1192,0,1194,0,1196,0,1198,0,1200,0,1202,0,1204,0,1206,0,1208,0,1210,0,1212,0,1214};
+static unsigned short U19[UL_SIZE] = {0,0,1217,0,1219,0,1221,0,1223,0,1225,0,1227,0,1229,1216,0,1232,0,1234,0,1236,0,1238,0,1240,0,1242,0,1244,0,1246,0,1248,0,1250,0,1252,0,1254,0,1256,0,1258,0,1260,0,1262,0,1264,0,1266,0,1268,0,1270,0,1272,0,1274,0,1276,0,1278};
+static unsigned short U20[UL_SIZE] = {0,1280,0,1282,0,1284,0,1286,0,1288,0,1290,0,1292,0,1294,0,1296,0,1298,0,1300,0,1302,0,1304,0,1306,0,1308,0,1310,0,1312,0,1314,0,1316,0,1318,0,1320,0,1322,0,1324,0,1326,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static unsigned short U21[UL_SIZE] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1329,1330,1331,1332,1333,1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359};
+static unsigned short U22[UL_SIZE] = {1360,1361,1362,1363,1364,1365,1366,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static unsigned short U79[UL_SIZE] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5104,5105,5106,5107,5108,5109,0,0};
+static unsigned short U117[UL_SIZE] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,42877,0,0,0,11363,0,0};
+static unsigned short U120[UL_SIZE] = {0,7680,0,7682,0,7684,0,7686,0,7688,0,7690,0,7692,0,7694,0,7696,0,7698,0,7700,0,7702,0,7704,0,7706,0,7708,0,7710,0,7712,0,7714,0,7716,0,7718,0,7720,0,7722,0,7724,0,7726,0,7728,0,7730,0,7732,0,7734,0,7736,0,7738,0,7740,0,7742};
+static unsigned short U121[UL_SIZE] = {0,7744,0,7746,0,7748,0,7750,0,7752,0,7754,0,7756,0,7758,0,7760,0,7762,0,7764,0,7766,0,7768,0,7770,0,7772,0,7774,0,7776,0,7778,0,7780,0,7782,0,7784,0,7786,0,7788,0,7790,0,7792,0,7794,0,7796,0,7798,0,7800,0,7802,0,7804,0,7806};
+static unsigned short U122[UL_SIZE] = {0,7808,0,7810,0,7812,0,7814,0,7816,0,7818,0,7820,0,7822,0,7824,0,7826,0,7828,0,0,0,0,0,7776,0,0,0,0,0,7840,0,7842,0,7844,0,7846,0,7848,0,7850,0,7852,0,7854,0,7856,0,7858,0,7860,0,7862,0,7864,0,7866,0,7868,0,7870};
+static unsigned short U123[UL_SIZE] = {0,7872,0,7874,0,7876,0,7878,0,7880,0,7882,0,7884,0,7886,0,7888,0,7890,0,7892,0,7894,0,7896,0,7898,0,7900,0,7902,0,7904,0,7906,0,7908,0,7910,0,7912,0,7914,0,7916,0,7918,0,7920,0,7922,0,7924,0,7926,0,7928,0,7930,0,7932,0,7934};
+static unsigned short U124[UL_SIZE] = {7944,7945,7946,7947,7948,7949,7950,7951,0,0,0,0,0,0,0,0,7960,7961,7962,7963,7964,7965,0,0,0,0,0,0,0,0,0,0,7976,7977,7978,7979,7980,7981,7982,7983,0,0,0,0,0,0,0,0,7992,7993,7994,7995,7996,7997,7998,7999,0,0,0,0,0,0,0,0};
+static unsigned short U125[UL_SIZE] = {8008,8009,8010,8011,8012,8013,0,0,0,0,0,0,0,0,0,0,0,8025,0,8027,0,8029,0,8031,0,0,0,0,0,0,0,0,8040,8041,8042,8043,8044,8045,8046,8047,0,0,0,0,0,0,0,0,8122,8123,8136,8137,8138,8139,8154,8155,8184,8185,8170,8171,8186,8187,0,0};
+static unsigned short U126[UL_SIZE] = {8072,8073,8074,8075,8076,8077,8078,8079,0,0,0,0,0,0,0,0,8088,8089,8090,8091,8092,8093,8094,8095,0,0,0,0,0,0,0,0,8104,8105,8106,8107,8108,8109,8110,8111,0,0,0,0,0,0,0,0,8120,8121,0,8124,0,0,0,0,0,0,0,0,0,0,921,0};
+static unsigned short U127[UL_SIZE] = {0,0,0,8140,0,0,0,0,0,0,0,0,0,0,0,0,8152,8153,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8168,8169,0,0,0,8172,0,0,0,0,0,0,0,0,0,0,0,0,0,8188,0,0,0,0,0,0,0,0,0,0,0,0};
+static unsigned short U133[UL_SIZE] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,8498,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8544,8545,8546,8547,8548,8549,8550,8551,8552,8553,8554,8555,8556,8557,8558,8559};
+static unsigned short U134[UL_SIZE] = {0,0,0,0,8579,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static unsigned short U147[UL_SIZE] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9398,9399,9400,9401,9402,9403,9404,9405,9406,9407,9408,9409,9410,9411,9412,9413,9414,9415,9416,9417,9418,9419,9420,9421,9422,9423,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static unsigned short U176[UL_SIZE] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11264,11265,11266,11267,11268,11269,11270,11271,11272,11273,11274,11275,11276,11277,11278,11279};
+static unsigned short U177[UL_SIZE] = {11280,11281,11282,11283,11284,11285,11286,11287,11288,11289,11290,11291,11292,11293,11294,11295,11296,11297,11298,11299,11300,11301,11302,11303,11304,11305,11306,11307,11308,11309,11310,0,0,11360,0,0,0,570,574,0,11367,0,11369,0,11371,0,0,0,0,0,0,11378,0,0,11381,0,0,0,0,0,0,0,0,0};
+static unsigned short U178[UL_SIZE] = {0,11392,0,11394,0,11396,0,11398,0,11400,0,11402,0,11404,0,11406,0,11408,0,11410,0,11412,0,11414,0,11416,0,11418,0,11420,0,11422,0,11424,0,11426,0,11428,0,11430,0,11432,0,11434,0,11436,0,11438,0,11440,0,11442,0,11444,0,11446,0,11448,0,11450,0,11452,0,11454};
+static unsigned short U179[UL_SIZE] = {0,11456,0,11458,0,11460,0,11462,0,11464,0,11466,0,11468,0,11470,0,11472,0,11474,0,11476,0,11478,0,11480,0,11482,0,11484,0,11486,0,11488,0,11490,0,0,0,0,0,0,0,0,11499,0,11501,0,0,0,0,11506,0,0,0,0,0,0,0,0,0,0,0,0};
+static unsigned short U180[UL_SIZE] = {4256,4257,4258,4259,4260,4261,4262,4263,4264,4265,4266,4267,4268,4269,4270,4271,4272,4273,4274,4275,4276,4277,4278,4279,4280,4281,4282,4283,4284,4285,4286,4287,4288,4289,4290,4291,4292,4293,0,4295,0,0,0,0,0,4301,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static unsigned short U665[UL_SIZE] = {0,42560,0,42562,0,42564,0,42566,0,42568,0,42570,0,42572,0,42574,0,42576,0,42578,0,42580,0,42582,0,42584,0,42586,0,42588,0,42590,0,42592,0,42594,0,42596,0,42598,0,42600,0,42602,0,42604,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static unsigned short U666[UL_SIZE] = {0,42624,0,42626,0,42628,0,42630,0,42632,0,42634,0,42636,0,42638,0,42640,0,42642,0,42644,0,42646,0,42648,0,42650,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static unsigned short U668[UL_SIZE] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,42786,0,42788,0,42790,0,42792,0,42794,0,42796,0,42798,0,0,0,42802,0,42804,0,42806,0,42808,0,42810,0,42812,0,42814};
+static unsigned short U669[UL_SIZE] = {0,42816,0,42818,0,42820,0,42822,0,42824,0,42826,0,42828,0,42830,0,42832,0,42834,0,42836,0,42838,0,42840,0,42842,0,42844,0,42846,0,42848,0,42850,0,42852,0,42854,0,42856,0,42858,0,42860,0,42862,0,0,0,0,0,0,0,0,0,0,42873,0,42875,0,0,42878};
+static unsigned short U670[UL_SIZE] = {0,42880,0,42882,0,42884,0,42886,0,0,0,0,42891,0,0,0,0,42896,0,42898,0,0,0,42902,0,42904,0,42906,0,42908,0,42910,0,42912,0,42914,0,42916,0,42918,0,42920,0,0,0,0,0,0,0,0,0,0,0,42932,0,42934,0,0,0,0,0,0,0,0};
+static unsigned short U685[UL_SIZE] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,42931,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5024,5025,5026,5027,5028,5029,5030,5031,5032,5033,5034,5035,5036,5037,5038,5039};
+static unsigned short U686[UL_SIZE] = {5040,5041,5042,5043,5044,5045,5046,5047,5048,5049,5050,5051,5052,5053,5054,5055,5056,5057,5058,5059,5060,5061,5062,5063,5064,5065,5066,5067,5068,5069,5070,5071,5072,5073,5074,5075,5076,5077,5078,5079,5080,5081,5082,5083,5084,5085,5086,5087,5088,5089,5090,5091,5092,5093,5094,5095,5096,5097,5098,5099,5100,5101,5102,5103};
+static unsigned short U1021[UL_SIZE] = {0,65313,65314,65315,65316,65317,65318,65319,65320,65321,65322,65323,65324,65325,65326,65327,65328,65329,65330,65331,65332,65333,65334,65335,65336,65337,65338,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+#define LMAX 1021
+#define UMAX 1022
+static unsigned short *LOWER[LMAX] = {_E,L1,_E,L3,L4,L5,L6,L7,L8,L9,_E,_E,_E,L13,L14,L15,L16,L17,L18,L19,L20,L21,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,L66,L67,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,L78,L79,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,L120,L121,L122,L123,L124,L125,L126,L127,_E,_E,_E,_E,L132,L133,L134,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,L146,L147,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,L176,L177,L178,L179,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,L665,L666,_E,L668,L669,L670,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,L1020};
+static unsigned short *UPPER[UMAX] = {_E,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,_E,_E,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,U79,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,U117,_E,_E,U120,U121,U122,U123,U124,U125,U126,U127,_E,_E,_E,_E,_E,U133,U134,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,U147,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,U176,U177,U178,U179,U180,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,U665,U666,_E,U668,U669,U670,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,U685,U686,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,_E,U1021};
+
+
+
+inline int unicase_toupper(int c)
+{
+   int up = c >> UL_BITS;
+   if( up < UMAX )
+   {
+      unsigned int c2 = UPPER[up][c&((1<<UL_BITS)-1)];
+      if( c2 )
+         return c2;
+   }
+   return c;
+}
+
+inline int unicase_tolower(int c)
+{
+   int up = c >> UL_BITS;
+   if( up < LMAX )
+   {
+      unsigned int c2 = LOWER[up][c&((1<<UL_BITS)-1)];
+      if( c2 )
+         return c2;
+   }
+   return c;
+}
+
+
diff --git a/Sources/c_snikket/src/hx/gc/GcCommon.cpp b/Sources/c_snikket/src/hx/gc/GcCommon.cpp
new file mode 100644
index 0000000..f336fd6
--- /dev/null
+++ b/Sources/c_snikket/src/hx/gc/GcCommon.cpp
@@ -0,0 +1,182 @@
+#include <hxcpp.h>
+
+#include <map>
+#include <vector>
+#include <set>
+#include <stdlib.h>
+
+#if defined(HXCPP_CAPTURE_x64) && !defined(__GNUC__)
+#include <windows.h>
+#endif
+
+
+#ifdef _WIN32
+
+#define GC_WIN32_THREADS
+#include <time.h>
+
+#endif
+
+#ifdef HXCPP_TELEMETRY
+extern void __hxt_new_string(void* result, int size);
+#endif
+
+
+
+
+namespace hx
+{
+#if defined(HX_MACOS) || defined(HX_WINDOWS) || defined(HX_LINUX) || defined(__ORBIS__)
+int sgMinimumWorkingMemory       = 20*1024*1024;
+int sgMinimumFreeSpace           = 10*1024*1024;
+#else
+int sgMinimumWorkingMemory       = 8*1024*1024;
+int sgMinimumFreeSpace           = 4*1024*1024;
+#endif
+// Once you use more than the minimum, this kicks in...
+int sgTargetFreeSpacePercentage  = 100;
+
+
+
+
+
+
+// Called internally before and GC operations
+void CommonInitAlloc()
+{
+   #if !defined(HX_WINRT) && !defined(__SNC__) && !defined(__ORBIS__)
+   const char *minimumWorking = getenv("HXCPP_MINIMUM_WORKING_MEMORY");
+   if (minimumWorking)
+   {
+      int mem =  atoi(minimumWorking);
+      if (mem>0)
+         sgMinimumWorkingMemory = mem;
+   }
+
+   const char *minimumFreeSpace = getenv("HXCPP_MINIMUM_FREE_SPACE");
+   if (minimumFreeSpace)
+   {
+      int mem =  atoi(minimumFreeSpace);
+      if (mem>0)
+         sgMinimumFreeSpace = mem;
+   }
+
+
+   const char *targetFree = getenv("HXCPP_TARGET_FREE_SPACE");
+   if (targetFree)
+   {
+      int percent =  atoi(targetFree);
+      if (percent>0)
+         sgTargetFreeSpacePercentage = percent;
+   }
+   #endif
+}
+
+} // end namespace hx
+
+
+
+void *String::operator new( size_t inSize )
+{
+   return hx::InternalNew(inSize,false);
+}
+
+
+void __hxcpp_collect(bool inMajor)
+{
+   hx::InternalCollect(inMajor,inMajor);
+}
+
+
+void __hxcpp_gc_compact()
+{
+   int mem = hx::InternalCollect(true,true);
+   while(true)
+   {
+      int compact = hx::InternalCollect(true,true);
+      if (compact>=mem-16384)
+         break;
+      mem = compact;
+   }
+}
+
+namespace hx
+{
+
+void GCAddFinalizer(hx::Object *v, finalizer f)
+{
+   if (v)
+   {
+      throw Dynamic(HX_CSTRING("Add finalizer error"));
+   }
+}
+
+HX_CHAR *NewString(int inLen)
+{
+   char *result =  (char *)hx::InternalNew( (inLen+1)*sizeof(char), false );
+   result[inLen] = '\0';
+#ifdef HXCPP_TELEMETRY
+   __hxt_new_string(result, inLen+1);
+#endif
+   return result;
+
+}
+
+void *NewGCBytes(void *inData,int inSize)
+{
+   void *result =  hx::InternalNew(inSize,false);
+   if (inData)
+   {
+      memcpy(result,inData,inSize);
+   }
+   return result;
+}
+
+
+void *NewGCPrivate(void *inData,int inSize)
+{
+   void *result =  InternalNew(inSize,false);
+   if (inData)
+   {
+      memcpy(result,inData,inSize);
+   }
+   return result;
+}
+
+
+
+} // end namespace hx
+
+
+
+
+void __hxcpp_enable(bool inEnable)
+{
+   hx::InternalEnableGC(inEnable);
+}
+
+void  __hxcpp_set_minimum_working_memory(int inBytes)
+{
+   hx::sgMinimumWorkingMemory = inBytes;
+}
+
+void  __hxcpp_set_minimum_free_space(int inBytes)
+{
+   hx::sgMinimumFreeSpace = inBytes;
+}
+
+void  __hxcpp_set_target_free_space_percentage(int inPercentage)
+{
+   hx::sgTargetFreeSpacePercentage = inPercentage;
+}
+
+bool __hxcpp_is_const_string(const ::String &inString)
+{
+   #ifdef HXCPP_ALIGN_ALLOC
+   // Unaligned must be native const
+   if ( ((size_t)inString.__s) & 0x3 )
+      return true;
+   #endif
+   return ((unsigned int *)inString.raw_ptr())[-1] & HX_GC_CONST_ALLOC_BIT;
+}
+
diff --git a/Sources/c_snikket/src/hx/gc/GcRegCapture.cpp b/Sources/c_snikket/src/hx/gc/GcRegCapture.cpp
new file mode 100644
index 0000000..00a3859
--- /dev/null
+++ b/Sources/c_snikket/src/hx/gc/GcRegCapture.cpp
@@ -0,0 +1,159 @@
+#include "GcRegCapture.h"
+
+#ifdef HXCPP_CAPTURE_SETJMP // {
+
+// Nothing
+
+#elif defined(HXCPP_CAPTURE_x86) // }  {
+
+#pragma optimize( "", off )
+
+
+namespace hx {
+
+void CaptureX86(RegisterCaptureBuffer &outBuffer)
+{
+   void *regEsi;
+   void *regEdi;
+   void *regEbx;
+   #ifdef __GNUC__
+   asm ("mov %%esi, %0\n\t" : "=r" (regEsi) );
+   asm ("mov %%edi, %0\n\t" : "=r" (regEdi) );
+   asm ("mov %%ebx, %0\n\t" : "=r" (regEbx) );
+   #else
+   __asm {
+      mov regEsi, esi
+      mov regEdi, edi
+      mov regEbx, ebx
+   }
+   #endif
+   outBuffer.esi = regEsi;
+   outBuffer.edi = regEdi;
+   outBuffer.ebx = regEbx;
+}
+
+} // end namespace hx
+
+#elif defined(HXCPP_CAPTURE_x64) // } {
+
+#if !defined(__GNUC__)
+#include <windows.h>
+#endif
+
+namespace hx {
+
+void CaptureX64(RegisterCaptureBuffer &outBuffer)
+{
+   #if !defined(__GNUC__)
+      CONTEXT context;
+
+      context.ContextFlags = CONTEXT_INTEGER;
+      RtlCaptureContext(&context);
+
+      outBuffer.rbx = (void *)context.Rbx;
+      outBuffer.rbp = (void *)context.Rbp;
+      outBuffer.rdi = (void *)context.Rdi;
+      outBuffer.r12 = (void *)context.R12;
+      outBuffer.r13 = (void *)context.R13;
+      outBuffer.r14 = (void *)context.R14;
+      outBuffer.r15 = (void *)context.R15;
+      memcpy(outBuffer.xmm, &context.Xmm0, sizeof(outBuffer.xmm));
+   #else
+      void *regBx;
+      void *regBp;
+      void *regDi;
+      void *reg12;
+      void *reg13;
+      void *reg14;
+      void *reg15;
+      asm ("movq %%rbx, %0\n\t" : "=r" (regBx) );
+      asm ("movq %%rbp, %0\n\t" : "=r" (regBp) );
+      asm ("movq %%rdi, %0\n\t" : "=r" (regDi) );
+      asm ("movq %%r12, %0\n\t" : "=r" (reg12) );
+      asm ("movq %%r13, %0\n\t" : "=r" (reg13) );
+      asm ("movq %%r14, %0\n\t" : "=r" (reg14) );
+      asm ("movq %%r15, %0\n\t" : "=r" (reg15) );
+      outBuffer.rbx = regBx;
+      outBuffer.rbp = regBp;
+      outBuffer.r12 = reg12;
+      outBuffer.r13 = reg13;
+      outBuffer.r14 = reg14;
+      outBuffer.r15 = reg15;
+   #endif
+}
+
+} // end namespace hx
+
+
+#elif defined(HXCPP_CAPTURE_ARM64) // } {
+
+namespace hx {
+
+void CaptureArm64(RegisterCaptureBuffer &outBuffer)
+{
+   void *regX19;
+   void *regX20;
+   void *regX21;
+   void *regX22;
+   void *regX23;
+   void *regX24;
+   void *regX25;
+   void *regX26;
+   void *regX27;
+   void *regX28;
+   asm ("mov %0, x19\n\t" : "=r" (regX19) );
+   asm ("mov %0, x20\n\t" : "=r" (regX20) );
+   asm ("mov %0, x21\n\t" : "=r" (regX21) );
+   asm ("mov %0, x22\n\t" : "=r" (regX22) );
+   asm ("mov %0, x23\n\t" : "=r" (regX23) );
+   asm ("mov %0, x24\n\t" : "=r" (regX24) );
+   asm ("mov %0, x25\n\t" : "=r" (regX25) );
+   asm ("mov %0, x26\n\t" : "=r" (regX26) );
+   asm ("mov %0, x27\n\t" : "=r" (regX27) );
+   asm ("mov %0, x28\n\t" : "=r" (regX28) );
+   outBuffer.x19 = regX19;
+   outBuffer.x20 = regX20;
+   outBuffer.x21 = regX21;
+   outBuffer.x22 = regX22;
+   outBuffer.x23 = regX23;
+   outBuffer.x24 = regX24;
+   outBuffer.x25 = regX25;
+   outBuffer.x26 = regX26;
+   outBuffer.x27 = regX27;
+   outBuffer.x28 = regX28;
+}
+
+} // end namespace
+
+#else // }  {
+
+#include <string.h>
+
+namespace hx {
+
+// Put this function here so we can be reasonablly sure that "this" register and
+// the 4 registers that may be used to pass args are on the stack.
+int RegisterCapture::Capture(int *inTopOfStack,int **inBuf,int &outSize,int inMaxSize, int *inBottom)
+{
+	int size = ( (char *)inTopOfStack - (char *)inBottom )/sizeof(void *);
+	if (size>inMaxSize)
+		size = inMaxSize;
+	outSize = size;
+	if (size>0)
+	   memcpy(inBuf,inBottom,size*sizeof(void*));
+	return 1;
+}
+
+
+RegisterCapture *gRegisterCaptureInstance = 0;
+RegisterCapture *RegisterCapture::Instance()
+{
+	if (!gRegisterCaptureInstance)
+		gRegisterCaptureInstance = new RegisterCapture();
+	return gRegisterCaptureInstance;
+}
+
+} // end namespace hx
+
+#endif // }
+
diff --git a/Sources/c_snikket/src/hx/gc/GcRegCapture.h b/Sources/c_snikket/src/hx/gc/GcRegCapture.h
new file mode 100644
index 0000000..61e4171
--- /dev/null
+++ b/Sources/c_snikket/src/hx/gc/GcRegCapture.h
@@ -0,0 +1,140 @@
+#ifndef HX_GC_HELPERS_INCLUDED
+#define HX_GC_HELPERS_INCLUDED
+
+#if defined(HX_WINDOWS) && defined(HXCPP_ARM64)
+// Eg, Microsoft Surface 
+#define HXCPP_CAPTURE_SETJMP
+#endif
+
+#ifdef HXCPP_CAPTURE_SETJMP
+   #include <setjmp.h>
+#else
+
+   #if (defined(HX_WINDOWS) || defined(HX_MACOS)  || (defined(HX_LINUX) && defined(__i386__))) && !defined(HXCPP_M64)
+      #define HXCPP_CAPTURE_x86
+   #endif
+
+   #if (defined(HX_MACOS) || (defined(HX_WINDOWS) && !defined(HX_WINRT)) || defined(_XBOX_ONE) || (defined(HX_LINUX) && defined(__x86_64__)) ) && defined(HXCPP_M64)
+      #define HXCPP_CAPTURE_x64
+   #endif
+
+   #if defined(HXCPP_ARM64)
+      //#define HXCPP_CAPTURE_ARM64
+      // Awlays use setjmp on arm64
+      #include <setjmp.h>
+      #define HXCPP_CAPTURE_SETJMP
+   #endif
+
+#endif
+
+
+namespace hx
+{
+
+// Capture Registers
+//
+#ifdef HXCPP_CAPTURE_SETJMP // {
+
+typedef jmp_buf RegisterCaptureBuffer;
+
+#define CAPTURE_REGS \
+   setjmp(mRegisterBuf);
+
+#define CAPTURE_REG_START (int *)(&mRegisterBuf)
+#define CAPTURE_REG_END (int *)(&mRegisterBuf+1)
+
+#elif defined(HXCPP_CAPTURE_x86) // } {
+
+struct RegisterCaptureBuffer
+{
+   void *ebx;
+   void *edi;
+   void *esi;
+};
+
+void CaptureX86(RegisterCaptureBuffer &outBuffer);
+
+#define CAPTURE_REGS \
+   hx::CaptureX86(mRegisterBuf);
+
+#define CAPTURE_REG_START (int *)(&mRegisterBuf)
+#define CAPTURE_REG_END (int *)(&mRegisterBuf+1)
+
+#elif defined(HXCPP_CAPTURE_x64) // }  {
+
+
+struct RegisterCaptureBuffer
+{
+   void *rbx;
+   void *rbp;
+   void *rdi;
+   void *r12;
+   void *r13;
+   void *r14;
+   void *r15;
+
+   void *xmm[16*2];
+};
+
+void CaptureX64(RegisterCaptureBuffer &outBuffer);
+
+#define CAPTURE_REGS \
+   hx::CaptureX64(mRegisterBuf);
+
+#define CAPTURE_REG_START (int *)(&mRegisterBuf)
+#define CAPTURE_REG_END (int *)(&mRegisterBuf+1)
+
+
+#elif defined(HXCPP_CAPTURE_ARM64) // }  {
+
+
+struct RegisterCaptureBuffer
+{
+   void *x19;
+   void *x20;
+   void *x21;
+   void *x22;
+   void *x23;
+   void *x24;
+   void *x25;
+   void *x26;
+   void *x27;
+   void *x28;
+};
+
+void CaptureArm64(RegisterCaptureBuffer &outBuffer);
+
+#define CAPTURE_REGS \
+   hx::CaptureArm64(mRegisterBuf);
+
+#define CAPTURE_REG_START (int *)(&mRegisterBuf)
+#define CAPTURE_REG_END (int *)(&mRegisterBuf+1)
+
+
+#else //  }  default capture... {
+
+
+class RegisterCapture
+{
+public:
+	virtual int Capture(int *inTopOfStack,int **inBuf,int &outSize,int inMaxSize,int *inDummy);
+   static RegisterCapture *Instance();
+};
+
+typedef int *RegisterCaptureBuffer[20];
+
+#define CAPTURE_REGS \
+   hx::RegisterCapture::Instance()->Capture(mTopOfStack, \
+                mRegisterBuf,mRegisterBufSize,20,mBottomOfStack); \
+
+#define CAPTURE_REG_START (int *)mRegisterBuf
+#define CAPTURE_REG_END (int *)(mRegisterBuf+mRegisterBufSize)
+
+#endif // }
+
+
+
+}
+
+
+#endif
diff --git a/Sources/c_snikket/src/hx/gc/Immix.cpp b/Sources/c_snikket/src/hx/gc/Immix.cpp
new file mode 100644
index 0000000..880b51c
--- /dev/null
+++ b/Sources/c_snikket/src/hx/gc/Immix.cpp
@@ -0,0 +1,7139 @@
+#include <hxcpp.h>
+
+#include <hx/GC.h>
+#include <hx/Memory.h>
+#include <hx/Thread.h>
+#include "../Hash.h"
+#include "GcRegCapture.h"
+#include <hx/Unordered.h>
+
+#ifdef EMSCRIPTEN
+   #include <emscripten/stack.h>
+   #ifdef HXCPP_SINGLE_THREADED_APP
+      // Use provided tools to measure stack extent
+      #define HXCPP_EXPLICIT_STACK_EXTENT
+   #endif
+#endif
+
+#include <string>
+#include <stdlib.h>
+
+
+static bool sgIsCollecting = false;
+
+namespace hx
+{
+   int gByteMarkID = 0x10;
+   int gRememberedByteMarkID = 0x10 | HX_GC_REMEMBERED;
+
+
+int gFastPath = 0;
+int gSlowPath = 0;
+
+
+}
+
+using hx::gByteMarkID;
+using hx::gRememberedByteMarkID;
+
+
+namespace hx
+{
+#ifdef HXCPP_GC_DEBUG_ALWAYS_MOVE
+
+enum { gAlwaysMove = true };
+typedef hx::UnorderedSet<void *> PointerMovedSet;
+PointerMovedSet sgPointerMoved;
+
+#else
+enum { gAlwaysMove = false };
+#endif
+}
+
+#ifdef ANDROID
+#include <android/log.h>
+#endif
+
+#ifdef HX_WINDOWS
+#include <windows.h>
+#endif
+
+#include <vector>
+#include <stdio.h>
+
+#include <hx/QuickVec.h>
+
+// #define HXCPP_GC_BIG_BLOCKS
+
+
+#ifndef __has_builtin
+#define __has_builtin(x) 0
+#endif
+namespace {
+void DebuggerTrap()
+{
+   static bool triggeredOnce = false;
+
+   if (!triggeredOnce)
+   {
+      triggeredOnce = true;
+
+      #if __has_builtin(__builtin_trap)
+      __builtin_trap();
+      #else
+      *(int *)0=0;
+      #endif
+   }
+}
+}
+
+
+
+
+static bool sgAllocInit = 0;
+static bool sgInternalEnable = true;
+static void *sgObject_root = 0;
+// With virtual inheritance, stack pointers can point to the middle of an object
+#ifdef _MSC_VER
+// MSVC optimizes by taking the address of an initernal data member
+static int sgCheckInternalOffset = sizeof(void *)*2;
+static int sgCheckInternalOffsetRows = 1;
+#else
+static int sgCheckInternalOffset = 0;
+static int sgCheckInternalOffsetRows = 0;
+#endif
+
+int gInAlloc = false;
+
+// This is recalculated from the other parameters
+static size_t sWorkingMemorySize          = 10*1024*1024;
+
+#ifdef HXCPP_GC_MOVING
+// Just not sure what this shold be
+static size_t sgMaximumFreeSpace  = 1024*1024*1024;
+#else
+static size_t sgMaximumFreeSpace  = 1024*1024*1024;
+#endif
+
+
+// #define HXCPP_GC_DEBUG_LEVEL 1
+
+#if HXCPP_GC_DEBUG_LEVEL>1
+  #define PROFILE_COLLECT
+  #if HXCPP_GC_DEBUG_LEVEL>2
+     #define SHOW_FRAGMENTATION
+     #if HXCPP_GC_DEBUG_LEVEL>3
+        #define SHOW_MEM_EVENTS
+     #endif
+  #endif
+#endif
+
+// #define SHOW_FRAGMENTATION_BLOCKS
+#if defined SHOW_FRAGMENTATION_BLOCKS
+  #define SHOW_FRAGMENTATION
+#endif
+
+#define RECYCLE_LARGE
+
+// HXCPP_GC_DYNAMIC_SIZE
+
+//#define HXCPP_GC_SUMMARY
+//#define PROFILE_COLLECT
+//#define PROFILE_THREAD_USAGE
+//#define HXCPP_GC_VERIFY
+//#define HX_GC_VERIFY_ALLOC_START
+//#define SHOW_MEM_EVENTS
+//#define SHOW_MEM_EVENTS_VERBOSE
+//#define SHOW_FRAGMENTATION
+//
+// Setting this can make it easier to reproduce this problem since it takes
+//  the timing of the zeroing out of the equation
+//#define HX_GC_ZERO_EARLY
+
+// Setting this on windows64 will mean this objects are allocated in the same place,
+//  which can make native debugging easier
+//#define HX_GC_FIXED_BLOCKS
+//
+// If the problem happens on the same object, you can print info about the object
+//  every collect so you can see where it goes wrong (usually requires HX_GC_FIXED_BLOCKS)
+//#define HX_WATCH
+
+#if defined(HXCPP_GC_VERIFY) && defined(HXCPP_GC_GENERATIONAL)
+#define HX_GC_VERIFY_GENERATIONAL
+#endif
+
+
+#ifdef HX_WATCH
+void *hxWatchList[] = {
+  (void *)0x0000000100000200,
+  (void *)0
+};
+bool hxInWatchList(void *watch)
+{
+   for(void **t = hxWatchList; *t; t++)
+      if (*t==watch)
+         return true;
+   return false;
+}
+#endif
+
+#ifdef HX_GC_FIXED_BLOCKS
+#ifdef HX_WINDOWS
+#include <Memoryapi.h>
+#endif
+#endif
+
+#ifdef PROFILE_COLLECT
+   #define HXCPP_GC_SUMMARY
+#endif
+
+#ifdef HX_GC_VERIFY_GENERATIONAL
+static bool sGcVerifyGenerational = false;
+#endif
+
+
+#if HX_HAS_ATOMIC && (HXCPP_GC_DEBUG_LEVEL==0) && !defined(HXCPP_GC_VERIFY) && !defined(EMSCRIPTEN)
+  #if defined(HX_MACOS) || defined(HX_WINDOWS) || defined(HX_LINUX)
+  enum { MAX_GC_THREADS = 4 };
+  #else
+  enum { MAX_GC_THREADS = 2 };
+  #endif
+#else
+  enum { MAX_GC_THREADS = 1 };
+#endif
+
+#if (MAX_GC_THREADS>1)
+   // You can uncomment this for better call stacks if it crashes while collecting
+   #define HX_MULTI_THREAD_MARKING
+#endif
+
+#ifdef PROFILE_THREAD_USAGE
+static int sThreadMarkCountData[MAX_GC_THREADS+1];
+static int sThreadArrayMarkCountData[MAX_GC_THREADS+1];
+static int *sThreadMarkCount = sThreadMarkCountData + 1;
+static int *sThreadArrayMarkCount = sThreadArrayMarkCountData + 1;
+static int sThreadChunkPushCount;
+static int sThreadChunkWakes;
+static int sSpinCount = 0;
+static int sThreadZeroWaits = 0;
+static int sThreadZeroPokes = 0;
+static int sThreadBlockZeroCount = 0;
+static volatile int sThreadZeroMisses = 0;
+#endif
+
+enum { MARK_BYTE_MASK = 0x0f };
+enum { FULL_MARK_BYTE_MASK = 0x3f };
+
+
+enum
+{
+   MEM_INFO_USAGE = 0,
+   MEM_INFO_RESERVED = 1,
+   MEM_INFO_CURRENT = 2,
+   MEM_INFO_LARGE = 3,
+};
+
+enum GcMode
+{
+   gcmFull,
+   gcmGenerational,
+};
+
+// Start with full gc - since all objects will be new
+static GcMode sGcMode = gcmFull;
+
+
+
+#ifndef HXCPP_GC_MOVING
+  #ifdef HXCPP_GC_DEBUG_ALWAYS_MOVE
+  #define HXCPP_GC_MOVING
+  #endif
+// Enable moving collector...
+//#define HXCPP_GC_MOVING
+#endif
+
+// Allocate this many blocks at a time - this will increase memory usage % when rounding to block size must be done.
+// However, a bigger number makes it harder to release blocks due to pinning
+#define IMMIX_BLOCK_GROUP_BITS  5
+
+
+#ifdef HXCPP_DEBUG
+static hx::Object *gCollectTrace = 0;
+static bool gCollectTraceDoPrint = false;
+static int gCollectTraceCount = 0;
+static int sgSpamCollects = 0;
+#endif
+
+#if defined(HXCPP_DEBUG) || defined(HXCPP_GC_DEBUG_ALWAYS_MOVE)
+volatile int sgAllocsSinceLastSpam = 0;
+#endif
+
+#ifdef ANDROID
+#define GCLOG(...) __android_log_print(ANDROID_LOG_INFO, "gclog", __VA_ARGS__)
+#else
+#define GCLOG printf
+#endif
+
+#ifdef PROFILE_COLLECT
+   #define STAMP(t) double t = __hxcpp_time_stamp();
+   #define MEM_STAMP(t) t = __hxcpp_time_stamp();
+   static double sLastCollect = __hxcpp_time_stamp();
+   static int sObjectMarks =0;
+   static int sAllocMarks =0;
+
+#else
+   #define STAMP(t)
+   #define MEM_STAMP(t)
+#endif
+
+#if defined(HXCPP_GC_SUMMARY) || defined(HXCPP_GC_DYNAMIC_SIZE)
+struct ProfileCollectSummary
+{
+   enum { COUNT = 10 };
+   double timeWindow[COUNT];
+   int    windowIdx;
+   double startTime;
+   double lastTime;
+   double totalCollecting;
+   double maxStall;
+   double spaceFactor;
+
+   ProfileCollectSummary()
+   {
+      startTime = __hxcpp_time_stamp();
+      lastTime = startTime;
+      totalCollecting = 0;
+      maxStall = 0;
+      windowIdx = 0;
+      spaceFactor = 1.0;
+      for(int i=0;i<COUNT;i++)
+         timeWindow[i] = 0.1;
+   }
+   ~ProfileCollectSummary()
+   {
+      #ifdef HXCPP_GC_SUMMARY
+      double time = __hxcpp_time_stamp() - startTime;
+      GCLOG("Total time     : %.2fms\n", time*1000.0);
+      GCLOG("Collecting time: %.2fms\n", totalCollecting*1000.0);
+      GCLOG("Max Stall time : %.2fms\n", maxStall*1000.0);
+      if (time==0) time = 1;
+      GCLOG(" Fraction      : %.2f%%\n",totalCollecting*100.0/time);
+
+      #ifdef HXCPP_GC_DYNAMIC_SIZE
+      GCLOG("Space factor   : %.2fx\n",spaceFactor);
+      #endif
+      #endif
+   }
+
+   void addTime(double inCollectStart)
+   {
+      double now = __hxcpp_time_stamp();
+      double dt =  now-inCollectStart;
+      if (dt>maxStall)
+         maxStall = dt;
+      totalCollecting += dt;
+      #ifdef HXCPP_GC_DYNAMIC_SIZE
+      double wholeTime = now - lastTime;
+      if (wholeTime)
+      {
+         lastTime = now;
+         double ratio = dt/wholeTime;
+         windowIdx = (windowIdx +1)%COUNT;
+         timeWindow[windowIdx] = ratio;
+         double sum = 0;
+         for(int i=0;i<COUNT;i++)
+            sum += timeWindow[i];
+         ratio = sum/COUNT;
+
+         if (ratio<0.05)
+         {
+            if (spaceFactor>1.0)
+            {
+               spaceFactor -= 0.2;
+               if (spaceFactor<1.0)
+                  spaceFactor = 1.0;
+            }
+         }
+         else if (ratio>0.12)
+         {
+            if (ratio>0.2)
+               spaceFactor += 0.5;
+            else
+               spaceFactor += 0.2;
+
+            if (spaceFactor>5.0)
+               spaceFactor = 5.0;
+         }
+      }
+      #endif
+   }
+
+};
+
+static ProfileCollectSummary profileCollectSummary;
+#define PROFILE_COLLECT_SUMMARY_START double collectT0 = __hxcpp_time_stamp();
+#define PROFILE_COLLECT_SUMMARY_END profileCollectSummary.addTime(collectT0);
+
+#else
+#define PROFILE_COLLECT_SUMMARY_START 
+#define PROFILE_COLLECT_SUMMARY_END
+#endif
+
+
+
+// TODO: Telemetry.h ?
+#ifdef HXCPP_TELEMETRY
+extern void __hxt_gc_realloc(void* old_obj, void* new_obj, int new_size);
+extern void __hxt_gc_start();
+extern void __hxt_gc_end();
+extern void __hxt_gc_after_mark(int gByteMarkID, int markIdByte);
+#endif
+
+static int sgTimeToNextTableUpdate = 1;
+
+
+
+
+HxMutex  *gThreadStateChangeLock=0;
+HxMutex  *gSpecialObjectLock=0;
+
+class LocalAllocator;
+enum LocalAllocState { lasNew, lasRunning, lasStopped, lasWaiting, lasTerminal };
+
+
+static void MarkLocalAlloc(LocalAllocator *inAlloc,hx::MarkContext *__inCtx);
+#ifdef HXCPP_VISIT_ALLOCS
+static void VisitLocalAlloc(LocalAllocator *inAlloc,hx::VisitContext *__inCtx);
+#endif
+static void WaitForSafe(LocalAllocator *inAlloc);
+static void ReleaseFromSafe(LocalAllocator *inAlloc);
+static void ClearPooledAlloc(LocalAllocator *inAlloc);
+static void CollectFromThisThread(bool inMajor,bool inForceCompact);
+
+namespace hx
+{
+int gPauseForCollect = 0x00000000;
+
+StackContext *gMainThreadContext = 0;
+
+unsigned int gImmixStartFlag[128];
+
+int gMarkID = 0x10 << 24;
+int gMarkIDWithContainer = (0x10 << 24) | IMMIX_ALLOC_IS_CONTAINER;
+
+int gPrevByteMarkID = 0x2f;
+unsigned int gPrevMarkIdMask = ((~0x2f000000) & 0x30000000) | HX_GC_CONST_ALLOC_BIT;
+
+
+
+
+void ExitGCFreeZoneLocked();
+
+
+DECLARE_FAST_TLS_DATA(StackContext, tlsStackContext);
+
+#ifdef HXCPP_SCRIPTABLE
+extern void scriptMarkStack(hx::MarkContext *);
+#endif
+}
+
+//#define DEBUG_ALLOC_PTR ((char *)0xb68354)
+
+
+#ifdef HX_WINDOWS
+#define ZERO_MEM(ptr, n) ZeroMemory(ptr,n)
+#else
+#define ZERO_MEM(ptr, n) memset(ptr,0,n)
+#endif
+
+
+// ---  Internal GC - IMMIX Implementation ------------------------------
+
+
+
+// Some inline implementations ...
+// Use macros to allow for mark/move
+
+
+
+/*
+  IMMIX block size, and various masks for converting addresses
+
+*/
+
+#ifdef HXCPP_GC_BIG_BLOCKS
+   #define IMMIX_BLOCK_BITS      16
+   typedef unsigned int BlockIdType;
+#else
+   #define IMMIX_BLOCK_BITS      15
+   typedef unsigned short BlockIdType;
+#endif
+
+#define IMMIX_BLOCK_SIZE        (1<<IMMIX_BLOCK_BITS)
+#define IMMIX_BLOCK_OFFSET_MASK (IMMIX_BLOCK_SIZE-1)
+#define IMMIX_BLOCK_BASE_MASK   (~(size_t)(IMMIX_BLOCK_OFFSET_MASK))
+#define IMMIX_LINE_COUNT_BITS   (IMMIX_BLOCK_BITS-IMMIX_LINE_BITS)
+#define IMMIX_LINES             (1<<IMMIX_LINE_COUNT_BITS)
+
+
+#define IMMIX_HEADER_LINES      (IMMIX_LINES>>IMMIX_LINE_BITS)
+#define IMMIX_USEFUL_LINES      (IMMIX_LINES - IMMIX_HEADER_LINES)
+
+#define IMMIX_MAX_ALLOC_GROUPS_SIZE  (1<<IMMIX_BLOCK_GROUP_BITS)
+
+
+// Every second line used
+#define MAX_HOLES (IMMIX_USEFUL_LINES>>1)
+
+/*
+
+ IMMIX Alloc Header - 32 bits
+
+
+ The header is placed in the 4 bytes before the object pointer, and it is placed there using a uint32.
+ When addressed as the uint32, you can use the bitmasks below to extract the various data.
+
+ The "mark id" can conveniently be interpreted as a byte, however the offsets well
+  be different depending on whether the system is little endian or big endian.
+
+
+  Little endian - lsb first
+
+ 7   0 15 8 23 16 31 24
+ -----------------------
+ |    |    |     | MID  | obj start here .....
+ -----------------------
+
+
+
+  Big endian - msb first
+
+ 31 24 23 16 15 8 7   0
+ -----------------------
+ |MID |    |     |      | obj start here .....
+ -----------------------
+
+MID = HX_ENDIAN_MARK_ID_BYTE = is measured from the object pointer
+      HX_ENDIAN_MARK_ID_BYTE_HEADER = is measured from the header pointer (4 bytes before object)
+
+
+*/
+
+#define HX_ENDIAN_MARK_ID_BYTE_HEADER (HX_ENDIAN_MARK_ID_BYTE + 4)
+
+
+// Used by strings
+// HX_GC_CONST_ALLOC_BIT  0x80000000
+
+//#define HX_GC_REMEMBERED          0x40000000
+#define IMMIX_ALLOC_MARK_ID         0x3f000000
+//#define IMMIX_ALLOC_IS_CONTAINER  0x00800000
+//#define IMMIX_ALLOC_IS_PINNED     not used at object level
+//#define HX_GX_STRING_EXTENDED     0x00200000
+//#define HX_GC_STRING_HASH         0x00100000
+// size will shift-right IMMIX_ALLOC_SIZE_SHIFT (6).  Low two bits are 0
+#define IMMIX_ALLOC_SIZE_MASK       0x000fff00
+#define IMMIX_ALLOC_ROW_COUNT       0x000000ff
+
+#define IMMIX_HEADER_PRESERVE       0x00f00000
+
+
+#define IMMIX_OBJECT_HAS_MOVED 0x000000fe
+
+
+// Bigger than this, and they go in the large object pool
+#define IMMIX_LARGE_OBJ_SIZE 4000
+
+#ifdef allocString
+#undef allocString
+#endif
+
+
+void CriticalGCError(const char *inMessage)
+{
+   // Can't perfrom normal handling because it needs the GC system
+   #ifdef ANDROID
+   __android_log_print(ANDROID_LOG_ERROR, "HXCPP", "Critical Error: %s", inMessage);
+   #elif defined(HX_WINRT)
+      WINRT_LOG("HXCPP Critical Error: %s\n", inMessage);
+   #else
+   printf("Critical Error: %s\n", inMessage);
+   #endif
+
+   DebuggerTrap();
+}
+
+
+
+
+
+enum AllocType { allocNone, allocString, allocObject, allocMarked };
+
+struct BlockDataInfo *gBlockStack = 0;
+typedef hx::QuickVec<hx::Object *> ObjectStack;
+
+
+typedef HxMutex ThreadPoolLock;
+
+static ThreadPoolLock sThreadPoolLock;
+
+#if !defined(HX_WINDOWS) && !defined(EMSCRIPTEN) && \
+   !defined(__SNC__) && !defined(__ORBIS__)
+#define HX_GC_PTHREADS
+typedef pthread_cond_t ThreadPoolSignal;
+inline void WaitThreadLocked(ThreadPoolSignal &ioSignal)
+{
+   pthread_cond_wait(&ioSignal, sThreadPoolLock.mMutex);
+}
+#else
+typedef HxSemaphore ThreadPoolSignal;
+#endif
+
+typedef TAutoLock<ThreadPoolLock> ThreadPoolAutoLock;
+
+// For threaded marking/block reclaiming
+static unsigned int sRunningThreads = 0;
+static unsigned int sAllThreads = 0;
+static bool sLazyThreads = false;
+static bool sThreadPoolInit = false;
+
+enum ThreadPoolJob
+{
+   tpjNone,
+   tpjMark,
+   tpjReclaim,
+   tpjReclaimFull,
+   tpjCountRows,
+   tpjAsyncZero,
+   tpjAsyncZeroJit,
+   tpjGetStats,
+   tpjVisitBlocks,
+};
+
+int sgThreadCount = 0;
+static ThreadPoolJob sgThreadPoolJob = tpjNone;
+static bool sgThreadPoolAbort = false;
+
+// Pthreads enters the sleep state while holding a mutex, so it no cost to update
+//  the sleeping state and thereby avoid over-signalling the condition
+bool             sThreadSleeping[MAX_GC_THREADS];
+ThreadPoolSignal sThreadWake[MAX_GC_THREADS];
+bool             sThreadJobDoneSleeping = false;
+ThreadPoolSignal sThreadJobDone;
+
+
+static inline void SignalThreadPool(ThreadPoolSignal &ioSignal, bool sThreadSleeping)
+{
+   #ifdef HX_GC_PTHREADS
+   if (sThreadSleeping)
+      pthread_cond_signal(&ioSignal);
+   #else
+   ioSignal.Set();
+   #endif
+}
+
+static void wakeThreadLocked(int inThreadId)
+{
+   sRunningThreads |= (1<<inThreadId);
+   sLazyThreads = sRunningThreads != sAllThreads;
+   SignalThreadPool(sThreadWake[inThreadId],sThreadSleeping[inThreadId]);
+}
+
+union BlockData
+{
+   // First 2/4 bytes are not needed for row markers (first 2/4 rows are for flags)
+   BlockIdType mId;
+
+   // First 2/4 rows contain a byte-flag-per-row 
+   unsigned char  mRowMarked[IMMIX_LINES];
+   // Row data as union - don't use first 2/4 rows
+   unsigned char  mRow[IMMIX_LINES][IMMIX_LINE_LEN];
+
+};
+
+struct BlockDataStats
+{
+   void clear() { ZERO_MEM(this, sizeof(BlockDataStats)); }
+   void add(const BlockDataStats &inOther)
+   {
+      rowsInUse += inOther.rowsInUse;
+      bytesInUse += inOther.bytesInUse;
+      emptyBlocks += inOther.emptyBlocks;
+      fraggedBlocks += inOther.fraggedBlocks;
+      fragScore += inOther.fragScore;
+      fraggedRows += inOther.fraggedRows;
+   }
+
+   int rowsInUse;
+   size_t bytesInUse;
+   int emptyBlocks;
+   int fragScore;
+   int fraggedBlocks;
+   int fraggedRows;
+};
+
+static BlockDataStats sThreadBlockDataStats[MAX_GC_THREADS];
+#ifdef HXCPP_VISIT_ALLOCS
+static hx::VisitContext *sThreadVisitContext = 0;
+#endif
+   
+
+
+namespace hx { void MarkerReleaseWorkerLocked(); }
+
+
+
+
+struct GroupInfo
+{
+   int  blocks;
+   char *alloc;
+
+   bool pinned;
+   bool isEmpty;
+   int  usedBytes;
+   int  usedSpace;
+
+   void clear()
+   {
+      pinned = false;
+      usedBytes = 0;
+      usedSpace = 0;
+      isEmpty = true;
+   }
+   int getMoveScore()
+   {
+      return pinned ?  0 : usedSpace-usedBytes;
+   }
+
+};
+ 
+hx::QuickVec<GroupInfo> gAllocGroups;
+
+
+
+struct HoleRange
+{
+   unsigned short start;
+   unsigned short length;
+};
+
+
+hx::QuickVec<struct BlockDataInfo *> *gBlockInfo = 0;
+static int gBlockInfoEmptySlots = 0;
+
+#define FRAG_THRESH 14
+
+#define ZEROED_NOT    0
+#define ZEROED_THREAD 1
+#define ZEROED_AUTO   2
+
+// Align padding based on block offset
+#ifdef HXCPP_ALIGN_ALLOC
+    #define ALIGN_PADDING(x) (4-(x&4))
+#else
+    #define ALIGN_PADDING(x) 0
+#endif
+
+struct BlockDataInfo
+{
+   int             mId;
+   int             mGroupId;
+   BlockData       *mPtr;
+
+   unsigned int allocStart[IMMIX_LINES];
+
+   HoleRange    mRanges[MAX_HOLES];
+   int          mHoles;
+
+   int          mUsedRows;
+   int          mMaxHoleSize;
+   int          mMoveScore;
+   int          mUsedBytes;
+   int          mFraggedRows;
+   bool         mPinned;
+   unsigned char mZeroed;
+   bool         mReclaimed;
+   bool         mOwned;
+   #ifdef HXCPP_GC_GENERATIONAL
+   bool         mHasSurvivor;
+   #endif
+   volatile int mZeroLock;
+
+
+   BlockDataInfo(int inGid, BlockData *inData)
+   {
+      if (gBlockInfoEmptySlots)
+      {
+         for(int i=0;i<gBlockInfo->size();i++)
+            if ( !(*gBlockInfo)[i] )
+            {
+               gBlockInfoEmptySlots--;
+               mId = i;
+               (*gBlockInfo)[i] = this;
+               break;
+            }
+      }
+      else
+      {
+         if (gBlockInfo==0)
+            gBlockInfo = new hx::QuickVec<BlockDataInfo *>;
+         mId = gBlockInfo->size();
+         gBlockInfo->push( this );
+      }
+
+
+      mZeroLock = 0;
+      mOwned = false;
+      mGroupId = inGid;
+      mPtr     = inData;
+      inData->mId = mId;
+      #ifdef SHOW_MEM_EVENTS
+      //GCLOG("  create block %d : %p -> %p\n",  mId, this, mPtr );
+      #endif
+      clear();
+   }
+
+   void clear()
+   {
+      mUsedRows = 0;
+      mUsedBytes = 0;
+      mFraggedRows = 0;
+      mPinned = false;
+      ZERO_MEM(allocStart,sizeof(int)*IMMIX_LINES);
+      ZERO_MEM(mPtr->mRowMarked+IMMIX_HEADER_LINES, IMMIX_USEFUL_LINES); 
+      mRanges[0].start = IMMIX_HEADER_LINES << IMMIX_LINE_BITS;
+      mRanges[0].length = IMMIX_USEFUL_LINES << IMMIX_LINE_BITS;
+      mMaxHoleSize = mRanges[0].length;
+      mMoveScore = 0;
+      mHoles = 1;
+      mZeroed = ZEROED_NOT;
+      mReclaimed = true;
+      mZeroLock = 0;
+      mOwned = false;
+   }
+
+   void makeFull()
+   {
+      mUsedRows = IMMIX_USEFUL_LINES;
+      mUsedBytes = mUsedRows<<IMMIX_LINE_BITS;
+      mFraggedRows = 0;
+      memset(mPtr->mRowMarked+IMMIX_HEADER_LINES, 1,IMMIX_USEFUL_LINES); 
+      mRanges[0].start = 0;
+      mRanges[0].length = 0;
+      mMaxHoleSize = 0;
+      mMoveScore = 0;
+      mHoles = 0;
+      mZeroed = ZEROED_AUTO;
+      mReclaimed = true;
+      mZeroLock = 0;
+      mOwned = false;
+   }
+
+
+   void clearBlockMarks()
+   {
+      mPinned = false;
+      #ifdef HXCPP_GC_GENERATIONAL
+      mHasSurvivor = false;
+      #endif
+   }
+
+   void clearRowMarks()
+   {
+      clearBlockMarks();
+      ZERO_MEM((char *)mPtr+IMMIX_HEADER_LINES, IMMIX_USEFUL_LINES);
+   }
+
+   inline int GetFreeRows() const { return (IMMIX_USEFUL_LINES - mUsedRows); }
+   inline int GetFreeData() const { return (IMMIX_USEFUL_LINES - mUsedRows)<<IMMIX_LINE_BITS; }
+
+
+   bool zeroAndUnlock()
+   {
+      bool doZero = !mZeroed;
+      if (doZero)
+      {
+         if (!mReclaimed)
+            reclaim<false>(0);
+
+         for(int i=0;i<mHoles;i++)
+             ZERO_MEM( (char *)mPtr+mRanges[i].start, mRanges[i].length );
+         mZeroed = ZEROED_THREAD;
+      }
+      mZeroLock = 0;
+      return doZero;
+   }
+
+   bool tryZero()
+   {
+      if (mZeroed)
+         return false;
+
+      if (_hx_atomic_compare_exchange(&mZeroLock, 0,1) == 0)
+         return zeroAndUnlock();
+
+      return false;
+   }
+
+   void destroy()
+   {
+      #ifdef SHOW_MEM_EVENTS_VERBOSE
+      GCLOG("  release block %d : %p\n",  mId, this );
+      #endif
+      (*gBlockInfo)[mId] = 0;
+      gBlockInfoEmptySlots++;
+      delete this;
+   }
+
+   bool isEmpty() const { return mUsedRows == 0; }
+   int getUsedRows() const { return mUsedRows; }
+
+   void getStats(BlockDataStats &outStats)
+   {
+      outStats.rowsInUse += mUsedRows;
+      outStats.bytesInUse += mUsedBytes;
+      outStats.fraggedRows += mFraggedRows;
+      //outStats.bytesInUse += 0;
+      outStats.fragScore += mPinned ? (mMoveScore>0?1:0) : mMoveScore;
+
+      if (mUsedRows==0)
+         outStats.emptyBlocks++;
+      if (mMoveScore> FRAG_THRESH )
+         outStats.fraggedBlocks++;
+   }
+
+   #ifdef HX_GC_VERIFY_ALLOC_START
+   void verifyAllocStart()
+   {
+      unsigned char *rowMarked = mPtr->mRowMarked;
+
+      for(int r = IMMIX_HEADER_LINES; r<IMMIX_LINES; r++)
+      {
+         if (!rowMarked[r] && allocStart[r])
+         {
+            printf("allocStart set without marking\n");
+            DebuggerTrap();
+         }
+      }
+   }
+   #endif
+
+   void countRows(BlockDataStats &outStats)
+   {
+      unsigned char *rowMarked = mPtr->mRowMarked;
+      unsigned int *rowTotals = ((unsigned int *)rowMarked) + 1;
+
+      // TODO - sse/neon
+      #ifdef HXCPP_GC_BIG_BLOCKS
+      unsigned int total = 0;
+      #else
+      unsigned int total = rowMarked[2] + rowMarked[3];
+      #endif
+
+      total +=
+       rowTotals[0]  + rowTotals[1]  + rowTotals[2]  + rowTotals[3]  + rowTotals[4] +
+       rowTotals[5]  + rowTotals[6]  + rowTotals[7]  + rowTotals[8]  + rowTotals[9] +
+       rowTotals[10] + rowTotals[11] + rowTotals[12] + rowTotals[13] + rowTotals[14] +
+       rowTotals[15] + rowTotals[16] + rowTotals[17] + rowTotals[18] + rowTotals[19] +
+       rowTotals[20] + rowTotals[21] + rowTotals[22] + rowTotals[23] + rowTotals[24] +
+       rowTotals[25] + rowTotals[26] + rowTotals[27] + rowTotals[28] + rowTotals[29] +
+       rowTotals[30] + rowTotals[31] + rowTotals[32] + rowTotals[33] + rowTotals[34] +
+       rowTotals[35] + rowTotals[36] + rowTotals[37] + rowTotals[38] + rowTotals[39] +
+       rowTotals[40] + rowTotals[41] + rowTotals[42] + rowTotals[43] + rowTotals[44] +
+       rowTotals[45] + rowTotals[46] + rowTotals[47] + rowTotals[48] + rowTotals[49] +
+       rowTotals[50] + rowTotals[51] + rowTotals[52] + rowTotals[53] + rowTotals[54] +
+       rowTotals[55] + rowTotals[56] + rowTotals[57] + rowTotals[58] + rowTotals[59] +
+       rowTotals[60] + rowTotals[61] + rowTotals[62];
+
+
+      #ifdef HXCPP_GC_BIG_BLOCKS
+      rowTotals += 63;
+      total +=
+       rowTotals[0]  + rowTotals[1]  + rowTotals[2]  + rowTotals[3]  + rowTotals[4] +
+       rowTotals[5]  + rowTotals[6]  + rowTotals[7]  + rowTotals[8]  + rowTotals[9] +
+       rowTotals[10] + rowTotals[11] + rowTotals[12] + rowTotals[13] + rowTotals[14] +
+       rowTotals[15] + rowTotals[16] + rowTotals[17] + rowTotals[18] + rowTotals[19] +
+       rowTotals[20] + rowTotals[21] + rowTotals[22] + rowTotals[23] + rowTotals[24] +
+       rowTotals[25] + rowTotals[26] + rowTotals[27] + rowTotals[28] + rowTotals[29] +
+       rowTotals[30] + rowTotals[31] + rowTotals[32] + rowTotals[33] + rowTotals[34] +
+       rowTotals[35] + rowTotals[36] + rowTotals[37] + rowTotals[38] + rowTotals[39] +
+       rowTotals[40] + rowTotals[41] + rowTotals[42] + rowTotals[43] + rowTotals[44] +
+       rowTotals[45] + rowTotals[46] + rowTotals[47] + rowTotals[48] + rowTotals[49] +
+       rowTotals[50] + rowTotals[51] + rowTotals[52] + rowTotals[53] + rowTotals[54] +
+       rowTotals[55] + rowTotals[56] + rowTotals[57] + rowTotals[58] + rowTotals[59] +
+       rowTotals[60] + rowTotals[61] + rowTotals[62] + rowTotals[63];
+
+      #endif
+
+      mUsedRows = (total & 0xff) + ((total>>8) & 0xff) + ((total>>16)&0xff) + ((total>>24)&0xff);
+      mUsedBytes = mUsedRows<<IMMIX_LINE_BITS;
+
+      mZeroLock = 0;
+      mOwned = false;
+      outStats.rowsInUse += mUsedRows;
+      outStats.bytesInUse += mUsedBytes;
+      outStats.fraggedRows += mFraggedRows;
+      mFraggedRows = 0;
+      mHoles = 0;
+
+      if (mUsedRows==IMMIX_USEFUL_LINES)
+      {
+         // All rows used - write the block off
+         mMoveScore = 0;
+         mZeroed = ZEROED_AUTO;
+         mReclaimed = true;
+      }
+      else
+      {
+         mZeroed = ZEROED_NOT;
+         mReclaimed = false;
+      }
+
+      int left = (IMMIX_USEFUL_LINES - mUsedRows) << IMMIX_LINE_BITS;
+      if (left<mMaxHoleSize)
+         mMaxHoleSize = left;
+   }
+
+   template<bool FULL>
+   void reclaim(BlockDataStats *outStats)
+   {
+      HoleRange *ranges = mRanges;
+      ranges[0].length = 0;
+      mZeroed = ZEROED_NOT;
+      int usedBytes = 0;
+
+      unsigned char *rowMarked = mPtr->mRowMarked;
+
+      int r = IMMIX_HEADER_LINES;
+      // Count unused rows ....
+     
+      // start on 4-byte boundary...
+      #ifdef HXCPP_ALIGN_ALLOC
+      while(r<4 && rowMarked[r]==0)
+         r++;
+      if (!rowMarked[r])
+      #endif
+      {
+         while(r<(IMMIX_LINES-4) && *(int *)(rowMarked+r)==0 )
+            r += 4;
+         while(r<(IMMIX_LINES) && rowMarked[r]==0)
+            r++;
+      }
+
+      if (r==IMMIX_LINES)
+      {
+         ranges[0].start  = IMMIX_HEADER_LINES<<IMMIX_LINE_BITS;
+         ranges[0].length = (IMMIX_USEFUL_LINES)<<IMMIX_LINE_BITS;
+         mMaxHoleSize = (IMMIX_USEFUL_LINES)<<IMMIX_LINE_BITS;
+         mUsedRows = 0;
+         mHoles = 1;
+         mMoveScore = 0;
+         ZERO_MEM(allocStart+IMMIX_HEADER_LINES, IMMIX_USEFUL_LINES*sizeof(int));
+      }
+      else
+      {
+         int hole = 0;
+
+         if (r>IMMIX_HEADER_LINES)
+         {
+            ranges[hole].start  = IMMIX_HEADER_LINES;
+            ranges[hole].length = r-IMMIX_HEADER_LINES;
+            hole++;
+         }
+
+         while(r<IMMIX_LINES)
+         {
+            if (rowMarked[r])
+            {
+               if (FULL)
+               {
+                  unsigned int &starts = allocStart[r];
+                  if (starts)
+                  {
+                     unsigned int *headerPtr = ((unsigned int *)mPtr->mRow[r]);
+                     #define CHECK_FLAG(i,byteMask) \
+                     { \
+                        unsigned int mask = 1<<i; \
+                        if ( starts & mask ) \
+                        { \
+                           unsigned int header = headerPtr[i]; \
+                           if ( (header & IMMIX_ALLOC_MARK_ID) != hx::gMarkID ) \
+                           { \
+                              starts ^= mask; \
+                              if (!(starts & byteMask)) \
+                                 break; \
+                           } \
+                           else \
+                              usedBytes += sizeof(int) + ((header & IMMIX_ALLOC_SIZE_MASK) >> IMMIX_ALLOC_SIZE_SHIFT); \
+                        } \
+                     }
+
+                     if (starts & 0x000000ff)
+                        for(int i=0;i<8;i++)
+                           CHECK_FLAG(i,0x000000ff);
+
+                     if (starts & 0x0000ff00)
+                        for(int i=8;i<16;i++)
+                           CHECK_FLAG(i,0x0000ff00);
+
+                     if (starts & 0x00ff0000)
+                        for(int i=16;i<24;i++)
+                           CHECK_FLAG(i,0x00ff0000);
+
+                     if (starts & 0xff000000)
+                        for(int i=24;i<32;i++)
+                           CHECK_FLAG(i,0xff000000);
+                  }
+               }
+               r++;
+            }
+            else
+            {
+               int start = r;
+               ranges[hole].start = start;
+
+               #ifdef HXCPP_ALIGN_ALLOC
+               int alignR = (r+3) & ~3;
+               while(r<alignR && rowMarked[r]==0)
+                  r++;
+               if (!rowMarked[r])
+               #endif
+               {
+                  while(r<(IMMIX_LINES-4) && *(int *)(rowMarked+r)==0 )
+                     r += 4;
+                  while(r<(IMMIX_LINES) && rowMarked[r]==0)
+                     r++;
+               }
+               ranges[hole].length = r-start;
+               hole++;
+            }
+         }
+
+
+         int freeLines = 0;
+         // Convert hole rows to hole bytes...
+         mMaxHoleSize = 0;
+         for(int h=0;h<hole;h++)
+         {
+            int s = ranges->start;
+            int l = ranges->length;
+            freeLines += l;
+            ZERO_MEM(allocStart+s, l*sizeof(int));
+
+            int sBytes = s<<IMMIX_LINE_BITS;
+            ranges->start = sBytes;
+
+            int lBytes = l<<IMMIX_LINE_BITS;
+            ranges->length = lBytes;
+
+            if (lBytes>mMaxHoleSize)
+              mMaxHoleSize = lBytes;
+
+            ranges++;
+         }
+         mUsedRows = IMMIX_USEFUL_LINES - freeLines;
+         mHoles = hole;
+      }
+
+      mUsedBytes =  FULL ? usedBytes : (mUsedRows<<IMMIX_LINE_BITS);
+      mMoveScore = calcFragScore();
+      mReclaimed = true;
+
+      if (outStats)
+      {
+         outStats->rowsInUse += mUsedRows;
+         outStats->bytesInUse += mUsedBytes;
+         outStats->fragScore += mMoveScore;
+         outStats->fraggedRows += mFraggedRows;
+
+         if (mUsedRows==0)
+            outStats->emptyBlocks++;
+         if (mMoveScore> FRAG_THRESH )
+            outStats->fraggedBlocks++;
+      }
+
+      mFraggedRows = 0;
+   }
+
+   int calcFragScore()
+   {
+      return mPinned ? 0 : (mHoles>3 ? mHoles-3 : 0) + 8 * (mUsedRows<<IMMIX_LINE_BITS) / (mUsedBytes+IMMIX_LINE_LEN);
+   }
+
+
+   // When known to be an actual object start...
+   AllocType GetAllocTypeChecked(int inOffset, bool allowPrevious)
+   {
+      char time = mPtr->mRow[0][inOffset+HX_ENDIAN_MARK_ID_BYTE_HEADER];
+      if ( ((time+1) & MARK_BYTE_MASK) != (gByteMarkID & MARK_BYTE_MASK)  )
+      {
+         // Object is either out-of-date, or already marked....
+         return time==gByteMarkID ? allocMarked : allocNone;
+      }
+
+      if (!allowPrevious)
+         return allocNone;
+
+      if (*(unsigned int *)(mPtr->mRow[0] + inOffset) & IMMIX_ALLOC_IS_CONTAINER)
+      {
+         // See if object::new has been called, but not constructed yet ...
+         void **vtable = (void **)(mPtr->mRow[0] + inOffset + sizeof(int));
+         if (vtable[0]==0)
+         {
+            // GCLOG("Partially constructed object.");
+            return allocString;
+         }
+         return allocObject;
+      }
+
+      return allocString;
+   }
+
+   #ifdef HXCPP_GC_NURSERY
+   AllocType GetEnclosingNurseryType(int inOffset, void **outPtr)
+   {
+      // The block did not get used in the previous cycle, so allocStart is invalid and
+      //  no new objects should be in here
+      if (!mZeroed)
+         return allocNone;
+      // For the nursery(generational) case, the allocStart markers are not set
+      // So trace tne new object links through the new allocation holes
+      for(int h=0;h<mHoles;h++)
+      {
+         int scan = mRanges[h].start;
+         if (inOffset<scan)
+            break;
+
+         int size = 0;
+         int last = scan + mRanges[h].length;
+         if (inOffset<last)
+         {
+            #ifdef HXCPP_ALIGN_ALLOC
+            // Make sure header scan is odd-int aligned so the following object will be even-int
+            // aligned
+            if (!(scan & 0x4))
+               scan += 4;
+            #endif
+
+            // Found hole that the object was possibly allocated in
+            while(scan<=inOffset)
+            {
+               // Trace along the hole...
+               unsigned int header = *(unsigned int *)(mPtr->mRow[0]+scan);
+               if (!(header & 0xff000000))
+                  size = header & 0x0000ffff;
+               else
+                  size = (header & IMMIX_ALLOC_SIZE_MASK) >> IMMIX_ALLOC_SIZE_SHIFT;
+
+               int end = scan+size+sizeof(int);
+               if (!size || end > last)
+                  return allocNone;
+
+               if (inOffset>=scan && inOffset<end)
+               {
+                  if (inOffset>scan+sgCheckInternalOffset)
+                     return allocNone;
+
+                  *outPtr = mPtr->mRow[0] + scan + sizeof(int);
+
+                  if (header & IMMIX_ALLOC_IS_CONTAINER)
+                  {
+                     // See if object::new has been called, but not constructed yet ...
+                     void **vtable = (void **)(mPtr->mRow[0] + scan + sizeof(int));
+                     if (vtable[0]==0)
+                     {
+                        // GCLOG("Partially constructed object.");
+                        return allocString;
+                     }
+                     return allocObject;
+                  }
+                  return allocString;
+               }
+               scan = end;
+               #ifdef HXCPP_ALIGN_ALLOC
+               // Make sure scan is odd-int aligned so the following object will be even-int
+               // aligned
+               if (!(scan & 0x4))
+                  scan += 4;
+               #endif
+            }
+            break;
+         }
+      }
+      return allocNone;
+}
+   #endif
+
+   AllocType GetAllocType(int inOffset,bool inAllowPrevious)
+   {
+      // Row that the header would be on
+      int r = inOffset >> IMMIX_LINE_BITS;
+
+      // Out of bounds - can't be a new object start
+      if (r < IMMIX_HEADER_LINES || r >= IMMIX_LINES)
+      {
+         return allocNone;
+      }
+
+      // Does a live object start on this row
+      if ( !( allocStart[r] & hx::gImmixStartFlag[inOffset &127]) )
+      {
+         #ifdef HXCPP_GC_NURSERY
+         void *ptr;
+         return GetEnclosingNurseryType(inOffset,&ptr);
+         #endif
+         //Not a actual start...
+         return allocNone;
+      }
+
+      return GetAllocTypeChecked(inOffset,inAllowPrevious);
+   }
+
+   AllocType GetEnclosingAllocType(int inOffset,void **outPtr,bool inAllowPrevious)
+   {
+      for(int dx=0;dx<=sgCheckInternalOffset;dx+=4)
+      {
+         int blockOffset = inOffset - dx;
+         if (blockOffset >= 0)
+         {
+            int r = blockOffset >> IMMIX_LINE_BITS;
+            if (r >= IMMIX_HEADER_LINES && r < IMMIX_LINES)
+            {
+               // Normal, good alloc
+               int rowPos = hx::gImmixStartFlag[blockOffset &127];
+               if ( allocStart[r] & rowPos )
+               {
+                  // Found last valid object - is it big enough?
+                  unsigned int header =  *(unsigned int *)((char *)mPtr + blockOffset);
+                  int size = (header & IMMIX_ALLOC_SIZE_MASK) >> IMMIX_ALLOC_SIZE_SHIFT;
+                  // Valid object not big enough...
+                  if (blockOffset + size +sizeof(int) <= inOffset )
+                     break;
+
+                  // If the object is old, it could be the tail end of an old row that
+                  //  thinks is is covering this row, but it is not because this row is reused.
+                  // So we can say there is no other object that could be covering
+                  //  this spot, but not that it is not a nursery object.
+                  AllocType result = GetAllocTypeChecked(blockOffset,inAllowPrevious);
+                  if (result!=allocNone)
+                  {
+                     *outPtr = (void *)(mPtr->mRow[0] + blockOffset + sizeof(int));
+                     return result;
+                  }
+                  break;
+               }
+            }
+          }
+      }
+
+      #ifdef HXCPP_GC_NURSERY
+      return GetEnclosingNurseryType(inOffset,outPtr);
+      #endif
+      // Not a actual start...
+      return allocNone;
+   }
+
+
+   void pin() { mPinned = true; }
+
+
+   #ifdef HXCPP_VISIT_ALLOCS
+   void VisitBlock(hx::VisitContext *inCtx)
+   {
+      if (isEmpty())
+         return;
+
+      unsigned char *rowMarked = mPtr->mRowMarked;
+      for(int r=IMMIX_HEADER_LINES;r<IMMIX_LINES;r++)
+      {
+         if (rowMarked[r])
+         {
+            unsigned int starts = allocStart[r];
+            if (!starts)
+               continue;
+            unsigned char *row = mPtr->mRow[r];
+            for(int i=0;i<32;i++)
+            {
+               int pos = i<<2;
+               if ( (starts & (1<<i)) &&
+                   (row[pos+HX_ENDIAN_MARK_ID_BYTE_HEADER]&FULL_MARK_BYTE_MASK) == gByteMarkID)
+                  {
+                     if ( (*(unsigned int *)(row+pos)) & IMMIX_ALLOC_IS_CONTAINER )
+                     {
+                        hx::Object *obj = (hx::Object *)(row+pos+4);
+                        // May be partially constructed
+                        if (*(void **)obj)
+                           obj->__Visit(inCtx);
+                     }
+                  }
+            }
+         }
+      }
+   }
+   #endif
+
+   #ifdef HXCPP_GC_VERIFY
+   void verify(const char *inWhere)
+   {
+      for(int i=IMMIX_HEADER_LINES;i<IMMIX_LINES;i++)
+      {
+         for(int j=0;j<32;j++)
+            if (allocStart[i] & (1<<j))
+            {
+               unsigned int header = *(unsigned int *)( (char *)mPtr + i*IMMIX_LINE_LEN + j*4 );
+               if ((header & IMMIX_ALLOC_MARK_ID) == hx::gMarkID )
+               {
+                  int rows = header & IMMIX_ALLOC_ROW_COUNT;
+                  if (rows==0)
+                  {
+                     printf("BAD ROW0 %s\n", inWhere);
+                     DebuggerTrap();
+                  }
+                  for(int r=0;r<rows;r++)
+                     if (!mPtr->mRowMarked[r+i])
+                     {
+                        printf("Unmarked row %dx %d/%d %s, t=%d!\n", i, r, rows, inWhere,sgTimeToNextTableUpdate);
+                        DebuggerTrap();
+                     }
+               }
+            }
+         }
+
+   }
+   #endif
+};
+
+
+
+
+
+bool MostUsedFirst(BlockDataInfo *inA, BlockDataInfo *inB)
+{
+   return inA->getUsedRows() > inB->getUsedRows();
+}
+
+bool BiggestFreeFirst(BlockDataInfo *inA, BlockDataInfo *inB)
+{
+   return inA->mMaxHoleSize > inB->mMaxHoleSize;
+}
+bool SmallestFreeFirst(BlockDataInfo *inA, BlockDataInfo *inB)
+{
+   return inA->mMaxHoleSize < inB->mMaxHoleSize;
+}
+
+
+bool LeastUsedFirst(BlockDataInfo *inA, BlockDataInfo *inB)
+{
+   return inA->getUsedRows() < inB->getUsedRows();
+}
+
+
+
+bool SortMoveOrder(BlockDataInfo *inA, BlockDataInfo *inB)
+{
+   return inA->mMoveScore > inB->mMoveScore;
+}
+
+
+namespace hx
+{
+
+
+
+void BadImmixAlloc()
+{
+
+   #ifdef HX_WINRT
+   WINRT_LOG("Bad local allocator - requesting memory from unregistered thread!");
+   #else
+   #ifdef ANDROID
+   __android_log_print(ANDROID_LOG_ERROR, "hxcpp",
+   #else
+   fprintf(stderr,
+   #endif
+
+   "Bad local allocator - requesting memory from unregistered thread!"
+
+   #ifdef ANDROID
+   );
+   #else
+   );
+   #endif
+   #endif
+
+   DebuggerTrap();
+}
+
+
+
+void GCCheckPointer(void *inPtr)
+{
+   #ifdef HXCPP_GC_DEBUG_ALWAYS_MOVE
+   if (hx::sgPointerMoved.find(inPtr)!=hx::sgPointerMoved.end())
+   {
+      GCLOG("Accessing moved pointer %p\n", inPtr);
+      DebuggerTrap();
+   }
+   #endif
+
+   unsigned char&mark = ((unsigned char *)inPtr)[HX_ENDIAN_MARK_ID_BYTE];
+   #ifdef HXCPP_GC_NURSERY
+   if (mark)
+   #endif
+   if ( !(mark & HX_GC_CONST_ALLOC_MARK_BIT) && (mark&FULL_MARK_BYTE_MASK)!=gByteMarkID  )
+   {
+      GCLOG("Old object access %p\n", inPtr);
+      NullReference("Object", false);
+   }
+}
+
+
+void GCOnNewPointer(void *inPtr)
+{
+   #ifdef HXCPP_ALIGN_ALLOC
+   if ( (size_t)inPtr & 0x7 )
+   {
+      GCLOG("Misaligned pointer %p\n", inPtr);
+      NullReference("Object", false);
+   }
+   #endif
+
+   #ifdef HXCPP_GC_DEBUG_ALWAYS_MOVE
+   hx::sgPointerMoved.erase(inPtr);
+   _hx_atomic_add(&sgAllocsSinceLastSpam, 1);
+   #endif
+}
+
+// --- Marking ------------------------------------
+
+struct MarkInfo
+{
+   const char *mClass;
+   const char *mMember;
+};
+
+struct GlobalChunks
+{
+   volatile MarkChunk *processList;
+   volatile int       processListPopLock;
+   volatile MarkChunk *freeList;
+   volatile int       freeListPopLock;
+
+   GlobalChunks()
+   {
+      processList = 0;
+      freeList = 0;
+      freeListPopLock = 0;
+      processListPopLock = 0;
+   }
+
+   MarkChunk *pushJobNoWake(MarkChunk *inChunk)
+   {
+      while(true)
+      {
+         MarkChunk *head = (MarkChunk *)processList;
+         inChunk->next = head;
+         if (_hx_atomic_compare_exchange_cast_ptr(&processList, head, inChunk) == head)
+            break;
+      }
+
+      return alloc();
+   }
+
+   MarkChunk *pushJob(MarkChunk *inChunk,bool inAndAlloc)
+   {
+      while(true)
+      {
+         MarkChunk *head = (MarkChunk *)processList;
+         inChunk->next = head;
+         if (_hx_atomic_compare_exchange_cast_ptr(&processList, head, inChunk) == head)
+            break;
+      }
+
+      #ifdef PROFILE_THREAD_USAGE
+      _hx_atomic_add(&sThreadChunkPushCount, 1);
+      #endif
+
+      if (MAX_GC_THREADS>1 && sLazyThreads)
+      {
+         ThreadPoolAutoLock l(sThreadPoolLock);
+
+         #ifdef PROFILE_THREAD_USAGE
+           #define CHECK_THREAD_WAKE(tid) \
+            if (MAX_GC_THREADS >tid && sgThreadCount>tid && (!(sRunningThreads & (1<<tid)))) { \
+            wakeThreadLocked(tid); \
+            sThreadChunkWakes++; \
+           } 
+         #else
+           #define CHECK_THREAD_WAKE(tid)  \
+            if (MAX_GC_THREADS >tid && sgThreadCount>tid && (!(sRunningThreads & (1<<tid)))) { \
+            wakeThreadLocked(tid); \
+           }
+         #endif
+
+
+         CHECK_THREAD_WAKE(0)
+         else CHECK_THREAD_WAKE(1)
+         else CHECK_THREAD_WAKE(2)
+         else CHECK_THREAD_WAKE(3)
+         else CHECK_THREAD_WAKE(4)
+         else CHECK_THREAD_WAKE(5)
+         else CHECK_THREAD_WAKE(6)
+         else CHECK_THREAD_WAKE(7)
+      }
+
+      if (inAndAlloc)
+         return alloc();
+      return 0;
+   }
+
+   void addLocked(MarkChunk *inChunk)
+   {
+      inChunk->next = (MarkChunk *)processList;
+      processList = (volatile MarkChunk *)inChunk;
+   }
+
+   void copyPointers( QuickVec<hx::Object *> &outPointers,bool andFree=false)
+   {
+      int size = 0;
+      for(MarkChunk *c =(MarkChunk *)processList; c; c=c->next )
+         size += c->count;
+
+      outPointers.setSize(size);
+      int idx = 0;
+      if (andFree)
+      {
+         while(processList)
+         {
+            MarkChunk *c = (MarkChunk *)processList;
+            processList = c->next;
+
+            for(int i=0;i<c->count;i++)
+               outPointers[idx++] = c->stack[i];
+            c->count = 0;
+            c->next = (MarkChunk *)freeList;
+            freeList = c;
+         }
+      }
+      else
+      {
+         for(MarkChunk *c = (MarkChunk *)processList; c; c=c->next )
+         {
+            for(int i=0;i<c->count;i++)
+               outPointers[idx++] = c->stack[i];
+         }
+      }
+   }
+
+   int takeArrayJob(hx::Object **inPtr, int inLen)
+   {
+      if (sLazyThreads)
+      {
+         int n = (inLen/2) & ~15;
+
+         if (n)
+         {
+            MarkChunk *chunk = alloc();
+            chunk->count = MarkChunk::OBJ_ARRAY_JOB;
+            chunk->arrayBase = inPtr;
+            chunk->arrayElements = n;
+
+            pushJob(chunk,false);
+         }
+
+         // Return how many to skip
+         return n;
+      }
+
+      return 0;
+   }
+
+   inline void release(MarkChunk *inChunk)
+   {
+      while(true)
+      {
+         MarkChunk *head = (MarkChunk *)freeList;
+         inChunk->next = head;
+         if (_hx_atomic_compare_exchange_cast_ptr(&freeList, head, inChunk) == head)
+            return;
+      }
+   }
+
+
+   MarkChunk *popJobLocked(MarkChunk *inChunk)
+   {
+      if (inChunk)
+         release(inChunk);
+
+      while(_hx_atomic_compare_exchange(&processListPopLock, 0, 1) != 0)
+      {
+         // Spin
+         #ifdef PROFILE_THREAD_USAGE
+         _hx_atomic_add(&sSpinCount, 1);
+         #endif
+      }
+
+      while(true)
+      {
+         MarkChunk *head = (MarkChunk *)processList;
+         if (!head)
+         {
+            processListPopLock = 0;
+            return 0;
+         }
+         MarkChunk *next = head->next;
+         if (_hx_atomic_compare_exchange_cast_ptr(&processList, head, next) == head)
+         {
+            processListPopLock = 0;
+
+            head->next = 0;
+            return head;
+         }
+      }
+      return 0;
+   }
+
+
+   void completeThreadLocked(int inThreadId)
+   {
+      if (!(sRunningThreads & (1<<inThreadId)))
+      {
+         printf("Complete non-running thread?\n");
+         DebuggerTrap();
+      }
+      sRunningThreads &= ~(1<<inThreadId);
+      sLazyThreads = sRunningThreads != sAllThreads;
+
+      if (!sRunningThreads)
+         SignalThreadPool(sThreadJobDone,sThreadJobDoneSleeping);
+   }
+
+
+   // Optionally returns inChunk to empty pool (while we have the lock),
+   //  and returns a new job if there is one
+   MarkChunk *popJobOrFinish(MarkChunk *inChunk,int inThreadId)
+   {
+      #ifdef HX_MULTI_THREAD_MARKING
+      if (sAllThreads)
+      {
+         MarkChunk *result =  popJobLocked(inChunk);
+         if (!result)
+         {
+            for(int spinCount = 0; spinCount<10000; spinCount++)
+            {
+               if ( sgThreadPoolAbort || sAllThreads == (1<<inThreadId) )
+                  break;
+               if (processList)
+               {
+                  result =  popJobLocked(0);
+                  if (result)
+                     return result;
+               }
+            }
+            ThreadPoolAutoLock l(sThreadPoolLock);
+            completeThreadLocked(inThreadId);
+         }
+         return result;
+      }
+      #endif
+
+      return popJobLocked(inChunk);
+   }
+
+
+   void free(MarkChunk *inChunk)
+   {
+      release(inChunk);
+   }
+
+   inline MarkChunk *alloc()
+   {
+      while(_hx_atomic_compare_exchange(&freeListPopLock, 0, 1) != 0)
+      {
+         // Spin
+         #ifdef PROFILE_THREAD_USAGE
+         _hx_atomic_add(&sSpinCount, 1);
+         #endif
+      }
+
+      while(true)
+      {
+         MarkChunk *head = (MarkChunk *)freeList;
+         if (!head)
+         {
+            freeListPopLock = 0;
+            return new MarkChunk;
+         }
+         MarkChunk *next = head->next;
+         if (_hx_atomic_compare_exchange_cast_ptr(&freeList, head, next) == head)
+         {
+            freeListPopLock = 0;
+
+            head->next = 0;
+            return head;
+         }
+      }
+   }
+
+
+
+
+   MarkChunk *getInitJob()
+   {
+      MarkChunk *result = popJobLocked(0);
+      if (result)
+      {
+         if (result->count==MarkChunk::OBJ_ARRAY_JOB)
+         {
+            GCLOG("Popped array job?\n");
+            pushJob(result,false);
+         }
+         else
+            return result;
+      }
+      return alloc();
+   }
+
+};
+
+GlobalChunks sGlobalChunks;
+
+class MarkContext
+{
+    #ifdef HXCPP_DEBUG
+    MarkInfo  *mInfo;
+    int       mPos;
+    #endif
+
+    int       mThreadId;
+    MarkChunk *marking;
+
+
+public:
+    enum { StackSize = 8192 };
+
+    bool isGenerational;
+
+    MarkContext(int inThreadId = -1)
+    {
+       #ifdef HXCPP_DEBUG
+       mInfo = new MarkInfo[StackSize];
+       mPos = 0;
+       #endif
+       mThreadId = inThreadId;
+       marking = sGlobalChunks.alloc();
+
+       isGenerational = false;
+    }
+    ~MarkContext()
+    {
+       if (marking) sGlobalChunks.free(marking);
+       #ifdef HXCPP_DEBUG
+       delete [] mInfo;
+       #endif
+       // TODO: Free slabs
+    }
+
+
+    #ifdef HXCPP_DEBUG
+    void PushClass(const char *inClass)
+    {
+       if (mPos<StackSize-1)
+       {
+          mInfo[mPos].mClass = inClass;
+          mInfo[mPos].mMember = 0;
+       }
+       mPos++;
+    }
+
+
+    void SetMember(const char *inMember)
+    {
+       // Should not happen...
+       if (mPos==0)
+          return;
+       if (mPos<StackSize)
+          mInfo[mPos-1].mMember = inMember ? inMember : "Unknown";
+    }
+    void PopClass() { mPos--; }
+
+    void Trace()
+    {
+       int n = mPos < StackSize ? mPos : StackSize;
+       #ifdef ANDROID
+       __android_log_print(ANDROID_LOG_ERROR, "trace", "Class referenced from");
+       #else
+       printf("Class referenced from:\n");
+       #endif
+
+       for(int i=0;i<n;i++)
+          #ifdef ANDROID
+          __android_log_print(ANDROID_LOG_INFO, "trace", "%s.%s",  mInfo[i].mClass, mInfo[i].mMember );
+          #else
+          printf("%s.%s\n",  mInfo[i].mClass, mInfo[i].mMember );
+          #endif
+
+       if (mPos>=StackSize)
+       {
+          #ifdef ANDROID
+          __android_log_print(ANDROID_LOG_INFO, "trace", "... + deeper");
+          #else
+          printf("... + deeper\n");
+          #endif
+       }
+    }
+    #endif
+
+
+    void pushObj(hx::Object *inObject)
+    {
+       if (marking->count < MarkChunk::SIZE)
+       {
+          marking->push(inObject);
+       }
+       else
+       {
+          marking = sGlobalChunks.pushJob(marking,true);
+          marking->push(inObject);
+       }
+    }
+
+    void init()
+    {
+       if (!marking)
+          marking = sGlobalChunks.getInitJob();
+    }
+
+    void releaseJobs()
+    {
+       if (marking && marking->count)
+       {
+          sGlobalChunks.pushJob(marking,false);
+       }
+       else if (marking)
+       {
+          sGlobalChunks.release(marking);
+       }
+       marking = 0;
+    }
+
+    void processMarkStack()
+    {
+       while(true)
+       {
+          if (!marking || !marking->count)
+          {
+             #ifdef HX_MULTI_THREAD_MARKING
+             if (sgThreadPoolAbort)
+             {
+                releaseJobs();
+                return;
+             }
+             #endif
+
+             marking = sGlobalChunks.popJobOrFinish(marking,mThreadId);
+             if (!marking)
+                break;
+
+             if (marking->count==MarkChunk::OBJ_ARRAY_JOB)
+             {
+                int n = marking->arrayElements;
+                hx::Object **elems = marking->arrayBase;
+                marking->count = 0;
+                MarkObjectArray(elems, n, this);
+                continue;
+             }
+          }
+
+          while(marking)
+          {
+             hx::Object *obj = marking->pop();
+             if (obj)
+             {
+                obj->__Mark(this);
+                #if HX_MULTI_THREAD_MARKING
+                // Load balance
+                if (sLazyThreads && marking->count>32)
+                {
+                   MarkChunk *c = sGlobalChunks.alloc();
+                   marking->count -= 16;
+                   c->count = 16;
+                   memcpy( c->stack, marking->stack + marking->count, 16*sizeof(hx::Object *));
+                   sGlobalChunks.pushJob(c,false);
+                }
+                #ifdef PROFILE_THREAD_USAGE
+                sThreadMarkCount[mThreadId]++;
+                #endif
+                #endif
+             }
+             else
+                break;
+          }
+       }
+    }
+};
+
+
+/*
+void MarkerReleaseWorkerLocked( )
+{
+   //printf("Release...\n");
+   for(int i=0;i<sAllThreads;i++)
+   {
+      if ( ! (sRunningThreads & (1<<i) ) )
+      {
+         //printf("Wake %d\n",i);
+         sRunningThreads |= (1<<i);
+         sThreadWake[i]->Set();
+         return;
+      }
+   }
+}
+*/
+
+
+
+#ifdef HXCPP_DEBUG
+static bool breakOnce = 1;
+void MarkSetMember(const char *inName,hx::MarkContext *__inCtx)
+{
+   if (gCollectTrace)
+      __inCtx->SetMember(inName);
+}
+
+void MarkPushClass(const char *inName,hx::MarkContext *__inCtx)
+{
+   if (gCollectTrace)
+      __inCtx->PushClass(inName);
+}
+
+void MarkPopClass(hx::MarkContext *__inCtx)
+{
+   if (gCollectTrace)
+      __inCtx->PopClass();
+}
+#endif
+
+
+
+
+struct AutoMarkPush
+{
+   hx::MarkContext *mCtx;
+   AutoMarkPush(hx::MarkContext *ctx, const char *cls, const char *member)
+   {
+      #ifdef HXCPP_DEBUG
+      mCtx = ctx;
+      MarkPushClass(cls,mCtx);
+      MarkSetMember(member,mCtx);
+      #endif
+   }
+   ~AutoMarkPush()
+   {
+      #ifdef HXCPP_DEBUG
+      MarkPopClass(mCtx);
+      #endif
+   }
+};
+
+
+
+
+
+
+void MarkAllocUnchecked(void *inPtr,hx::MarkContext *__inCtx)
+{
+   #ifdef PROFILE_COLLECT
+   sAllocMarks++;
+   #endif
+
+   size_t ptr_i = ((size_t)inPtr)-sizeof(int);
+   unsigned int flags =  *((unsigned int *)ptr_i);
+
+   #ifdef HXCPP_GC_NURSERY
+   if (!(flags & 0xff000000))
+   {
+      #ifdef HX_GC_VERIFY_GENERATIONAL
+      if (sGcVerifyGenerational)
+      {
+         printf("Nursery alloc escaped generational collection %p\n", inPtr);
+         DebuggerTrap();
+      }
+      #endif
+
+      int size = flags & 0xffff;
+      // Size will be 0 for large allocs -> no need to mark block
+      if (size)
+      {
+         int start = (int)(ptr_i & IMMIX_BLOCK_OFFSET_MASK);
+         int startRow = start>>IMMIX_LINE_BITS;
+         int blockId = *(BlockIdType *)(ptr_i & IMMIX_BLOCK_BASE_MASK);
+         BlockDataInfo *info = (*gBlockInfo)[blockId];
+
+         int endRow = (start + size + sizeof(int) + IMMIX_LINE_LEN-1)>>IMMIX_LINE_BITS;
+         *(unsigned int *)ptr_i = flags = (flags & IMMIX_HEADER_PRESERVE) |
+                                          (endRow -startRow) |
+                                          (size<<IMMIX_ALLOC_SIZE_SHIFT) |
+                                          gMarkID;
+
+         unsigned int *pos = info->allocStart + startRow;
+         unsigned int val = *pos;
+         while(_hx_atomic_compare_exchange((volatile int *)pos, val,val|gImmixStartFlag[start&127]) != val)
+            val = *pos;
+
+         #ifdef HXCPP_GC_GENERATIONAL
+         info->mHasSurvivor = true;
+         #endif
+      }
+      else
+      {
+         // Large nursury object
+         ((unsigned char *)inPtr)[HX_ENDIAN_MARK_ID_BYTE] = gByteMarkID;
+      }
+   }
+   else
+   #endif
+   {
+      #ifdef HX_GC_VERIFY_GENERATIONAL
+      if (sGcVerifyGenerational && ((unsigned char *)inPtr)[HX_ENDIAN_MARK_ID_BYTE] != gPrevByteMarkID)
+      {
+         printf("Alloc missed int generational collection %p\n", inPtr);
+         DebuggerTrap();
+      }
+      #endif
+      ((unsigned char *)inPtr)[HX_ENDIAN_MARK_ID_BYTE] = gByteMarkID;
+   }
+
+   int rows = flags & IMMIX_ALLOC_ROW_COUNT;
+   if (rows)
+   {
+      #if HXCPP_GC_DEBUG_LEVEL>0
+      if ( ((ptr_i & IMMIX_BLOCK_OFFSET_MASK)>>IMMIX_LINE_BITS) + rows > IMMIX_LINES) DebuggerTrap();
+      #endif
+
+      char *block = (char *)(ptr_i & IMMIX_BLOCK_BASE_MASK);
+      char *rowMark = block + ((ptr_i & IMMIX_BLOCK_OFFSET_MASK)>>IMMIX_LINE_BITS);
+      *rowMark = 1;
+      if (rows>1)
+      {
+         rowMark[1] = 1;
+         if (rows>2)
+         {
+            rowMark[2] = 1;
+            if (rows>3)
+            {
+               rowMark[3] = 1;
+               for(int r=4; r<rows; r++)
+                  rowMark[r]=1;
+            }
+         }
+      }
+
+   // MARK_ROWS_UNCHECKED_END
+   }
+}
+
+void MarkObjectAllocUnchecked(hx::Object *inPtr,hx::MarkContext *__inCtx)
+{
+   size_t ptr_i = ((size_t)inPtr)-sizeof(int);
+   unsigned int flags =  *((unsigned int *)ptr_i);
+   #ifdef HXCPP_GC_NURSERY
+   if (!(flags & 0xff000000))
+   {
+      #if defined(HX_GC_VERIFY_GENERATIONAL)
+         if (sGcVerifyGenerational)
+         {
+            printf("Nursery object escaped generational collection %p\n", inPtr);
+            DebuggerTrap();
+         }
+      #endif
+
+
+      int size = flags & 0xffff;
+      int start = (int)(ptr_i & IMMIX_BLOCK_OFFSET_MASK);
+      int startRow = start>>IMMIX_LINE_BITS;
+      int blockId = *(BlockIdType *)(ptr_i & IMMIX_BLOCK_BASE_MASK);
+      BlockDataInfo *info = (*gBlockInfo)[blockId];
+
+      int endRow = (start + size + sizeof(int) + IMMIX_LINE_LEN-1)>>IMMIX_LINE_BITS;
+      *(unsigned int *)ptr_i = flags = (flags & IMMIX_HEADER_PRESERVE) |
+                                       (endRow -startRow) |
+                                       (size<<IMMIX_ALLOC_SIZE_SHIFT) |
+                                       gMarkID;
+
+      unsigned int *pos = info->allocStart + startRow;
+      unsigned int val = *pos;
+      while(_hx_atomic_compare_exchange( (volatile int *)pos, val, val|gImmixStartFlag[start&127]) != val)
+         val = *pos;
+      #ifdef HXCPP_GC_GENERATIONAL
+      info->mHasSurvivor = true;
+      #endif
+   }
+   else
+   #endif
+      ((unsigned char *)inPtr)[HX_ENDIAN_MARK_ID_BYTE] = gByteMarkID;
+
+   int rows = flags & IMMIX_ALLOC_ROW_COUNT;
+   if (rows)
+   {
+      char *block = (char *)(ptr_i & IMMIX_BLOCK_BASE_MASK);
+      char *rowMark = block + ((ptr_i & IMMIX_BLOCK_OFFSET_MASK)>>IMMIX_LINE_BITS);
+      #if HXCPP_GC_DEBUG_LEVEL>0
+      if ( ((ptr_i & IMMIX_BLOCK_OFFSET_MASK)>>IMMIX_LINE_BITS) + rows > IMMIX_LINES) DebuggerTrap();
+      #endif
+
+      *rowMark = 1;
+      if (rows>1)
+      {
+         rowMark[1] = 1;
+         if (rows>2)
+         {
+            rowMark[2] = 1;
+            if (rows>3)
+            {
+               rowMark[3] = 1;
+               for(int r=4; r<rows; r++)
+                  rowMark[r]=1;
+            }
+         }
+      }
+
+      if (flags & IMMIX_ALLOC_IS_CONTAINER)
+      {
+         #ifdef PROFILE_COLLECT
+         sObjectMarks++;
+         #endif
+
+         #ifdef HXCPP_DEBUG
+            if (gCollectTrace && gCollectTrace==inPtr->__GetClass().GetPtr())
+            {
+               gCollectTraceCount++;
+               if (gCollectTraceDoPrint)
+                   __inCtx->Trace();
+            }
+
+            // Recursive mark so stack stays intact..
+            #if (HXCPP_GC_DEBUG_LEVEL>0)
+            inPtr->__Mark(__inCtx);
+            #else
+            if (gCollectTrace)
+               inPtr->__Mark(__inCtx);
+            else
+               __inCtx->pushObj(inPtr);
+            #endif
+         #else // Not debug
+
+            // There is a slight performance gain by calling recursively, but you
+            //   run the risk of stack overflow.  Also, a parallel mark algorithm could be
+            //   done when the marking is stack based.
+            //inPtr->__Mark(__inCtx);
+            #if (HXCPP_GC_DEBUG_LEVEL>0)
+            inPtr->__Mark(__inCtx);
+            #else
+            __inCtx->pushObj(inPtr);
+            #endif
+        #endif
+      }
+      else
+      {
+         #ifdef PROFILE_COLLECT
+         sAllocMarks++;
+         #endif
+      }
+
+   // MARK_ROWS_UNCHECKED_END
+   }
+}
+
+
+void MarkObjectArray(hx::Object **inPtr, int inLength, hx::MarkContext *__inCtx)
+{
+   hx::Object *tmp;
+
+   int extra = inLength & 0x0f;
+   for(int i=0;i<extra;i++)
+      if (inPtr[i]) MarkObjectAlloc(inPtr[i],__inCtx);
+   if (inLength==extra)
+      return;
+
+   inLength -= extra;
+   hx::Object **ptrI = inPtr + extra;
+   hx::Object **end = ptrI + inLength;
+
+
+   #define MARK_PTR_I \
+   tmp = *ptrI++; \
+   if (tmp) MarkObjectAlloc(tmp,__inCtx);
+
+
+
+   #ifdef HX_MULTI_THREAD_MARKING
+   if (sAllThreads && inLength>4096)
+   {
+      hx::Object **dishOffEnd = end - 4096;
+      while(ptrI<end)
+      {
+         // Are the other threads slacking off?
+         if ((sRunningThreads != sAllThreads) && ptrI<dishOffEnd)
+         {
+            ptrI += sGlobalChunks.takeArrayJob(ptrI, end-ptrI);
+         }
+         else
+         {
+            MARK_PTR_I;
+            MARK_PTR_I;
+            MARK_PTR_I;
+            MARK_PTR_I;
+
+            MARK_PTR_I;
+            MARK_PTR_I;
+            MARK_PTR_I;
+            MARK_PTR_I;
+
+            MARK_PTR_I;
+            MARK_PTR_I;
+            MARK_PTR_I;
+            MARK_PTR_I;
+
+            MARK_PTR_I;
+            MARK_PTR_I;
+            MARK_PTR_I;
+            MARK_PTR_I;
+         }
+      }
+   }
+   else
+   #endif
+   {
+      while(ptrI<end)
+      {
+         MARK_PTR_I;
+         MARK_PTR_I;
+         MARK_PTR_I;
+         MARK_PTR_I;
+
+         MARK_PTR_I;
+         MARK_PTR_I;
+         MARK_PTR_I;
+         MARK_PTR_I;
+
+         MARK_PTR_I;
+         MARK_PTR_I;
+         MARK_PTR_I;
+         MARK_PTR_I;
+
+         MARK_PTR_I;
+         MARK_PTR_I;
+         MARK_PTR_I;
+         MARK_PTR_I;
+      }
+   }
+}
+
+void MarkStringArray(String *inPtr, int inLength, hx::MarkContext *__inCtx)
+{
+   #if 0
+   if (MAX_GC_THREADS>1 && sAllThreads && inLength>4096)
+   {
+      int extra = inLength & 0x0f;
+      for(int i=0;i<extra;i++)
+         if (inPtr[i]) MarkObjectAlloc(inPtr[i],__inCtx);
+
+      hx::Object **ptrI = inPtr + extra;
+      hx::Object **end = ptrI + (inLength& ~0x0f);
+      hx::Object **dishOffEnd = end - 4096;
+      while(ptrI<end)
+      {
+         // Are the other threads slacking off?
+         if ((sRunningThreads != sAllThreads) && ptrI<dishOffEnd)
+         {
+            ptrI += sGlobalChunks.takeArrayJob(ptrI, end-ptrI);
+         }
+
+         if (*ptrI) MarkObjectAlloc(*ptrI,__inCtx); ptrI++;
+         if (*ptrI) MarkObjectAlloc(*ptrI,__inCtx); ptrI++;
+         if (*ptrI) MarkObjectAlloc(*ptrI,__inCtx); ptrI++;
+         if (*ptrI) MarkObjectAlloc(*ptrI,__inCtx); ptrI++;
+         if (*ptrI) MarkObjectAlloc(*ptrI,__inCtx); ptrI++;
+         if (*ptrI) MarkObjectAlloc(*ptrI,__inCtx); ptrI++;
+         if (*ptrI) MarkObjectAlloc(*ptrI,__inCtx); ptrI++;
+         if (*ptrI) MarkObjectAlloc(*ptrI,__inCtx); ptrI++;
+         if (*ptrI) MarkObjectAlloc(*ptrI,__inCtx); ptrI++;
+         if (*ptrI) MarkObjectAlloc(*ptrI,__inCtx); ptrI++;
+         if (*ptrI) MarkObjectAlloc(*ptrI,__inCtx); ptrI++;
+         if (*ptrI) MarkObjectAlloc(*ptrI,__inCtx); ptrI++;
+         if (*ptrI) MarkObjectAlloc(*ptrI,__inCtx); ptrI++;
+         if (*ptrI) MarkObjectAlloc(*ptrI,__inCtx); ptrI++;
+         if (*ptrI) MarkObjectAlloc(*ptrI,__inCtx); ptrI++;
+         if (*ptrI) MarkObjectAlloc(*ptrI,__inCtx); ptrI++;
+      }
+   }
+   else
+   #endif
+   {
+      for(int i=0;i<inLength;i++)
+      {
+         const char *str = inPtr[i].raw_ptr();
+         HX_MARK_STRING(str);
+      }
+   }
+}
+
+#ifdef HXCPP_DEBUG
+#define FILE_SCOPE
+#else
+#define FILE_SCOPE static
+#endif
+
+// --- Roots -------------------------------
+
+FILE_SCOPE HxMutex *sGCRootLock = 0;
+typedef hx::UnorderedSet<hx::Object **> RootSet;
+static RootSet sgRootSet;
+
+typedef hx::UnorderedMap<void *,int> OffsetRootSet;
+static OffsetRootSet *sgOffsetRootSet=0;
+
+void GCAddRoot(hx::Object **inRoot)
+{
+   AutoLock lock(*sGCRootLock);
+   sgRootSet.insert(inRoot);
+}
+
+void GCRemoveRoot(hx::Object **inRoot)
+{
+   AutoLock lock(*sGCRootLock);
+   sgRootSet.erase(inRoot);
+}
+
+
+void GcAddOffsetRoot(void *inRoot, int inOffset)
+{
+   AutoLock lock(*sGCRootLock);
+   if (!sgOffsetRootSet)
+      sgOffsetRootSet = new OffsetRootSet();
+   (*sgOffsetRootSet)[inRoot] = inOffset;
+}
+
+void GcSetOffsetRoot(void *inRoot, int inOffset)
+{
+   AutoLock lock(*sGCRootLock);
+   (*sgOffsetRootSet)[inRoot] = inOffset;
+}
+
+void GcRemoveOffsetRoot(void *inRoot)
+{
+   AutoLock lock(*sGCRootLock);
+   OffsetRootSet::iterator r = sgOffsetRootSet->find(inRoot);
+   sgOffsetRootSet->erase(r);
+}
+
+
+
+
+// --- Finalizers -------------------------------
+
+
+class WeakRef;
+typedef hx::QuickVec<WeakRef *> WeakRefs;
+
+FILE_SCOPE HxMutex *sFinalizerLock = 0;
+FILE_SCOPE WeakRefs sWeakRefs;
+
+class WeakRef : public hx::Object
+{
+public:
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdWeakRef };
+
+   WeakRef(Dynamic inRef)
+   {
+      mRef = inRef;
+      if (mRef.mPtr)
+      {
+         sFinalizerLock->Lock();
+         sWeakRefs.push(this);
+         sFinalizerLock->Unlock();
+      }
+   }
+
+   // Don't mark our ref !
+
+   #ifdef HXCPP_VISIT_ALLOCS
+   void __Visit(hx::VisitContext *__inCtx) { HX_VISIT_MEMBER(mRef); }
+   #endif
+
+   Dynamic mRef;
+};
+
+
+
+typedef hx::QuickVec<InternalFinalizer *> FinalizerList;
+
+FILE_SCOPE FinalizerList *sgFinalizers = 0;
+
+typedef hx::UnorderedMap<hx::Object *,hx::finalizer> FinalizerMap;
+FILE_SCOPE FinalizerMap sFinalizerMap;
+
+typedef void (*HaxeFinalizer)(Dynamic);
+typedef hx::UnorderedMap<hx::Object *,HaxeFinalizer> HaxeFinalizerMap;
+FILE_SCOPE HaxeFinalizerMap sHaxeFinalizerMap;
+
+hx::QuickVec<int> sFreeObjectIds;
+typedef hx::UnorderedMap<hx::Object *,int> ObjectIdMap;
+typedef hx::QuickVec<hx::Object *> IdObjectMap;
+FILE_SCOPE ObjectIdMap sObjectIdMap;
+FILE_SCOPE IdObjectMap sIdObjectMap;
+
+typedef hx::UnorderedSet<hx::Object *> MakeZombieSet;
+FILE_SCOPE MakeZombieSet sMakeZombieSet;
+
+typedef hx::QuickVec<hx::Object *> ZombieList;
+FILE_SCOPE ZombieList sZombieList;
+
+typedef hx::QuickVec<hx::HashRoot *> WeakHashList;
+FILE_SCOPE WeakHashList sWeakHashList;
+
+
+InternalFinalizer::InternalFinalizer(hx::Object *inObj, finalizer inFinalizer)
+{
+   mValid = true;
+   mObject = inObj;
+   mFinalizer = inFinalizer;
+
+   // Ensure this survives generational collect
+   AutoLock lock(*gSpecialObjectLock);
+   sgFinalizers->push(this);
+}
+
+#ifdef HXCPP_VISIT_ALLOCS
+void InternalFinalizer::Visit(VisitContext *__inCtx)
+{
+   HX_VISIT_OBJECT(mObject);
+}
+#endif
+
+void InternalFinalizer::Detach()
+{
+   mValid = false;
+}
+
+void FindZombies(MarkContext &inContext)
+{
+   for(MakeZombieSet::iterator i=sMakeZombieSet.begin(); i!=sMakeZombieSet.end(); )
+   {
+      hx::Object *obj = *i;
+      MakeZombieSet::iterator next = i;
+      ++next;
+
+      unsigned char mark = ((unsigned char *)obj)[HX_ENDIAN_MARK_ID_BYTE];
+      if ( mark!=gByteMarkID )
+      {
+         sZombieList.push(obj);
+         sMakeZombieSet.erase(i);
+
+         // Mark now to prevent secondary zombies...
+         inContext.init();
+         hx::MarkObjectAlloc(obj , &inContext );
+         inContext.processMarkStack();
+      }
+
+      i = next;
+   }
+}
+
+bool IsWeakRefValid(const HX_CHAR *inPtr)
+{
+   unsigned char mark = ((unsigned char *)inPtr)[HX_ENDIAN_MARK_ID_BYTE];
+
+    // Special case of member closure - check if the 'this' pointer is still alive
+   return  mark==gByteMarkID;
+}
+
+bool IsWeakRefValid(hx::Object *inPtr)
+{
+   unsigned char mark = ((unsigned char *)inPtr)[HX_ENDIAN_MARK_ID_BYTE];
+
+    // Special case of member closure - check if the 'this' pointer is still alive
+    bool isCurrent = mark==gByteMarkID;
+    if ( !isCurrent && inPtr->__GetType()==vtFunction)
+    {
+        hx::Object *thiz = (hx::Object *)inPtr->__GetHandle();
+        if (thiz)
+        {
+            mark = ((unsigned char *)thiz)[HX_ENDIAN_MARK_ID_BYTE];
+            if (mark==gByteMarkID)
+            {
+               // The object is still alive, so mark the closure and continue
+               MarkAlloc(inPtr,0);
+               return true;
+            }
+         }
+    }
+    return isCurrent;
+}
+
+static void someHackyFunc(hx::Object *)
+{
+}
+
+static void (*hackyFunctionCall)(hx::Object *) = someHackyFunc;
+
+struct Finalizable
+{
+   union
+   {
+      _hx_member_finalizer member;
+      _hx_alloc_finalizer  alloc;
+   };
+   void *base;
+   bool pin;
+   bool isMember;
+
+   Finalizable(hx::Object *inBase, _hx_member_finalizer inMember, bool inPin)
+   {
+      base = inBase;
+      member = inMember;
+      pin = inPin;
+      isMember = true;
+   }
+
+   Finalizable(void *inBase, _hx_alloc_finalizer inAlloc, bool inPin)
+   {
+      base = inBase;
+      alloc = inAlloc;
+      pin = inPin;
+      isMember = false;
+   }
+   void run()
+   {
+      if (isMember)
+      {
+         hx::Object *object = (hx::Object *)base;
+         // I can't tell if it is msvc over-optimizing this code, to I am not
+         //  quite calling things right, but this seems to fix it...
+         hackyFunctionCall(object);
+         (object->*member)();
+      }
+      else
+         alloc( base );
+   }
+};
+typedef hx::QuickVec< Finalizable > FinalizableList;
+FILE_SCOPE FinalizableList sFinalizableList;
+
+
+static double tFinalizers;
+static int finalizerCount;
+static int localCount;
+static int localObjects;
+static int localAllocs;
+static int rootObjects;
+static int rootAllocs;
+
+void RunFinalizers()
+{
+   finalizerCount = 0;
+
+   FinalizerList &list = *sgFinalizers;
+   int idx = 0;
+   while(idx<list.size())
+   {
+      InternalFinalizer *f = list[idx];
+      if (!f->mValid)
+      {
+         list.qerase(idx);
+         delete f;
+      }
+      else if (((unsigned char *)(f->mObject))[HX_ENDIAN_MARK_ID_BYTE] != gByteMarkID)
+      {
+         if (f->mFinalizer)
+         {
+            f->mFinalizer(f->mObject);
+            finalizerCount++;
+         }
+         list.qerase(idx);
+         delete f;
+      }
+      else
+      {
+         idx++;
+      }
+   }
+
+   idx = 0;
+   while(idx<sFinalizableList.size())
+   {
+      Finalizable &f = sFinalizableList[idx];
+      unsigned char mark = ((unsigned char *)f.base)[HX_ENDIAN_MARK_ID_BYTE];
+      if ( mark!=gByteMarkID )
+      {
+         finalizerCount++;
+         f.run();
+         sFinalizableList.qerase(idx);
+      }
+      else
+         idx++;
+   }
+
+   for(FinalizerMap::iterator i=sFinalizerMap.begin(); i!=sFinalizerMap.end(); )
+   {
+      hx::Object *obj = i->first;
+      FinalizerMap::iterator next = i;
+      ++next;
+
+      unsigned char mark = ((unsigned char *)obj)[HX_ENDIAN_MARK_ID_BYTE];
+      if ( mark!=gByteMarkID )
+      {
+         finalizerCount++;
+         (*i->second)(obj);
+         sFinalizerMap.erase(i);
+      }
+
+      i = next;
+   }
+
+
+   for(HaxeFinalizerMap::iterator i=sHaxeFinalizerMap.begin(); i!=sHaxeFinalizerMap.end(); )
+   {
+      hx::Object *obj = i->first;
+      HaxeFinalizerMap::iterator next = i;
+      ++next;
+
+      unsigned char mark = ((unsigned char *)obj)[HX_ENDIAN_MARK_ID_BYTE];
+      if ( mark!=gByteMarkID )
+      {
+         finalizerCount++;
+         (*i->second)(obj);
+         sHaxeFinalizerMap.erase(i);
+      }
+
+      i = next;
+   }
+
+   MEM_STAMP(hx::tFinalizers);
+
+   for(ObjectIdMap::iterator i=sObjectIdMap.begin(); i!=sObjectIdMap.end(); )
+   {
+      ObjectIdMap::iterator next = i;
+      next++;
+
+      hx::Object *o = i->first;
+      unsigned char mark = ((unsigned char *)o)[HX_ENDIAN_MARK_ID_BYTE];
+      if ( mark!=gByteMarkID && !(((unsigned int *)o)[-1] & HX_GC_CONST_ALLOC_BIT))
+      {
+         sFreeObjectIds.push(i->second);
+         sIdObjectMap[i->second] = 0;
+         sObjectIdMap.erase(i);
+      }
+
+      i = next;
+   }
+
+   for(int i=0;i<sWeakHashList.size();    )
+   {
+      HashRoot *ref = sWeakHashList[i];
+      unsigned char mark = ((unsigned char *)ref)[HX_ENDIAN_MARK_ID_BYTE];
+      // Object itself is gone - no need to worry about that again
+      if ( mark!=gByteMarkID )
+      {
+         sWeakHashList.qerase(i);
+         // no i++ ...
+      }
+      else
+      {
+         ref->updateAfterGc();
+         i++;
+      }
+   }
+
+
+
+   for(int i=0;i<sWeakRefs.size();    )
+   {
+      WeakRef *ref = sWeakRefs[i];
+      unsigned char mark = ((unsigned char *)ref)[HX_ENDIAN_MARK_ID_BYTE];
+      // Object itself is gone ...
+      if ( mark!=gByteMarkID )
+      {
+         sWeakRefs.qerase(i);
+         // no i++ ...
+      }
+      else
+      {
+         // what about the reference?
+         hx::Object *r = ref->mRef.mPtr;
+         unsigned char mark = ((unsigned char *)r)[HX_ENDIAN_MARK_ID_BYTE];
+
+         // Special case of member closure - check if the 'this' pointer is still alive
+         if ( mark!=gByteMarkID && r->__GetType()==vtFunction)
+         {
+            hx::Object *thiz = (hx::Object *)r->__GetHandle();
+            if (thiz)
+            {
+               mark = ((unsigned char *)thiz)[HX_ENDIAN_MARK_ID_BYTE];
+               if (mark==gByteMarkID)
+               {
+                  // The object is still alive, so mark the closure and continue
+                  MarkAlloc(r,0);
+               }
+            }
+         }
+
+         if ( mark!=gByteMarkID )
+         {
+            ref->mRef.mPtr = 0;
+            sWeakRefs.qerase(i);
+         }
+         else
+            i++;
+      }
+   }
+}
+
+// Callback finalizer on non-abstract type;
+void  GCSetFinalizer( hx::Object *obj, hx::finalizer f )
+{
+   if (!obj)
+      throw Dynamic(HX_CSTRING("set_finalizer - invalid null object"));
+   if (((unsigned int *)obj)[-1] & HX_GC_CONST_ALLOC_BIT)
+      throw Dynamic(HX_CSTRING("set_finalizer - invalid const object"));
+
+   AutoLock lock(*gSpecialObjectLock);
+   if (f==0)
+   {
+      FinalizerMap::iterator i = sFinalizerMap.find(obj);
+      if (i!=sFinalizerMap.end())
+         sFinalizerMap.erase(i);
+   }
+   else
+      sFinalizerMap[obj] = f;
+}
+
+
+// Callback finalizer on non-abstract type;
+void  GCSetHaxeFinalizer( hx::Object *obj, HaxeFinalizer f )
+{
+   if (!obj)
+      throw Dynamic(HX_CSTRING("set_finalizer - invalid null object"));
+   if (((unsigned int *)obj)[-1] & HX_GC_CONST_ALLOC_BIT)
+      throw Dynamic(HX_CSTRING("set_finalizer - invalid const object"));
+
+   AutoLock lock(*gSpecialObjectLock);
+   if (f==0)
+   {
+      HaxeFinalizerMap::iterator i = sHaxeFinalizerMap.find(obj);
+      if (i!=sHaxeFinalizerMap.end())
+         sHaxeFinalizerMap.erase(i);
+   }
+   else
+      sHaxeFinalizerMap[obj] = f;
+}
+
+void GCDoNotKill(hx::Object *inObj)
+{
+   if (!inObj)
+      throw Dynamic(HX_CSTRING("doNotKill - invalid null object"));
+   if (((unsigned int *)inObj)[-1] & HX_GC_CONST_ALLOC_BIT)
+      throw Dynamic(HX_CSTRING("doNotKill - invalid const object"));
+
+   AutoLock lock(*gSpecialObjectLock);
+   sMakeZombieSet.insert(inObj);
+}
+
+hx::Object *GCGetNextZombie()
+{
+   AutoLock lock(*gSpecialObjectLock);
+   if (sZombieList.empty())
+      return 0;
+   hx::Object *result = sZombieList.pop();
+   return result;
+}
+
+void RegisterWeakHash(HashBase<String> *inHash)
+{
+   AutoLock lock(*gSpecialObjectLock);
+   sWeakHashList.push(inHash);
+}
+
+void RegisterWeakHash(HashBase<Dynamic> *inHash)
+{
+   AutoLock lock(*gSpecialObjectLock);
+   sWeakHashList.push(inHash);
+}
+
+
+
+void InternalEnableGC(bool inEnable)
+{
+   //printf("Enable %d\n", sgInternalEnable);
+   sgInternalEnable = inEnable;
+}
+
+bool IsConstAlloc(const void *inData)
+{
+   unsigned int *header = (unsigned int *)inData;
+   return header[-1] & HX_GC_CONST_ALLOC_BIT;
+}
+
+void *InternalCreateConstBuffer(const void *inData,int inSize,bool inAddStringHash)
+{
+   bool addHash = inAddStringHash && inSize>0;
+
+   int *result = (int *)HxAlloc(inSize + sizeof(int) + (addHash ? sizeof(int):0) );
+   if (addHash)
+   {
+      unsigned int hash = 0;
+      if (inData)
+         for(int i=0;i<inSize-1;i++)
+            hash = hash*223 + ((unsigned char *)inData)[i];
+
+      //*((unsigned int *)((char *)result + inSize + sizeof(int))) = hash;
+      *result++ = hash;
+      *result++ = HX_GC_CONST_ALLOC_BIT | HX_GC_STRING_HASH;
+   }
+   else
+   {
+      *result++ = HX_GC_CONST_ALLOC_BIT;
+   }
+
+   if (inData)
+   {
+      memcpy(result,inData,inSize);
+   }
+   else if (inSize)
+   {
+      ZERO_MEM(result,inSize);
+   }
+
+   return result;
+}
+
+// Used when the allocation size is zero for a non-null pointer
+void *emptyAlloc = InternalCreateConstBuffer(0,0,false);
+
+
+} // namespace hx
+
+
+hx::Object *__hxcpp_weak_ref_create(Dynamic inObject)
+{
+   return new hx::WeakRef(inObject);
+}
+
+hx::Object *__hxcpp_weak_ref_get(Dynamic inRef)
+{
+   #ifdef HXCPP_DEBUG
+   hx::WeakRef *ref = dynamic_cast<hx::WeakRef *>(inRef.mPtr);
+   #else
+   hx::WeakRef *ref = static_cast<hx::WeakRef *>(inRef.mPtr);
+   #endif
+   return ref->mRef.mPtr;
+}
+
+
+// --- GlobalAllocator -------------------------------------------------------
+
+typedef hx::QuickVec<BlockDataInfo *> BlockList;
+
+typedef hx::QuickVec<unsigned int *> LargeList;
+
+enum MemType { memUnmanaged, memBlock, memLarge };
+
+
+
+
+#ifdef HXCPP_VISIT_ALLOCS
+class AllocCounter : public hx::VisitContext
+{
+public:
+   int count;
+
+   AllocCounter() { count = 0; }
+
+   void visitObject(hx::Object **ioPtr) { count ++; }
+   void visitAlloc(void **ioPtr) { count ++; }
+};
+
+
+#endif
+
+
+class GlobalAllocator *sGlobalAlloc = 0;
+
+
+inline bool SortByBlockPtr(BlockDataInfo *inA, BlockDataInfo *inB)
+{
+   return inA->mPtr < inB->mPtr;
+}
+
+struct MoveBlockJob
+{
+   BlockList blocks;
+   int from;
+   int to;
+
+   MoveBlockJob(BlockList &inAllBlocks)
+   {
+      blocks.setSize(inAllBlocks.size());
+      memcpy(&blocks[0], &inAllBlocks[0], inAllBlocks.size()*sizeof(void*));
+
+      std::sort(&blocks[0], &blocks[0]+blocks.size(), SortMoveOrder );
+      from = 0;
+      to = blocks.size()-1;
+   }
+
+   BlockDataInfo *getFrom()
+   {
+      while(true)
+      {
+         if (from>=to)
+         {
+            //printf("Caught up!\n");
+            return 0;
+         }
+         #ifndef HXCPP_GC_DEBUG_ALWAYS_MOVE
+         // Pinned / full
+         if (blocks[from]->mMoveScore<2)
+         {
+            //printf("All other blocks good!\n");
+            while(from<to)
+            {
+               //printf("Ignore DEFRAG %p ... %p\n", blocks[from]->mPtr, blocks[from]->mPtr+1);
+               from++;
+            }
+            return 0;
+         }
+         #endif
+         if (blocks[from]->mPinned)
+         {
+            //printf("PINNED DEFRAG %p ... %p\n", blocks[from]->mPtr, blocks[from]->mPtr+1);
+            from++;
+         }
+         else // Found one...
+            break;
+      }
+      //printf("From block %d (id=%d)\n", from, blocks[from]->mId);
+      BlockDataInfo *result = blocks[from++];
+      ////printf("FROM DEFRAG %p ... %p\n", result->mPtr, result->mPtr + 1 );
+      return result;
+   }
+   BlockDataInfo *getTo()
+   {
+      if (from>=to)
+      {
+         //printf("No more room!\n");
+         return 0;
+      }
+      //printf("To block %d (id=%d)\n", to, blocks[to]->mId);
+      BlockDataInfo *result = blocks[to--];
+      //printf("TO DEFRAG %p ... %p\n", result->mPtr, result->mPtr + 1 );
+      return result;
+   }
+};
+
+
+#ifndef HX_MEMORY_H_OVERRIDE
+
+#if 0
+static hx::QuickVec<void *> sBlockPool;
+static int gcBlockAllocs = 0;
+
+void *HxAllocGCBlock(size_t size)
+{
+   if (sBlockPool.size())
+      return sBlockPool.pop();
+   gcBlockAllocs++;
+   GCLOG("===========================================> New Chunk (%d)\n", gcBlockAllocs);
+   return HxAlloc(size);
+}
+
+void HxFreeGCBlock(void *p)
+{
+   sBlockPool.push(p);
+}
+
+#else
+
+#ifdef HX_GC_FIXED_BLOCKS
+unsigned char *chunkData = 0;
+void *HxAllocGCBlock(size_t inSize)
+{
+   if (!chunkData)
+   {
+      size_t size = 65536;
+      size *= IMMIX_BLOCK_SIZE;
+      #if defined(HX_WINDOWS) && defined(HXCPP_M64)
+      chunkData = (unsigned char *)0x100000000;
+      VirtualAlloc(chunkData,size,MEM_COMMIT|MEM_RESERVE,PAGE_READWRITE);
+      #else
+      chunkData = (unsigned char *)HxAlloc(size);
+      size_t ptr_i = (size_t)(chunkData+0xffff) & ~((size_t)0xffff);
+      chunkData = (unsigned char *)ptr_i;
+      #endif
+      //printf("Using fixed blocks %p...%p\n", chunkData, chunkData+size);
+   }
+   void *result = chunkData;
+   //printf(" %p\n", result);
+   chunkData += inSize;
+   return result;
+}
+void HxFreeGCBlock(void *p)
+{
+   printf("todo - HX_GC_FIXED_BLOCKS %p\n",p);
+}
+#else
+void *HxAllocGCBlock(size_t size) { return HxAlloc(size); }
+void HxFreeGCBlock(void *p) { HxFree(p); }
+#endif
+
+#endif
+
+#endif // HX_MEMORY_H_OVERRIDE
+
+
+//#define VERIFY_STACK_READ
+
+#ifdef VERIFY_STACK_READ
+// Just have something to do...
+int gVerifyVoidCount = 0;
+void VerifyStackRead(int *inBottom, int *inTop)
+{
+   #ifdef HXCPP_STACK_UP
+   int *start = inTop-1;
+   inTop = inBottom+1;
+   inBottom = start;
+   #endif
+
+   int n = inTop - inBottom;
+   int check = std::min(n,5);
+   for(int c=0;c<check;c++)
+   {
+      if (inBottom[c]==0)
+         gVerifyVoidCount++;
+      if (inTop[-1-c]==0)
+         gVerifyVoidCount++;
+   }
+}
+#endif
+
+// TODO - work out best size based on cache size?
+#ifdef HXCPP_GC_BIG_BLOCKS
+static int sMinZeroQueueSize = 4;
+static int sMaxZeroQueueSize = 16;
+#else
+static int sMinZeroQueueSize = 8;
+static int sMaxZeroQueueSize = 32;
+#endif
+
+#define BLOCK_OFSIZE_COUNT 12
+
+
+class GlobalAllocator
+{
+   enum { LOCAL_POOL_SIZE = 2 };
+
+public:
+   GlobalAllocator()
+   {
+      memset((void *)mNextFreeBlockOfSize,0,sizeof(mNextFreeBlockOfSize));
+      mRowsInUse = 0;
+      mLargeAllocated = 0;
+      mLargeAllocSpace = 40 << 20;
+      mLargeAllocForceRefresh = mLargeAllocSpace;
+      // Start at 1 Meg...
+      mTotalAfterLastCollect = 1<<20;
+      mCurrentRowsInUse = 0;
+      mAllBlocksCount = 0;
+      mGenerationalRetainEstimate = 0.5;
+      for(int p=0;p<LOCAL_POOL_SIZE;p++)
+         mLocalPool[p] = 0;
+
+      createFreeList();
+   }
+   void AddLocal(LocalAllocator *inAlloc)
+   {
+      if (!gThreadStateChangeLock)
+      {
+         gThreadStateChangeLock = new HxMutex();
+         gSpecialObjectLock = new HxMutex();
+      }
+      // Until we add ourselves, the collector will not wait
+      //  on us - ie, we are assumed ot be in a GC free zone.
+      AutoLock lock(*gThreadStateChangeLock);
+      mLocalAllocs.push(inAlloc);
+      // TODO Attach debugger
+   }
+
+   bool ReturnToPoolLocked(LocalAllocator *inAlloc)
+   {
+      // Until we add ourselves, the colled will not wait
+      //  on us - ie, we are assumed ot be in a GC free zone.
+      for(int p=0;p<LOCAL_POOL_SIZE;p++)
+      {
+         if (!mLocalPool[p])
+         {
+            mLocalPool[p] = inAlloc;
+            return true;
+         }
+      }
+      // I told him we already got one
+      return false;
+   }
+
+   LocalAllocator *GetPooledAllocator()
+   {
+      AutoLock lock(*gThreadStateChangeLock);
+      for(int p=0;p<LOCAL_POOL_SIZE;p++)
+      {
+         if (mLocalPool[p])
+         {
+            LocalAllocator *result = mLocalPool[p];
+            mLocalPool[p] = 0;
+            return result;
+         }
+      }
+      return 0;
+   }
+
+   void RemoveLocalLocked(LocalAllocator *inAlloc)
+   {
+      // You should be in the GC free zone before you call this...
+      if (!mLocalAllocs.qerase_val(inAlloc))
+      {
+         CriticalGCError("LocalAllocator removed without being added");
+      }
+   }
+
+   void FreeLarge(void *inLarge)
+   {
+#ifdef HXCPP_TELEMETRY
+       __hxt_gc_free_large(inLarge);
+#endif
+
+      ((unsigned char *)inLarge)[HX_ENDIAN_MARK_ID_BYTE] = 0;
+      // AllocLarge will not lock this list unless it decides there is a suitable
+      //  value, so we can't doa realloc without potentially crashing it.
+      if (largeObjectRecycle.hasExtraCapacity(1))
+      {
+         unsigned int *blob = ((unsigned int *)inLarge) - 2;
+         unsigned int size = *blob;
+         mLargeListLock.Lock();
+         mLargeAllocated -= size;
+         // Could somehow keep it in the list, but mark as recycled?
+         mLargeList.qerase_val(blob);
+         // We could maybe free anyhow?
+         if (!largeObjectRecycle.hasExtraCapacity(1))
+         {
+            mLargeListLock.Unlock();
+            HxFree(blob);
+            return;
+         }
+         largeObjectRecycle.push(blob);
+         mLargeListLock.Unlock();
+      }
+   }
+
+   void *AllocLarge(int inSize, bool inClear)
+   {
+      if (hx::gPauseForCollect)
+         __hxcpp_gc_safe_point();
+
+      //Should we force a collect ? - the 'large' data are not considered when allocating objects
+      // from the blocks, and can 'pile up' between smalll object allocations
+      if ((inSize+mLargeAllocated > mLargeAllocForceRefresh) && sgInternalEnable)
+      {
+         #ifdef SHOW_MEM_EVENTS
+         //GCLOG("Large alloc causing collection");
+         #endif
+         CollectFromThisThread(false,false);
+      }
+
+      inSize = (inSize +3) & ~3;
+
+      if (inSize<<1 > mLargeAllocSpace)
+         mLargeAllocSpace = inSize<<1;
+
+      unsigned int *result = 0;
+      #ifndef HXCPP_SINGLE_THREADED_APP
+      bool do_lock = true;
+      #else
+      bool do_lock = false;
+      #endif
+      bool isLocked = false;
+
+
+      if (largeObjectRecycle.size())
+      {
+         for(int i=0;i<largeObjectRecycle.size();i++)
+         {
+            if ( largeObjectRecycle[i][0] == inSize )
+            {
+               if (do_lock && !isLocked)
+               {
+                  mLargeListLock.Lock();
+                  isLocked = true;
+                  if (  i>=largeObjectRecycle.size() || largeObjectRecycle[i][0] != inSize )
+                     continue;
+               }
+
+               result = largeObjectRecycle[i];
+               largeObjectRecycle.qerase(i);
+               // You can use this to test race condition
+               //Sleep(1);
+               break;
+            }
+         }
+      }
+
+      if (!result)
+         result = (unsigned int *)HxAlloc(inSize + sizeof(int)*2);
+
+      if (!result)
+      {
+         #ifdef SHOW_MEM_EVENTS
+         GCLOG("Large alloc failed - forcing collect\n");
+         #endif
+
+         if (isLocked)
+         {
+            mLargeListLock.Unlock();
+            isLocked = false;
+         }
+
+         CollectFromThisThread(true,true);
+         result = (unsigned int *)HxAlloc(inSize + sizeof(int)*2);
+      }
+
+      if (!result)
+      {
+         GCLOG("Memory Exhausted!\n");
+         DebuggerTrap();
+      }
+
+      if (inClear)
+         ZERO_MEM(result, inSize + sizeof(int)*2);
+
+      result[0] = inSize;
+      #ifdef HXCPP_GC_NURSERY
+      result[1] = 0;
+      #else
+      result[1] = hx::gMarkID;
+      #endif
+
+      if (do_lock && !isLocked)
+         mLargeListLock.Lock();
+
+      mLargeList.push(result);
+      mLargeAllocated += inSize;
+
+      if (do_lock)
+         mLargeListLock.Unlock();
+
+#ifdef HXCPP_TELEMETRY
+      __hxt_gc_alloc(result + 2, inSize);
+#endif
+
+      return result+2;
+   }
+
+   void onMemoryChange(int inDelta, const char *inWhy)
+   {
+      if (hx::gPauseForCollect)
+         __hxcpp_gc_safe_point();
+
+      if (inDelta>0)
+      {
+         //Should we force a collect ? - the 'large' data are not considered when allocating objects
+         // from the blocks, and can 'pile up' between smalll object allocations
+         if (inDelta>0 && (inDelta+mLargeAllocated > mLargeAllocForceRefresh) && sgInternalEnable)
+         {
+            //GCLOG("onMemoryChange alloc causing collection");
+            CollectFromThisThread(false,false);
+         }
+
+         int rounded = (inDelta +3) & ~3;
+   
+         if (rounded<<1 > mLargeAllocSpace)
+            mLargeAllocSpace = rounded<<1;
+      }
+
+      #ifndef HXCPP_SINGLE_THREADED_APP
+      bool do_lock = true;
+      #else
+      bool do_lock = false;
+      #endif
+
+      if (do_lock)
+         mLargeListLock.Lock();
+
+      mLargeAllocated += inDelta;
+
+      if (do_lock)
+         mLargeListLock.Unlock();
+   }
+
+   // Gets a block with the 'zeroLock' acquired, which means the zeroing thread
+   //  will leave it alone from now on
+   //
+   // This contains some "lock free" code that triggers the thread sanitizer.
+   //  * mOwned can only be changed with the mZeroLock
+   //  * mFreeBlocks may increase size, but it is not critical whether the mNextFreeBlockOfSize
+   //     is increased since skipping only leads to a bit of extra searhing for the
+   //     next allocation
+   #if defined(__has_feature)
+     #if __has_feature(thread_sanitizer)
+      __attribute__((no_sanitize("thread")))
+     #endif
+   #endif
+   BlockDataInfo *GetNextFree(int inRequiredBytes)
+   {
+      bool failedLock = true;
+      int sizeSlot = inRequiredBytes>>IMMIX_LINE_BITS;
+      if (sizeSlot>=BLOCK_OFSIZE_COUNT)
+         sizeSlot = BLOCK_OFSIZE_COUNT-1;
+      //volatile int &nextFreeBlock = mNextFreeBlockOfSize[sizeSlot];
+      int nextFreeBlock = mNextFreeBlockOfSize[sizeSlot];
+      while(failedLock && nextFreeBlock<mFreeBlocks.size())
+      {
+         failedLock = false;
+
+         for(int i=nextFreeBlock; i<mFreeBlocks.size(); i++)
+         {
+             BlockDataInfo *info = mFreeBlocks[i];
+             if (!info->mOwned && info->mMaxHoleSize>=inRequiredBytes)
+             {
+                // Acquire the zero-lock
+                if (_hx_atomic_compare_exchange(&info->mZeroLock, 0, 1) == 0)
+                {
+                   // Acquire ownership...
+                   if (info->mOwned)
+                   {
+                      // Someone else got it...
+                      info->mZeroLock = 0;
+                   }
+                   else
+                   {
+                      info->mOwned = true;
+
+                      // Increase the mNextFreeBlockOfSize
+                      int idx = nextFreeBlock;
+                      while(idx<mFreeBlocks.size() && mFreeBlocks[idx]->mOwned)
+                      {
+                         _hx_atomic_compare_exchange(mNextFreeBlockOfSize+sizeSlot, idx, idx+1);
+                         idx++;
+                      }
+
+                      if (sgThreadPoolJob==tpjAsyncZeroJit)
+                      {
+                         if (info->mZeroed==ZEROED_THREAD)
+                            onZeroedBlockDequeued();
+                         #ifdef PROFILE_THREAD_USAGE
+                         else
+                         {
+                            if (!info->mZeroed)
+                               _hx_atomic_add(&sThreadZeroMisses, 1);
+                         }
+                         #endif
+                       }
+
+                      return info;
+                   }
+                 }
+                 else if (!info->mOwned)
+                 {
+                    // Zeroing thread is currently working on this block
+                    // Go to next one or spin around again
+                    failedLock = true;
+                 }
+             }
+         }
+      }
+
+      return 0;
+   }
+
+   inline size_t GetWorkingMemory()
+   {
+       return ((size_t)mAllBlocks.size()) << IMMIX_BLOCK_BITS;
+   }
+
+   // Making this function "virtual" is actually a (big) performance enhancement!
+   // On the iphone, sjlj (set-jump-long-jump) exceptions are used, which incur a
+   //  performance overhead.  It seems that the overhead in only in routines that call
+   //  malloc/new.  This is not called very often, so the overhead should be minimal.
+   //  However, gcc inlines this function!  requiring every alloc the have sjlj overhead.
+   //  Making it virtual prevents the overhead.
+   virtual bool AllocMoreBlocks(bool &outForceCompact, bool inJustBorrowing)
+   {
+      enum { newBlockCount = 1<<(IMMIX_BLOCK_GROUP_BITS) };
+
+      #ifdef HXCPP_GC_MOVING
+      if (!inJustBorrowing)
+      {
+         // Do compact next collect sooner
+         if (sgTimeToNextTableUpdate>1)
+         {
+            #ifdef SHOW_FRAGMENTATION
+              #ifdef SHOW_MEM_EVENTS_VERBOSE
+                GCLOG("  alloc -> enable full collect\n");
+              #endif
+            #endif
+            //sgTimeToNextTableUpdate = 1;
+         }
+      }
+      #endif
+
+      #ifndef HXCPP_GC_BIG_BLOCKS
+      // Currently, we only have 2 bytes for a block header
+      if (mAllBlocks.size()+newBlockCount >= 0xfffe )
+      {
+         #if defined(SHOW_MEM_EVENTS) || defined(SHOW_FRAGMENTATION)
+         GCLOG("Block id count used - collect");
+         #endif
+         // The problem is we are out of blocks, not out of memory
+         outForceCompact = false;
+         return false;
+      }
+      #endif
+
+      // Find spare group...
+      int gid = -1;
+      for(int i=0;i<gAllocGroups.size();i++)
+         if (!gAllocGroups[i].alloc)
+         {
+            gid = i;
+            break;
+         }
+      if (gid<0)
+      {
+         if (!gAllocGroups.safeReserveExtra(1))
+         {
+            outForceCompact = true;
+            return false;
+         }
+         gid = gAllocGroups.next();
+         gAllocGroups[gid].alloc = 0;
+      }
+
+      int n = 1<<IMMIX_BLOCK_GROUP_BITS;
+
+
+      if (!mAllBlocks.safeReserveExtra(n) || !mFreeBlocks.hasExtraCapacity(n))
+      {
+         outForceCompact = true;
+         return false;
+      }
+
+      char *chunk = (char *)HxAllocGCBlock( 1<<(IMMIX_BLOCK_GROUP_BITS + IMMIX_BLOCK_BITS) );
+      if (!chunk)
+      {
+         //DebuggerTrap();
+         #ifdef SHOW_MEM_EVENTS
+         GCLOG("Alloc failed - try collect\n");
+         #endif
+         outForceCompact = true;
+         return false;
+      }
+
+      char *aligned = (char *)( (((size_t)chunk) + IMMIX_BLOCK_SIZE-1) & IMMIX_BLOCK_BASE_MASK);
+      if (aligned!=chunk)
+         n--;
+      gAllocGroups[gid].alloc = chunk;
+      gAllocGroups[gid].blocks = n;
+      gAllocGroups[gid].clear();
+
+      int newSize = mFreeBlocks.size();
+      for(int i=0;i<n;i++)
+      {
+         BlockData *block = (BlockData *)(aligned + i*IMMIX_BLOCK_SIZE);
+         BlockDataInfo *info = new BlockDataInfo(gid,block);
+
+         mAllBlocks.push(info);
+         mFreeBlocks.push(info);
+      }
+      std::stable_sort(&mAllBlocks[0], &mAllBlocks[0] + mAllBlocks.size(), SortByBlockPtr );
+      mAllBlocksCount = mAllBlocks.size();
+      for(int i=0;i<BLOCK_OFSIZE_COUNT;i++)
+         mNextFreeBlockOfSize[i] = newSize;
+
+      #ifdef HXCPP_GC_VERIFY
+      VerifyBlockOrder();
+      #endif
+
+      #if defined(SHOW_MEM_EVENTS_VERBOSE) || defined(SHOW_FRAGMENTATION_BLOCKS)
+      if (inJustBorrowing)
+      {
+         GCLOG("Borrow Blocks %d = %d k\n", mAllBlocks.size(), (mAllBlocks.size() << IMMIX_BLOCK_BITS)>>10);
+      }
+      else
+      {
+         GCLOG("Blocks %d = %d k\n", mAllBlocks.size(), (mAllBlocks.size() << IMMIX_BLOCK_BITS)>>10);
+      }
+      #endif
+
+
+      return true;
+   }
+
+   bool allowMoreBlocks()
+   {
+      #ifdef HXCPP_GC_GENERATIONAL
+      return sGcMode==gcmFull;
+      #else
+      return true;
+      #endif
+   }
+
+   void repoolReclaimedBlock(BlockDataInfo *block)
+   {
+      // The mMaxHoleSize has changed - possibly return to one of the pools
+   }
+
+
+   BlockDataInfo *GetFreeBlock(int inRequiredBytes, hx::ImmixAllocator *inAlloc)
+   {
+      while(true)
+      {
+         BlockDataInfo *result = GetNextFree(inRequiredBytes);
+         if (result)
+         {
+            result->zeroAndUnlock();
+
+            // After zero/reclaim, it might be that the hole size is smaller than we thought.
+            if (result->mMaxHoleSize>=inRequiredBytes)
+               return result;
+
+            repoolReclaimedBlock(result);
+            continue;
+         }
+
+         if (hx::gPauseForCollect)
+         {
+            hx::PauseForCollect();
+            continue;
+         }
+
+         #ifndef HXCPP_SINGLE_THREADED_APP
+         hx::EnterGCFreeZone();
+         gThreadStateChangeLock->Lock();
+         hx::ExitGCFreeZoneLocked();
+
+         result = GetNextFree(inRequiredBytes);
+         #endif
+
+         bool forceCompact = false;
+         if (!result && allowMoreBlocks() && (!sgInternalEnable || GetWorkingMemory()<sWorkingMemorySize))
+         {
+            if (AllocMoreBlocks(forceCompact,false))
+               result = GetNextFree(inRequiredBytes);
+         }
+
+         if (!result)
+         {
+            inAlloc->SetupStackAndCollect(false,forceCompact,true,true);
+            result = GetNextFree(inRequiredBytes);
+         }
+
+         if (!result && !forceCompact)
+         {
+            // Try with compact this time...
+            forceCompact = true;
+            inAlloc->SetupStackAndCollect(false,forceCompact,true,true);
+            result = GetNextFree(inRequiredBytes);
+         }
+
+         if (!result)
+         {
+            if (AllocMoreBlocks(forceCompact,false))
+               result = GetNextFree(inRequiredBytes);
+         }
+
+         if (!result)
+         {
+            GCLOG("Memory exhausted.\n");
+            #ifndef HXCPP_M64
+            GCLOG(" try 64 bit build.\n");
+            #endif
+            #ifndef HXCPP_GC_BIG_BLOCKS
+            GCLOG(" try HXCPP_GC_BIG_BLOCKS.\n");
+            #endif
+            DebuggerTrap();
+         }
+
+         // Assume all wil be used
+         mCurrentRowsInUse += result->GetFreeRows();
+
+         #ifndef HXCPP_SINGLE_THREADED_APP
+         gThreadStateChangeLock->Unlock();
+         #endif
+
+
+         result->zeroAndUnlock();
+
+         // After zero/reclaim, it might be that the hole size is smaller than we thought.
+         if (result->mMaxHoleSize>=inRequiredBytes)
+            return result;
+
+         repoolReclaimedBlock(result);
+      }
+  }
+
+   #if  defined(HXCPP_VISIT_ALLOCS) // {
+
+  void MoveSpecial(hx::Object *inTo, hx::Object *inFrom, int size)
+   {
+      #ifdef HX_WATCH
+      if (hxInWatchList(inFrom))
+         GCLOG("****** watch MOVE from %p\n",inFrom);
+      if (hxInWatchList(inTo))
+         GCLOG("****** watch MOVE to %p\n",inTo);
+      #endif
+       // FinalizerList will get visited...
+
+       hx::FinalizerMap::iterator i = hx::sFinalizerMap.find(inFrom);
+       if (i!=hx::sFinalizerMap.end())
+       {
+          hx::finalizer f = i->second;
+          hx::sFinalizerMap.erase(i);
+          hx::sFinalizerMap[inTo] = f;
+       }
+
+       hx::HaxeFinalizerMap::iterator h = hx::sHaxeFinalizerMap.find(inFrom);
+       if (h!=hx::sHaxeFinalizerMap.end())
+       {
+          hx::HaxeFinalizer f = h->second;
+          hx::sHaxeFinalizerMap.erase(h);
+          hx::sHaxeFinalizerMap[inTo] = f;
+       }
+
+       hx::MakeZombieSet::iterator mz = hx::sMakeZombieSet.find(inFrom);
+       if (mz!=hx::sMakeZombieSet.end())
+       {
+          hx::sMakeZombieSet.erase(mz);
+          hx::sMakeZombieSet.insert(inTo);
+       }
+
+       hx::ObjectIdMap::iterator id = hx::sObjectIdMap.find(inFrom);
+       if (id!=hx::sObjectIdMap.end())
+       {
+          hx::sIdObjectMap[id->second] = inTo;
+          hx::sObjectIdMap[inTo] = id->second;
+          hx::sObjectIdMap.erase(id);
+       }
+
+       // Maybe do something faster with weakmaps
+
+#ifdef HXCPP_TELEMETRY
+       //printf(" -- moving %018x to %018x, size %d\n", inFrom, inTo, size);
+       __hxt_gc_realloc(inFrom, inTo, size);
+#endif
+
+   }
+
+
+
+   bool MoveBlocks(MoveBlockJob &inJob,BlockDataStats &ioStats)
+   {
+      BlockData *dest = 0;
+      BlockDataInfo *destInfo = 0;
+      unsigned int *destStarts = 0;
+      int hole = -1;
+      int holes = 0;
+      int destPos = 0;
+      int destLen = 0;
+
+      int moveObjs = 0;
+      int clearedBlocks = 0;
+
+      while(true)
+      {
+         BlockDataInfo *from = inJob.getFrom();
+         if (!from)
+            break;
+         if (from->calcFragScore()>FRAG_THRESH)
+            ioStats.fraggedBlocks--;
+         ioStats.rowsInUse -= from->mUsedRows;
+         if (!from->isEmpty())
+            ioStats.emptyBlocks ++;
+
+         unsigned int *allocStart = from->allocStart;
+         #ifdef SHOW_MEM_EVENTS
+         //GCLOG("Move from %p (%d x %d)\n", from, from->mUsedRows, from->mHoles );
+         #endif
+
+         const unsigned char *rowMarked = from->mPtr->mRowMarked;
+         for(int r=IMMIX_HEADER_LINES;r<IMMIX_LINES;r++)
+         {
+            if (rowMarked[r])
+            {
+               unsigned int starts = allocStart[r];
+               if (!starts)
+                  continue;
+               for(int i=0;i<32;i++)
+               {
+                  if ( starts & (1<<i))
+                  {
+                     unsigned int *row = (unsigned int *)from->mPtr->mRow[r];
+                     unsigned int &header = row[i];
+
+                     if ((header&IMMIX_ALLOC_MARK_ID) == hx::gMarkID)
+                     {
+                        int size = ((header & IMMIX_ALLOC_SIZE_MASK) >> IMMIX_ALLOC_SIZE_SHIFT);
+                        int allocSize = size + sizeof(int);
+
+                        while(allocSize + ALIGN_PADDING(destPos)>destLen)
+                        {
+                           hole++;
+                           if (hole<holes)
+                           {
+                              destPos = destInfo->mRanges[hole].start;
+                              destLen = destInfo->mRanges[hole].length;
+                           }
+                           else
+                           {
+                              if (destInfo)
+                                 destInfo->makeFull();
+                              do
+                              {
+                                 destInfo = inJob.getTo();
+                                 if (!destInfo)
+                                    goto all_done;
+                              } while(destInfo->mHoles==0);
+
+
+                              ioStats.rowsInUse += IMMIX_USEFUL_LINES - destInfo->mUsedRows;
+                              //destInfo->zero();
+                              dest = destInfo->mPtr;
+                              destStarts = destInfo->allocStart;
+
+                              hole = 0;
+                              holes = destInfo->mHoles;
+                              destPos = destInfo->mRanges[hole].start;
+                              destLen = destInfo->mRanges[hole].length;
+                           }
+                        }
+
+                        #ifdef HXCPP_ALIGN_ALLOC
+                        destPos += ALIGN_PADDING(destPos);
+                        #endif
+
+                        int startRow = destPos>>IMMIX_LINE_BITS;
+
+                        destStarts[ startRow ] |= hx::gImmixStartFlag[destPos&127];
+
+                        unsigned int *buffer = (unsigned int *)((char *)dest + destPos);
+
+                        unsigned int headerPreserve = header & IMMIX_HEADER_PRESERVE;
+
+                        int end = destPos + allocSize;
+
+                        *buffer++ =  (( (end+(IMMIX_LINE_LEN-1))>>IMMIX_LINE_BITS) -startRow) |
+                                        (size<<IMMIX_ALLOC_SIZE_SHIFT) |
+                                        headerPreserve |
+                                        hx::gMarkID;
+                        destPos = end;
+                        destLen -= allocSize;
+
+                        unsigned int *src = row + i + 1;
+
+                        MoveSpecial((hx::Object *)buffer,(hx::Object *)src, size);
+
+                        // Result has moved - store movement in original position...
+                        memcpy(buffer, src, size);
+                        //GCLOG("   move %p -> %p %d (%08x %08x )\n", src, buffer, size, buffer[-1], buffer[1] );
+
+                        *(unsigned int **)src = buffer;
+                        header = IMMIX_OBJECT_HAS_MOVED;
+                        moveObjs++;
+
+                        starts &= ~(1<<i);
+                        if (!starts)
+                           break;
+                     }
+                  }
+               }
+            }
+         }
+
+         all_done:
+         if (destInfo)
+         {
+            // Still have space, which means from finished.
+            destInfo->makeFull();
+            from->clear();
+            clearedBlocks++;
+            // Could remove some used rows from stats
+         }
+         else
+         {
+            // Partialy cleared, then ran out of to blocks - remove from allocation this round
+            if (from)
+            {
+               // Could maybe be a bit smarter here
+               ioStats.rowsInUse += from->mUsedRows;
+               from->makeFull();
+            }
+         }
+      }
+
+      #ifdef SHOW_FRAGMENTATION
+      GCLOG("Moved %d objects (%d/%d blocks)\n", moveObjs, clearedBlocks, mAllBlocks.size());
+      #endif
+
+      if (moveObjs)
+      {
+         AdjustPointers(0);
+      }
+
+
+      return moveObjs;
+   }
+
+   void AdjustPointers(hx::QuickVec<hx::Object *> *inRemembered)
+   {
+      class AdjustPointer : public hx::VisitContext
+      {
+         GlobalAllocator *mAlloc;
+      public:
+         AdjustPointer(GlobalAllocator *inAlloc) : mAlloc(inAlloc) {  }
+      
+         void visitObject(hx::Object **ioPtr)
+         {
+            if ( ((*(unsigned int **)ioPtr)[-1]) == IMMIX_OBJECT_HAS_MOVED )
+            {
+               //GCLOG("  patch object to  %p -> %p\n", *ioPtr,  (*(hx::Object ***)ioPtr)[0]);
+               *ioPtr = (*(hx::Object ***)ioPtr)[0];
+               //GCLOG("    %08x %08x ...\n", ((int *)(*ioPtr))[0], ((int *)(*ioPtr))[1] ); 
+            }
+         }
+
+         void visitAlloc(void **ioPtr)
+         {
+            if ( ((*(unsigned int **)ioPtr)[-1]) == IMMIX_OBJECT_HAS_MOVED )
+            {
+               //GCLOG("  patch reference to  %p -> %p\n", *ioPtr,  (*(void ***)ioPtr)[0]);
+               *ioPtr = (*(void ***)ioPtr)[0];
+               //GCLOG("    %08x %08x ...\n", ((int *)(*ioPtr))[0], ((int *)(*ioPtr))[1] ); 
+            }
+         }
+      };
+
+
+      AdjustPointer adjust(this);
+      VisitAll(&adjust,true, inRemembered);
+   }
+
+
+   #ifdef HXCPP_GC_GENERATIONAL
+   BlockDataInfo *getNextBlockWithoutSurvivors(int &ioPosition)
+   {
+      while(ioPosition<mAllBlocks.size())
+      {
+         BlockDataInfo *b = mAllBlocks[ioPosition++];
+         if (b->mHoles>0 && !b->mHasSurvivor)
+            return b;
+      }
+      return 0;
+   }
+
+ 
+
+   int MoveSurvivors(hx::QuickVec<hx::Object *> *inRemembered)
+   {
+      int sourceScan = 0;
+      int destScan = 0;
+      int moveObjs = 0;
+      int clearedBlocks = 0;
+
+      BlockDataInfo *destInfo = 0;
+      BlockData *dest = 0;
+      int destHole = 0;
+      int destPos = 0;
+      int destLen = 0;
+      unsigned int *destStarts = 0;
+
+      BlockDataInfo *from = 0;
+
+      int tested = 0;
+
+      int all = mAllBlocks.size();
+      for(int srcBlock=0; srcBlock<all; srcBlock++)
+      {
+         from = mAllBlocks[srcBlock];
+         if (from->mPinned || !from->mHasSurvivor)
+         {
+            from = 0;
+            continue;
+         }
+         tested++;
+         unsigned int *srcStart = from->allocStart;
+
+         // Scan nursery for survivors
+         for(int hole = 0; hole<from->mHoles; hole++)
+         {
+            int start = from->mRanges[hole].start;
+            int len = from->mRanges[hole].length;
+            int startRow = start >> IMMIX_LINE_BITS;
+            int end = startRow + (len >> IMMIX_LINE_BITS);
+            for(int r = startRow; r<end;r++)
+            {
+               unsigned int &startFlags = srcStart[r];
+               if (startFlags)
+               {
+                  for(int loc=0;loc<32;loc++)
+                     if (startFlags & (1<<loc))
+                     {
+                        unsigned int *row = (unsigned int *)from->mPtr->mRow[r];
+                        unsigned int &header = row[loc];
+
+                        if ((header&IMMIX_ALLOC_MARK_ID) == hx::gMarkID)
+                        {
+                           int size = ((header & IMMIX_ALLOC_SIZE_MASK) >> IMMIX_ALLOC_SIZE_SHIFT);
+                           int allocSize = size + sizeof(int);
+
+                           // Find dest reqion ...
+                           while(destHole==0 || destLen < ALIGN_PADDING(destPos) + allocSize)
+                           {
+                              if (destHole==0)
+                              {
+                                 if (destInfo)
+                                    destInfo->makeFull();
+                                 destInfo = getNextBlockWithoutSurvivors(destScan);
+                                 if (!destInfo)
+                                    goto no_more_moves;
+
+                                 destHole = -1;
+                                 destLen = 0;
+                              }
+                              if (destLen + ALIGN_PADDING(0)<allocSize)
+                              {
+                                 destHole++;
+                                 if (destHole>=destInfo->mHoles)
+                                    destHole = 0;
+                                 else
+                                 {
+                                    dest = destInfo->mPtr;
+                                    destPos = destInfo->mRanges[destHole].start;
+                                    destLen = destInfo->mRanges[destHole].length;
+                                    destStarts = destInfo->allocStart;
+                                 }
+                              }
+                           }
+
+                           // TODO - not copy + paste
+
+                        printf("Move!\n");
+                           #ifdef HXCPP_ALIGN_ALLOC
+                           destPos += ALIGN_PADDING(destPos);
+                           #endif
+
+                           int startRow = destPos>>IMMIX_LINE_BITS;
+
+                           destStarts[ startRow ] |= hx::gImmixStartFlag[destPos&127];
+
+                           unsigned int *buffer = (unsigned int *)((char *)dest + destPos);
+
+                           unsigned int headerPreserve = header & IMMIX_HEADER_PRESERVE;
+
+                           int end = destPos + allocSize;
+
+                           *buffer++ =  (( (end+(IMMIX_LINE_LEN-1))>>IMMIX_LINE_BITS) -startRow) |
+                                           (size<<IMMIX_ALLOC_SIZE_SHIFT) |
+                                           headerPreserve |
+                                           hx::gMarkID;
+                           destPos = end;
+                           destLen -= allocSize;
+
+                           unsigned int *src = row + loc + 1;
+
+                           MoveSpecial((hx::Object *)buffer,(hx::Object *)src, size);
+
+                           // Result has moved - store movement in original position...
+                           memcpy(buffer, src, size);
+                           //GCLOG("   move %p -> %p %d (%08x %08x )\n", src, buffer, size, buffer[-1], buffer[1] );
+
+                           *(unsigned int **)src = buffer;
+                           header = IMMIX_OBJECT_HAS_MOVED;
+                           moveObjs++;
+
+                           startFlags &= ~(1<<loc);
+                           if (!startFlags)
+                              break;
+                        }
+                     }
+               }
+            }
+         }
+
+         no_more_moves:
+            if (destInfo)
+            {
+               destInfo->makeFull();
+               clearedBlocks++;
+            }
+            else
+            {
+               // Partialy cleared, then ran out of to blocks - remove from allocation this round
+               if (from && moveObjs)
+               {
+                  // Could maybe be a bit smarter here
+                  //ioStats.rowsInUse += from->mUsedRows;
+                  from->makeFull();
+               }
+            }
+      }
+
+      #ifdef SHOW_FRAGMENTATION
+      //GCLOG("Compacted nursery %d objects (%d/%d blocks)\n", moveObjs, clearedBlocks, mAllBlocks.size());
+      #endif
+
+      if (moveObjs)
+      {
+         AdjustPointers(inRemembered);
+      }
+
+      return moveObjs;
+   }
+   #endif
+
+   int releaseEmptyGroups(BlockDataStats &outStats, size_t releaseSize)
+   {
+      int released=0;
+      int groups=0;
+      for(int i=0; i<mAllBlocks.size(); i++ )
+      {
+         if (!mAllBlocks[i]->isEmpty())
+             gAllocGroups[mAllBlocks[i]->mGroupId].isEmpty=false;
+      }
+
+      #ifdef HXCPP_GC_VERIFY
+      typedef std::pair< void *, void * > ReleasedRange;
+      std::vector<ReleasedRange> releasedRange;
+      std::vector<int> releasedGids;
+      #endif
+
+      for(int i=0;i<gAllocGroups.size();i++)
+      {
+         GroupInfo &g = gAllocGroups[i];
+         if (g.alloc && g.isEmpty && !g.pinned)
+         {
+            size_t groupBytes = g.blocks << (IMMIX_BLOCK_BITS);
+
+            #ifdef SHOW_MEM_EVENTS_VERBOSE
+            GCLOG("Release group %d: %p -> %p\n", i, g.alloc, g.alloc+groupBytes);
+            #endif
+            #ifdef HXCPP_GC_VERIFY
+            releasedRange.push_back( ReleasedRange(g.alloc, g.alloc+groupBytes) );
+            releasedGids.push_back(i);
+            #endif
+
+            HxFreeGCBlock(g.alloc);
+            g.alloc = 0;
+
+            groups++;
+
+            if (groupBytes > releaseSize)
+               break;
+
+            releaseSize -= groupBytes;
+         }
+      }
+
+      // Release blocks
+      for(int i=0; i<mAllBlocks.size();  )
+      {
+         if (!gAllocGroups[mAllBlocks[i]->mGroupId].alloc)
+         {
+            outStats.emptyBlocks--;
+            released++;
+            mAllBlocks[i]->destroy();
+            mAllBlocks.erase(i);
+         }
+         else
+         {
+            #ifdef HXCPP_GC_VERIFY
+            for(int g=0;g<releasedGids.size();g++)
+               if (mAllBlocks[i]->mGroupId == releasedGids[g])
+               {
+                  printf("Group %d should be released.\n", mAllBlocks[i]->mGroupId);
+                  DebuggerTrap();
+               }
+            #endif
+            i++;
+         }
+      }
+
+      #ifdef HXCPP_GC_VERIFY
+      for(int i=0;i<mAllBlocks.size();i++)
+      {
+         BlockDataInfo *info = mAllBlocks[i];
+         void *ptr = info->mPtr;
+         for(int r=0;r<releasedRange.size();r++)
+         if ( ptr>=releasedRange[r].first && ptr<releasedRange[r].second )
+         {
+            printf("Released block %p(%d:%p) still in list\n", info, info->mId, info->mPtr );
+            DebuggerTrap();
+         }
+      }
+
+      VerifyBlockOrder();
+      #endif
+
+
+      #if defined(SHOW_MEM_EVENTS) || defined(SHOW_FRAGMENTATION)
+      GCLOG("Release %d blocks, %d groups,  %s\n", released, groups, formatBytes((size_t)released<<(IMMIX_BLOCK_BITS)).c_str());
+      #endif
+      return released;
+   }
+
+
+   void calcMoveOrder()
+   {
+      for(int i=0;i<gAllocGroups.size();i++)
+         gAllocGroups[i].clear();
+
+      for(int i=0; i<mAllBlocks.size(); i++ )
+      {
+         BlockDataInfo &block = *mAllBlocks[i];
+         GroupInfo &g = gAllocGroups[block.mGroupId];
+         if (block.mPinned)
+            g.pinned = true;
+         g.usedBytes += block.mUsedBytes;
+         g.usedSpace += block.mUsedRows<<IMMIX_LINE_BITS;
+      }
+
+      for(int i=0; i<mAllBlocks.size(); i++ )
+      {
+         BlockDataInfo &block = *mAllBlocks[i];
+         GroupInfo &g = gAllocGroups[block.mGroupId];
+         // Base on group wasted space (when not pinned)
+         block.mMoveScore = g.getMoveScore();
+      }
+   }
+
+   #endif // } defined(HXCPP_VISIT_ALLOCS)
+ 
+   void *GetIDObject(int inIndex)
+   {
+      AutoLock lock(*gSpecialObjectLock);
+      if (inIndex<0 || inIndex>hx::sIdObjectMap.size())
+         return 0;
+      return hx::sIdObjectMap[inIndex];
+   }
+
+   int GetObjectID(void * inPtr)
+   {
+      AutoLock lock(*gSpecialObjectLock);
+      hx::ObjectIdMap::iterator i = hx::sObjectIdMap.find( (hx::Object *)inPtr );
+      if (i!=hx::sObjectIdMap.end())
+         return i->second;
+
+      int id = 0;
+      if (hx::sFreeObjectIds.size()>0)
+      {
+         id = hx::sFreeObjectIds.pop();
+      }
+      else
+      {
+         id = hx::sObjectIdMap.size();
+         hx::sIdObjectMap.push(0);
+      }
+      hx::sObjectIdMap[(hx::Object *)inPtr] = id;
+      hx::sIdObjectMap[id] = (hx::Object *)inPtr;
+      return id;
+   }
+
+
+   void ClearRowMarks()
+   {
+      for(int i=0;i<mAllBlocks.size();i++)
+         mAllBlocks[i]->clearRowMarks();
+   }
+
+
+   void ClearBlockMarks()
+   {
+      for(int i=0;i<mAllBlocks.size();i++)
+         mAllBlocks[i]->clearBlockMarks();
+   }
+
+   #ifdef HXCPP_VISIT_ALLOCS
+   void VisitAll(hx::VisitContext *inCtx,bool inMultithread = false,hx::QuickVec<hx::Object *> *inRemembered = 0)
+   {
+      if (inRemembered)
+      {
+         int n = inRemembered->size();
+         for(int i=0;i<n;i++)
+            (*inRemembered)[i]->__Visit(inCtx);
+      }
+      else if (MAX_GC_THREADS>1 && inMultithread && mAllBlocks.size())
+      {
+         sThreadVisitContext = inCtx;
+         StartThreadJobs(tpjVisitBlocks, mAllBlocks.size(), true);
+         sThreadVisitContext = 0;
+      }
+      else
+         for(int i=0;i<mAllBlocks.size();i++)
+            mAllBlocks[i]->VisitBlock(inCtx);
+
+      for(int i=0;i<mLocalAllocs.size();i++)
+         VisitLocalAlloc(mLocalAllocs[i], inCtx);
+
+      hx::VisitClassStatics(inCtx);
+
+      for(hx::RootSet::iterator i = hx::sgRootSet.begin(); i!=hx::sgRootSet.end(); ++i)
+      {
+         hx::Object **obj = *i;
+         if (*obj)
+            inCtx->visitObject(obj);
+      }
+
+
+      if (hx::sgOffsetRootSet)
+         for(hx::OffsetRootSet::iterator i = hx::sgOffsetRootSet->begin(); i!=hx::sgOffsetRootSet->end(); ++i)
+         {
+            char *ptr = *(char **)(i->first);
+            int offset = i->second;
+            hx::Object *obj = (hx::Object *)(ptr - offset);
+
+            if (obj)
+            {
+               hx::Object *obj0 = obj;
+               inCtx->visitObject(&obj);
+               if (obj!=obj0)
+                  *(char **)(i->first) = (char *)(obj) + offset;
+            }
+         }
+
+      if (hx::sgFinalizers)
+         for(int i=0;i<hx::sgFinalizers->size();i++)
+            (*hx::sgFinalizers)[i]->Visit(inCtx);
+
+      for(int i=0;i<hx::sFinalizableList.size();i++)
+         inCtx->visitAlloc( &hx::sFinalizableList[i].base );
+
+      for(int i=0;i<hx::sZombieList.size();i++)
+         inCtx->visitObject( &hx::sZombieList[i] );
+
+      for(int i=0;i<hx::sWeakRefs.size(); i++)
+         inCtx->visitObject( (hx::Object **) &hx::sWeakRefs[i] );
+
+      for(int i=0;i<hx::sWeakHashList.size();i++)
+         inCtx->visitObject( (hx::Object **) &hx::sWeakHashList[i] );
+
+   }
+
+   #endif
+
+   void ReclaimAsync(BlockDataStats &outStats)
+   {
+      while(!sgThreadPoolAbort)
+      {
+         int blockId = _hx_atomic_add(&mThreadJobId, 1);
+         if (blockId>=mAllBlocks.size())
+            break;
+
+         if ( sgThreadPoolJob==tpjReclaimFull)
+            mAllBlocks[blockId]->reclaim<true>(&outStats);
+         else
+            mAllBlocks[blockId]->reclaim<false>(&outStats);
+      }
+   }
+
+   void CountAsync(BlockDataStats &outStats)
+   {
+      while(!sgThreadPoolAbort)
+      {
+         int blockId = _hx_atomic_add(&mThreadJobId, 1);
+         if (blockId>=mAllBlocks.size())
+            break;
+
+         mAllBlocks[blockId]->countRows(outStats);
+      }
+   }
+
+
+   void GetStatsAsync(BlockDataStats &outStats)
+   {
+      while(!sgThreadPoolAbort)
+      {
+         int blockId = _hx_atomic_add(&mThreadJobId, 1);
+         if (blockId>=mAllBlocks.size())
+            break;
+
+         mAllBlocks[blockId]->getStats( outStats );
+      }
+   }
+
+  
+
+   #ifdef HXCPP_VISIT_ALLOCS
+   void VisitBlockAsync(hx::VisitContext *inCtx)
+   {
+      while(!sgThreadPoolAbort)
+      {
+         int blockId = _hx_atomic_add(&mThreadJobId, 1);
+         if (blockId>=mAllBlocks.size())
+            break;
+
+         mAllBlocks[blockId]->VisitBlock(inCtx);
+      }
+   }
+   #endif
+
+
+   void ZeroAsync()
+   {
+      while(!sgThreadPoolAbort)
+      {
+         int zeroListId = _hx_atomic_add(&mThreadJobId, 1);
+         if (zeroListId>=mZeroList.size())
+            break;
+
+         BlockDataInfo *info = mZeroList[zeroListId];
+         info->tryZero();
+      }
+   }
+
+   bool ZeroAsyncJit()
+   {
+      int spinCount = 0;
+      while(!sgThreadPoolAbort)
+      {
+         if (mZeroListQueue>=sMaxZeroQueueSize)
+         {
+            spinCount++;
+            if (spinCount<10000)
+               // Spin
+               continue;
+            // Full for now, so sleep...
+            return true;
+         }
+         spinCount = 0;
+
+         // Look at next block...
+         int zeroListId = _hx_atomic_add(&mThreadJobId, 1);
+         if (zeroListId>=mZeroList.size())
+         {
+            // Done, so sleep...
+            return true;
+         }
+
+         BlockDataInfo *info = mZeroList[zeroListId];
+         if (info->tryZero())
+         {
+            // We zeroed it, so increase queue count
+            _hx_atomic_add(&mZeroListQueue, 1);
+            #ifdef PROFILE_THREAD_USAGE
+            sThreadBlockZeroCount++;
+            #endif
+         }
+      }
+
+      return true;
+   }
+
+   // Try to maintain between sMinZeroQueueSize and sMaxZeroQueueSize pre-zeroed blocks
+   void onZeroedBlockDequeued()
+   {
+      // Wake the thread?
+      if (_hx_atomic_sub(&mZeroListQueue, 1)<sMinZeroQueueSize && !sRunningThreads)
+      {
+         if (mZeroListQueue + mThreadJobId < mZeroList.size())
+         {
+            // Wake zeroing thread
+            ThreadPoolAutoLock l(sThreadPoolLock);
+            if (!(sRunningThreads & 0x01))
+            {
+               #ifdef PROFILE_THREAD_USAGE
+               sThreadZeroPokes++;
+               #endif
+               wakeThreadLocked(0);
+            }
+         }
+      }
+   }
+
+
+   void finishThreadJob(int inId)
+   {
+      ThreadPoolAutoLock l(sThreadPoolLock);
+      if (sRunningThreads & (1<<inId))
+      {
+         sRunningThreads &= ~(1<<inId);
+         sLazyThreads = sRunningThreads != sAllThreads;
+
+         if (!sRunningThreads)
+            SignalThreadPool(sThreadJobDone,sThreadJobDoneSleeping);
+      }
+      else
+      {
+         printf("Finishe non-runnning thread?\n");
+         DebuggerTrap();
+      }
+   }
+
+   void waitForThreadWake(int inId)
+   {
+      #ifdef HX_GC_PTHREADS
+      {
+         ThreadPoolAutoLock l(sThreadPoolLock);
+         int count = 0;
+
+         // May be woken multiple times if sRunningThreads is set to 0 then 1 before we sleep
+         sThreadSleeping[inId] = true;
+         // Spurious wake?
+         while( !(sRunningThreads & (1<<inId) ) )
+            WaitThreadLocked(sThreadWake[inId]);
+         sThreadSleeping[inId] = false;
+      }
+      #else
+      while( !(sRunningThreads & (1<<inId) ) )
+         sThreadWake[inId].Wait();
+      #endif
+   }
+
+
+   void ThreadLoop(int inId)
+   {
+      hx::MarkContext context(inId);
+
+      while(true)
+      {
+         waitForThreadWake(inId);
+
+         #ifdef HXCPP_GC_VERIFY
+         if (! (sRunningThreads & (1<<inId)) )
+            printf("Bad running threads!\n");
+         #endif
+
+         if (sgThreadPoolJob==tpjMark)
+         {
+            context.processMarkStack();
+         }
+         else if (sgThreadPoolJob==tpjAsyncZeroJit)
+         {
+            #ifdef PROFILE_THREAD_USAGE
+            sThreadZeroWaits++;
+            #endif
+            if (ZeroAsyncJit())
+               finishThreadJob(inId);
+         }
+         else
+         {
+            if (sgThreadPoolJob==tpjReclaimFull || sgThreadPoolJob==tpjReclaim)
+               ReclaimAsync(sThreadBlockDataStats[inId]);
+
+            else if (sgThreadPoolJob==tpjCountRows)
+               CountAsync(sThreadBlockDataStats[inId]);
+
+            else if (sgThreadPoolJob==tpjGetStats)
+               GetStatsAsync(sThreadBlockDataStats[inId]);
+
+            #ifdef HXCPP_VISIT_ALLOCS
+            else if (sgThreadPoolJob==tpjVisitBlocks)
+               VisitBlockAsync(sThreadVisitContext);
+            #endif
+
+            else if (sgThreadPoolJob==tpjAsyncZero)
+               ZeroAsync();
+
+            finishThreadJob(inId);
+         }
+      }
+   }
+
+   static THREAD_FUNC_TYPE SThreadLoop( void *inInfo )
+   {
+      sGlobalAlloc->ThreadLoop((int)(size_t)inInfo);
+      THREAD_FUNC_RET;
+   }
+
+   void CreateWorker(int inId)
+   {
+      void *info = (void *)(size_t)inId;
+
+      #ifdef HX_GC_PTHREADS
+         pthread_cond_init(&sThreadWake[inId],0);
+         sThreadSleeping[inId] = false;
+         if (inId==0)
+            pthread_cond_init(&sThreadJobDone,0);
+
+         pthread_t result = 0;
+         int created = pthread_create(&result,0,SThreadLoop,info);
+         bool ok = created==0;
+      #elif defined(EMSCRIPTEN)
+         // Only one thread
+      #else
+         bool ok = HxCreateDetachedThread(SThreadLoop, info);
+      #endif
+   }
+
+   void StopThreadJobs(bool inKill)
+   {
+      bool maybeExtraWake = false;
+
+      if (sAllThreads)
+      {
+         if (inKill)
+         {
+            sgThreadPoolAbort = true;
+            if (sgThreadPoolJob==tpjAsyncZeroJit)
+            {
+               ThreadPoolAutoLock l(sThreadPoolLock);
+               // Thread will be waiting, but not finished
+               if (sRunningThreads & 0x1)
+               {
+                  sgThreadPoolJob = tpjNone;
+                  maybeExtraWake = true;
+                  wakeThreadLocked(0);
+               }
+            }
+         }
+
+
+         #ifdef HX_GC_PTHREADS
+         ThreadPoolAutoLock lock(sThreadPoolLock);
+         sThreadJobDoneSleeping = true;
+         while(sRunningThreads)
+             WaitThreadLocked(sThreadJobDone);
+         sThreadJobDoneSleeping = false;
+         #else
+         while(sRunningThreads)
+            sThreadJobDone.Wait();
+         #endif
+         sgThreadPoolAbort = false;
+         sAllThreads = 0;
+         sgThreadPoolJob = tpjNone;
+         sLazyThreads = 0;
+      }
+   }
+
+
+   void StartThreadJobs(ThreadPoolJob inJob, int inWorkers, bool inWait, int inThreadLimit = -1)
+   {
+      mThreadJobId = 0;
+
+      if (!inWorkers)
+         return;
+
+      if (!sThreadPoolInit)
+      {
+         sThreadPoolInit = true;
+         for(int i=0;i<MAX_GC_THREADS;i++)
+            CreateWorker(i);
+      }
+
+      #ifdef HX_GC_PTHREADS
+      ThreadPoolAutoLock lock(sThreadPoolLock);
+      #endif
+
+
+      sgThreadPoolJob = inJob;
+
+      sgThreadCount = inThreadLimit<0 ? MAX_GC_THREADS : std::min((int)MAX_GC_THREADS, inThreadLimit) ;
+
+      int start = std::min(inWorkers, sgThreadCount );
+
+      sAllThreads = (1<<sgThreadCount) - 1;
+
+      sRunningThreads = (1<<start) - 1;
+
+      sLazyThreads = sRunningThreads != sAllThreads;
+
+      for(int i=0;i<start;i++)
+         SignalThreadPool(sThreadWake[i],sThreadSleeping[i]);
+
+      if (inWait)
+      {
+         // Join the workers...
+         #ifdef HX_GC_PTHREADS
+         sThreadJobDoneSleeping = true;
+         while(sRunningThreads)
+            WaitThreadLocked(sThreadJobDone);
+         sThreadJobDoneSleeping = false;
+         #else
+         while(sRunningThreads)
+            sThreadJobDone.Wait();
+         #endif
+
+         sAllThreads = 0;
+         sgThreadPoolJob = tpjNone;
+         sLazyThreads = 0;
+
+         if (sRunningThreads)
+         {
+            printf("Bad thread stop %d\n", sRunningThreads);
+            DebuggerTrap();
+         }
+      }
+   }
+
+
+   #if defined(SHOW_FRAGMENTATION) || defined(SHOW_MEM_EVENTS)
+   std::string formatBytes(size_t bytes)
+   {
+      size_t k = 1<<10;
+      size_t meg = 1<<20;
+
+      char strBuf[100];
+      if (bytes<k)
+         snprintf(strBuf,sizeof(strBuf),"%d", (int)bytes);
+      else if (bytes<meg)
+         snprintf(strBuf,sizeof(strBuf),"%.2fk", (double)bytes/k);
+      else
+         snprintf(strBuf,sizeof(strBuf),"%.2fmb", (double)bytes/meg);
+      return strBuf;
+   }
+   #endif
+
+
+   double tMarkInit;
+   double tMarkLocal;
+   double tMarkLocalEnd;
+   double tMarked;
+   void MarkAll(bool inGenerational)
+   {
+      if (!inGenerational)
+      {
+         hx::gPrevByteMarkID = hx::gByteMarkID;
+
+         // The most-significant header byte looks like:
+         // C nH Odd Even  c c c c
+         //  C = "is const alloc bit" - in this case Odd and Even will be false
+         // nH = non-hashed const string bit
+         // Odd = true if cycle is odd
+         // Even = true if cycle is even
+         // c c c c = 4 bit cycle code
+         //
+         hx::gPrevMarkIdMask = ((~hx::gMarkID) & 0x30000000) | HX_GC_CONST_ALLOC_BIT;
+
+         // 4 bits of cycle
+         gByteMarkID = (gByteMarkID + 1) & 0x0f;
+         if (gByteMarkID & 0x1)
+            gByteMarkID |= 0x20;
+         else
+            gByteMarkID |= 0x10;
+
+         hx::gMarkID = gByteMarkID << 24;
+         hx::gMarkIDWithContainer = (gByteMarkID << 24) | IMMIX_ALLOC_IS_CONTAINER;
+         gRememberedByteMarkID = gByteMarkID | HX_GC_REMEMBERED;
+
+         #ifdef HX_WATCH
+         GCLOG(" non-gen mark byte -> %02x\n", hx::gByteMarkID);
+         #endif
+         gBlockStack = 0;
+
+         ClearRowMarks();
+      }
+      else
+      {
+         #ifdef HX_WATCH
+         GCLOG(" generational mark byte -> %02x\n", hx::gByteMarkID);
+         #endif
+         ClearBlockMarks();
+      }
+
+      MEM_STAMP(tMarkInit);
+
+      #ifdef PROFILE_THREAD_USAGE
+      for(int i=-1;i<MAX_GC_THREADS;i++)
+         sThreadChunkPushCount = sThreadChunkWakes = sThreadMarkCount[i] = sThreadArrayMarkCount[i] = 0;
+      #endif
+
+
+
+      mMarker.init();
+
+      hx::MarkClassStatics(&mMarker);
+
+      {
+      hx::AutoMarkPush info(&mMarker,"Roots","root");
+
+      for(hx::RootSet::iterator i = hx::sgRootSet.begin(); i!=hx::sgRootSet.end(); ++i)
+      {
+         hx::Object *&obj = **i;
+         if (obj)
+            hx::MarkObjectAlloc(obj , &mMarker );
+      }
+
+      if (hx::sgOffsetRootSet)
+         for(hx::OffsetRootSet::iterator i = hx::sgOffsetRootSet->begin(); i!=hx::sgOffsetRootSet->end(); ++i)
+         {
+            char *ptr = *(char **)(i->first);
+            int offset = i->second;
+            hx::Object *obj = (hx::Object *)(ptr - offset);
+
+            if (obj)
+               hx::MarkObjectAlloc(obj , &mMarker );
+         }
+      } // automark
+
+      #ifdef PROFILE_COLLECT
+      hx::rootObjects = sObjectMarks;
+      hx::rootAllocs = sAllocMarks;
+      #endif
+
+
+      {
+      hx::AutoMarkPush info(&mMarker,"Zombies","zombie");
+      // Mark zombies too....
+      for(int i=0;i<hx::sZombieList.size();i++)
+         hx::MarkObjectAlloc(hx::sZombieList[i] , &mMarker );
+      } // automark
+
+      MEM_STAMP(tMarkLocal);
+      hx::localCount = 0;
+
+      mMarker.isGenerational = inGenerational;
+
+      // Mark local stacks
+      for(int i=0;i<mLocalAllocs.size();i++)
+         MarkLocalAlloc(mLocalAllocs[i] , &mMarker);
+
+      #ifdef PROFILE_COLLECT
+      hx::localObjects = sObjectMarks;
+      hx::localAllocs = sAllocMarks;
+      #endif
+
+      MEM_STAMP(tMarkLocalEnd);
+
+      #ifdef HX_MULTI_THREAD_MARKING
+         mMarker.releaseJobs();
+
+         // Unleash the workers...
+         StartThreadJobs(tpjMark, MAX_GC_THREADS, true);
+      #else
+         mMarker.processMarkStack();
+      #endif
+
+
+
+      MEM_STAMP(tMarked);
+
+      hx::FindZombies(mMarker);
+
+      hx::RunFinalizers();
+
+      #ifdef HXCPP_GC_VERIFY
+      for(int i=0;i<mAllBlocks.size();i++)
+         mAllBlocks[i]->verify("After mark");
+      #endif
+
+      #ifdef HX_WATCH
+      for(void **watch = hxWatchList; *watch; watch++)
+      {
+         GCLOG("********* Watch mark : %p %08x\n",*watch, ((unsigned int *)*watch)[-1]);
+         GCLOG(" ******** is marked  : %d\n", (((unsigned char *)(*watch))[HX_ENDIAN_MARK_ID_BYTE]== gByteMarkID));
+      }
+      #endif
+   }
+
+
+   
+   #ifdef HX_GC_VERIFY_ALLOC_START
+   void verifyAllocStart()
+   {
+      for(int i=1;i<mAllBlocks.size();i++)
+         mAllBlocks[i]->verifyAllocStart();
+   }
+   #endif
+
+   #ifdef HXCPP_GC_VERIFY
+   void VerifyBlockOrder()
+   {
+      for(int i=1;i<mAllBlocks.size();i++)
+      {
+         if ( mAllBlocks[i-1]->mPtr >= mAllBlocks[i]->mPtr)
+         {
+            printf("Bad block order block[%d]=%p >= block[%d]=%p / %d\n", i-1, mAllBlocks[i-1]->mPtr,
+                    i, mAllBlocks[i]->mPtr, mAllBlocks.size() );
+            DebuggerTrap();
+         }
+      }
+   }
+   #endif
+
+   void Collect(bool inMajor, bool inForceCompact, bool inLocked,bool inFreeIsFragged)
+   {
+      PROFILE_COLLECT_SUMMARY_START;
+
+      #ifndef HXCPP_SINGLE_THREADED_APP
+      // If we set the flag from 0 -> 0xffffffff then we are the collector
+      //  otherwise, someone else is collecting at the moment - so wait...
+      if (_hx_atomic_compare_exchange((volatile int *)&hx::gPauseForCollect, 0, 0xffffffff) != 0)
+      {
+         if (inLocked)
+         {
+            gThreadStateChangeLock->Unlock();
+
+            hx::PauseForCollect();
+
+            hx::EnterGCFreeZone();
+            gThreadStateChangeLock->Lock();
+            hx::ExitGCFreeZoneLocked();
+         }
+         else
+         {
+            hx::PauseForCollect();
+         }
+         return;
+      }
+      #endif
+
+      STAMP(t0)
+
+      // We are the collector - all must wait for us
+      LocalAllocator *this_local = 0;
+      #ifndef HXCPP_SINGLE_THREADED_APP
+      this_local = (LocalAllocator *)(hx::ImmixAllocator *)hx::tlsStackContext;
+
+      if (!inLocked)
+         gThreadStateChangeLock->Lock();
+
+      for(int i=0;i<mLocalAllocs.size();i++)
+         if (mLocalAllocs[i]!=this_local)
+            WaitForSafe(mLocalAllocs[i]);
+      #endif
+
+      sgIsCollecting = true;
+
+      StopThreadJobs(true);
+      #ifdef HXCPP_DEBUG
+      sgAllocsSinceLastSpam = 0;
+      #endif
+
+      HX_STACK_FRAME("GC", "collect", 0, "GC::collect", __FILE__, __LINE__,0)
+      #ifdef SHOW_MEM_EVENTS
+      int here = 0;
+      GCLOG("=== Collect === %p\n",&here);
+      #endif
+
+
+      #ifdef PROFILE_THREAD_USAGE
+      GCLOG("Thread zero waits %d/%d/%d, misses=%d, hits=%d\n", sThreadZeroPokes, sThreadZeroWaits, mFreeBlocks.size(), sThreadZeroMisses, sThreadBlockZeroCount);
+      sThreadZeroWaits = 0;
+      sThreadZeroPokes = 0;
+      sThreadZeroMisses = 0;
+      sThreadBlockZeroCount = 0;
+      #endif
+
+
+
+      #ifdef HXCPP_TELEMETRY
+      __hxt_gc_start();
+      #endif
+
+      size_t freeFraggedRows = 0; 
+      if (inFreeIsFragged)
+      {
+         for(int i=mNextFreeBlockOfSize[0]; i<mFreeBlocks.size(); i++)
+            freeFraggedRows += mFreeBlocks[i]->GetFreeRows();
+      }
+
+      // Now all threads have mTopOfStack & mBottomOfStack set.
+      bool generational = false; 
+
+      #ifdef HXCPP_GC_GENERATIONAL
+      bool compactSurviors = false;
+
+      if (sGcMode==gcmGenerational)
+      {
+         for(int i=0;i<mLocalAllocs.size();i++)
+         {
+            hx::StackContext *ctx = (hx::StackContext *)mLocalAllocs[i];
+            if( ctx->mOldReferrers->count )
+                hx::sGlobalChunks.addLocked( ctx->mOldReferrers );
+            else
+                hx::sGlobalChunks.free( ctx->mOldReferrers );
+            ctx->mOldReferrers = 0;
+         }
+      }
+
+      hx::QuickVec<hx::Object *> rememberedSet;
+      generational = !inMajor && !inForceCompact && sGcMode == gcmGenerational;
+      if (sGcMode==gcmGenerational)
+      {
+         hx::sGlobalChunks.copyPointers(rememberedSet,!generational);
+         #ifdef SHOW_MEM_EVENTS
+         GCLOG("Patch remembered set marks %d\n", rememberedSet.size());
+         #endif
+         for(int i=0;i<rememberedSet.size();i++)
+            ((unsigned char *)rememberedSet[i])[HX_ENDIAN_MARK_ID_BYTE] = gByteMarkID;
+      }
+      #endif
+
+      STAMP(t1)
+
+      MarkAll(generational);
+
+      #ifdef HX_GC_VERIFY_GENERATIONAL
+      {
+         #ifdef SHOW_MEM_EVENTS
+         GCLOG("verify generational [\n");
+         #endif
+         sGcVerifyGenerational = true;
+         sgTimeToNextTableUpdate--;
+         MarkAll(false);
+         sGcVerifyGenerational = false;
+         #ifdef SHOW_MEM_EVENTS
+         GCLOG("] verify generational\n");
+         #endif
+      }
+      #endif
+
+      STAMP(t2)
+
+
+      // Sweep blocks
+
+      // Update table entries?  This needs to be done before the gMarkID count clocks
+      //  back to the same number
+      if (!generational)
+         sgTimeToNextTableUpdate--;
+
+      bool full = inMajor || (sgTimeToNextTableUpdate<=0) || inForceCompact;
+
+      // Setup memory target ...
+      // Count free rows, and prep blocks for sorting
+      BlockDataStats stats;
+
+      /*
+       This reduces the stall time, but adds a bit of background cpu usage
+       Might be good to just countRows for non-generational too
+      */
+      if (!full && generational)
+      {
+         countRows(stats);
+         size_t currentRows = stats.rowsInUse + stats.fraggedRows + freeFraggedRows;
+         double filled = (double)(currentRows) / (double)(mAllBlocks.size()*IMMIX_USEFUL_LINES);
+         if (filled>0.85)
+         {
+            // Failure of generational estimation
+            int retained = currentRows - mRowsInUse;
+            int space = mAllBlocks.size()*IMMIX_USEFUL_LINES - mRowsInUse;
+            if (space<retained)
+               space = retained;
+            if (space<1)
+               space = 1;
+            mGenerationalRetainEstimate = (double)retained/(double)space;
+            #ifdef SHOW_MEM_EVENTS
+            GCLOG("Generational retention/fragmentation too high %f, do normal collect\n", mGenerationalRetainEstimate);
+            #endif
+
+            #ifdef HX_GC_VERIFY_ALLOC_START
+            verifyAllocStart();
+            #endif
+
+            generational = false;
+            MarkAll(generational);
+
+            sgTimeToNextTableUpdate--;
+            full = sgTimeToNextTableUpdate<=0;
+
+            stats.clear();
+            reclaimBlocks(full,stats);
+         }
+      }
+      else
+      {
+         reclaimBlocks(full,stats);
+      }
+
+
+      #ifdef HXCPP_GC_GENERATIONAL
+      if (compactSurviors)
+      {
+         MoveSurvivors(&rememberedSet);
+      }
+      #endif
+
+
+      #ifdef HXCPP_GC_MOVING
+      if (!full)
+      {
+         double useRatio = (double)(mRowsInUse<<IMMIX_LINE_BITS) / (sWorkingMemorySize);
+         #if defined(SHOW_FRAGMENTATION) || defined(SHOW_MEM_EVENTS)
+            GCLOG("Row use ratio:%f\n", useRatio);
+         #endif
+         // Could be either expanding, or fragmented...
+         if (useRatio>0.75)
+         {
+            #if defined(SHOW_FRAGMENTATION) || defined(SHOW_MEM_EVENTS)
+               GCLOG("Do full stats\n", useRatio);
+            #endif
+            full = true;
+            stats.clear();
+            reclaimBlocks(full,stats);
+         }
+      }
+      #endif
+
+      if (full)
+      {
+         #ifdef HXCPP_GC_MOVING
+         sgTimeToNextTableUpdate = 7;
+         #else
+         sgTimeToNextTableUpdate = 15;
+         #endif
+      }
+
+      size_t oldRowsInUse = mRowsInUse;
+      mRowsInUse = stats.rowsInUse + stats.fraggedRows + freeFraggedRows;
+
+      bool moved = false;
+
+      #if defined(SHOW_FRAGMENTATION) || defined(SHOW_MEM_EVENTS)
+      GCLOG("Total memory : %s\n", formatBytes(GetWorkingMemory()).c_str());
+      GCLOG("  reserved bytes : %s\n", formatBytes(mRowsInUse*IMMIX_LINE_LEN).c_str());
+      if (full)
+      {
+         GCLOG("  active bytes   : %s\n", formatBytes(stats.bytesInUse).c_str());
+         GCLOG("  active ratio   : %f\n", (double)stats.bytesInUse/( mRowsInUse*IMMIX_LINE_LEN));
+         GCLOG("  fragged blocks : %d (%.1f%%)\n", stats.fraggedBlocks, stats.fraggedBlocks*100.0/mAllBlocks.size() );
+         GCLOG("  fragged score  : %f\n", (double)stats.fragScore/mAllBlocks.size() );
+      }
+      GCLOG("  large size   : %s\n", formatBytes(mLargeAllocated).c_str());
+      GCLOG("  empty blocks : %d (%.1f%%)\n", stats.emptyBlocks, stats.emptyBlocks*100.0/mAllBlocks.size());
+      #endif
+
+      size_t bytesInUse = mRowsInUse<<IMMIX_LINE_BITS;
+
+      STAMP(t3)
+
+
+      #ifdef HXCPP_TELEMETRY
+      // Detect deallocations - TODO: add STAMP() ?
+      __hxt_gc_after_mark(gByteMarkID, HX_ENDIAN_MARK_ID_BYTE);
+      #endif
+
+      // Sweep large
+
+      // Manage recycle size ?
+      //  clear old frames recycle objects
+      int l2 = largeObjectRecycle.size();
+      for(int i=0;i<largeObjectRecycle.size();i++)
+         HxFree(largeObjectRecycle[i]);
+      largeObjectRecycle.setSize(0);
+
+      size_t recycleRemaining = 0;
+      #ifdef RECYCLE_LARGE
+      if (!inForceCompact)
+         recycleRemaining = mLargeAllocForceRefresh;
+      #endif
+
+      int idx = 0;
+      int l0 = mLargeList.size();
+      while(idx<mLargeList.size())
+      {
+         unsigned int *blob = mLargeList[idx];
+         if ( (blob[1] & IMMIX_ALLOC_MARK_ID) != hx::gMarkID )
+         {
+            unsigned int size = *blob;
+            mLargeAllocated -= size;
+            if (size < recycleRemaining)
+            {
+               recycleRemaining -= size;
+               largeObjectRecycle.push(blob);
+            }
+            else
+            {
+               HxFree(blob);
+            }
+
+            mLargeList.qerase(idx);
+         }
+         else
+            idx++;
+      }
+
+      int l1 = mLargeList.size();
+
+
+      STAMP(t4)
+
+      bool defragged = false;
+
+      // Compact/Defrag?
+      #if defined(HXCPP_GC_MOVING) && defined(HXCPP_VISIT_ALLOCS)
+      if (full)
+      {
+         bool doRelease = false;
+
+         if (inForceCompact)
+            doRelease = true;
+         else
+         {
+            size_t mem = mRowsInUse<<IMMIX_LINE_BITS;
+            size_t targetFree = std::max((size_t)hx::sgMinimumFreeSpace, mem/100 * (size_t)hx::sgTargetFreeSpacePercentage );
+            targetFree = std::min(targetFree, (size_t)sgMaximumFreeSpace );
+            sWorkingMemorySize = std::max( mem + targetFree, (size_t)hx::sgMinimumWorkingMemory);
+
+            size_t allMem = GetWorkingMemory();
+            // 8 Meg too much?
+            size_t allowExtra = std::max( (size_t)8*1024*1024, sWorkingMemorySize*5/4 );
+
+            if ( allMem > sWorkingMemorySize + allowExtra )
+            {
+               #if defined(SHOW_FRAGMENTATION) || defined(SHOW_MEM_EVENTS)
+               int releaseGroups = (int)((allMem - sWorkingMemorySize) / (IMMIX_BLOCK_SIZE<<IMMIX_BLOCK_GROUP_BITS));
+               if (releaseGroups)
+                  GCLOG("Try to release %d groups\n", releaseGroups );
+               #endif
+               doRelease = true;
+            }
+         }
+
+
+         bool isFragged = stats.fragScore > mAllBlocks.size()*FRAG_THRESH;
+         if (doRelease || isFragged || hx::gAlwaysMove)
+         {
+            if (isFragged && sgTimeToNextTableUpdate>3)
+               sgTimeToNextTableUpdate = 3;
+            calcMoveOrder( );
+
+            // Borrow some blocks to ensuure space to defrag into
+            int workingBlocks = mAllBlocks.size()*3/2 - stats.emptyBlocks;
+            int borrowed = 0;
+            while( mAllBlocks.size()<workingBlocks )
+            {
+               bool dummy = false;
+               if (!AllocMoreBlocks(dummy, true))
+                  break;
+               doRelease = true;
+               borrowed++;
+            }
+            stats.emptyBlocks += borrowed;
+            #if defined(SHOW_FRAGMENTATION)
+               GCLOG("Borrowed %d groups for %d target blocks\n", borrowed, workingBlocks);
+            #endif
+
+            MoveBlockJob job(mAllBlocks);
+
+            if (MoveBlocks(job,stats) || doRelease)
+            {
+               if (doRelease)
+               {
+                  size_t mem = mRowsInUse<<IMMIX_LINE_BITS;
+                  size_t targetFree = std::max((size_t)hx::sgMinimumFreeSpace, bytesInUse/100 *hx::sgTargetFreeSpacePercentage );
+                  targetFree = std::min(targetFree, (size_t)sgMaximumFreeSpace );
+                  size_t targetMem = std::max( mem + targetFree, (size_t)hx::sgMinimumWorkingMemory) +
+                                        (2<<(IMMIX_BLOCK_GROUP_BITS+IMMIX_BLOCK_BITS));
+
+                  if (inForceCompact)
+                     targetMem = 0;
+                  size_t have = GetWorkingMemory();
+                  if (targetMem<have)
+                  {
+                     size_t releaseSize = have - targetMem;
+                     #ifdef SHOW_FRAGMENTATION
+                     GCLOG(" Release %s bytes to leave %s\n", formatBytes(releaseSize).c_str(), formatBytes(targetMem).c_str() );
+                     #endif
+
+                     int releasedBlocks = releaseEmptyGroups(stats, releaseSize);
+                     #ifdef SHOW_FRAGMENTATION
+                     int releasedGroups = releasedBlocks >> IMMIX_BLOCK_GROUP_BITS;
+                     GCLOG(" Released %s, %d groups\n", formatBytes((size_t)releasedBlocks<<IMMIX_BLOCK_BITS).c_str(), releasedGroups );
+                     #endif
+                  }
+               }
+
+               // Reduce sWorkingMemorySize now we have defragged
+               #if defined(SHOW_FRAGMENTATION) || defined(SHOW_MEM_EVENTS)
+               GCLOG("After compacting---\n");
+               GCLOG("  total memory : %s\n", formatBytes(GetWorkingMemory()).c_str() );
+               GCLOG("  total needed : %s\n", formatBytes((size_t)mRowsInUse*IMMIX_LINE_LEN).c_str() );
+               GCLOG("  for bytes    : %s\n", formatBytes(bytesInUse).c_str() );
+               GCLOG("  empty blocks : %d (%.1f%%)\n", stats.emptyBlocks, stats.emptyBlocks*100.0/mAllBlocks.size());
+               GCLOG("  fragged blocks : %d (%.1f%%)\n", stats.fraggedBlocks, stats.fraggedBlocks*100.0/mAllBlocks.size() );
+               #endif
+            }
+
+            std::stable_sort(&mAllBlocks[0], &mAllBlocks[0] + mAllBlocks.size(), SortByBlockPtr );
+
+            #ifdef HXCPP_GC_VERIFY
+            VerifyBlockOrder();
+            #endif
+         }
+      }
+      #endif
+
+
+      STAMP(t5)
+
+      size_t mem = mRowsInUse<<IMMIX_LINE_BITS;
+      size_t baseMem = full ? bytesInUse : mem;
+      #ifdef HXCPP_GC_DYNAMIC_SIZE
+      size_t targetFree = std::max((size_t)hx::sgMinimumFreeSpace, (size_t)(baseMem * profileCollectSummary.spaceFactor ) );
+      #else
+      size_t targetFree = std::max((size_t)hx::sgMinimumFreeSpace, baseMem/100 *hx::sgTargetFreeSpacePercentage );
+      #endif
+      targetFree = std::min(targetFree, (size_t)sgMaximumFreeSpace );
+      // Only adjust if non-generational
+      if (!generational)
+         sWorkingMemorySize = std::max( mem + targetFree, (size_t)hx::sgMinimumWorkingMemory);
+
+      #if defined(SHOW_FRAGMENTATION) || defined(SHOW_MEM_EVENTS)
+      GCLOG("Target memory %s, using %s\n",  formatBytes(sWorkingMemorySize).c_str(), formatBytes(mem).c_str() );
+      #endif
+
+      // Large alloc target
+      int blockSize =  mAllBlocks.size()<<IMMIX_BLOCK_BITS;
+      if (blockSize > mLargeAllocSpace)
+         mLargeAllocSpace = blockSize;
+      mLargeAllocForceRefresh = mLargeAllocated + mLargeAllocSpace;
+
+      mTotalAfterLastCollect = MemUsage();
+
+      #ifdef HXCPP_GC_GENERATIONAL
+      if (generational)
+      {
+         // TODO - include large too?
+         int retained = mRowsInUse - oldRowsInUse;
+         int space = mAllBlocks.size()*IMMIX_USEFUL_LINES - oldRowsInUse;
+         if (space<retained)
+            space = retained;
+
+         mGenerationalRetainEstimate = (double)retained/(double)space;
+      }
+      else
+      {
+         // move towards 0.2
+         mGenerationalRetainEstimate += (0.2-mGenerationalRetainEstimate)*0.25;
+      }
+
+      double filled_ratio = (double)mRowsInUse/(double)(mAllBlocksCount*IMMIX_USEFUL_LINES);
+      double after_gen = filled_ratio + (1.0-filled_ratio)*mGenerationalRetainEstimate;
+
+      if (after_gen<0.75)
+      {
+         sGcMode = gcmGenerational;
+      }
+      else
+      {
+         sGcMode = gcmFull;
+         // What was I thinking here?  This breaks #851
+         //gByteMarkID |= 0x30;
+      }
+
+      #ifdef SHOW_MEM_EVENTS
+      GCLOG("filled=%.2f%% + estimate = %.2f%% = %.2f%% -> %s\n",
+            filled_ratio*100, mGenerationalRetainEstimate*100, after_gen*100, sGcMode==gcmFull?"Full":"Generational");
+      #endif
+
+      #endif
+
+      createFreeList();
+
+      // This saves some running/stall time, but increases the total CPU usage
+      // Delaying it until just before the block is used to improve the cache locality
+      backgroundProcessFreeList(true);
+
+      mAllBlocksCount   = mAllBlocks.size();
+      mCurrentRowsInUse = mRowsInUse;
+
+      #ifdef SHOW_MEM_EVENTS
+      GCLOG("Collect Done\n");
+      #endif
+
+      #ifdef PROFILE_COLLECT
+      STAMP(t6)
+      double period = t6-sLastCollect;
+      sLastCollect=t6;
+      GCLOG("Collect time %s total=%.2fms =%.1f%%\n  setup=%.2f\n  %s=%.2f(init=%.2f/roots=%.2f %d+%d/loc=%.2f*%d %d+%d/mark=%.2f %d+%d/fin=%.2f*%d/ids=%.2f)\n  reclaim=%.2f\n  large(%d->%d, recyc %d)=%.2f\n  defrag=%.2f\n",
+               generational ? "gen" : "std",
+              (t6-t0)*1000, (t6-t0)*100.0/period, // total %
+              (t1-t0)*1000, // sync/setup
+              generational ? "mark gen" : "mark", (t2-t1)*1000,
+                      (tMarkInit-t1)*1000,
+                      (tMarkLocal-tMarkInit)*1000,  hx::rootObjects, hx::rootAllocs,
+                      (tMarkLocalEnd-tMarkLocal)*1000, hx::localCount, hx::localObjects-hx::rootObjects, hx::localAllocs-hx::rootAllocs,
+                      (tMarked-tMarkLocalEnd)*1000, sObjectMarks-hx::localObjects, sAllocMarks-hx::localAllocs,
+                      (hx::tFinalizers-tMarked)*1000, hx::finalizerCount,
+                      (t2-hx::tFinalizers)*1000,
+              (t3-t2)*1000, // reclaim
+              l0, l1, l2, (t4-t3)*1000, // large
+              (t5-t4)*1000 // defrag
+              );
+      sObjectMarks = sAllocMarks = 0;
+
+      #endif
+
+      #ifdef PROFILE_THREAD_USAGE
+      GCLOG("Thread chunks:%d, wakes=%d\n", sThreadChunkPushCount, sThreadChunkWakes);
+      for(int i=-1;i<MAX_GC_THREADS;i++)
+        GCLOG(" thread %d] %d + %d\n", i, sThreadMarkCount[i], sThreadArrayMarkCount[i]);
+      GCLOG("Locking spins  : %d\n", sSpinCount);
+      sSpinCount = 0;
+      #endif
+
+      #ifdef HXCPP_GC_GENERATIONAL
+      if (sGcMode==gcmGenerational)
+         for(int i=0;i<mLocalAllocs.size();i++)
+         {
+            hx::StackContext *ctx = (hx::StackContext *)mLocalAllocs[i];
+            ctx->mOldReferrers = hx::sGlobalChunks.alloc();
+         }
+      #endif
+
+
+      #ifdef HXCPP_GC_VERIFY
+      VerifyBlockOrder();
+      #endif
+
+      for(int i=0;i<LOCAL_POOL_SIZE;i++)
+      {
+         LocalAllocator *l = mLocalPool[i];
+         if (l)
+            ClearPooledAlloc(l);
+      }
+
+      #ifdef HXCPP_TELEMETRY
+      __hxt_gc_end();
+      #endif
+
+      sgIsCollecting = false;
+
+
+      hx::gPauseForCollect = 0x00000000;
+      #ifndef HXCPP_SINGLE_THREADED_APP
+         for(int i=0;i<mLocalAllocs.size();i++)
+         {
+            #ifdef HXCPP_SCRIPTABLE
+            ((hx::StackContext *)mLocalAllocs[i])->byteMarkId = hx::gByteMarkID;
+            #endif
+            if (mLocalAllocs[i]!=this_local)
+               ReleaseFromSafe(mLocalAllocs[i]);
+         }
+
+         if (!inLocked)
+            gThreadStateChangeLock->Unlock();
+      #else
+        #ifdef HXCPP_SCRIPTABLE
+        hx::gMainThreadContext->byteMarkId = hx::gByteMarkID;
+        #endif
+      #endif
+
+
+      PROFILE_COLLECT_SUMMARY_END;
+   }
+
+   void reclaimBlocks(bool full, BlockDataStats &outStats)
+   {
+      if (MAX_GC_THREADS>1)
+      {
+         for(int i=0;i<MAX_GC_THREADS;i++)
+            sThreadBlockDataStats[i].clear();
+         StartThreadJobs(full ? tpjReclaimFull : tpjReclaim, mAllBlocks.size(), true);
+         outStats = sThreadBlockDataStats[0];
+         for(int i=1;i<MAX_GC_THREADS;i++)
+            outStats.add(sThreadBlockDataStats[i]);
+      }
+      else
+      {
+         outStats.clear();
+         for(int i=0;i<mAllBlocks.size();i++)
+         {
+            if (full)
+               mAllBlocks[i]->reclaim<true>(&outStats);
+            else
+               mAllBlocks[i]->reclaim<false>(&outStats);
+         }
+      }
+   }
+
+
+   void countRows(BlockDataStats &outStats)
+   {
+      if (MAX_GC_THREADS>1)
+      {
+         for(int i=0;i<MAX_GC_THREADS;i++)
+            sThreadBlockDataStats[i].clear();
+         StartThreadJobs(tpjCountRows, mAllBlocks.size(), true);
+         outStats = sThreadBlockDataStats[0];
+         for(int i=1;i<MAX_GC_THREADS;i++)
+            outStats.add(sThreadBlockDataStats[i]);
+      }
+      else
+      {
+         outStats.clear();
+         for(int i=0;i<mAllBlocks.size();i++)
+            mAllBlocks[i]->countRows(outStats);
+      }
+   }
+
+
+   // buils mFreeBlocks and maybe starts the async-zero process on mZeroList
+   void createFreeList()
+   {
+      mFreeBlocks.clear();
+
+      for(int i=0;i<mAllBlocks.size();i++)
+      {
+         BlockDataInfo *info = mAllBlocks[i];
+         if (info->GetFreeRows() > 0 && info->mMaxHoleSize>256)
+         {
+            info->mOwned = false;
+            mFreeBlocks.push(info);
+         }
+      }
+
+      int extra = std::max( mAllBlocks.size(), 8<<IMMIX_BLOCK_GROUP_BITS);
+      mFreeBlocks.safeReserveExtra(extra);
+
+      std::sort(&mFreeBlocks[0], &mFreeBlocks[0] + mFreeBlocks.size(), SmallestFreeFirst );
+
+      for(int i=0;i<BLOCK_OFSIZE_COUNT;i++)
+         mNextFreeBlockOfSize[i] = mFreeBlocks.size();
+
+      for(int i=mFreeBlocks.size()-1;i>=0;i--)
+      {
+         int slot = mFreeBlocks[i]->mMaxHoleSize >> IMMIX_LINE_BITS;
+         if (slot>=BLOCK_OFSIZE_COUNT)
+            slot = BLOCK_OFSIZE_COUNT-1;
+         mNextFreeBlockOfSize[slot] = i;
+      }
+
+      for(int i=BLOCK_OFSIZE_COUNT-2;i>=0;i--)
+         if (mNextFreeBlockOfSize[i]>mNextFreeBlockOfSize[i+1])
+            mNextFreeBlockOfSize[i] = mNextFreeBlockOfSize[i+1];
+
+      mZeroList.clear();
+   }
+
+   void backgroundProcessFreeList(bool inJit)
+   {
+      mZeroListQueue = 0;
+      #ifdef HX_GC_ZERO_EARLY
+      mZeroList.setSize(mFreeBlocks.size());
+      memcpy( &mZeroList[0], &mFreeBlocks[0], mFreeBlocks.size()*sizeof(void *));
+
+      StartThreadJobs(tpjAsyncZero, mZeroList.size(),true);
+      #else
+      if ( MAX_GC_THREADS>1 && mFreeBlocks.size()>4)
+      {
+         mZeroList.setSize(mFreeBlocks.size());
+         memcpy( &mZeroList[0], &mFreeBlocks[0], mFreeBlocks.size()*sizeof(void *));
+
+         // Only use one thread for parallel zeroing.  Try to get though the work wihout
+         //  slowing down the main thread
+         StartThreadJobs(inJit ? tpjAsyncZeroJit : tpjAsyncZero, mZeroList.size(), false, 1);
+      }
+      #endif
+   }
+
+
+
+
+   size_t MemLarge()
+   {
+      return mLargeAllocated;
+   }
+
+   size_t MemReserved()
+   {
+      return mLargeAllocated + (mAllBlocksCount*IMMIX_USEFUL_LINES<<IMMIX_LINE_BITS);
+   }
+
+   size_t MemCurrent()
+   {
+      return mLargeAllocated + (mCurrentRowsInUse<<IMMIX_LINE_BITS);
+   }
+
+   size_t MemUsage()
+   {
+      return mLargeAllocated + (mRowsInUse<<IMMIX_LINE_BITS);
+   }
+
+   bool IsAllBlock(BlockData *block)
+   {
+      if (mAllBlocks.size())
+      {
+         int min = 0;
+         int max = mAllBlocks.size()-1;
+         if (block==mAllBlocks[0]->mPtr)
+            return true;
+         if (block==mAllBlocks[max]->mPtr)
+            return true;
+         if (block>mAllBlocks[0]->mPtr && block<mAllBlocks[max]->mPtr)
+         {
+            while(min<max-1)
+            {
+               int mid = (max+min)>>1;
+               if (mAllBlocks[mid]->mPtr==block)
+                  return true;
+
+               if (mAllBlocks[mid]->mPtr<block)
+                  min = mid;
+               else
+                  max = mid;
+            }
+         }
+      }
+      return false;
+   }
+
+   MemType GetMemType(void *inPtr)
+   {
+      BlockData *block = (BlockData *)( ((size_t)inPtr) & IMMIX_BLOCK_BASE_MASK);
+
+      bool isBlock = IsAllBlock(block);
+      /*
+      bool found = false;
+      for(int i=0;i<mAllBlocks.size();i++)
+      {
+         if (mAllBlocks[i]==block)
+         {
+            found = true;
+            break;
+         }
+      }
+      */
+
+      if (isBlock)
+         return memBlock;
+
+      for(int i=0;i<mLargeList.size();i++)
+      {
+         unsigned int *blob = mLargeList[i] + 2;
+         if (blob==inPtr)
+            return memLarge;
+      }
+
+      return memUnmanaged;
+   }
+
+
+   size_t mRowsInUse;
+   size_t mCurrentRowsInUse;
+   size_t mLargeAllocSpace;
+   size_t mLargeAllocForceRefresh;
+   size_t mLargeAllocated;
+   size_t mTotalAfterLastCollect;
+   size_t mAllBlocksCount;
+   double mGenerationalRetainEstimate;
+
+   hx::MarkContext mMarker;
+
+   volatile int mNextFreeBlockOfSize[BLOCK_OFSIZE_COUNT];
+   volatile int mThreadJobId;
+
+   BlockList mAllBlocks;
+   BlockList mFreeBlocks;
+   BlockList mZeroList;
+   volatile int mZeroListQueue;
+
+   LargeList mLargeList;
+   HxMutex    mLargeListLock;
+   hx::QuickVec<LocalAllocator *> mLocalAllocs;
+   LocalAllocator *mLocalPool[LOCAL_POOL_SIZE];
+   hx::QuickVec<unsigned int *> largeObjectRecycle;
+};
+
+
+
+namespace hx
+{
+
+MarkChunk *MarkChunk::swapForNew()
+{
+   return sGlobalChunks.pushJobNoWake(this);
+}
+
+
+
+void MarkConservative(int *inBottom, int *inTop,hx::MarkContext *__inCtx)
+{
+   #ifdef VERIFY_STACK_READ
+   VerifyStackRead(inBottom, inTop);
+   #endif
+
+   #ifdef SHOW_MEM_EVENTS
+   GCLOG("Mark conservative %p...%p (%d) [...", inBottom, inTop, (int)(inTop-inBottom) );
+     #ifdef HX_WATCH
+     GCLOG("\n");
+     #endif
+   #endif
+
+   #ifdef HXCPP_STACK_UP
+   int *start = inTop-1;
+   inTop = inBottom+1;
+   inBottom = start;
+   #endif
+
+   if (sizeof(int)==4 && sizeof(void *)==8)
+   {
+      // Can't start pointer on last integer boundary...
+      inTop--;
+   }
+
+   void *prev = 0;
+   void *lastPin = 0;
+   #ifdef HX_WATCH
+   void *lastWatch = 0;
+   bool isWatch = false;
+   #endif
+
+   #ifdef HXCPP_GC_GENERATIONAL
+   // If this is a generational mark, then the byte marker has not been increased.
+   // Previous mark Ids are therfore from more than 1 collection ago
+   bool allowPrevious = !__inCtx->isGenerational;
+   #else
+   const bool allowPrevious = true;
+   #endif
+
+
+   for(int *ptr = inBottom ; ptr<inTop; ptr++)
+   {
+      void *vptr = *(void **)ptr;
+
+      MemType mem;
+      #ifdef HXCPP_ALIGN_ALLOC
+      const size_t validObjectMask = 0x07;
+      #else
+      const size_t validObjectMask = 0x03;
+      #endif
+
+      if (vptr && !((size_t)vptr & validObjectMask) && vptr!=prev && vptr!=lastPin)
+      {
+
+         #ifdef PROFILE_COLLECT
+         hx::localCount++;
+         #endif
+         MemType mem = sGlobalAlloc->GetMemType(vptr);
+
+         #ifdef HX_WATCH
+         isWatch = false;
+         if (hxInWatchList(vptr) && vptr!=lastWatch)
+         {
+            isWatch = true;
+            lastWatch = vptr;
+            GCLOG("********* Watch location conservative mark %p:%d\n",vptr,mem);
+         }
+         #endif
+
+         if (mem!=memUnmanaged)
+         {
+            if (mem==memLarge)
+            {
+               unsigned char &mark = ((unsigned char *)(vptr))[HX_ENDIAN_MARK_ID_BYTE];
+               if (mark!=gByteMarkID)
+                  mark = gByteMarkID;
+            }
+            else
+            {
+               BlockData *block = (BlockData *)( ((size_t)vptr) & IMMIX_BLOCK_BASE_MASK);
+               BlockDataInfo *info = (*gBlockInfo)[block->mId];
+
+               int pos = (int)(((size_t)vptr) & IMMIX_BLOCK_OFFSET_MASK);
+               AllocType t = sgCheckInternalOffset ?
+                     info->GetEnclosingAllocType(pos-sizeof(int),&vptr, allowPrevious):
+                     info->GetAllocType(pos-sizeof(int), allowPrevious);
+
+               #ifdef HX_WATCH
+               if (!isWatch && hxInWatchList(vptr))
+               {
+                  isWatch = true;
+                  GCLOG("********* Watch location conservative mark offset %p:%d\n",vptr,mem);
+               }
+               #endif
+
+
+               if ( t==allocObject )
+               {
+                  #ifdef HX_WATCH
+                  if (isWatch)
+                  {
+                     GCLOG(" Mark object %p (%p)\n", vptr,ptr);
+                  }
+                  #endif
+                  hx::MarkObjectAlloc( ((hx::Object *)vptr), __inCtx );
+                  lastPin = vptr;
+                  info->pin();
+               }
+               else if (t==allocString)
+               {
+                  #ifdef HX_WATCH
+                  if (isWatch)
+                     GCLOG(" Mark string %p (%p)\n", vptr,ptr);
+                  #endif
+                  HX_MARK_STRING(vptr);
+                  lastPin = vptr;
+                  info->pin();
+               }
+               else if (t==allocMarked)
+               {
+                  #ifdef HX_WATCH
+                  if (isWatch)
+                     GCLOG(" pin alloced %p (%p)\n", vptr,ptr);
+                  #endif
+                  lastPin = vptr;
+                  info->pin();
+               }
+               #ifdef HX_WATCH
+               else // memBlock
+               {
+                  if (isWatch)
+                  {
+                     GCLOG(" missed watch %p:%d\n", vptr,t);
+                     int x = info->GetAllocType(pos-sizeof(int),allowPrevious);
+                     int y = info->GetEnclosingAllocType(pos-sizeof(int),&vptr,allowPrevious);
+                     #ifdef HXCPP_GC_NURSERY
+                     void *nptr;
+                     int z = info->GetEnclosingNurseryType(pos-sizeof(int),&nptr);
+                     #else
+                     int z = 0;
+                     #endif
+                     printf("but got alloc type=%d, enclosing=%d nurs=%d o=%d\n",x,y,z,sgCheckInternalOffset);
+                  }
+               }
+               #endif
+            }
+         }
+         // GCLOG(" rejected %p %p %d %p %d=%d\n", ptr, vptr, !((size_t)vptr & 0x03), prev,
+         // sGlobalAlloc->GetMemType(vptr) , memUnmanaged );
+      }
+   }
+   #ifdef SHOW_MEM_EVENTS
+   GCLOG("...]\n");
+   #endif
+}
+
+} // namespace hx
+
+
+// --- LocalAllocator -------------------------------------------------------
+//
+// One per thread ...
+
+static int sFragIgnore=0;
+
+class LocalAllocator : public hx::StackContext
+{
+   int            mCurrentHole;
+   int            mCurrentHoles;
+   HoleRange     *mCurrentRange;
+   int           *mFraggedRows;
+
+   bool           mMoreHoles;
+
+   #ifndef HXCPP_EXPLICIT_STACK_EXTENT
+   int *mTopOfStack;
+   int *mBottomOfStack;
+   #endif
+
+   hx::RegisterCaptureBuffer mRegisterBuf;
+   int                   mRegisterBufSize;
+
+   #ifndef HXCPP_SINGLE_THREADED_APP
+   bool            mGCFreeZone;
+   HxSemaphore     mReadyForCollect;
+   HxSemaphore     mCollectDone;
+   #endif
+
+   int             mID;
+
+
+   // Must be called locked
+   ~LocalAllocator()
+   {
+   }
+
+public:
+   bool            mGlobalStackLock;
+   int             mStackLocks;
+
+public:
+   LocalAllocator(int *inTopOfStack=0)
+   {
+      Reset();
+
+      #ifdef HXCPP_GC_GENERATIONAL
+      mOldReferrers = 0;
+      #endif
+
+      AttachThread(inTopOfStack);
+   }
+
+
+   void AttachThread(int *inTopOfStack)
+   {
+      #ifndef HXCPP_EXPLICIT_STACK_EXTENT
+      mTopOfStack = mBottomOfStack = inTopOfStack;
+      #endif
+
+      mRegisterBufSize = 0;
+      mStackLocks = 0;
+      mGlobalStackLock = false;
+      #ifdef HX_WINDOWS
+      mID = GetCurrentThreadId();
+      #endif
+
+      #ifdef HXCPP_GC_GENERATIONAL
+      if (mOldReferrers)
+      {
+         GCLOG("Uncleaned referrers\n");
+      }
+
+      if (sGcMode==gcmGenerational)
+         mOldReferrers = hx::sGlobalChunks.alloc();
+      else
+         mOldReferrers = 0;
+      #endif
+
+
+      // It is in the free zone - wait for 'SetTopOfStack' to activate
+      #ifndef HXCPP_SINGLE_THREADED_APP
+      mGCFreeZone = true;
+      mReadyForCollect.Set();
+      #endif
+      sGlobalAlloc->AddLocal(this);
+   }
+
+   void Release()
+   {
+      mStackLocks = 0;
+
+      onThreadDetach();
+
+      #ifndef HXCPP_SINGLE_THREADED_APP
+      if (!mGCFreeZone)
+         EnterGCFreeZone();
+      #endif
+
+      AutoLock lock(*gThreadStateChangeLock);
+
+      #ifdef HX_WINDOWS
+      mID = 0;
+      #endif
+
+      #ifdef HXCPP_GC_GENERATIONAL
+      if (mOldReferrers)
+      {
+         if ( mOldReferrers->count )
+            hx::sGlobalChunks.pushJob( mOldReferrers, false );
+         else
+            hx::sGlobalChunks.free( mOldReferrers );
+         mOldReferrers = 0;
+      }
+      #endif
+
+      #ifndef HXCPP_EXPLICIT_STACK_EXTENT
+      mTopOfStack = mBottomOfStack = 0;
+      #endif
+
+      sGlobalAlloc->RemoveLocalLocked(this);
+
+      hx::tlsStackContext = 0;
+
+      if (!sGlobalAlloc->ReturnToPoolLocked(this))
+         delete this;
+   }
+
+   void Reset()
+   {
+      allocBase = 0;
+      mCurrentHole = 0;
+      mCurrentHoles = 0;
+      mFraggedRows = 0;
+      #ifdef HXCPP_GC_NURSERY
+      spaceFirst = 0;
+      spaceOversize = 0;
+      #else
+      spaceEnd = 0;
+      spaceStart = 0;
+      #endif
+      mMoreHoles = false;
+   }
+
+   // The main of haxe calls SetTopOfStack(top,false)
+   //   via hxcpp_set_top_of_stack or HX_TOP_OF_STACK in HxcppMain.cpp/Macros.h
+   // The means "register current thread indefinitely"
+   // Other places may call this to ensure the the current thread is registered
+   //  indefinitely (until forcefully revoked)
+   //
+   // Normally libraries/mains will then let this dangle.
+   //
+   // However after the main, on android it calls SetTopOfStack(0,true), to unregister the thread,
+   // because it is likely to be the ui thread, and the remaining call will be from
+   // callbacks from the render thread.
+   // 
+   // When threads want to attach temporarily, they will call
+   // gc_set_top_of_stack(top,true)
+   //  -> SetTopOfStack(top,true)
+   //    do stuff...
+   // gc_set_top_of_stack(0,true)
+   //  -> SetTopOfStack(0,true)
+   //
+   //  OR
+   //
+   //  PushTopOfStack(top)
+   //   ...
+   //  PopTopOfStack
+   //
+   //  However, we really want the gc_set_top_of_stack(top,true) to allow recursive locks so:
+   //
+   //  SetTopOfStack(top,false) -> ensure global stack lock exists
+   //  SetTopOfStack(top,true) -> add stack lock
+   //  SetTopOfStack(0,_) -> pop stack lock. If all gone, clear global stack lock
+   //
+
+   #ifdef HXCPP_EXPLICIT_STACK_EXTENT // {
+
+   void SetTopOfStack(int *inTop,bool inPush) { }
+   void PushTopOfStack(void *inTop) { }
+   void PopTopOfStack() { }
+   void SetBottomOfStack(int *inBottom) { }
+   void PauseForCollect() { }
+   void EnterGCFreeZone() { }
+   bool TryGCFreeZone() { return true; }
+   bool TryExitGCFreeZone() { return false; }
+   void ExitGCFreeZoneLocked() { }
+
+
+   #else // } !HXCPP_EXPLICIT_STACK_EXTENT {
+   void SetTopOfStack(int *inTop,bool inPush)
+   {
+      if (inTop)
+      {
+         if (!mTopOfStack)
+            mTopOfStack = inTop;
+         // EMSCRIPTEN the stack grows upwards - not wasm.
+         // It could be that the main routine was called from deep with in the stack,
+         //  then some callback was called from a higher location on the stack
+         #ifdef HXCPP_STACK_UP
+         else if (inTop < mTopOfStack)
+            mTopOfStack = inTop;
+         #else
+         else if (inTop > mTopOfStack)
+            mTopOfStack = inTop;
+         #endif
+
+         if (inPush)
+            mStackLocks++;
+         else
+            mGlobalStackLock = true;
+
+         #ifndef HXCPP_SINGLE_THREADED_APP
+         if (mGCFreeZone)
+            ExitGCFreeZone();
+         #endif
+      }
+      else
+      {
+         if (mStackLocks>0)
+            mStackLocks--;
+         else
+            mGlobalStackLock = false;
+
+         if (!mStackLocks && !mGlobalStackLock)
+         {
+            Release();
+         }
+      }
+
+      #ifdef VerifyStackRead
+      VerifyStackRead(mBottomOfStack, mTopOfStack)
+      #endif
+   }
+
+
+   void PushTopOfStack(void *inTop)
+   {
+      SetTopOfStack((int *)inTop,true);
+   }
+
+
+   void PopTopOfStack()
+   {
+      mStackLocks--;
+      if (mStackLocks<=0 && !mGlobalStackLock)
+      {
+         Release();
+      }
+   }
+
+
+
+   void SetBottomOfStack(int *inBottom)
+   {
+      mBottomOfStack = inBottom;
+      #ifdef VerifyStackRead
+      VerifyStackRead(mBottomOfStack, mTopOfStack)
+      #endif
+   }
+
+
+   void PauseForCollect()
+   {
+      #ifndef HXCPP_SINGLE_THREADED_APP
+      volatile int dummy = 1;
+      mBottomOfStack = (int *)&dummy;
+      CAPTURE_REGS;
+      #ifdef VerifyStackRead
+      VerifyStackRead(mBottomOfStack, mTopOfStack)
+      #endif
+
+      if (sgIsCollecting)
+         CriticalGCError("Bad Allocation while collecting - from finalizer?");
+
+      mReadyForCollect.Set();
+      mCollectDone.Wait();
+      #endif
+   }
+
+   void EnterGCFreeZone()
+   {
+      #ifndef HXCPP_SINGLE_THREADED_APP
+      volatile int dummy = 1;
+      mBottomOfStack = (int *)&dummy;
+      if (mTopOfStack)
+      {
+         CAPTURE_REGS;
+      }
+      #ifdef VerifyStackRead
+      VerifyStackRead(mBottomOfStack, mTopOfStack)
+      #endif
+
+      mGCFreeZone = true;
+      mReadyForCollect.Set();
+      #endif
+   }
+
+   bool TryGCFreeZone()
+   {
+      #ifndef HXCPP_SINGLE_THREADED_APP
+      if (mGCFreeZone)
+         return false;
+      EnterGCFreeZone();
+      #endif
+      return true;
+   }
+
+   bool TryExitGCFreeZone()
+   {
+      #ifndef HXCPP_SINGLE_THREADED_APP
+      if (!mGCFreeZone)
+         return false;
+      ExitGCFreeZone();
+      return true;
+      #endif
+      return false;
+   }
+
+
+   void ExitGCFreeZone()
+   {
+      #ifndef HXCPP_SINGLE_THREADED_APP
+      if (!mGCFreeZone)
+         CriticalGCError("GCFree Zone mismatch");
+
+      AutoLock lock(*gThreadStateChangeLock);
+      mReadyForCollect.Reset();
+      mGCFreeZone = false;
+      #endif
+   }
+        // For when we already hold the lock
+   void ExitGCFreeZoneLocked()
+   {
+      #ifndef HXCPP_SINGLE_THREADED_APP
+      mReadyForCollect.Reset();
+      mGCFreeZone = false;
+      #endif
+   }
+
+
+
+   // Called by the collecting thread to make sure this allocator is paused.
+   // The collecting thread has the lock, and will not be releasing it until
+   //  it has finished the collect.
+   //
+   //  The mGCFreeZone is set without a lock in the EnterGCFreeZone code, and then
+   //   mReadyForCollect is set.  So it is possible the mGCFreeZone check may or may not
+   //   trigger.  If this call happens first, mGCFreeZone will be zero, and mReadyForCollect
+   //   will wait.  By this time mGCFreeZone will be set and the next call not check
+   //   mReadyForCollect again.  If this one happens later, it is possible mReadyForCollect
+   //   will not be waited on. mReadyForCollect will be cleared when the zone is left.
+   //
+   //  The mMoreHoles/spaceOversize/spaceEnd get zeroed without a lock.  The timing should
+   //   not be critical since the allocation code shold expect that these are volatile.
+   //   If the allocation works, all is good.  If it fails then the collection will happed soon.
+   #if defined(__has_feature)
+     #if __has_feature(thread_sanitizer)
+      __attribute__((no_sanitize("thread")))
+     #endif
+   #endif
+   void WaitForSafe()
+   {
+      #ifndef HXCPP_SINGLE_THREADED_APP
+      if (!mGCFreeZone)
+      {
+         // Cause allocation routines to fail ...
+         mMoreHoles = false;
+         #ifdef HXCPP_GC_NURSERY
+         spaceOversize = 0;
+         #else
+         spaceEnd = 0;
+         #endif
+         mReadyForCollect.Wait();
+      }
+      #endif
+   }
+
+   void ReleaseFromSafe()
+   {
+      #ifndef HXCPP_SINGLE_THREADED_APP
+      if (!mGCFreeZone)
+         mCollectDone.Set();
+      #endif
+   }
+
+   #endif // }  HXCPP_EXPLICIT_STACK_EXTENT
+
+
+   void SetupStackAndCollect(bool inMajor, bool inForceCompact, bool inLocked=false,bool inFreeIsFragged=false)
+   {
+      #ifndef HXCPP_SINGLE_THREADED_APP
+        #if HXCPP_DEBUG
+        if (mGCFreeZone)
+           CriticalGCError("Collecting from a GC-free thread");
+        #endif
+      #endif
+
+      #ifndef HXCPP_EXPLICIT_STACK_EXTENT
+      volatile int dummy = 1;
+      mBottomOfStack = (int *)&dummy;
+
+      CAPTURE_REGS;
+
+      if (!mTopOfStack)
+         mTopOfStack = mBottomOfStack;
+
+      // EMSCRIPTEN the stack grows upwards
+      #ifdef HXCPP_STACK_UP
+      if (mBottomOfStack < mTopOfStack)
+         mTopOfStack = mBottomOfStack;
+      #else
+      if (mBottomOfStack > mTopOfStack)
+         mTopOfStack = mBottomOfStack;
+      #endif
+
+      #ifdef VerifyStackRead
+      VerifyStackRead(mBottomOfStack, mTopOfStack)
+      #endif
+
+      #endif
+
+
+      sGlobalAlloc->Collect(inMajor, inForceCompact, inLocked, inFreeIsFragged);
+   }
+
+
+
+   void ExpandAlloc(int &ioSize)
+   {
+      #ifdef HXCPP_ALIGN_ALLOC
+      // Do nothing here - aligning to the end of the row will bump the
+      // next allocation, so it's not clear if its a good idea.
+      #else
+         #ifdef HXCPP_GC_NURSERY
+         int spaceStart = spaceFirst - allocBase - 4;
+         int spaceEnd = spaceOversize - allocBase - 4;
+         #endif
+
+         int size = ioSize + sizeof(int);
+         int end = spaceStart + size;
+         if (end <= spaceEnd)
+         {
+            int linePad = IMMIX_LINE_LEN - (end & (IMMIX_LINE_LEN-1));
+            if (linePad>0 && linePad<=64)
+               ioSize += linePad;
+         }
+      #endif
+   }
+
+
+   void *CallAlloc(int inSize,unsigned int inObjectFlags)
+   {
+      #ifndef HXCPP_SINGLE_THREADED_APP
+      #if HXCPP_DEBUG
+      if (mGCFreeZone)
+         CriticalGCError("Allocating from a GC-free thread");
+      #endif
+      if (hx::gPauseForCollect)
+         PauseForCollect();
+      #endif
+
+      if (inSize==0)
+         return hx::emptyAlloc;
+
+      #if defined(HXCPP_VISIT_ALLOCS) && (defined(HXCPP_M64)||defined(HXCPP_ARM64))
+      // Make sure we can fit a relocation pointer
+      int allocSize = sizeof(int) + std::max(8,inSize);
+      #else
+      int allocSize = sizeof(int) + inSize;
+      #endif
+
+      #if HXCPP_GC_DEBUG_LEVEL>0
+      if (inSize & 3) DebuggerTrap();
+      #endif
+
+      while(1)
+      {
+         #ifdef HXCPP_GC_NURSERY
+            unsigned char *buffer = spaceFirst;
+            #ifdef HXCPP_ALIGN_ALLOC
+            if ((size_t)buffer & 0x4 )
+               buffer += 4;
+            #endif
+            unsigned char *end = buffer + allocSize;
+
+            if ( end <= spaceOversize )
+            {
+               spaceFirst = end;
+
+               int size = allocSize - 4;
+               ((unsigned int *)buffer)[-1] = size | inObjectFlags;
+
+               #if defined(HXCPP_GC_CHECK_POINTER) && defined(HXCPP_GC_DEBUG_ALWAYS_MOVE)
+               hx::GCOnNewPointer(buffer);
+               #endif
+
+               return buffer;
+            }
+            // spaceOversize might have been set to zero for quick-termination of alloc.
+            unsigned char *s = spaceOversize;
+            if (s>spaceFirst && mFraggedRows)
+               *mFraggedRows += (s - spaceFirst)>>IMMIX_LINE_BITS;
+         #else
+            #ifdef HXCPP_ALIGN_ALLOC
+            if (!((size_t)spaceStart & 0x4 ))
+               spaceStart += 4;
+            #endif
+
+            int end = spaceStart + allocSize;
+            if (end <= spaceEnd)
+            {
+               unsigned int *buffer = (unsigned int *)(allocBase + spaceStart);
+
+               int startRow = spaceStart>>IMMIX_LINE_BITS;
+               allocStartFlags[ startRow ] |= hx::gImmixStartFlag[spaceStart &127];
+
+               int endRow = (end+(IMMIX_LINE_LEN-1))>>IMMIX_LINE_BITS;
+
+               *buffer++ = inObjectFlags | hx::gMarkID |
+                     (inSize<<IMMIX_ALLOC_SIZE_SHIFT) | (endRow-startRow);
+
+               spaceStart = end;
+
+               #if defined(HXCPP_GC_CHECK_POINTER) && defined(HXCPP_GC_DEBUG_ALWAYS_MOVE)
+               hx::GCOnNewPointer(buffer);
+               #endif
+
+               #ifdef HXCPP_TELEMETRY
+               __hxt_gc_alloc(buffer, inSize);
+               #endif
+
+               return buffer;
+            }
+            if (mFraggedRows)
+            {
+               int frag = spaceEnd-spaceStart;
+               if (frag>0)
+                  *mFraggedRows += frag>>IMMIX_LINE_BITS;
+            }
+         #endif
+
+
+         if (mMoreHoles)
+         {
+            #ifdef HXCPP_GC_NURSERY
+            spaceFirst = allocBase + mCurrentRange[mCurrentHole].start + sizeof(int);
+            spaceOversize = spaceFirst + mCurrentRange[mCurrentHole].length;
+            #else
+            spaceStart = mCurrentRange[mCurrentHole].start;
+            spaceEnd = spaceStart + mCurrentRange[mCurrentHole].length;
+            #endif
+            mCurrentHole++;
+            mMoreHoles = mCurrentHole<mCurrentHoles;
+
+         }
+         else
+         {
+            // For opmtimized windows 64 builds, this dummy var technique does not
+            //  quite work, since the compiler might recycle one of the earlier stack
+            //  slots, and place dummy behind the stack values we are actually trying to
+            //  capture.  Moving the dummy into the GetFreeBlock seems to have fixed this.
+            //  Not 100% sure this is the best answer, but it is working.
+            //volatile int dummy = 1;
+            //mBottomOfStack = (int *)&dummy;
+            //CAPTURE_REGS;
+
+            BlockDataInfo *info = sGlobalAlloc->GetFreeBlock(allocSize,this);
+
+            allocBase = (unsigned char *)info->mPtr;
+            mCurrentRange = info->mRanges;
+            allocStartFlags = info->allocStart;
+            mCurrentHoles = info->mHoles;
+            mFraggedRows = &info->mFraggedRows;
+            #ifdef HXCPP_GC_NURSERY
+            spaceFirst = allocBase + mCurrentRange->start + sizeof(int);
+            spaceOversize = spaceFirst + mCurrentRange->length;
+            #else
+            spaceStart = mCurrentRange->start;
+            spaceEnd = spaceStart + mCurrentRange->length;
+            #endif
+            mCurrentHole = 1;
+            mMoreHoles = mCurrentHole<mCurrentHoles;
+         }
+
+         // Other thread may have started collect, in which case we may just
+         //  overwritted the 'mMoreHoles' and 'spaceEnd' termination attempt
+         if (hx::gPauseForCollect)
+         {
+            mMoreHoles = 0;
+            #ifdef HXCPP_GC_NURSERY
+            spaceOversize = 0;
+            #else
+            spaceEnd = 0;
+            #endif
+         }
+      }
+      return 0;
+   }
+
+   #ifdef HXCPP_VISIT_ALLOCS
+   void Visit(hx::VisitContext *__inCtx)
+   {
+      #ifdef HXCPP_COMBINE_STRINGS
+      if (stringSet)
+      {
+         __inCtx->visitObject( (hx::Object **)&stringSet);
+      }
+      #endif
+   }
+   #endif
+
+
+   void Mark(hx::MarkContext *__inCtx)
+   {
+      #ifndef HXCPP_SINGLE_THREADED_APP
+      if (!mTopOfStack)
+      {
+         Reset();
+         return;
+      }
+      #endif
+
+      #ifdef SHOW_MEM_EVENTS
+      //int here = 0;
+      //GCLOG("=========== Mark Stack ==================== %p ... %p (%p)\n",mBottomOfStack,mTopOfStack,&here);
+      #endif
+
+      #ifdef HXCPP_DEBUG
+         MarkPushClass("Stack",__inCtx);
+         MarkSetMember("Stack",__inCtx);
+
+         #ifdef HXCPP_EXPLICIT_STACK_EXTENT
+           hx::MarkConservative( (int *)emscripten_stack_get_current(),(int *)emscripten_stack_get_base(), __inCtx);
+         #else
+         if (mTopOfStack && mBottomOfStack)
+            hx::MarkConservative(mBottomOfStack, mTopOfStack , __inCtx);
+         #endif
+
+         #ifdef HXCPP_SCRIPTABLE
+            MarkSetMember("ScriptStack",__inCtx);
+            hx::MarkConservative((int *)(stack), (int *)(pointer),__inCtx);
+         #endif
+         MarkSetMember("Registers",__inCtx);
+         hx::MarkConservative(CAPTURE_REG_START, CAPTURE_REG_END, __inCtx);
+
+
+         MarkPopClass(__inCtx);
+      #else
+
+         #ifdef HXCPP_EXPLICIT_STACK_EXTENT
+           hx::MarkConservative( (int *)emscripten_stack_get_current(), (int *) emscripten_stack_get_base(), __inCtx);
+         #else
+            if (mTopOfStack && mBottomOfStack)
+               hx::MarkConservative(mBottomOfStack, mTopOfStack , __inCtx);
+            hx::MarkConservative(CAPTURE_REG_START, CAPTURE_REG_END, __inCtx);
+         #endif
+
+         #ifdef HXCPP_SCRIPTABLE
+            hx::MarkConservative((int *)(stack), (int *)(pointer),__inCtx);
+         #endif
+      #endif
+
+      #ifdef HXCPP_COMBINE_STRINGS
+         if (stringSet)
+            MarkMember( *(hx::Object **)&stringSet, __inCtx);
+      #endif
+
+      Reset();
+
+   }
+
+};
+
+
+
+
+inline LocalAllocator *GetLocalAlloc(bool inAllowEmpty=false)
+{
+   #ifndef HXCPP_SINGLE_THREADED_APP
+      LocalAllocator *result = (LocalAllocator *)(hx::ImmixAllocator *)hx::tlsStackContext;
+      if (!result && !inAllowEmpty)
+         hx::BadImmixAlloc();
+
+      return result;
+   #else
+      return (LocalAllocator *)hx::gMainThreadContext;
+   #endif
+}
+
+#ifndef HXCPP_SINGLE_THREADED_APP
+void WaitForSafe(LocalAllocator *inAlloc)
+{
+   inAlloc->WaitForSafe();
+}
+
+void ReleaseFromSafe(LocalAllocator *inAlloc)
+{
+   inAlloc->ReleaseFromSafe();
+}
+#endif
+
+void MarkLocalAlloc(LocalAllocator *inAlloc,hx::MarkContext *__inCtx)
+{
+   inAlloc->Mark(__inCtx);
+}
+
+void ClearPooledAlloc(LocalAllocator *inAlloc)
+{
+   inAlloc->Reset();
+}
+
+#ifdef HXCPP_VISIT_ALLOCS
+void VisitLocalAlloc(LocalAllocator *inAlloc,hx::VisitContext *__inCtx)
+{
+   inAlloc->Visit(__inCtx);
+}
+#endif
+
+
+
+void CollectFromThisThread(bool inMajor,bool inForceCompact)
+{
+   LocalAllocator *la = GetLocalAlloc();
+   la->SetupStackAndCollect(inMajor,inForceCompact);
+}
+
+namespace hx
+{
+
+void *ImmixAllocator::CallAlloc(int inSize,unsigned int inObjectFlags)
+{
+   return reinterpret_cast<LocalAllocator *>(this)->CallAlloc(inSize, inObjectFlags);
+}
+
+
+
+void PauseForCollect()
+{
+   GetLocalAlloc()->PauseForCollect();
+}
+
+
+
+void EnterGCFreeZone()
+{
+   #ifndef HXCPP_SINGLE_THREADED_APP
+      LocalAllocator *tla = GetLocalAlloc();
+      tla->EnterGCFreeZone();
+   #endif
+}
+
+
+bool TryGCFreeZone()
+{
+   #ifndef HXCPP_SINGLE_THREADED_APP
+      LocalAllocator *tla = GetLocalAlloc();
+      return tla->TryGCFreeZone();
+   #else
+      return false;
+   #endif
+}
+
+bool TryExitGCFreeZone()
+{
+   #ifndef HXCPP_SINGLE_THREADED_APP
+      LocalAllocator *tla = GetLocalAlloc(true);
+      if (!tla)
+         return 0;
+      bool left = tla->TryExitGCFreeZone();
+      return left;
+   #else
+      return false;
+   #endif
+}
+
+
+void ExitGCFreeZone()
+{
+   #ifndef HXCPP_SINGLE_THREADED_APP
+      LocalAllocator *tla = GetLocalAlloc();
+      tla->ExitGCFreeZone();
+   #endif
+}
+
+void ExitGCFreeZoneLocked()
+{
+   #ifndef HXCPP_SINGLE_THREADED_APP
+      LocalAllocator *tla = GetLocalAlloc();
+      tla->ExitGCFreeZoneLocked();
+   #endif
+}
+
+void InitAlloc()
+{
+   for(int i=0;i<IMMIX_LINE_LEN;i++)
+      gImmixStartFlag[i] = 1<<( i>>2 ) ;
+
+   hx::CommonInitAlloc();
+   sgAllocInit = true;
+   sGlobalAlloc = new GlobalAllocator();
+   sgFinalizers = new FinalizerList();
+   sFinalizerLock = new HxMutex();
+   sGCRootLock = new HxMutex();
+   hx::Object tmp;
+   void **stack = *(void ***)(&tmp);
+   sgObject_root = stack[0];
+
+   //GCLOG("__root pointer %p\n", sgObject_root);
+   gMainThreadContext =  new LocalAllocator();
+
+   tlsStackContext = gMainThreadContext;
+
+   ExitGCFreeZone();
+
+   // Setup main thread ...
+   __hxcpp_thread_current();
+
+   gMainThreadContext->onThreadAttach();
+}
+
+
+void GCPrepareMultiThreaded()
+{
+   #ifdef HXCPP_SINGLE_THREADED_APP
+   CriticalGCError("GCPrepareMultiThreaded called with HXCPP_SINGLE_THREADED_APP");
+   #endif
+}
+
+
+
+void SetTopOfStack(int *inTop,bool inForce)
+{
+   bool threadAttached = false;
+   if (inTop)
+   {
+      if (!sgAllocInit)
+         InitAlloc();
+      else
+      {
+         if (tlsStackContext==0)
+         {
+            GCPrepareMultiThreaded();
+            RegisterCurrentThread(inTop);
+            threadAttached = true;
+         }
+      }
+   }
+
+   LocalAllocator *tla = (LocalAllocator *)(hx::ImmixAllocator *)tlsStackContext;
+
+   if (tla)
+   {
+      tla->SetTopOfStack(inTop,inForce);
+      if (threadAttached)
+         tla->onThreadAttach();
+   }
+}
+
+
+void *InternalNew(int inSize,bool inIsObject)
+{
+   // HX_STACK_FRAME("GC", "new", 0, "GC::new", __FILE__, __LINE__, 0)
+
+   #ifdef HXCPP_DEBUG
+   if (sgSpamCollects && sgAllocsSinceLastSpam>=sgSpamCollects)
+   {
+      //GCLOG("InternalNew spam\n");
+      CollectFromThisThread(false,false);
+   }
+   _hx_atomic_add(&sgAllocsSinceLastSpam, 1);
+   #endif
+
+   if (inSize>=IMMIX_LARGE_OBJ_SIZE)
+   {
+      void *result = sGlobalAlloc->AllocLarge(inSize, true);
+      return result;
+   }
+   else
+   {
+      LocalAllocator *tla = GetLocalAlloc();
+
+      if (inIsObject)
+      {
+         void* result = tla->CallAlloc(inSize,IMMIX_ALLOC_IS_CONTAINER);
+         return result;
+      }
+      else
+      {
+         #if defined(HXCPP_GC_MOVING) && defined(HXCPP_M64)
+         if (inSize<8)
+            return tla->CallAlloc(8,0);
+         #endif
+
+         void* result = tla->CallAlloc( (inSize+3)&~3,0);
+         return result;
+      }
+   }
+}
+
+
+// Force global collection - should only be called from 1 thread.
+int InternalCollect(bool inMajor,bool inCompact)
+{
+   if (!sgAllocInit)
+       return 0;
+
+   GetLocalAlloc()->SetupStackAndCollect(inMajor, inCompact);
+
+   return sGlobalAlloc->MemUsage();
+}
+
+inline unsigned int ObjectSize(void *inData)
+{
+   unsigned int header = ((unsigned int *)(inData))[-1];
+
+   return (header & IMMIX_ALLOC_ROW_COUNT) ?
+            ( (header & IMMIX_ALLOC_SIZE_MASK) >> IMMIX_ALLOC_SIZE_SHIFT) :
+             ((unsigned int *)(inData))[-2];
+}
+
+
+unsigned int ObjectSizeSafe(void *inData)
+{
+   unsigned int header = ((unsigned int *)(inData))[-1];
+   if (header & HX_GC_CONST_ALLOC_BIT)
+      return 0;
+
+   #ifdef HXCPP_GC_NURSERY
+   if (!(header & 0xff000000))
+   {
+      // Small object
+      if (header & 0x00ffffff)
+         return header & 0x0000ffff;
+      // Large object
+   }
+   #endif
+
+
+   return (header & IMMIX_ALLOC_ROW_COUNT) ?
+            ( (header & IMMIX_ALLOC_SIZE_MASK) >> IMMIX_ALLOC_SIZE_SHIFT) :
+             ((unsigned int *)(inData))[-2];
+}
+
+void GCChangeManagedMemory(int inDelta, const char *inWhy)
+{
+   sGlobalAlloc->onMemoryChange(inDelta, inWhy);
+}
+
+void InternalReleaseMem(void *inMem)
+{
+   if (inMem)
+   {
+      unsigned int s = ObjectSizeSafe(inMem);
+      if (s>=IMMIX_LARGE_OBJ_SIZE)
+      {
+         //Can release asap
+         sGlobalAlloc->FreeLarge(inMem);
+      }
+   }
+}
+
+
+
+void *InternalRealloc(int inFromSize, void *inData,int inSize, bool inExpand)
+{
+   if (inData==0 || inFromSize==0)
+   {
+      if (inData)
+         InternalReleaseMem(inData);
+      return hx::InternalNew(inSize,false);
+   }
+
+   // HX_STACK_FRAME("GC", "realloc", 0, "GC::relloc", __FILE__ , __LINE__, 0)
+
+   #ifdef HXCPP_DEBUG
+   if (sgSpamCollects && sgAllocsSinceLastSpam>=sgSpamCollects)
+   {
+      //GCLOG("InternalNew spam\n");
+      CollectFromThisThread(false,false);
+   }
+   _hx_atomic_add(&sgAllocsSinceLastSpam, 1);
+   #endif
+
+   void *new_data = 0;
+   if (inSize==0)
+   {
+      new_data = hx::emptyAlloc;
+   }
+   else if (inSize>=IMMIX_LARGE_OBJ_SIZE)
+   {
+      new_data = sGlobalAlloc->AllocLarge(inSize, false);
+      if (inSize>inFromSize)
+         ZERO_MEM((char *)new_data + inFromSize,inSize-inFromSize);
+   }
+   else
+   {
+      LocalAllocator *tla = GetLocalAlloc();
+
+      #if defined(HXCPP_GC_MOVING) && defined(HXCPP_M64)
+      if (inSize<8)
+          new_data =  tla->CallAlloc(8,0);
+      else
+      #endif
+      {
+         inSize = (inSize+3) & ~3;
+         if (inExpand)
+            tla->ExpandAlloc(inSize);
+
+         new_data = tla->CallAlloc(inSize,0);
+      }
+   }
+
+
+#ifdef HXCPP_TELEMETRY
+   //printf(" -- reallocating %018x to %018x, size from %d to %d\n", inData, new_data, s, inSize);
+   __hxt_gc_realloc(inData, new_data, inSize);
+#endif
+
+   int min_size = inFromSize < inSize ? inFromSize : inSize;
+
+   if (min_size)
+      memcpy(new_data, inData, min_size );
+
+   InternalReleaseMem(inData);
+
+   return new_data;
+}
+
+#ifdef HXCPP_GC_GENERATIONAL
+void NewMarkedObject(hx::Object *inPtr)
+{
+   HX_OBJ_WB_PESSIMISTIC_GET(inPtr);
+}
+#endif
+
+void RegisterCurrentThread(void *inTopOfStack)
+{
+   // Create a local-alloc
+   LocalAllocator *local = sGlobalAlloc->GetPooledAllocator();
+   if (!local)
+   {
+      local = new LocalAllocator((int *)inTopOfStack);
+   }
+   else
+   {
+      local->AttachThread((int *)inTopOfStack);
+   }
+
+   tlsStackContext = local;
+   #ifdef HXCPP_SCRIPTABLE
+   local->byteMarkId = hx::gByteMarkID;
+   #endif
+}
+
+void UnregisterCurrentThread()
+{
+   LocalAllocator *local = (LocalAllocator *)(hx::ImmixAllocator *)tlsStackContext;
+   local->Release();
+}
+
+void RegisterVTableOffset(int inOffset)
+{
+   if (inOffset>sgCheckInternalOffset)
+   {
+      sgCheckInternalOffset = inOffset;
+      sgCheckInternalOffsetRows = 1 + (inOffset>>IMMIX_LINE_BITS);
+   }
+}
+
+void PushTopOfStack(void *inTop)
+{
+   bool threadAttached = false;
+   if (!sgAllocInit)
+      InitAlloc();
+   else
+   {
+      if (tlsStackContext==0)
+      {
+         GCPrepareMultiThreaded();
+         RegisterCurrentThread(inTop);
+         threadAttached = true;
+      }
+   }
+ 
+   LocalAllocator *tla = GetLocalAlloc();
+   tla->PushTopOfStack(inTop);
+   if (threadAttached)
+      tla->onThreadAttach();
+}
+
+void PopTopOfStack()
+{
+   LocalAllocator *tla = GetLocalAlloc();
+   tla->PopTopOfStack();
+}
+
+int GcGetThreadAttachedCount()
+{
+   LocalAllocator *tla = GetLocalAlloc(true);
+   if (!tla)
+      return 0;
+   return tla->mStackLocks + (tla->mGlobalStackLock ? 1 : 0);
+}
+
+
+#ifdef HXCPP_VISIT_ALLOCS
+class GcFreezer : public hx::VisitContext
+{
+public:
+   void visitObject(hx::Object **ioPtr)
+   {
+      hx::Object *obj = *ioPtr;
+      if (!obj || IsConstAlloc(obj))
+         return;
+
+      unsigned int s = ObjectSize(obj);
+      void *result = InternalCreateConstBuffer(obj,s,false);
+      //printf(" Freeze %d\n", s);
+      *ioPtr = (hx::Object *)result;
+      (*ioPtr)->__Visit(this);
+   }
+
+   void visitAlloc(void **ioPtr)
+   {
+      void *data = *ioPtr;
+      if (!data || IsConstAlloc(data))
+         return;
+      unsigned int s = ObjectSize(data);
+      //printf(" Freeze %d\n", s);
+      void *result = InternalCreateConstBuffer(data,s,false);
+      *ioPtr = result;
+   }
+};
+#endif
+
+
+} // end namespace hx
+
+
+Dynamic _hx_gc_freeze(Dynamic inObject)
+{
+#ifdef HXCPP_VISIT_ALLOCS
+   hx::GcFreezer freezer;
+   hx::Object *base = inObject.mPtr;
+   freezer.visitObject(&base);
+   return base;
+#else
+   return inObject;
+#endif
+}
+
+
+
+void __hxcpp_spam_collects(int inEveryNCalls)
+{
+   #ifdef HXCPP_DEBUG
+   sgSpamCollects = inEveryNCalls;
+   #else
+   GCLOG("Spam collects only available on debug versions\n");
+   #endif
+}
+
+int __hxcpp_gc_trace(hx::Class inClass,bool inPrint)
+{
+    #if  !defined(HXCPP_DEBUG)
+       #ifdef ANDROID
+       __android_log_print(ANDROID_LOG_ERROR, "hxcpp", "GC trace not enabled in release build.");
+       #elif defined(HX_WINRT)
+       WINRT_LOG("GC trace not enabled in release build.");
+       #else
+       printf("WARNING : GC trace not enabled in release build.\n");
+       #endif
+       return 0;
+    #else
+       gCollectTrace = inClass.GetPtr();
+       gCollectTraceCount = 0;
+       gCollectTraceDoPrint = inPrint;
+       hx::InternalCollect(false,false);
+       gCollectTrace = 0;
+       return gCollectTraceCount;
+    #endif
+}
+
+int   __hxcpp_gc_large_bytes()
+{
+   return sGlobalAlloc->MemLarge();
+}
+
+int   __hxcpp_gc_reserved_bytes()
+{
+   return sGlobalAlloc->MemReserved();
+}
+
+double __hxcpp_gc_mem_info(int inWhich)
+{
+   switch(inWhich)
+   {
+      case MEM_INFO_USAGE:
+         return (double)sGlobalAlloc->MemUsage();
+      case MEM_INFO_RESERVED:
+         return (double)sGlobalAlloc->MemReserved();
+      case MEM_INFO_CURRENT:
+         return (double)sGlobalAlloc->MemCurrent();
+      case MEM_INFO_LARGE:
+         return (double)sGlobalAlloc->MemLarge();
+   }
+   return 0;
+}
+
+int   __hxcpp_gc_used_bytes()
+{
+   return sGlobalAlloc->MemUsage();
+}
+
+void  __hxcpp_gc_do_not_kill(Dynamic inObj)
+{
+   hx::GCDoNotKill(inObj.GetPtr());
+}
+
+hx::Object *__hxcpp_get_next_zombie()
+{
+   return hx::GCGetNextZombie();
+}
+
+
+void _hx_set_finalizer(Dynamic inObj, void (*inFunc)(Dynamic) )
+{
+   GCSetHaxeFinalizer( inObj.mPtr, inFunc );
+}
+
+void __hxcpp_set_finalizer(Dynamic inObj, void *inFunc)
+{
+   GCSetHaxeFinalizer( inObj.mPtr, (hx::HaxeFinalizer) inFunc );
+}
+
+void __hxcpp_add_member_finalizer(hx::Object *inObject, _hx_member_finalizer f, bool inPin)
+{
+   AutoLock lock(*gSpecialObjectLock);
+   hx::sFinalizableList.push( hx::Finalizable(inObject, f, inPin) );
+}
+
+void __hxcpp_add_alloc_finalizer(void *inAlloc, _hx_alloc_finalizer f, bool inPin)
+{
+   AutoLock lock(*gSpecialObjectLock);
+   hx::sFinalizableList.push( hx::Finalizable(inAlloc, f, inPin) );
+}
+
+
+
+extern "C"
+{
+void hxcpp_set_top_of_stack()
+{
+   int i = 0;
+   hx::SetTopOfStack(&i,false);
+}
+}
+
+void __hxcpp_enter_gc_free_zone()
+{
+   hx::EnterGCFreeZone();
+}
+
+
+bool __hxcpp_try_gc_free_zone()
+{
+   return hx::TryGCFreeZone();
+}
+
+
+
+void __hxcpp_exit_gc_free_zone()
+{
+   hx::ExitGCFreeZone();
+}
+
+
+void __hxcpp_gc_safe_point()
+{
+    if (hx::gPauseForCollect)
+      hx::PauseForCollect();
+}
+
+//#define HXCPP_FORCE_OBJ_MAP
+
+#if defined(HXCPP_M64) || defined(HXCPP_GC_MOVING) || defined(HXCPP_FORCE_OBJ_MAP)
+#define HXCPP_USE_OBJECT_MAP
+#endif
+
+int __hxcpp_obj_id(Dynamic inObj)
+{
+   hx::Object *obj = inObj.mPtr;
+   if (!obj) return -1;
+   #ifdef HXCPP_USE_OBJECT_MAP
+   return sGlobalAlloc->GetObjectID(obj);
+   #else
+   return (int)(obj);
+   #endif
+}
+
+hx::Object *__hxcpp_id_obj(int inId)
+{
+   #ifdef HXCPP_USE_OBJECT_MAP
+   return (hx::Object *)sGlobalAlloc->GetIDObject(inId);
+   #else
+   return (hx::Object *)(inId);
+   #endif
+}
+
+#ifdef HXCPP_USE_OBJECT_MAP
+unsigned int __hxcpp_obj_hash(Dynamic inObj)
+{
+   return __hxcpp_obj_id(inObj);
+}
+#else
+unsigned int __hxcpp_obj_hash(Dynamic inObj)
+{
+   if (!inObj.mPtr) return 0;
+   hx::Object *obj = inObj.mPtr;
+   #if defined(HXCPP_M64)
+   size_t h64 = (size_t)obj;
+   return (unsigned int)(h64>>2) ^ (unsigned int)(h64>>32);
+   #else
+   return ((unsigned int)inObj.mPtr) >> 4;
+   #endif
+}
+#endif
+
+
+
+
+void DummyFunction(void *inPtr) { }
+
diff --git a/Sources/c_snikket/src/hx/libs/regexp/Build.xml b/Sources/c_snikket/src/hx/libs/regexp/Build.xml
new file mode 100644
index 0000000..46a1fba
--- /dev/null
+++ b/Sources/c_snikket/src/hx/libs/regexp/Build.xml
@@ -0,0 +1,45 @@
+<xml>
+
+<pragma once="true" />
+
+<set name="PCRE_DIR" value="${HXCPP}/project/thirdparty/pcre2-10.42/src" />
+
+<files id="pcre2-8" tags="" >
+  <depend files="hxcpp-depends"/>
+  <depend name="${this_dir}/Build.xml" dateOnly="true" />
+  <cache value="true" asLibrary="true" />
+
+  <compilerflag value="-DPCRE2_CODE_UNIT_WIDTH=8" />
+  <compilerflag value="-DSUPPORT_PCRE2_8" />
+
+  <include name="${this_dir}/pcre2_sources.xml" />
+</files>
+
+<files id="pcre2-16" tags="" >
+  <depend files="hxcpp-depends"/>
+  <depend name="${this_dir}/Build.xml" dateOnly="true" />
+  <cache value="true" asLibrary="true" />
+
+  <compilerflag value="-DPCRE2_CODE_UNIT_WIDTH=16" />
+  <compilerflag value="-DSUPPORT_PCRE2_16" />
+
+  <include name="${this_dir}/pcre2_sources.xml" />
+</files>
+
+<files id="hxcpp_regexp">
+  <depend files="hxcpp-depends"/>
+  <depend name="${this_dir}/Build.xml" dateOnly="true" />
+  <cache value="true" asLibrary="true" />
+
+  <compilerflag value="-I${PCRE_DIR}"/>
+
+  <file name="${this_dir}/RegExp.cpp"/>
+</files>
+
+<target id="haxe">
+  <files id="hxcpp_regexp" />
+  <files id="pcre2-8" />
+  <files id="pcre2-16" if="hxcpp_smart_strings" />
+</target>
+
+</xml>
diff --git a/Sources/c_snikket/src/hx/libs/regexp/RegExp.cpp b/Sources/c_snikket/src/hx/libs/regexp/RegExp.cpp
new file mode 100644
index 0000000..9c66167
--- /dev/null
+++ b/Sources/c_snikket/src/hx/libs/regexp/RegExp.cpp
@@ -0,0 +1,292 @@
+#include <hxcpp.h>
+#include <string.h>
+
+#define PCRE2_STATIC
+#define PCRE2_CODE_UNIT_WIDTH 0
+
+#include <pcre2.h>
+
+#define PCRE(o)      ((pcredata*)o.mPtr)
+
+static void regexp_compilation_error(String pattern, int error_code, size_t error_offset) {
+   PCRE2_UCHAR8 error_buffer[128];
+   pcre2_get_error_message_8(error_code, error_buffer, sizeof(error_buffer));
+   hx::Throw(HX_CSTRING("Regexp compilation error : ") + String((const char*)error_buffer) + HX_CSTRING(" in ") + pattern);
+}
+
+struct pcredata : public hx::Object
+{
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdPcreData };
+
+   pcre2_code_8   *rUtf8;
+   #ifdef HX_SMART_STRINGS
+   pcre2_code_16   *rUtf16;
+   #endif
+
+   int n_groups;
+   pcre2_match_data_8* match_data8;
+   #ifdef HX_SMART_STRINGS
+   pcre2_match_data_16* match_data16;
+   #endif
+
+   unsigned int flags;
+   String string;
+   String expr;
+
+   void create8(pcre2_code_8 *inR, String inExpr, int inFlags)
+   {
+      rUtf8 = inR;
+      #ifdef HX_SMART_STRINGS
+      rUtf16 = 0;
+      #endif
+      expr = inExpr;
+      HX_OBJ_WB_GET(this, expr.raw_ref());
+      flags = inFlags;
+
+      n_groups = 0;
+      pcre2_pattern_info_8(rUtf8,PCRE2_INFO_CAPTURECOUNT,&n_groups);
+      n_groups++;
+      match_data8 = pcre2_match_data_create_from_pattern_8(rUtf8, NULL);
+      #ifdef HX_SMART_STRINGS
+      match_data16 = 0;
+      #endif
+
+      _hx_set_finalizer(this, finalize);
+   }
+
+   #ifdef HX_SMART_STRINGS
+   void create16(pcre2_code_16 *inR, String inExpr, int inFlags)
+   {
+      rUtf8 = 0;
+      rUtf16 = inR;
+      expr = inExpr;
+      HX_OBJ_WB_GET(this, expr.raw_ref());
+      flags = inFlags;
+
+      n_groups = 0;
+      pcre2_pattern_info_16(rUtf16,PCRE2_INFO_CAPTURECOUNT,&n_groups);
+      n_groups++;
+      match_data8 = 0;
+      match_data16 = pcre2_match_data_create_from_pattern_16(rUtf16, NULL);
+
+      _hx_set_finalizer(this, finalize);
+   }
+   #endif
+
+   bool run(String string,int pos,int len)
+   {
+      #ifdef HX_SMART_STRINGS
+      if (string.isUTF16Encoded())
+      {
+         if (!rUtf16)
+         {
+            int error_code;
+            size_t error_offset;
+            hx::strbuf buf;
+            int utf16Length = 0;
+            PCRE2_SPTR16 utf16 = (PCRE2_SPTR16)expr.wc_str(&buf, &utf16Length);
+            rUtf16 = pcre2_compile_16((PCRE2_SPTR16)expr.wc_str(&buf),utf16Length,flags,&error_code,&error_offset,NULL);
+            if (!rUtf16) {
+               regexp_compilation_error(expr,error_code,error_offset);
+            }
+            match_data16 = pcre2_match_data_create_from_pattern_16(rUtf16, NULL);
+         }
+
+         int n = pcre2_match_16(rUtf16,(PCRE2_SPTR16)string.raw_wptr(),pos+len,pos,PCRE2_NO_UTF_CHECK,match_data16,NULL);
+         return n>=0;
+      }
+
+      if (!rUtf8)
+      {
+         int error_code;
+         size_t error_offset;
+         int utf8Length = 0;
+         PCRE2_SPTR8 utf8 = (PCRE2_SPTR8)expr.utf8_str(NULL, true, &utf8Length);
+         rUtf8 = pcre2_compile_8(utf8, utf8Length, flags, &error_code, &error_offset, NULL);
+         if (!rUtf8) {
+            regexp_compilation_error(expr,error_code,error_offset);
+         }
+         match_data8 = pcre2_match_data_create_from_pattern_8(rUtf8, NULL);
+      }
+
+      #endif
+      return pcre2_match_8(rUtf8,(PCRE2_SPTR8)string.utf8_str(),pos+len,pos,PCRE2_NO_UTF_CHECK,match_data8,NULL) >= 0;
+   }
+
+   size_t* get_matches() {
+      #ifdef HX_SMART_STRINGS
+      if (string.isUTF16Encoded()) {
+         return pcre2_get_ovector_pointer_16(match_data16);
+      }
+      #endif
+      return pcre2_get_ovector_pointer_8(match_data8);
+   }
+
+   void destroy()
+   {
+      pcre2_code_free_8( rUtf8 );
+      pcre2_match_data_free_8( match_data8 );
+
+      #ifdef HX_SMART_STRINGS
+      pcre2_code_free_16( rUtf16 );
+      pcre2_match_data_free_16( match_data16 );
+      #endif
+   }
+
+   void __Mark(hx::MarkContext *__inCtx) { HX_MARK_MEMBER(string); HX_MARK_MEMBER(expr); }
+   #ifdef HXCPP_VISIT_ALLOCS
+   void __Visit(hx::VisitContext *__inCtx) { HX_VISIT_MEMBER(string); HX_VISIT_MEMBER(expr); }
+   #endif
+
+   static void finalize(Dynamic obj)
+   {
+      ((pcredata *)(obj.mPtr))->destroy();
+   }
+
+   String toString() { return expr; }
+};
+
+
+/**
+   regexp_new_options : reg:string -> options:string -> 'regexp
+   <doc>Build a new regexpr with the following options :
+   <ul>
+      <li>i : case insensitive matching</li>
+      <li>s : . match anything including newlines</li>
+      <li>m : treat the input as a multiline string</li>
+      <li>u : run in utf8 mode</li>
+      <li>g : turn off greedy behavior</li>
+   </ul>
+   </doc>
+**/
+
+Dynamic _hx_regexp_new_options(String s, String opt)
+{
+   hx::strbuf buf;
+   const char *o = opt.utf8_str(&buf);
+   int options = PCRE2_UCP | PCRE2_UTF;
+   while( *o )
+   {
+      switch( *o++ )
+      {
+      case 'i':
+         options |= PCRE2_CASELESS;
+         break;
+      case 's':
+         options |= PCRE2_DOTALL;
+         break;
+      case 'm':
+         options |= PCRE2_MULTILINE;
+         break;
+      case 'g':
+         options |= PCRE2_UNGREEDY;
+         break;
+      case 'u':
+         break;
+      default:
+         hx::Throw( HX_CSTRING("Regexp unknown modifier : ") + String::fromCharCode(o[-1]) );
+         break;
+      }
+   }
+
+   #ifdef HX_SMART_STRINGS
+   if (s.isUTF16Encoded())
+   {
+      int error_code;
+      size_t error_offset;
+      pcre2_code_16 *p = pcre2_compile_16((PCRE2_SPTR16)s.raw_wptr(),s.length,options,&error_code,&error_offset,NULL);
+      if( !p ) {
+         regexp_compilation_error(s,error_code,error_offset);
+      }
+
+      pcredata *pdata = new pcredata;
+      pdata->create16(p,s,options);
+      return pdata;
+   }
+   else
+   #endif
+   {
+      int error_code = 0;
+      size_t error_offset;
+      pcre2_code_8 *p =  pcre2_compile_8((PCRE2_SPTR8)s.utf8_str(),s.length,options,&error_code,&error_offset,NULL);
+      if( !p ) {
+         regexp_compilation_error(s,error_code,error_offset);
+      }
+
+      pcredata *pdata = new pcredata;
+      pdata->create8(p,s,options);
+      return pdata;
+   }
+}
+
+bool _hx_regexp_match(Dynamic handle, String string, int pos, int len)
+{
+   if( pos < 0 || len < 0 || pos > string.length || pos + len > string.length )
+      return false;
+
+   pcredata *d = PCRE(handle);
+
+   if( d->run(string,pos,len) )
+   {
+      d->string = string;
+      HX_OBJ_WB_GET(d, d->string.raw_ref());
+      return true;
+   }
+   else
+   {
+      d->string = String();
+      return false;
+   }
+}
+
+String _hx_regexp_matched(Dynamic handle, int m)
+{
+   pcredata *d = PCRE(handle);
+
+   if( m < 0 || m >= d->n_groups || !d->string.raw_ptr() )
+      hx::Throw( HX_CSTRING("regexp_matched - no valid match"));
+
+   size_t* matches = d->get_matches();
+   int start = matches[m*2];
+   int len = matches[m*2+1] - start;
+   if( start == -1 )
+      return String();
+   return d->string.substr(start, len);
+}
+
+/**
+   regexp_matched_pos : 'regexp -> n:int -> { pos => int, len => int }
+   <doc>Return the [n]th matched block position by the regexp. If [n] is 0 then
+   return the whole matched substring position</doc>
+**/
+Dynamic _hx_regexp_matched_pos(Dynamic handle, int m)
+{
+   pcredata *d = PCRE(handle);
+   if (m < 0 || m >= d->n_groups || !d->string.raw_ptr())
+      return null();
+
+   size_t* matches = d->get_matches();
+   int start = matches[m*2];
+   int len = matches[m*2+1] - start;
+
+   return hx::Anon_obj::Create(2)
+            ->setFixed(0,HX_("len",d5,4b,52,00),len)
+            ->setFixed(1,HX_("pos",94,5d,55,00),start);
+}
+
+/**
+   regexp_matched_num : 'regexp -> int
+   <doc>Return the total number of matched groups, or -1 if the regexp has not
+   been matched yet</doc>
+**/
+int _hx_regexp_matched_num(Dynamic handle)
+{
+   pcredata *d = PCRE(handle);
+
+   if( !d->string.raw_ptr() )
+      return -1;
+   else
+      return d->n_groups;
+}
+
+
diff --git a/Sources/c_snikket/src/hx/libs/regexp/pcre2_sources.xml b/Sources/c_snikket/src/hx/libs/regexp/pcre2_sources.xml
new file mode 100644
index 0000000..a70d8fa
--- /dev/null
+++ b/Sources/c_snikket/src/hx/libs/regexp/pcre2_sources.xml
@@ -0,0 +1,35 @@
+<xml>
+  <compilerflag value="-DHAVE_CONFIG_H" />
+  <compilerflag value="-DPCRE2_STATIC" />
+  <compilerflag value="-DSUPPORT_UNICODE" />
+  <compilerflag value="-I${PCRE_DIR}" />
+  <compilerflag value="-std=c99" unless="MSVC_VER" />
+
+  <file name="${PCRE_DIR}/pcre2_auto_possess.c" />
+  <file name="${PCRE_DIR}/pcre2_chartables.c" />
+  <file name="${PCRE_DIR}/pcre2_compile.c" />
+  <file name="${PCRE_DIR}/pcre2_config.c" />
+  <file name="${PCRE_DIR}/pcre2_context.c" />
+  <file name="${PCRE_DIR}/pcre2_convert.c" />
+  <file name="${PCRE_DIR}/pcre2_dfa_match.c" />
+  <file name="${PCRE_DIR}/pcre2_error.c" />
+  <file name="${PCRE_DIR}/pcre2_extuni.c" />
+  <file name="${PCRE_DIR}/pcre2_find_bracket.c" />
+  <file name="${PCRE_DIR}/pcre2_jit_compile.c" />
+  <file name="${PCRE_DIR}/pcre2_maketables.c" />
+  <file name="${PCRE_DIR}/pcre2_match.c" />
+  <file name="${PCRE_DIR}/pcre2_match_data.c" />
+  <file name="${PCRE_DIR}/pcre2_newline.c" />
+  <file name="${PCRE_DIR}/pcre2_ord2utf.c" />
+  <file name="${PCRE_DIR}/pcre2_pattern_info.c" />
+  <file name="${PCRE_DIR}/pcre2_script_run.c" />
+  <file name="${PCRE_DIR}/pcre2_serialize.c" />
+  <file name="${PCRE_DIR}/pcre2_string_utils.c" />
+  <file name="${PCRE_DIR}/pcre2_study.c" />
+  <file name="${PCRE_DIR}/pcre2_substitute.c" />
+  <file name="${PCRE_DIR}/pcre2_substring.c" />
+  <file name="${PCRE_DIR}/pcre2_tables.c" />
+  <file name="${PCRE_DIR}/pcre2_ucd.c" />
+  <file name="${PCRE_DIR}/pcre2_valid_utf.c" />
+  <file name="${PCRE_DIR}/pcre2_xclass.c" />
+</xml>
\ No newline at end of file
diff --git a/Sources/c_snikket/src/hx/libs/sqlite/Build.xml b/Sources/c_snikket/src/hx/libs/sqlite/Build.xml
new file mode 100644
index 0000000..40f9246
--- /dev/null
+++ b/Sources/c_snikket/src/hx/libs/sqlite/Build.xml
@@ -0,0 +1,25 @@
+<xml>
+
+<pragma once="true" />
+
+<set name="SQLITE_DIR" value="${HXCPP}/project/thirdparty/sqlite-3.49.1"/>
+
+<files id="hxcpp_sqlite" dir="${this_dir}" >
+  <depend files="hxcpp-depends"/>
+  <depend name="${this_dir}/Build.xml" dateOnly="true" />
+  <cache value="true" asLibrary="true" />
+
+  <compilerflag value="-I${SQLITE_DIR}"/>
+
+  <file name="Sqlite.cpp"/>
+
+  <depend name="${SQLITE_DIR}/sqlite3.h" />
+  <file name="${SQLITE_DIR}/sqlite3.c" tags="" />
+</files>
+
+<target id="haxe">
+  <files id="hxcpp_sqlite"/>
+  <lib name="-lpthread" if="linux" unless="static_link" />
+</target>
+
+</xml>
diff --git a/Sources/c_snikket/src/hx/libs/sqlite/Sqlite.cpp b/Sources/c_snikket/src/hx/libs/sqlite/Sqlite.cpp
new file mode 100644
index 0000000..211c934
--- /dev/null
+++ b/Sources/c_snikket/src/hx/libs/sqlite/Sqlite.cpp
@@ -0,0 +1,404 @@
+/*
+ * Copyright (C)2005-2012 Haxe Foundation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <hxcpp.h>
+#include "sqlite3.h"
+#include <stdlib.h>
+
+
+// Put in anon-namespace to avoid conflicts if static-linked
+namespace {
+
+
+
+struct result : public hx::Object
+{
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdSqlite };
+
+   sqlite3 *db;
+   sqlite3_stmt *r;
+   int ncols;
+   int count;
+   String *names;
+   int *bools;
+   int done;
+   int first;
+
+   void create(sqlite3 *inDb, sqlite3_stmt *inR, String sql)
+   {
+      _hx_set_finalizer(this, finalize);
+
+      db = inDb;
+      r = inR;
+
+      ncols = sqlite3_column_count(r);
+      names = (String *)malloc(sizeof(String)*ncols);
+      bools = (int*)malloc(sizeof(int)*ncols);
+      first = 1;
+      done = 0;
+      for(int i=0;i<ncols;i++)
+      {
+         names[i] = String::createPermanent(sqlite3_column_name(r,i),-1);
+         for(int j=0;j<i;j++)
+            if( names[j] == names[i] )
+               hx::Throw(HX_CSTRING("Error, same field is two times in the request ") + sql);
+
+         const char *dtype = sqlite3_column_decltype(r,i);
+         bools[i] = dtype?(strcmp(dtype,"BOOL") == 0):0;
+      }
+   }
+
+   static void finalize(Dynamic obj) { ((result *)(obj.mPtr))->destroy(false); }
+   void destroy(bool inThrowError)
+   {
+      if (bools)
+      {
+         free(bools);
+         bools = 0;
+      }
+      if (names)
+      {
+         free(names);
+         names = 0;
+      }
+      if (r)
+      {
+         first = 0;
+         done = 1;
+         if( ncols == 0 )
+            count = sqlite3_changes(db);
+
+         bool err = sqlite3_finalize(r) != SQLITE_OK;
+         db = 0;
+         r = 0;
+
+         if( err && inThrowError)
+            hx::Throw(HX_CSTRING("Could not finalize request"));
+      }
+   }
+
+   String toString() { return HX_CSTRING("Sqlite Result"); }
+
+ //static void finalize_result( result *r, int exc, bool throwError = true )
+};
+
+
+
+/**
+   <doc>
+   <h1>SQLite</h1>
+   <p>
+   Sqlite is a small embeddable SQL database that store all its data into
+   a single file. See http://sqlite.org for more details.
+   </p>
+   </doc>
+**/
+
+struct database : public hx::Object
+{
+   sqlite3 *db;
+   hx::ObjectPtr<result> last;
+
+   void create(sqlite3 *inDb)
+   {
+      db = inDb;
+      _hx_set_finalizer(this, finalize);
+   }
+   static void finalize(Dynamic obj) { ((database *)(obj.mPtr))->destroy(false); }
+   void destroy(bool inThrowError)
+   {
+      if (db)
+      {
+         if (last.mPtr)
+         {
+            last->destroy(inThrowError);
+            last = null();
+         }
+
+         if( sqlite3_close(db) != SQLITE_OK )
+         {
+            if (inThrowError)
+               hx::Throw(HX_CSTRING("Sqlite: could not close"));
+         }
+         db = 0;
+      }
+   }
+
+
+   void setResult(result *inResult)
+   {
+      if (last.mPtr)
+         last->destroy(true);
+
+      last = inResult;
+      HX_OBJ_WB_GET(this, last.mPtr);
+   }
+
+   void __Mark(hx::MarkContext *__inCtx) { HX_MARK_MEMBER(last); }
+   #ifdef HXCPP_VISIT_ALLOCS
+   void __Visit(hx::VisitContext *__inCtx) { HX_VISIT_MEMBER(last); }
+   #endif
+
+   String toString() { return HX_CSTRING("Sqlite Databse"); }
+};
+
+static void sqlite_error( sqlite3 *db ) {
+   hx::Throw( HX_CSTRING("Sqlite error : ") + String(sqlite3_errmsg(db)) );
+}
+
+database *getDatabase(Dynamic handle)
+{
+   database *db = dynamic_cast<database *>(handle.mPtr);
+   if (!db || !db->db)
+      hx::Throw( HX_CSTRING("Invalid sqlite database") );
+   return db;
+}
+
+
+result *getResult(Dynamic handle, bool inRequireStatement)
+{
+   result *r = dynamic_cast<result *>(handle.mPtr);
+   if (!r || (inRequireStatement && !r->r))
+      hx::Throw( HX_CSTRING("Invalid sqlite result") );
+   return r;
+}
+
+
+} // End anon-namespace
+
+
+
+
+/**
+   connect : filename:string -> 'db
+   <doc>Open or create the database stored in the specified file.</doc>
+**/
+Dynamic _hx_sqlite_connect(String filename)
+{
+   int err;
+   sqlite3 *sqlDb = 0;
+   if( (err = sqlite3_open(filename.utf8_str(),&sqlDb)) != SQLITE_OK )
+      sqlite_error(sqlDb);
+
+   database *db = new database();
+   db->create(sqlDb);
+   return db;
+}
+
+
+/**
+   close : 'db -> void
+   <doc>Closes the database.</doc>
+**/
+void _hx_sqlite_close(Dynamic handle)
+{
+   database *db = getDatabase(handle);
+   db->destroy(true);
+}
+
+/**
+   last_insert_id : 'db -> int
+   <doc>Returns the last inserted auto_increment id.</doc>
+**/
+int     _hx_sqlite_last_insert_id(Dynamic handle)
+{
+   database *db = getDatabase(handle);
+   return sqlite3_last_insert_rowid(db->db);
+}
+
+/**
+   request : 'db -> sql:string -> 'result
+   <doc>Executes the SQL request and returns its result</doc>
+**/
+Dynamic _hx_sqlite_request(Dynamic handle,String sql)
+{
+   database *db = getDatabase(handle);
+
+   int byteLength = 0;
+   const char * sqlStr = sql.utf8_str(0, true, &byteLength);
+   sqlite3_stmt *statement = 0;
+   const char *tl = 0;
+   if( sqlite3_prepare(db->db,sqlStr,byteLength,&statement,&tl) != SQLITE_OK )
+   {
+      hx::Throw( HX_CSTRING("Sqlite error in ") + sql + HX_CSTRING(" : ") +
+                  String(sqlite3_errmsg(db->db) ) );
+   }
+   if( *tl )
+   {
+      sqlite3_finalize(statement);
+      hx::Throw(HX_CSTRING("Cannot execute several SQL requests at the same time"));
+   }
+
+   int i,j;
+
+   result *r = new result();
+   r->create(db->db, statement,sql);
+
+   db->setResult(r);
+
+   return r;
+}
+
+
+
+
+
+
+
+/**
+   result_get_length : 'result -> int
+   <doc>Returns the number of rows in the result or the number of rows changed by the request.</doc>
+**/
+int  _hx_sqlite_result_get_length(Dynamic handle)
+{
+   result *r = getResult(handle,false);
+   if( r->ncols != 0 )
+      hx::Throw(HX_CSTRING("Getting change count from non-change request")); // ???
+   return r->count;
+}
+
+/**
+   result_get_nfields : 'result -> int
+   <doc>Returns the number of fields in the result.</doc>
+**/
+int     _hx_sqlite_result_get_nfields(Dynamic handle)
+{
+   return getResult(handle,false)->ncols;
+}
+
+/**
+   result_next : 'result -> object?
+   <doc>Returns the next row in the result or [null] if no more result.</doc>
+**/
+
+Dynamic _hx_sqlite_result_next(Dynamic handle)
+{
+   result *r = getResult(handle,false);
+   if( r->done )
+      return null();
+
+   switch( sqlite3_step(r->r) )
+   {
+      case SQLITE_ROW:
+      {
+         hx::Anon v = hx::Anon_obj::Create();
+         r->first = 0;
+         for(int i=0;i<r->ncols;i++)
+         {
+            Dynamic f;
+            switch( sqlite3_column_type(r->r,i) )
+            {
+            case SQLITE_NULL:
+               break;
+            case SQLITE_INTEGER:
+               if( r->bools[i] )
+                  f = bool(sqlite3_column_int(r->r,i));
+               else
+                  f = int(sqlite3_column_int(r->r,i));
+               break;
+            case SQLITE_FLOAT:
+               f = Float(sqlite3_column_double(r->r,i));
+               break;
+            case SQLITE_TEXT:
+               f = String((char*)sqlite3_column_text(r->r,i));
+               break;
+            case SQLITE_BLOB:
+               {
+                  int size = sqlite3_column_bytes(r->r,i);
+                  f = Array_obj<unsigned char>::fromData((const unsigned char *)sqlite3_column_blob(r->r,i),size);
+                  break;
+               }
+            default:
+               {
+                  hx::Throw( HX_CSTRING("Unknown Sqlite type #") +
+                               String((int)sqlite3_column_type(r->r,i)));
+               }
+            }
+            v->__SetField(r->names[i],f,hx::paccDynamic);
+         }
+         return v;
+      }
+      case SQLITE_DONE:
+         r->destroy(true);
+         return null();
+      case SQLITE_BUSY:
+         hx::Throw(HX_CSTRING("Database is busy"));
+      case SQLITE_ERROR:
+         sqlite_error(r->db);
+      default:
+         hx::Throw(HX_CSTRING("Unkown sqlite result"));
+   }
+
+   return null();
+}
+
+
+static sqlite3_stmt *prepStatement(Dynamic handle,int n)
+{
+   result *r = getResult(handle,true);
+   if( n < 0 || n >= r->ncols )
+      hx::Throw( HX_CSTRING("Sqlite: Invalid index") );
+
+   if( r->first )
+      _hx_sqlite_result_next(handle);
+
+   if( r->done )
+      hx::Throw( HX_CSTRING("Sqlite: no more results") );
+
+   return r->r;
+}
+
+/**
+   result_get : 'result -> n:int -> string
+   <doc>Return the [n]th field of the current result row.</doc>
+**/
+
+
+String  _hx_sqlite_result_get(Dynamic handle,int n)
+{
+   sqlite3_stmt *r = prepStatement(handle,n);
+   return String((char*)sqlite3_column_text(r,n));
+}
+
+/**
+   result_get_int : 'result -> n:int -> int
+   <doc>Return the [n]th field of the current result row as an integer.</doc>
+**/
+int     _hx_sqlite_result_get_int(Dynamic handle,int n)
+{
+   sqlite3_stmt *r = prepStatement(handle,n);
+   return sqlite3_column_int(r,n);
+}
+
+/**
+   result_get_float : 'result -> n:int -> float
+   <doc>Return the [n]th field of the current result row as a float.</doc>
+**/
+Float   _hx_sqlite_result_get_float(Dynamic handle,int n)
+{
+   sqlite3_stmt *r = prepStatement(handle,n);
+   return sqlite3_column_double(r,n);
+}
+
+
+
+
diff --git a/Sources/c_snikket/src/hx/libs/ssl/SSL.cpp b/Sources/c_snikket/src/hx/libs/ssl/SSL.cpp
new file mode 100644
index 0000000..2c4904a
--- /dev/null
+++ b/Sources/c_snikket/src/hx/libs/ssl/SSL.cpp
@@ -0,0 +1,898 @@
+#include <string.h>
+
+#ifdef HX_WINDOWS
+#   include <winsock2.h>
+#   include <wincrypt.h>
+#else
+#   include <sys/socket.h>
+#   include <strings.h>
+#   include <errno.h>
+typedef int SOCKET;
+#endif
+
+
+#include <hxcpp.h>
+#include <hx/OS.h>
+
+#if defined(NEKO_MAC) && !defined(IPHONE) && !defined(APPLETV)
+#include <Security/Security.h>
+#endif
+
+typedef size_t socket_int;
+
+#define SOCKET_ERROR (-1)
+#define NRETRYS	20
+
+#include "mbedtls/error.h"
+#include "mbedtls/entropy.h"
+#include "mbedtls/ctr_drbg.h"
+#include "mbedtls/md.h"
+#include "mbedtls/pk.h"
+#include "mbedtls/oid.h"
+#include "mbedtls/x509_crt.h"
+#include "mbedtls/ssl.h"
+#include "mbedtls/net.h"
+#include "mbedtls/debug.h"
+
+#define val_ssl(o)	((sslctx*)o.mPtr)
+#define val_conf(o)	((sslconf*)o.mPtr)
+#define val_cert(o) ((sslcert*)o.mPtr)
+#define val_pkey(o) ((sslpkey*)o.mPtr)
+
+struct SocketWrapper : public hx::Object
+{
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdSocket };
+   SOCKET socket;
+};
+
+struct sslctx : public hx::Object
+{
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdSsl };
+
+	mbedtls_ssl_context *s;
+
+	void create()
+	{
+		s = (mbedtls_ssl_context *)malloc(sizeof(mbedtls_ssl_context));
+		mbedtls_ssl_init(s);
+		_hx_set_finalizer(this, finalize);
+	}
+
+	void destroy()
+	{
+		if( s )
+		{
+			mbedtls_ssl_free( s );
+			free(s);
+			s = 0;
+		}
+	}
+
+	static void finalize(Dynamic obj)
+	{
+		((sslctx *)(obj.mPtr))->destroy();
+	}
+
+	String toString() { return HX_CSTRING("sslctx"); }
+};
+
+struct sslconf : public hx::Object
+{
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdSslConf };
+
+	mbedtls_ssl_config *c;
+
+	void create()
+	{
+		c = (mbedtls_ssl_config *)malloc(sizeof(mbedtls_ssl_config));
+		mbedtls_ssl_config_init(c);
+		_hx_set_finalizer(this, finalize);
+	}
+
+	void destroy()
+	{
+		if( c )
+		{
+			mbedtls_ssl_config_free( c );
+			free(c);
+			c = 0;
+		}
+	}
+
+	static void finalize(Dynamic obj)
+	{
+		((sslconf *)(obj.mPtr))->destroy();
+	}
+
+	String toString() { return HX_CSTRING("sslconfig"); }
+};
+
+struct sslcert : public hx::Object
+{
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdSslCert };
+
+	mbedtls_x509_crt *c;
+	bool head;
+
+	void create(const mbedtls_x509_crt *inC)
+	{
+
+		if( inC ){
+			c = (mbedtls_x509_crt *)inC;
+			head = false;
+		}else{
+			c = (mbedtls_x509_crt *)malloc(sizeof(mbedtls_x509_crt));
+			mbedtls_x509_crt_init(c);
+			head = true;
+		}
+		_hx_set_finalizer(this, finalize);
+	}
+
+	void destroy()
+	{
+		if( c && head )
+		{
+			mbedtls_x509_crt_free( c );
+			free(c);
+			head = 0;
+		}
+		c = 0;
+	}
+
+	static void finalize(Dynamic obj)
+	{
+		((sslcert *)(obj.mPtr))->destroy();
+	}
+
+	String toString() { return HX_CSTRING("sslcert"); }
+};
+
+struct sslpkey : public hx::Object
+{
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdSslKey };
+
+	mbedtls_pk_context *k;
+
+	void create()
+	{
+		k = (mbedtls_pk_context *)malloc(sizeof(mbedtls_pk_context));
+		mbedtls_pk_init(k);
+		_hx_set_finalizer(this, finalize);
+	}
+
+	void destroy()
+	{
+		if( k )
+		{
+			mbedtls_pk_free(k);
+			free(k);
+			k = 0;
+		}
+	}
+
+	static void finalize(Dynamic obj)
+	{
+		((sslpkey *)(obj.mPtr))->destroy();
+	}
+
+	String toString() { return HX_CSTRING("sslpkey"); }
+};
+
+static mbedtls_entropy_context entropy;
+static mbedtls_ctr_drbg_context ctr_drbg;
+
+static bool is_ssl_blocking( int r ) {
+	return r == MBEDTLS_ERR_SSL_WANT_READ || r == MBEDTLS_ERR_SSL_WANT_WRITE;
+}
+
+static bool is_block_error() {
+	#ifdef NEKO_WINDOWS
+	int err = WSAGetLastError();
+	if( err == WSAEWOULDBLOCK || err == WSAEALREADY || err == WSAETIMEDOUT )
+	#else
+	if( errno == EAGAIN || errno == EWOULDBLOCK || errno == EINPROGRESS || errno == EALREADY )
+	#endif
+		return true;
+	return false;
+}
+
+static void ssl_error( int ret ){
+	char buf[256];
+	mbedtls_strerror(ret, buf, sizeof(buf));
+	hx::Throw( String(buf) );
+}
+
+Dynamic _hx_ssl_new( Dynamic hconf ) {
+	int ret;
+	sslctx *ssl = new sslctx();
+	ssl->create();
+	sslconf *conf = val_conf(hconf);
+	if( ret = mbedtls_ssl_setup(ssl->s, conf->c) != 0 ){
+		ssl->destroy();
+		ssl_error(ret);
+	}
+	return ssl;
+}
+
+void _hx_ssl_close( Dynamic hssl ) {
+	sslctx *ssl = val_ssl(hssl);
+	ssl->destroy();
+}
+
+void _hx_ssl_debug_set (int i) {
+	mbedtls_debug_set_threshold(i);
+}
+
+void _hx_ssl_handshake( Dynamic hssl ) {
+	int r;
+	sslctx *ssl = val_ssl(hssl);
+	POSIX_LABEL(handshake_again);
+	r = mbedtls_ssl_handshake( ssl->s );
+	if ( is_ssl_blocking(r) ) {
+		HANDLE_EINTR(handshake_again);
+		hx::Throw(HX_CSTRING("Blocking"));
+	}else if( r == SOCKET_ERROR ) {
+		HANDLE_EINTR(handshake_again);
+		hx::Throw(HX_CSTRING("ssl network error"));
+	}else if( r != 0 )
+		ssl_error(r);
+}
+
+int net_read( void *fd, unsigned char *buf, size_t len ){
+	hx::EnterGCFreeZone();
+	int r = recv((SOCKET)(socket_int)fd, (char *)buf, len, 0);
+ 	if( r == SOCKET_ERROR && is_block_error() )
+ 		r = MBEDTLS_ERR_SSL_WANT_READ;
+	hx::ExitGCFreeZone();
+	return r;
+}
+
+int net_write( void *fd, const unsigned char *buf, size_t len ){
+	hx::EnterGCFreeZone();
+	int r = send((SOCKET)(socket_int)fd, (char *)buf, len, 0);
+	if( r == SOCKET_ERROR && is_block_error() )
+ 		r = MBEDTLS_ERR_SSL_WANT_WRITE;
+	hx::ExitGCFreeZone();
+	return r;
+}
+
+void _hx_ssl_set_socket( Dynamic hssl, Dynamic hsocket ) {
+	sslctx *ssl = val_ssl(hssl);
+	SocketWrapper *socket = (SocketWrapper *)hsocket.mPtr;
+	mbedtls_ssl_set_bio( ssl->s, (void *)(socket_int)socket->socket, net_write, net_read, NULL );
+}
+
+void _hx_ssl_set_hostname( Dynamic hssl, String hostname ){
+	int ret;
+	sslctx *ssl = val_ssl(hssl);
+	hx::strbuf buf;
+	if( ret = mbedtls_ssl_set_hostname(ssl->s, hostname.utf8_str(&buf)) != 0 )
+		ssl_error(ret);
+}
+
+Dynamic _hx_ssl_get_peer_certificate( Dynamic hssl ){
+	sslctx *ssl = val_ssl(hssl);
+	const mbedtls_x509_crt *crt = mbedtls_ssl_get_peer_cert(ssl->s);
+	if( crt == NULL )
+		return null();
+	sslcert *cert = new sslcert();
+	cert->create( crt );
+	return cert;
+}
+
+bool _hx_ssl_get_verify_result( Dynamic hssl ){
+	sslctx *ssl = val_ssl(hssl);
+	int r = mbedtls_ssl_get_verify_result( ssl->s );
+	if( r == 0 )
+		return true;
+	else if( r != -1 )
+		return false;
+	hx::Throw( HX_CSTRING("not available") );
+	return false;
+}
+
+void _hx_ssl_send_char( Dynamic hssl, int c ) {
+	if( c < 0 || c > 255 )
+		hx::Throw( HX_CSTRING("invalid char") );
+	sslctx *ssl = val_ssl(hssl);
+	const unsigned char cc = c;
+	mbedtls_ssl_write( ssl->s, &cc, 1 );
+}
+
+int _hx_ssl_send( Dynamic hssl, Array<unsigned char> buf, int p, int l ) {
+	sslctx *ssl = val_ssl(hssl);
+	int dlen = buf->length;
+	if( p < 0 || l < 0 || p > dlen || p + l > dlen )
+		hx::Throw( HX_CSTRING("ssl_send") );
+	POSIX_LABEL(send_again);
+	const unsigned char *base = (const unsigned char *)&buf[0];
+	dlen = mbedtls_ssl_write( ssl->s, base + p, l );
+	if ( is_ssl_blocking(dlen) ) {
+		HANDLE_EINTR(send_again);
+		hx::Throw(HX_CSTRING("Blocking"));
+	}else if( dlen == SOCKET_ERROR ) {
+		HANDLE_EINTR(send_again);
+		hx::Throw(HX_CSTRING("ssl network error"));
+	}
+	return dlen;
+}
+
+void _hx_ssl_write( Dynamic hssl, Array<unsigned char> buf ) {
+	sslctx *ssl = val_ssl(hssl);
+	int len = buf->length;
+	unsigned char *cdata = &buf[0];
+	while( len > 0 ) {
+		POSIX_LABEL( write_again );
+		int slen = mbedtls_ssl_write( ssl->s, cdata, len );
+		if ( is_ssl_blocking(slen) ) {
+			HANDLE_EINTR( write_again );
+			hx::Throw(HX_CSTRING("Blocking"));
+		}else if( slen == SOCKET_ERROR ) {
+			HANDLE_EINTR( write_again );
+			hx::Throw(HX_CSTRING("ssl network error"));
+		}
+		cdata += slen;
+		len -= slen;
+	}
+}
+
+int _hx_ssl_recv_char( Dynamic hssl ) {
+	sslctx *ssl = val_ssl(hssl);
+	unsigned char cc;
+	int r = mbedtls_ssl_read( ssl->s, &cc, 1 );
+	if( r <= 0 )
+		hx::Throw( HX_CSTRING("ssl_recv_char") );
+	return (int)cc;
+}
+
+int _hx_ssl_recv( Dynamic hssl, Array<unsigned char> buf, int p, int l ) {
+	sslctx *ssl = val_ssl(hssl);
+	int dlen = buf->length;
+	if( p < 0 || l < 0 || p > dlen || p + l > dlen )
+		hx::Throw( HX_CSTRING("ssl_recv") );
+
+	unsigned char *base = &buf[0];
+	POSIX_LABEL(recv_again);
+	dlen = mbedtls_ssl_read( ssl->s, base + p, l );
+	if ( is_ssl_blocking(dlen) ) {
+		HANDLE_EINTR(recv_again);
+		hx::Throw(HX_CSTRING("Blocking"));
+	}else if( dlen == SOCKET_ERROR ) {
+		HANDLE_EINTR(recv_again);
+		hx::Throw(HX_CSTRING("ssl network error"));
+	}
+	if( dlen < 0 ) {  
+                if( dlen == MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY ) {
+                  mbedtls_ssl_close_notify( ssl->s );
+	  	  return 0;
+                }
+		hx::Throw( HX_CSTRING("ssl_recv") ); 
+	}
+	return dlen;
+}
+
+Array<unsigned char> _hx_ssl_read( Dynamic hssl ) {
+	sslctx *ssl = val_ssl(hssl);
+	Array<unsigned char> result = Array_obj<unsigned char>::__new();
+	unsigned char buf[256];
+
+	while( true ) {
+		POSIX_LABEL(read_again);
+		int len = mbedtls_ssl_read( ssl->s, buf, 256 );
+		if ( is_ssl_blocking(len) ) {
+			HANDLE_EINTR(read_again);
+			hx::Throw(HX_CSTRING("Blocking"));
+		}else if( len == SOCKET_ERROR ) {
+			HANDLE_EINTR(read_again);
+			hx::Throw(HX_CSTRING("ssl network error"));
+		}
+                if( len == MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY ) {
+                  mbedtls_ssl_close_notify( ssl->s );
+	  	  len = 0;
+                }
+		if( len == 0 )
+			break;
+		result->memcpy(result->length, buf, len);
+	}
+	return result;
+}
+
+#ifdef NEKO_WINDOWS
+static int verify_callback(void* param, mbedtls_x509_crt *crt, int depth, uint32_t *flags) {
+	if (*flags == 0 || *flags & MBEDTLS_X509_BADCERT_CN_MISMATCH) {
+		return 0;
+	}
+
+	HCERTSTORE store = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0, CERT_STORE_DEFER_CLOSE_UNTIL_LAST_FREE_FLAG, NULL);
+	if(store == NULL) {
+		return MBEDTLS_ERR_X509_FATAL_ERROR;
+	}
+	PCCERT_CONTEXT primary_context = {0};
+	if(!CertAddEncodedCertificateToStore(store, X509_ASN_ENCODING, crt->raw.p, crt->raw.len, CERT_STORE_ADD_REPLACE_EXISTING, &primary_context)) {
+		CertCloseStore(store, 0);
+		return MBEDTLS_ERR_X509_FATAL_ERROR;
+	}
+	PCCERT_CHAIN_CONTEXT chain_context = {0};
+	CERT_CHAIN_PARA parameters = {0};
+	if(!CertGetCertificateChain(NULL, primary_context, NULL, store, &parameters, 0, NULL, &chain_context)) {
+		CertFreeCertificateContext(primary_context);
+		CertCloseStore(store, 0);
+		return MBEDTLS_ERR_X509_FATAL_ERROR;
+	}
+	CERT_CHAIN_POLICY_PARA policy_parameters = {0};
+	CERT_CHAIN_POLICY_STATUS policy_status = {0};
+	if(!CertVerifyCertificateChainPolicy(CERT_CHAIN_POLICY_SSL, chain_context, &policy_parameters, &policy_status)) {
+		CertFreeCertificateChain(chain_context);
+		CertFreeCertificateContext(primary_context);
+		CertCloseStore(store, 0);
+		return MBEDTLS_ERR_X509_FATAL_ERROR;
+	}
+	if(policy_status.dwError == 0) {
+		*flags = 0;
+	} else {
+		// if we ever want to read the verification result,
+		// we need to properly map dwError to flags
+		*flags |= MBEDTLS_X509_BADCERT_OTHER;
+	}
+	CertFreeCertificateChain(chain_context);
+	CertFreeCertificateContext(primary_context);
+	CertCloseStore(store, 0);
+	return 0;
+}
+#endif
+
+Dynamic _hx_ssl_conf_new( bool server ) {
+	int ret;
+	sslconf *conf = new sslconf();
+	conf->create();
+	if( ret = mbedtls_ssl_config_defaults( conf->c,
+		server ? MBEDTLS_SSL_IS_SERVER : MBEDTLS_SSL_IS_CLIENT,
+		MBEDTLS_SSL_TRANSPORT_STREAM, 0 ) != 0 ){
+		conf->destroy();
+		ssl_error( ret );
+	}
+#ifdef NEKO_WINDOWS
+	mbedtls_ssl_conf_verify(conf->c, verify_callback, NULL);
+#endif
+	mbedtls_ssl_conf_rng( conf->c, mbedtls_ctr_drbg_random, &ctr_drbg );
+	return conf;
+}
+
+void _hx_ssl_conf_close( Dynamic hconf ) {
+	sslconf *conf = val_conf(hconf);
+	conf->destroy();
+}
+
+void _hx_ssl_conf_set_ca( Dynamic hconf, Dynamic hcert ) {
+	sslconf *conf = val_conf(hconf);
+	if( hconf.mPtr ){
+		sslcert *cert = val_cert(hcert);
+		mbedtls_ssl_conf_ca_chain( conf->c, cert->c, NULL );
+	}else{
+		mbedtls_ssl_conf_ca_chain( conf->c, NULL, NULL );
+	}
+}
+
+void _hx_ssl_conf_set_verify( Dynamic hconf, int mode ) {
+	sslconf *conf = val_conf(hconf);
+	if( mode == 2 )
+		mbedtls_ssl_conf_authmode(conf->c, MBEDTLS_SSL_VERIFY_OPTIONAL);
+	else if( mode == 1 )
+		mbedtls_ssl_conf_authmode(conf->c, MBEDTLS_SSL_VERIFY_REQUIRED);
+	else
+		mbedtls_ssl_conf_authmode(conf->c, MBEDTLS_SSL_VERIFY_NONE);
+}
+
+void _hx_ssl_conf_set_cert( Dynamic hconf, Dynamic hcert, Dynamic hpkey ) {
+	int r;
+	sslconf *conf = val_conf(hconf);
+	sslcert *cert = val_cert(hcert);
+	sslpkey *pkey = val_pkey(hpkey);
+
+	if( r = mbedtls_ssl_conf_own_cert(conf->c, cert->c, pkey->k) != 0 )
+		ssl_error(r);
+}
+
+static int sni_callback( void *arg, mbedtls_ssl_context *ctx, const unsigned char *name, size_t len ){
+	if( name && arg ){
+		Dynamic cb = new Dynamic();
+		cb.mPtr = (hx::Object*)arg;
+		const char *n = (const char *)name;
+		Dynamic ret = cb->__run( String(n,strlen(n)) );
+		if( ret != null() ){
+			// TODO authmode and ca
+			Dynamic hcert = ret->__Field(HX_CSTRING("cert"), hx::paccDynamic);
+			Dynamic hpkey = ret->__Field(HX_CSTRING("key"), hx::paccDynamic);
+			sslcert *cert = val_cert(hcert);
+			sslpkey *pk = val_pkey(hpkey);
+
+			return mbedtls_ssl_set_hs_own_cert( ctx, cert->c, pk->k );
+		}
+	}
+	return -1;
+}
+
+void _hx_ssl_conf_set_servername_callback( Dynamic hconf, Dynamic cb ){
+	sslconf *conf = val_conf(hconf);
+	mbedtls_ssl_conf_sni( conf->c, sni_callback, (void *)cb.mPtr );
+}
+
+Dynamic _hx_ssl_cert_load_defaults(){
+#if defined(NEKO_WINDOWS)
+	HCERTSTORE store;
+	PCCERT_CONTEXT cert;
+	sslcert *chain = NULL;
+	if( store = CertOpenSystemStore(0, (LPCSTR)"Root") ){
+		cert = NULL;
+		while( cert = CertEnumCertificatesInStore(store, cert) ){
+			if( chain == NULL ){
+				chain = new sslcert();
+				chain->create( NULL );
+			}
+			mbedtls_x509_crt_parse_der( chain->c, (unsigned char *)cert->pbCertEncoded, cert->cbCertEncoded );
+		}
+		CertCloseStore(store, 0);
+	}
+	if( chain != NULL )
+		return chain;
+#elif defined(NEKO_MAC) && !defined(IPHONE) && !defined(APPLETV)
+	CFMutableDictionaryRef search;
+	CFArrayRef result;
+	SecKeychainRef keychain;
+	SecCertificateRef item;
+	CFDataRef dat;
+	sslcert *chain = NULL;
+
+	// Load keychain
+	if( SecKeychainOpen("/System/Library/Keychains/SystemRootCertificates.keychain",&keychain) != errSecSuccess )
+		return null();
+
+	// Search for certificates
+	search = CFDictionaryCreateMutable( NULL, 0, NULL, NULL );
+	CFDictionarySetValue( search, kSecClass, kSecClassCertificate );
+	CFDictionarySetValue( search, kSecMatchLimit, kSecMatchLimitAll );
+	CFDictionarySetValue( search, kSecReturnRef, kCFBooleanTrue );
+	CFDictionarySetValue( search, kSecMatchSearchList, CFArrayCreate(NULL, (const void **)&keychain, 1, NULL) );
+	if( SecItemCopyMatching( search, (CFTypeRef *)&result ) == errSecSuccess ){
+		CFIndex n = CFArrayGetCount( result );
+		for( CFIndex i = 0; i < n; i++ ){
+			item = (SecCertificateRef)CFArrayGetValueAtIndex( result, i );
+
+			// Get certificate in DER format
+			dat = SecCertificateCopyData( item );
+			if( dat ){
+				if( chain == NULL ){
+					chain = new sslcert();
+					chain->create( NULL );
+				}
+				mbedtls_x509_crt_parse_der( chain->c, (unsigned char *)CFDataGetBytePtr(dat), CFDataGetLength(dat) );
+				CFRelease( dat );
+			}
+		}
+	}
+	CFRelease(keychain);
+	if( chain != NULL )
+		return chain;
+#endif
+	return null();
+}
+
+Dynamic _hx_ssl_cert_load_file( String file ){
+	int r;
+	sslcert *cert = new sslcert();
+	cert->create( NULL );
+   hx::strbuf buf;
+	if( r = mbedtls_x509_crt_parse_file(cert->c, file.utf8_str(&buf)) != 0 ){
+		cert->destroy();
+		ssl_error(r);
+	}
+	return cert;
+}
+
+Dynamic _hx_ssl_cert_load_path( String path ){
+	int r;
+	sslcert *cert = new sslcert();
+	cert->create( NULL );
+   hx::strbuf buf;
+	if( r = mbedtls_x509_crt_parse_path(cert->c, path.utf8_str(&buf)) != 0 ){
+		cert->destroy();
+		ssl_error(r);
+	}
+	return cert;
+}
+
+static String asn1_buf_to_string( mbedtls_asn1_buf *dat ){
+	unsigned int i, c;
+	HX_CHAR *result = hx::NewString( dat->len );
+	for( i = 0; i < dat->len; i++ )  {
+        c = dat->p[i];
+        if( c < 32 || c == 127 || ( c > 128 && c < 160 ) )
+             result[i] = '?';
+        else
+			result[i] = c;
+    }
+	result[i] = '\0';
+	return String(result,dat->len);
+}
+
+String _hx_ssl_cert_get_subject( Dynamic hcert, String objname ){
+	mbedtls_x509_name *obj;
+	int r;
+	const char *oname;
+	sslcert *cert = val_cert(hcert);
+	obj = &cert->c->subject;
+	if( obj == NULL )
+		hx::Throw( HX_CSTRING("cert_get_subject") );
+   hx::strbuf buf;
+	while( obj != NULL ){
+		r = mbedtls_oid_get_attr_short_name( &obj->oid, &oname );
+		if( r == 0 && strcmp( oname, objname.utf8_str(&buf) ) == 0 )
+			return asn1_buf_to_string( &obj->val );
+		obj = obj->next;
+	}
+	return String();
+}
+
+String _hx_ssl_cert_get_issuer( Dynamic hcert, String objname ){
+	mbedtls_x509_name *obj;
+	int r;
+	const char *oname;
+	sslcert *cert = val_cert(hcert);
+	obj = &cert->c->issuer;
+	if( obj == NULL )
+		hx::Throw( HX_CSTRING("cert_get_issuer") );
+   hx::strbuf buf;
+	while( obj != NULL ){
+		r = mbedtls_oid_get_attr_short_name( &obj->oid, &oname );
+		if( r == 0 && strcmp( oname, objname.utf8_str(&buf) ) == 0 )
+			return asn1_buf_to_string( &obj->val );
+		obj = obj->next;
+	}
+	return String();
+}
+
+Array<String> _hx_ssl_cert_get_altnames( Dynamic hcert ){
+	sslcert *cert = val_cert(hcert);
+	mbedtls_asn1_sequence *cur;
+	Array<String> result(0,1);
+	if( cert->c->ext_types & MBEDTLS_X509_EXT_SUBJECT_ALT_NAME ){
+		cur = &cert->c->subject_alt_names;
+
+		while( cur != NULL ){
+			result.Add( asn1_buf_to_string(&cur->buf) );
+			cur = cur->next;
+		}
+	}
+	return result;
+}
+
+static Array<int> x509_time_to_array( mbedtls_x509_time *t ){
+	if( !t )
+		hx::Throw( HX_CSTRING("x509_time_to_array") );
+	Array<int> result(6,6);
+	result[0] = t->year;
+	result[1] = t->mon;
+	result[2] = t->day;
+	result[3] = t->hour;
+	result[4] = t->min;
+	result[5] = t->sec;
+	return result;
+}
+
+Array<int> _hx_ssl_cert_get_notbefore( Dynamic hcert ){
+	sslcert *cert = val_cert(hcert);
+	if( !cert->c )
+		hx::Throw( HX_CSTRING("cert_get_notbefore") );
+	return x509_time_to_array( &cert->c->valid_from );
+}
+
+Array<int> _hx_ssl_cert_get_notafter( Dynamic hcert ){
+	sslcert *cert = val_cert(hcert);
+	if( !cert->c )
+		hx::Throw( HX_CSTRING("cert_get_notafter") );
+	return x509_time_to_array( &cert->c->valid_to );
+}
+
+Dynamic _hx_ssl_cert_get_next( Dynamic hcert ){
+	sslcert *cert = val_cert(hcert);
+	mbedtls_x509_crt *crt = cert->c->next;
+	if( crt == NULL )
+		return null();
+	cert = new sslcert();
+	cert->create(crt);
+	return cert;
+}
+
+Dynamic _hx_ssl_cert_add_pem( Dynamic hcert, String data ){
+   #ifdef HX_SMART_STRINGS
+   if (data.isUTF16Encoded())
+		hx::Throw( HX_CSTRING("Invalid data encoding") );
+   #endif
+	sslcert *cert = val_cert(hcert);
+	int r;
+	bool isnew = 0;
+	if( !cert ){
+		cert = new sslcert();
+		cert->create( NULL );
+		isnew = 1;
+	}
+	unsigned char *b = (unsigned char *)malloc((data.length+1) * sizeof(unsigned char));
+	memcpy(b,data.raw_ptr(),data.length);
+	b[data.length] = '\0';
+	r = mbedtls_x509_crt_parse( cert->c, b, data.length+1 );
+	free(b);
+	if( r < 0 ){
+		if( isnew )
+			cert->destroy();
+		ssl_error(r);
+	}
+	return cert;
+}
+
+Dynamic _hx_ssl_cert_add_der( Dynamic hcert, Array<unsigned char> buf ){
+	sslcert *cert = val_cert(hcert);
+	int r;
+	bool isnew = 0;
+	if( !cert ){
+		cert = new sslcert();
+		cert->create( NULL );
+		isnew = 1;
+	}
+	if( (r = mbedtls_x509_crt_parse_der( cert->c, &buf[0], buf->length)) < 0 ){
+		if( isnew )
+			cert->destroy();
+		ssl_error(r);
+	}
+	return cert;
+}
+
+Dynamic _hx_ssl_key_from_der( Array<unsigned char> buf, bool pub ){
+	sslpkey *pk = new sslpkey();
+	pk->create();
+	int r;
+	if( pub )
+		r = mbedtls_pk_parse_public_key( pk->k, &buf[0], buf->length );
+	else
+		r = mbedtls_pk_parse_key( pk->k, &buf[0], buf->length, NULL, 0 );
+	if( r != 0 ){
+		pk->destroy();
+		ssl_error(r);
+	}
+	return pk;
+}
+
+Dynamic _hx_ssl_key_from_pem( String data, bool pub, String pass ){
+   #ifdef HX_SMART_STRINGS
+   if (data.isUTF16Encoded())
+		hx::Throw( HX_CSTRING("Invalid data encoding") );
+   #endif
+	sslpkey *pk = new sslpkey();
+	pk->create();
+	int r;
+	unsigned char *b = (unsigned char *)malloc((data.length+1) * sizeof(unsigned char));
+	memcpy(b,data.raw_ptr(),data.length);
+	b[data.length] = '\0';
+	if( pub ){
+		r = mbedtls_pk_parse_public_key( pk->k, b, data.length+1 );
+	}else if( pass == null() ){
+		r = mbedtls_pk_parse_key( pk->k, b, data.length+1, NULL, 0 );
+	}else{
+      Array<unsigned char> pbytes(0,0);
+      __hxcpp_bytes_of_string(pbytes,pass);
+		r = mbedtls_pk_parse_key( pk->k, b, data.length+1, (const unsigned char *)pbytes->GetBase(), pbytes->length );
+	}
+	free(b);
+	if( r != 0 ){
+		pk->destroy();
+		ssl_error(r);
+	}
+	return pk;
+}
+
+Array<unsigned char> _hx_ssl_dgst_make( Array<unsigned char> buf, String alg ){
+   hx::strbuf ubuf;
+	const mbedtls_md_info_t *md = mbedtls_md_info_from_string(alg.utf8_str(&ubuf));
+	if( md == NULL )
+		hx::Throw( HX_CSTRING("Invalid hash algorithm") );
+
+	int size = mbedtls_md_get_size(md);
+	Array<unsigned char> out = Array_obj<int>::__new(size,size);
+	int r = -1;
+	if( r = mbedtls_md( md, &buf[0], buf->length, &out[0] ) != 0 )
+		ssl_error(r);
+
+	return out;
+}
+
+Array<unsigned char> _hx_ssl_dgst_sign( Array<unsigned char> buf, Dynamic hpkey, String alg ){
+	int r = -1;
+	size_t olen = 0;
+	unsigned char hash[32];
+	sslpkey *pk = val_pkey(hpkey);
+
+   hx::strbuf ubuf;
+	const mbedtls_md_info_t *md = mbedtls_md_info_from_string( alg.utf8_str(&ubuf) );
+	if( md == NULL )
+		hx::Throw( HX_CSTRING("Invalid hash algorithm") );
+
+	if( r = mbedtls_md( md, &buf[0], buf->length, hash ) != 0 )
+		ssl_error(r);
+
+	Array<unsigned char> result = Array_obj<unsigned char>::__new(MBEDTLS_MPI_MAX_SIZE,MBEDTLS_MPI_MAX_SIZE);
+	if( r = mbedtls_pk_sign( pk->k, mbedtls_md_get_type(md), hash, 0, &result[0], &olen, mbedtls_ctr_drbg_random, &ctr_drbg ) != 0 )
+		ssl_error(r);
+
+	result[olen] = 0;
+	result->__SetSize(olen);
+	return result;
+}
+
+bool _hx_ssl_dgst_verify( Array<unsigned char> buf, Array<unsigned char> sign, Dynamic hpkey, String alg ){
+	const mbedtls_md_info_t *md;
+	int r = -1;
+	unsigned char hash[32];
+	sslpkey *pk = val_pkey(hpkey);
+
+   hx::strbuf ubuf;
+	md = mbedtls_md_info_from_string( alg.utf8_str(&ubuf) );
+	if( md == NULL )
+		hx::Throw( HX_CSTRING("Invalid hash algorithm") );
+
+	if( r = mbedtls_md( md, &buf[0], buf->length, hash ) != 0 )
+		ssl_error(r);
+
+	if( r = mbedtls_pk_verify( pk->k, mbedtls_md_get_type(md), hash, 0, &sign[0], sign->length ) != 0 )
+		return false;
+
+	return true;
+}
+
+#if (_MSC_VER || defined(WIN32))
+
+static void threading_mutex_init_alt( mbedtls_threading_mutex_t *mutex ){
+	if( mutex == NULL )
+		return;
+	InitializeCriticalSection( &mutex->cs );
+	mutex->is_valid = 1;
+}
+
+static void threading_mutex_free_alt( mbedtls_threading_mutex_t *mutex ){
+    if( mutex == NULL || !mutex->is_valid )
+        return;
+	DeleteCriticalSection( &mutex->cs );
+	mutex->is_valid = 0;
+}
+
+static int threading_mutex_lock_alt( mbedtls_threading_mutex_t *mutex ){
+    if( mutex == NULL || !mutex->is_valid )
+        return( MBEDTLS_ERR_THREADING_BAD_INPUT_DATA );
+
+	EnterCriticalSection( &mutex->cs );
+    return( 0 );
+}
+
+static int threading_mutex_unlock_alt( mbedtls_threading_mutex_t *mutex ){
+    if( mutex == NULL || !mutex->is_valid )
+        return( MBEDTLS_ERR_THREADING_BAD_INPUT_DATA );
+
+    LeaveCriticalSection( &mutex->cs );
+    return( 0 );
+}
+
+#endif
+
+static bool _hx_ssl_inited = false;
+void _hx_ssl_init() {
+    if (_hx_ssl_inited) return;
+    _hx_ssl_inited = true;
+
+#if (_MSC_VER || defined(WIN32))
+	mbedtls_threading_set_alt( threading_mutex_init_alt, threading_mutex_free_alt,
+                           threading_mutex_lock_alt, threading_mutex_unlock_alt );
+#endif
+
+	// Init RNG
+	mbedtls_entropy_init( &entropy );
+	mbedtls_ctr_drbg_init( &ctr_drbg );
+	mbedtls_ctr_drbg_seed( &ctr_drbg, mbedtls_entropy_func, &entropy, NULL, 0 );
+}
diff --git a/Sources/c_snikket/src/hx/libs/std/Build.xml b/Sources/c_snikket/src/hx/libs/std/Build.xml
new file mode 100644
index 0000000..f18ee01
--- /dev/null
+++ b/Sources/c_snikket/src/hx/libs/std/Build.xml
@@ -0,0 +1,26 @@
+<xml>
+
+<pragma once="true" />
+
+<files id="hxcpp_std" dir="${this_dir}" >
+  <depend files="hxcpp-depends"/>
+  <depend name="${this_dir}/Build.xml" dateOnly="true" />
+  <cache value="1" asLibrary="true" />
+
+  <file name="File.cpp"/>
+  <file name="Sys.cpp"/>
+  <file name="Process.cpp"/>
+  <file name="Random.cpp"/>
+  <file name="Socket.cpp" />
+
+</files>
+
+
+<target id="haxe">
+  <files id="hxcpp_std"/>
+  <lib name="ws2_32.lib" if="windows" unless="static_link" />
+  <lib name="-lsocket" if="blackberry" unless="static_link" />
+</target>
+
+
+</xml>
diff --git a/Sources/c_snikket/src/hx/libs/std/File.cpp b/Sources/c_snikket/src/hx/libs/std/File.cpp
new file mode 100644
index 0000000..57a364f
--- /dev/null
+++ b/Sources/c_snikket/src/hx/libs/std/File.cpp
@@ -0,0 +1,425 @@
+#include <hxcpp.h>
+#include <stdio.h>
+#include <string.h>
+#include <vector>
+
+#include <hx/OS.h>
+
+#ifdef NEKO_WINDOWS
+#   include <windows.h>
+#endif
+
+/**
+   <doc>
+   <h1>File</h1>
+   <p>
+   The file api can be used for different kind of file I/O.
+   </p>
+   </doc>
+**/
+
+namespace
+{
+
+struct fio : public hx::Object
+{
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdFio };
+
+   String name;
+   FILE   *io;
+   bool   closeIo;
+
+   void create(FILE *inFile, String inName, bool inClose)
+   {
+      name = inName;
+      HX_OBJ_WB_GET(this,name.raw_ref());
+      io = inFile;
+      closeIo = inClose;
+
+      _hx_set_finalizer(this, finalize);
+   }
+
+   void destroy(bool inForceClose = false)
+   {
+      if (io && (inForceClose || closeIo))
+         fclose(io);
+      io = 0;
+      name = String();
+   }
+
+   void __Mark(hx::MarkContext *__inCtx) { HX_MARK_MEMBER(name); }
+   #ifdef HXCPP_VISIT_ALLOCS
+   void __Visit(hx::VisitContext *__inCtx) { HX_VISIT_MEMBER(name); }
+   #endif
+
+   static void finalize(Dynamic inObj)
+   {
+      ((fio *)(inObj.mPtr))->destroy();
+   }
+
+   String toString() { return HX_CSTRING("fio:") + name; }
+
+};
+
+fio *getFio(Dynamic handle, bool inRequireFile=true)
+{
+   fio *result = dynamic_cast<fio *>(handle.mPtr);
+   if (!result || (!result->io && inRequireFile))
+      hx::Throw( HX_CSTRING("Bad file handle") );
+   return result;
+}
+
+
+static void file_error(const char *msg, String inName)
+{
+   hx::ExitGCFreeZone();
+   Array<String> err = Array_obj<String>::__new(2,2);
+   err[0] = String(msg);
+   err[1] = inName;
+   hx::Throw(err);
+}
+
+}
+
+/**
+   file_open : f:string -> r:string -> 'file
+   <doc>
+   Call the C function [fopen] with the file path and access rights. 
+   Return the opened file or throw an exception if the file couldn't be open.
+   </doc>
+**/
+Dynamic _hx_std_file_open( String fname, String r )
+{
+   FILE *file = 0;
+
+   hx::strbuf buf0;
+   hx::strbuf buf1;
+#ifdef NEKO_WINDOWS
+   hx::EnterGCFreeZone();
+   file = _wfopen(fname.wchar_str(&buf0),r.wchar_str(&buf1));
+#else
+   hx::EnterGCFreeZone();
+   file = fopen(fname.utf8_str(&buf0),r.utf8_str(&buf1));
+#endif
+   if (!file)
+      file_error("file_open",fname);
+   hx::ExitGCFreeZone();
+
+   fio *f = new fio;
+   f->create(file,fname,true);
+   return f;
+}
+
+/**
+   file_close : 'file -> void
+   <doc>Close an file. Any other operations on this file will fail</doc> 
+**/
+void _hx_std_file_close( Dynamic handle )
+{
+   fio *fio = getFio(handle);
+   fio->destroy(true);
+}
+
+/**
+   file_name : 'file -> string
+   <doc>Return the name of the file which was opened</doc>
+**/
+String hx_std_file_name( Dynamic handle )
+{
+   fio *fio = getFio(handle);
+   return fio->name;
+}
+
+/**
+   file_write : 'file -> s:string -> p:int -> l:int -> int
+   <doc>
+   Write up to [l] chars of string [s] starting at position [p]. 
+   Returns the number of chars written which is >= 0.
+   </doc>
+**/
+int _hx_std_file_write( Dynamic handle, Array<unsigned char> s, int p, int n )
+{
+   fio *f = getFio(handle);
+
+   int buflen = s->length;
+   int len = n;
+   if( p < 0 || len < 0 || p > buflen || p + len > buflen )
+      return 0;
+
+   hx::EnterGCFreeZone();
+   while( len > 0 )
+   {
+      POSIX_LABEL(file_write_again);
+      int d = (int)fwrite(&s[p],1,len,f->io);
+      if( d <= 0 )
+      {
+         HANDLE_FINTR(f->io,file_write_again);
+         file_error("file_write",f->name);
+      }
+      p += d;
+      len -= d;
+   }
+   hx::ExitGCFreeZone();
+   return n;
+}
+
+/**
+   file_read : 'file -> s:string -> p:int -> l:int -> int
+   <doc>
+   Read up to [l] chars into the string [s] starting at position [p].
+   Returns the number of chars readed which is > 0 (or 0 if l == 0).
+   </doc>
+**/
+int _hx_std_file_read( Dynamic handle, Array<unsigned char> buf, int p, int n )
+{
+   fio *f = getFio(handle);
+
+   int buf_len = buf->length;
+   int len = n;
+   if( p < 0 || len < 0 || p > buf_len || p + len > buf_len )
+      return 0;
+
+   hx::EnterGCFreeZone();
+   // Attempt to increase the chances of pinning on the stack...
+   unsigned char *bufPtr = &buf[0];
+   while( len > 0 )
+   {
+      POSIX_LABEL(file_read_again);
+      int d = (int)fread(bufPtr + p,1,len,f->io);
+      if( d <= 0 )
+      {
+         int size = n - len;
+         HANDLE_FINTR(f->io,file_read_again);
+         if( size == 0 )
+            file_error("file_read",f->name);
+         hx::ExitGCFreeZone();
+         return size;
+      }
+      p += d;
+      len -= d;
+   }
+   hx::ExitGCFreeZone();
+   return n;
+}
+
+/**
+   file_write_char : 'file -> c:int -> void
+   <doc>Write the char [c]. Error if [c] outside of the range 0..255</doc>
+**/
+void _hx_std_file_write_char( Dynamic handle, int c )
+{
+   fio *f = getFio(handle);
+   if( c < 0 || c > 255 )
+      return;
+   char cc = (char)c;
+
+   hx::EnterGCFreeZone();
+   POSIX_LABEL(write_char_again);
+   if( fwrite(&cc,1,1,f->io) != 1 )
+   {
+      HANDLE_FINTR(f->io,write_char_again);
+      file_error("file_write_char",f->name);
+   }
+   hx::ExitGCFreeZone();
+}
+
+/**
+   file_read_char : 'file -> int
+   <doc>Read a char from the file. Exception on error</doc>
+**/
+int _hx_std_file_read_char( Dynamic handle )
+{
+   fio *f = getFio(handle);
+
+   unsigned char cc = 0;
+   hx::EnterGCFreeZone();
+   POSIX_LABEL(read_char_again);
+   if( fread(&cc,1,1,f->io) != 1 )
+   {
+      HANDLE_FINTR(f->io,read_char_again);
+      file_error("file_read_char",f->name);
+   }
+   hx::ExitGCFreeZone();
+   return cc;
+}
+
+/**
+   file_seek : 'file -> pos:int -> mode:int -> void
+   <doc>Use [fseek] to move the file pointer.</doc>
+**/
+void _hx_std_file_seek( Dynamic handle, int pos, int kind )
+{
+   fio *f = getFio(handle);
+   hx::EnterGCFreeZone();
+   if( fseek(f->io,pos,kind) != 0 )
+      file_error("file_seek",f->name);
+   hx::ExitGCFreeZone();
+}
+
+/**
+   file_tell : 'file -> int
+   <doc>Return the current position in the file</doc>
+**/
+int _hx_std_file_tell( Dynamic handle )
+{
+   fio *f = getFio(handle);
+   hx::EnterGCFreeZone();
+   int p = ftell(f->io);
+   if( p == -1 )
+      file_error("file_tell",f->name);
+   hx::ExitGCFreeZone();
+   return p;
+}
+
+/**
+   file_eof : 'file -> bool
+   <doc>Tell if we have reached the end of the file</doc>
+**/
+bool _hx_std_file_eof( Dynamic handle )
+{
+   fio *f = getFio(handle);
+   return feof(f->io);
+}
+
+/**
+   file_flush : 'file -> void
+   <doc>Flush the file buffer</doc>
+**/
+void _hx_std_file_flush( Dynamic handle )
+{
+   fio *f = getFio(handle);
+   hx::EnterGCFreeZone();
+   if( fflush( f->io ) != 0 )
+      file_error("file_flush",f->name);
+   hx::ExitGCFreeZone();
+}
+
+/**
+   file_contents : f:string -> string
+   <doc>Read the content of the file [f] and return it.</doc>
+**/
+String _hx_std_file_contents_string( String name )
+{
+   std::vector<char> buffer;
+
+   hx::strbuf buf;
+#ifdef NEKO_WINDOWS
+   hx::EnterGCFreeZone();
+   FILE *file = _wfopen(name.wchar_str(&buf), L"rb");
+#else
+   hx::EnterGCFreeZone();
+   FILE *file = fopen(name.utf8_str(&buf), "rb");
+#endif
+   if(!file)
+      file_error("file_contents",name);
+
+   fseek(file,0,SEEK_END);
+   int len = ftell(file);
+   if (len<0)
+      file_error("file_ftell",name);
+   if (len==0)
+   {
+      fclose(file);
+      hx::ExitGCFreeZone();
+      return String::emptyString;
+   }
+
+   fseek(file,0,SEEK_SET);
+   buffer.resize(len);
+   int p = 0;
+   while( len > 0 )
+   {
+      POSIX_LABEL(file_contents);
+      int d = (int)fread(&buffer[p],1,len,file);
+      if( d <= 0 )
+      {
+         HANDLE_FINTR(file,file_contents);
+         fclose(file);
+         file_error("file_contents",name);
+      }
+      p += d;
+      len -= d;
+   }
+   fclose(file);
+   hx::ExitGCFreeZone();
+
+   return String::create(&buffer[0], buffer.size());
+}
+
+
+
+/**
+   file_contents : f:string -> string
+   <doc>Read the content of the file [f] and return it.</doc>
+**/
+Array<unsigned char> _hx_std_file_contents_bytes( String name )
+{
+   hx::strbuf buf;
+#ifdef NEKO_WINDOWS
+   hx::EnterGCFreeZone();
+   FILE *file = _wfopen(name.wchar_str(&buf), L"rb");
+#else
+   hx::EnterGCFreeZone();
+   FILE *file = fopen(name.utf8_str(&buf), "rb");
+#endif
+   if(!file)
+      file_error("file_contents",name);
+
+   fseek(file,0,SEEK_END);
+   int len = ftell(file);
+   if (len<0)
+      file_error("file_ftell",name);
+
+   fseek(file,0,SEEK_SET);
+   hx::ExitGCFreeZone();
+
+   Array<unsigned char> buffer = Array_obj<unsigned char>::__new(len,len);
+   hx::EnterGCFreeZone();
+   if (len)
+   {
+      char *dest = (char *)&buffer[0];
+
+      int p = 0;
+      while( len > 0 )
+      {
+         POSIX_LABEL(file_contents1);
+         int d = (int)fread(dest + p,1,len,file);
+         if( d <= 0 )
+         {
+            HANDLE_FINTR(file,file_contents1);
+            fclose(file);
+            file_error("file_contents",name);
+         }
+         p += d;
+         len -= d;
+      }
+   }
+   fclose(file);
+   hx::ExitGCFreeZone();
+   return buffer;
+}
+
+
+
+Dynamic _hx_std_file_stdin()
+{
+   fio *f = new fio();
+   f->create(stdin, HX_CSTRING("stdin"), false);
+   return f;
+}
+
+
+Dynamic _hx_std_file_stdout()
+{
+   fio *f = new fio();
+   f->create(stdout, HX_CSTRING("stdout"), false);
+   return f;
+}
+
+Dynamic _hx_std_file_stderr()
+{
+   fio *f = new fio();
+   f->create(stderr, HX_CSTRING("stderr"), false);
+   return f;
+}
+
diff --git a/Sources/c_snikket/src/hx/libs/std/Process.cpp b/Sources/c_snikket/src/hx/libs/std/Process.cpp
new file mode 100644
index 0000000..d9f020e
--- /dev/null
+++ b/Sources/c_snikket/src/hx/libs/std/Process.cpp
@@ -0,0 +1,603 @@
+#include <hxcpp.h>
+#include <hx/OS.h>
+
+#if !defined(HX_WINRT) && !defined(EPPC)
+
+#ifdef NEKO_WINDOWS
+#   include <windows.h>
+#else
+#   include <sys/types.h>
+#   include <unistd.h>
+#   include <memory.h>
+#   include <errno.h>
+#   include <signal.h>
+#   if defined(ANDROID) || defined(BLACKBERRY) || defined(EMSCRIPTEN)
+#      include <sys/wait.h>
+#   elif !defined(NEKO_MAC)
+#      include <wait.h>
+#   endif
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
+#include <string>
+
+namespace
+{
+
+#ifndef NEKO_WINDOWS
+static int do_close( int fd )
+{
+   POSIX_LABEL(close_again);
+   if( close(fd) != 0 ) {
+      HANDLE_EINTR(close_again);
+      return 1;
+   }
+   return 0;
+}
+#endif
+
+
+struct vprocess : public hx::Object
+{
+  HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdProcess };
+
+   bool open;
+#ifdef NEKO_WINDOWS
+   HANDLE oread;
+   HANDLE eread;
+   HANDLE iwrite;
+   PROCESS_INFORMATION pinf;
+   #define HANDLE_INIT 0
+#else
+   int oread;
+   int eread;
+   int iwrite;
+   int pid;
+   #define HANDLE_INIT -1
+#endif
+
+   void create()
+   {
+      open = true;
+      oread = HANDLE_INIT;
+      eread = HANDLE_INIT;
+      iwrite = HANDLE_INIT;
+      _hx_set_finalizer(this, finalize);
+   }
+
+   void destroy()
+   {
+      if (open)
+      {
+         #ifdef NEKO_WINDOWS
+            if (eread)
+               CloseHandle(eread);
+            if (oread)
+               CloseHandle(oread);
+            if (iwrite)
+               CloseHandle(iwrite);
+            CloseHandle(pinf.hProcess);
+            CloseHandle(pinf.hThread);
+         #else
+            if (eread!=-1)
+               do_close(eread);
+            if (oread!=-1)
+               do_close(oread);
+            if (iwrite!=-1)
+               do_close(iwrite);
+         #endif
+         open = false;
+      }
+   }
+
+   static void finalize(Dynamic obj)
+   {
+      ((vprocess *)(obj.mPtr))->destroy();
+   }
+
+   String toString() { return HX_CSTRING("vprocess"); }
+};
+
+vprocess *getProcess(Dynamic handle)
+{
+   vprocess *p = dynamic_cast<vprocess *>(handle.mPtr);
+   if (!p)
+      hx::Throw(HX_CSTRING("Invalid process"));
+   return p;
+}
+
+
+/**
+   <doc>
+   <h1>Process</h1>
+   <p>
+   An API for starting and communication with sub processes.
+   </p>
+   </doc>
+**/
+
+} // end anon namespace
+
+
+
+template<typename T>
+static String TQuoted(const T *ptr, int len)
+{
+   std::vector<T> quoted;
+   quoted.reserve(len*2);
+
+   unsigned int bs_count = 0;
+   for(int j=0;j<len;j++)
+   {
+      T c = ptr[j];
+      switch( c )
+      {
+      case '"':
+         // Double backslashes.
+         for (int k=0;k<bs_count*2;k++)
+            quoted.push_back('\\');
+         bs_count = 0;
+         quoted.push_back('\\');
+         quoted.push_back('"');
+         break;
+      case '\\':
+         // Don't know if we need to double yet.
+         bs_count++;
+         break;
+      default:
+         // Normal char
+         for (int k=0;k<bs_count;k++)
+            quoted.push_back('\\');
+         bs_count = 0;
+         quoted.push_back(c);
+         break;
+      }
+   }
+   // Add remaining backslashes, if any.
+   for (int k=0;k<bs_count*2;k++)
+      quoted.push_back('\\');
+   int qlen = (int)quoted.size();
+   quoted.push_back('\0');
+
+   return String::create( &quoted[0], qlen );
+}
+
+static String quoteString(String v)
+{
+   #ifdef HX_SMART_STRINGS
+   if (v.isUTF16Encoded())
+      return TQuoted(v.raw_wptr(),v.length);
+   #endif
+   return TQuoted(v.raw_ptr(),v.length);
+}
+
+
+
+/**
+   process_run : cmd:string -> args:string array -> 'process
+   <doc>
+   Start a process using a command.
+   When args is not null, cmd and args will be auto-quoted/escaped.
+   If no auto-quoting/escaping is desired, you should append necessary 
+   arguments to cmd as if it is inputted to the shell directly, and pass
+   null to args.
+
+   inShowParam = only for windows, SHOW_* from "ShowWindow" function
+      default = 1 = SHOW_WINDOW
+   </doc>
+**/
+Dynamic _hx_std_process_run( String cmd, Array<String> vargs, int inShowParam )
+{
+   #if defined(APPLETV) || defined(HX_APPLEWATCH)
+   return null();
+
+   #else
+   vprocess *p = 0;
+   bool isRaw = !vargs.mPtr;
+
+   #ifdef NEKO_WINDOWS
+   {       
+      SECURITY_ATTRIBUTES sattr;      
+      STARTUPINFOW sinf;
+      HANDLE proc = GetCurrentProcess();
+      HANDLE oread,eread,iwrite;
+      // creates commandline
+      String b;
+      if (isRaw)
+      {
+         b = HX_CSTRING("\"");
+         const char* cmdexe = getenv("COMSPEC");
+         if (!cmdexe) cmdexe = "cmd.exe";
+         b += String(cmdexe) + HX_CSTRING("\" /C \"") + cmd + HX_CSTRING("\"");
+      }
+      else
+      {
+         b = HX_CSTRING("\"") + cmd + HX_CSTRING("\"");
+
+         for(int i=0;i<vargs->length;i++)
+         {
+            b += HX_CSTRING(" \"");
+            if (vargs[i].length)
+               b += quoteString(vargs[i]);
+            b += HX_CSTRING("\"");
+         }
+      }
+
+      const wchar_t *name = b.__WCStr();
+
+      hx::EnterGCFreeZone();
+      // startup process
+      sattr.nLength = sizeof(sattr);
+      sattr.bInheritHandle = TRUE;
+      sattr.lpSecurityDescriptor = NULL;
+      memset(&sinf,0,sizeof(sinf));
+      sinf.cb = sizeof(sinf);
+      sinf.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
+      sinf.wShowWindow = inShowParam;
+      CreatePipe(&oread,&sinf.hStdOutput,&sattr,0);
+      CreatePipe(&eread,&sinf.hStdError,&sattr,0);
+      CreatePipe(&sinf.hStdInput,&iwrite,&sattr,0);
+
+      HANDLE procOread,procEread,procIwrite;
+
+      DuplicateHandle(proc,oread,proc,&procOread,0,FALSE,DUPLICATE_SAME_ACCESS);
+      DuplicateHandle(proc,eread,proc,&procEread,0,FALSE,DUPLICATE_SAME_ACCESS);
+      DuplicateHandle(proc,iwrite,proc,&procIwrite,0,FALSE,DUPLICATE_SAME_ACCESS);
+      CloseHandle(oread);
+      CloseHandle(eread);
+      CloseHandle(iwrite);
+      //printf("Cmd %s\n",val_string(cmd));
+      PROCESS_INFORMATION pinf;
+      memset(&pinf,0,sizeof(pinf));
+      if( !CreateProcessW(NULL,(wchar_t *)name,NULL,NULL,TRUE,CREATE_NO_WINDOW,NULL,NULL,&sinf,&pinf) )
+      {
+         hx::ExitGCFreeZone();
+         hx::Throw(HX_CSTRING("Could not start process"));
+      }
+      // close unused pipes
+      CloseHandle(sinf.hStdOutput);
+      CloseHandle(sinf.hStdError);
+      CloseHandle(sinf.hStdInput);
+      hx::ExitGCFreeZone();
+
+      p = new vprocess;
+      p->create();
+      p->oread = procOread;
+      p->eread = procEread;
+      p->iwrite = procIwrite;
+      p->pinf = pinf;
+   }
+   #else // not windows ...
+   {
+   int input[2], output[2], error[2];
+   if( pipe(input) || pipe(output) || pipe(error) )
+      return null();
+
+   hx::strbuf buf;
+   std::vector< std::string > values;
+   if (isRaw)
+   {
+      values.resize(3);
+      values[0] = "/bin/sh";
+      values[1] = "-c";
+      values[2] = cmd.utf8_str(&buf);
+   }
+   else
+   {
+      values.resize(vargs->length+1);
+
+      values[0] = cmd.utf8_str(&buf);
+      for(int i=0;i<vargs->length;i++)
+         values[i+1] = vargs[i].utf8_str(&buf);
+   }
+
+   std::vector<const char *> argv(values.size()+1);
+   for(int i=0;i<values.size();i++)
+      argv[i] = values[i].c_str();
+
+   int pid = fork();
+   if( pid == -1 )
+      return null();
+
+   // child
+   if( pid == 0 )
+   {
+      close(input[1]);
+      close(output[0]);
+      close(error[0]);
+      dup2(input[0],0);
+      dup2(output[1],1);
+      dup2(error[1],2);
+      execvp(argv[0],(char* const*)&argv[0]);
+      fprintf(stderr,"Command not found : %S\n",cmd.wchar_str());
+      exit(1);
+   }
+
+   // parent
+   do_close(input[0]);
+   do_close(output[1]);
+   do_close(error[1]);
+
+   p = new vprocess;
+   p->create();
+   p->iwrite = input[1];
+   p->oread = output[0];
+   p->eread = error[0];
+   p->pid = pid;
+   }
+   #endif
+
+   return p;
+
+   #endif // not APPLETV/HX_APPLEWATCH
+}
+
+
+/**
+   process_stdout_read : 'process -> buf:string -> pos:int -> len:int -> int
+   <doc>
+   Read up to [len] bytes in [buf] starting at [pos] from the process stdout.
+   Returns the number of bytes readed this way. Raise an exception if this
+   process stdout is closed and no more data is available for reading.
+
+        For hxcpp, the input buffer is in bytes, not characters
+   </doc>
+**/
+int _hx_std_process_stdout_read( Dynamic handle, Array<unsigned char> buf, int pos, int len )
+{
+   if( pos < 0 || len < 0 || pos + len > buf->length )
+      return 0;
+   vprocess *p = getProcess(handle);
+
+   unsigned char *dest = &buf[0];
+   hx::EnterGCFreeZone();
+   #ifdef NEKO_WINDOWS
+   DWORD nbytes = 0;
+   if( !ReadFile(p->oread,dest+pos,len,&nbytes,0) )
+      nbytes = 0;
+   #else
+   int nbytes = read(p->oread,dest + pos,len);
+   if( nbytes <= 0 )
+      nbytes = 0;
+   #endif
+
+   hx::ExitGCFreeZone();
+   return nbytes;
+}
+
+
+/**
+   process_stderr_read : 'process -> buf:string -> pos:int -> len:int -> int
+   <doc>
+   Read up to [len] bytes in [buf] starting at [pos] from the process stderr.
+   Returns the number of bytes readed this way. Raise an exception if this
+   process stderr is closed and no more data is available for reading.
+   </doc>
+**/
+int _hx_std_process_stderr_read( Dynamic handle, Array<unsigned char> buf, int pos, int len )
+{
+   if( pos < 0 || len < 0 || pos + len > buf->length )
+      return 0;
+   vprocess *p = getProcess(handle);
+
+   unsigned char *dest = &buf[0];
+   hx::EnterGCFreeZone();
+   #ifdef NEKO_WINDOWS
+   DWORD nbytes = 0;
+   if( !ReadFile(p->eread,dest+pos,len,&nbytes,0) )
+      nbytes = 0;
+   #else
+   int nbytes = read(p->eread,dest + pos,len);
+   if( nbytes <= 0 )
+      nbytes = 0;
+   #endif
+
+   hx::ExitGCFreeZone();
+   return nbytes;
+}
+
+/**
+   process_stdin_write : 'process -> buf:string -> pos:int -> len:int -> int
+   <doc>
+   Write up to [len] bytes from [buf] starting at [pos] to the process stdin.
+   Returns the number of bytes writen this way. Raise an exception if this
+   process stdin is closed.
+   </doc>
+**/
+int _hx_std_process_stdin_write( Dynamic handle, Array<unsigned char> buf, int pos, int len )
+{
+   if( pos < 0 || len < 0 || pos + len > buf->length )
+      return 0;
+   vprocess *p = getProcess(handle);
+
+   unsigned char *src = &buf[0];
+
+
+   hx::EnterGCFreeZone();
+   #ifdef NEKO_WINDOWS
+   DWORD nbytes =0;
+   if( !WriteFile(p->iwrite,src+pos,len,&nbytes,0) )
+      nbytes = 0;
+   #else
+   int nbytes = write(p->iwrite,src+pos,len);
+   if( nbytes == -1 )
+      nbytes = 0;
+   #endif
+
+   hx::ExitGCFreeZone();
+   return nbytes;
+}
+
+/**
+   process_stdin_close : 'process -> void
+   <doc>
+   Close the process standard input.
+   </doc>
+**/
+void _hx_std_process_stdin_close( Dynamic handle )
+{
+   vprocess *p = getProcess(handle);
+
+   #ifdef NEKO_WINDOWS
+   if ( p->iwrite )
+      CloseHandle(p->iwrite);
+   #else
+   if( p->iwrite!=-1 )
+      do_close(p->iwrite);
+   #endif
+   p->iwrite = HANDLE_INIT;
+}
+
+/**
+   process_exit : 'process -> int
+   <doc>
+   Wait until the process terminate, then returns its exit code.
+   </doc>
+**/
+#if (HXCPP_API_LEVEL > 420)
+Dynamic _hx_std_process_exit( Dynamic handle, bool block )
+{
+   vprocess *p = getProcess(handle);
+
+   hx::EnterGCFreeZone();
+   #ifdef NEKO_WINDOWS
+   {
+      DWORD rval;
+      DWORD wait = INFINITE;
+      if (!block)
+         wait = 0;
+      
+      WaitForSingleObject(p->pinf.hProcess,wait);
+      hx::ExitGCFreeZone();
+
+      if( !GetExitCodeProcess(p->pinf.hProcess,&rval) && block)
+         return 0;
+      else if (!block && rval == STILL_ACTIVE)
+         return null();
+      else
+         return rval;
+   }
+   #else
+   int options=0;
+   if (!block)
+      options = WNOHANG;
+   
+   int rval=0;
+   pid_t ret=-1;
+   while( (ret = waitpid(p->pid,&rval,options)) != p->pid )
+   {
+      if( errno == EINTR )
+         continue;
+      
+      if (!block && ret == 0)
+      {
+         hx::ExitGCFreeZone();
+         return null();
+      }
+
+      hx::ExitGCFreeZone();
+      return 0;
+   }
+   hx::ExitGCFreeZone();
+   if( !WIFEXITED(rval) )
+      return 0;
+
+   return WEXITSTATUS(rval);
+   #endif
+}
+#else
+int _hx_std_process_exit( Dynamic handle )
+{
+   vprocess *p = getProcess(handle);
+
+   hx::EnterGCFreeZone();
+   #ifdef NEKO_WINDOWS
+   {
+      DWORD rval;
+      WaitForSingleObject(p->pinf.hProcess,INFINITE);
+      hx::ExitGCFreeZone();
+
+      if( !GetExitCodeProcess(p->pinf.hProcess,&rval) )
+         return 0;
+      return rval;
+   }
+   #else
+   int rval=0;
+   while( waitpid(p->pid,&rval,0) != p->pid )
+   {
+      if( errno == EINTR )
+         continue;
+      hx::ExitGCFreeZone();
+      return 0;
+   }
+   hx::ExitGCFreeZone();
+   if( !WIFEXITED(rval) )
+      return 0;
+
+   return WEXITSTATUS(rval);
+   #endif
+}
+#endif
+
+/**
+   process_pid : 'process -> int
+   <doc>
+   Returns the process id.
+   </doc>
+**/
+int _hx_std_process_pid( Dynamic handle )
+{
+   vprocess *p = getProcess(handle);
+
+   #ifdef NEKO_WINDOWS
+   return p->pinf.dwProcessId;
+   #else
+   return p->pid;
+   #endif
+}
+
+void _hx_std_process_kill( Dynamic handle )
+{
+   vprocess *p = getProcess(handle);
+
+   #ifdef NEKO_WINDOWS
+   TerminateProcess(p->pinf.hProcess, -1);
+   #else
+   kill(p->pid, SIGTERM);
+   #endif
+}
+
+
+
+/**
+   process_close : 'process -> void
+   <doc>
+   Close the process I/O.
+   </doc>
+**/
+void _hx_std_process_close( Dynamic handle )
+{
+   vprocess *p = getProcess(handle);
+   p->destroy();
+}
+
+#else  // !HX_WINRT
+
+Dynamic _hx_std_process_run( String cmd, Array<String> vargs, int inShowParam ){ return null(); }
+int _hx_std_process_stdout_read( Dynamic handle, Array<unsigned char> buf, int pos, int len ) { return 0; }
+int _hx_std_process_stderr_read( Dynamic handle, Array<unsigned char> buf, int pos, int len ) { return 0; }
+int _hx_std_process_stdin_write( Dynamic handle, Array<unsigned char> buf, int pos, int len ) { return 0; }
+void _hx_std_process_stdin_close( Dynamic handle ) { }
+#if (HXCPP_API_LEVEL > 420)
+Dynamic _hx_std_process_exit( Dynamic handle, bool block ) { return 0; }
+#else
+int _hx_std_process_exit( Dynamic handle ) { return 0; }
+#endif
+int _hx_std_process_pid( Dynamic handle ) { return 0; }
+void _hx_std_process_close( Dynamic handle ) { }
+void _hx_std_process_kill( Dynamic handle ) { }
+
+#endif // HX_WINRT
+
diff --git a/Sources/c_snikket/src/hx/libs/std/Random.cpp b/Sources/c_snikket/src/hx/libs/std/Random.cpp
new file mode 100644
index 0000000..af59c15
--- /dev/null
+++ b/Sources/c_snikket/src/hx/libs/std/Random.cpp
@@ -0,0 +1,178 @@
+#include <hxcpp.h>
+#include <hx/OS.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <time.h>
+#include <string.h>
+#ifdef HX_WINDOWS
+#   include <windows.h>
+#   include <process.h>
+#elif defined(EPPC)
+#   include <time.h>
+#else
+#   include <sys/time.h>
+#   include <sys/types.h>
+#   include <unistd.h>
+#endif
+
+
+/**
+   <doc>
+   <h1>Random</h1>
+   <p>A seeded pseudo-random generator</p>
+   </doc>
+**/
+
+
+
+#define NSEEDS   25
+#define MAX      7
+
+namespace
+{
+
+struct rnd  : public hx::Object
+{
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdRandom };
+
+   unsigned long seeds[NSEEDS];
+   unsigned long cur;
+
+   String toString() { return HX_CSTRING("rand"); }
+};
+
+static unsigned long mag01[2]={ 
+   0x0, 0x8ebfd028 // magic, don't change
+};
+
+static const unsigned long init_seeds[] = {
+   0x95f24dab, 0x0b685215, 0xe76ccae7, 0xaf3ec239, 0x715fad23,
+   0x24a590ad, 0x69e4b5ef, 0xbf456141, 0x96bc1b7b, 0xa7bdf825,
+   0xc1de75b7, 0x8858a9c9, 0x2da87693, 0xb657f9dd, 0xffdc8a9f,
+   0x8121da71, 0x8b823ecb, 0x885d05f5, 0x4e20cd47, 0x5a9ad5d9,
+   0x512c0c03, 0xea857ccd, 0x4cc1d30f, 0x8891a8a1, 0xa6b7aadb
+};
+
+
+
+static void rnd_set_seed( rnd *r, int s )
+{
+   int i;
+   r->cur = 0;
+   memcpy(r->seeds,init_seeds,sizeof(init_seeds));
+   for(i=0;i<NSEEDS;i++)
+      r->seeds[i] ^= s;
+}
+
+rnd *getRnd(Dynamic handle)
+{
+   rnd *r = dynamic_cast<rnd *>(handle.mPtr);
+   if (!r)
+      hx::Throw(HX_CSTRING("Invalid random handle"));
+   return r;
+}
+
+} // end anon namespace
+
+Dynamic _hx_std_random_new()
+{
+   rnd *r = new rnd();
+
+#if defined(NEKO_WINDOWS)
+  #if defined(HX_WINRT) && defined(__cplusplus_winrt)
+   int pid = Windows::Security::Cryptography::CryptographicBuffer::GenerateRandomNumber();
+  #else
+   int pid = GetCurrentProcessId();
+  #endif
+#elif defined(EPPC)
+   int pid = 1;
+#else
+   int pid = getpid();
+#endif
+
+   unsigned int t;
+#ifdef HX_WINRT
+   t = (unsigned int)GetTickCount64();
+#elif defined(NEKO_WINDOWS)
+   t = GetTickCount();
+#elif defined(EPPC)
+   time_t tod;
+   time(&tod);
+   t = (double)tod;
+#else
+   struct timeval tv;
+   gettimeofday(&tv,NULL);
+   t = tv.tv_sec * 1000000 + tv.tv_usec;
+#endif   
+
+
+   rnd_set_seed(r,t ^ (pid | (pid << 16)));
+   return r;
+}
+
+static unsigned int rnd_int( rnd *r )
+{
+   unsigned int y;
+   int pos = r->cur++;
+    if( pos >= NSEEDS ) {
+      int kk;
+      for(kk=0;kk<NSEEDS-MAX;kk++)
+         r->seeds[kk] = r->seeds[kk+MAX] ^ (r->seeds[kk] >> 1) ^ mag01[r->seeds[kk] % 2];      
+      for(;kk<NSEEDS;kk++)
+         r->seeds[kk] = r->seeds[kk+(MAX-NSEEDS)] ^ (r->seeds[kk] >> 1) ^ mag01[r->seeds[kk] % 2];      
+      r->cur = 1;
+      pos = 0;
+   }
+    y = r->seeds[pos];
+    y ^= (y << 7) & 0x2b5b2500;
+    y ^= (y << 15) & 0xdb8b0000;
+    y ^= (y >> 16);
+   return y;
+}
+
+static double rnd_float( rnd *r )
+{
+   double big = 4294967296.0;   
+   return ((rnd_int(r) / big + rnd_int(r)) / big + rnd_int(r)) / big;
+}
+
+/**
+   random_new : void -> 'random
+   <doc>Create a new random with random seed</doc>
+**/
+
+
+#include<stdlib.h>
+
+
+/**
+   random_set_seed : 'random -> int -> void
+   <doc>Set the generator seed</doc>
+**/
+void _hx_std_random_set_seed( Dynamic handle, int v )
+{
+   rnd_set_seed( getRnd(handle) ,v);
+}
+
+/**
+   random_int : 'random -> max:int -> int
+   <doc>Return a random integer modulo [max]</doc>
+**/
+int _hx_std_random_int( Dynamic handle, int max )
+{
+   if( max <= 0 )
+      return 0;
+   return (rnd_int( getRnd(handle)) & 0x3FFFFFFF) % max;
+}
+
+/**
+   random_float : 'random -> float
+   <doc>Return a random float</doc>
+**/
+double _hx_std_random_float( Dynamic handle )
+{
+   return rnd_float(getRnd(handle));
+}
+
+
diff --git a/Sources/c_snikket/src/hx/libs/std/Socket.cpp b/Sources/c_snikket/src/hx/libs/std/Socket.cpp
new file mode 100644
index 0000000..fe77cdc
--- /dev/null
+++ b/Sources/c_snikket/src/hx/libs/std/Socket.cpp
@@ -0,0 +1,1392 @@
+#if !defined(HX_WINRT) && !defined(EPPC)
+#include <hxcpp.h>
+#include <hx/OS.h>
+
+#include <string.h>
+
+
+#ifdef NEKO_WINDOWS
+
+#ifdef __GNUC__
+   // Mingw / gcc on windows
+   #define _WIN32_WINNT 0x0501
+   #include <winsock2.h>
+   #include <ws2tcpip.h>
+#else
+   // Windows...
+   #include <winsock2.h>
+   #include <In6addr.h>
+   #include <Ws2tcpip.h>
+#endif
+
+
+#define DYNAMIC_INET_FUNCS 1
+typedef WINSOCK_API_LINKAGE  INT (WSAAPI *inet_pton_func)( INT Family, PCSTR pszAddrString, PVOID pAddrBuf);
+typedef WINSOCK_API_LINKAGE  PCSTR (WSAAPI *inet_ntop_func)(INT  Family, PVOID pAddr, PSTR pStringBuf, size_t StringBufSize);
+
+
+
+
+
+#   define FDSIZE(n)   (sizeof(u_int) + (n) * sizeof(SOCKET))
+#   define SHUT_WR      SD_SEND
+#   define SHUT_RD      SD_RECEIVE
+#   define SHUT_RDWR   SD_BOTH
+   static bool init_done = false;
+   static WSADATA init_data;
+typedef int SocketLen;
+#else
+#   include <sys/types.h>
+#   include <sys/socket.h>
+#   include <sys/time.h>
+#   include <netinet/in.h>
+#  include <netinet/tcp.h>
+#   include <arpa/inet.h>
+#   include <unistd.h>
+#   include <netdb.h>
+#   include <fcntl.h>
+#   include <errno.h>
+#   include <stdio.h>
+#   include <poll.h>
+   typedef int SOCKET;
+#   define closesocket close
+#   define SOCKET_ERROR (-1)
+#   define INVALID_SOCKET (-1)
+typedef socklen_t SocketLen;
+#endif
+
+#if (defined(NEKO_WINDOWS) || defined(NEKO_MAC)) && !defined(MSG_NOSIGNAL)
+#   define MSG_NOSIGNAL 0
+#endif
+
+
+
+namespace
+{
+
+static int socketType = 0;
+
+struct SocketWrapper : public hx::Object
+{
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdSocket };
+
+   SOCKET socket;
+
+   int __GetType() const { return socketType; }
+};
+
+
+SOCKET val_sock(Dynamic inValue)
+{
+   if (inValue.mPtr)
+   {
+      int type = inValue->__GetType();
+      if (type==vtClass)
+      {
+         inValue = inValue->__Field( HX_CSTRING("__s"), hx::paccNever );
+         if (inValue.mPtr==0)
+            return 0;
+         type = inValue->__GetType();
+      }
+
+      if (type==socketType)
+         return static_cast<SocketWrapper *>(inValue.mPtr)->socket;
+   }
+
+   hx::Throw(HX_CSTRING("Invalid socket handle"));
+   return 0;
+}
+
+
+void reset_sock(Dynamic inValue)
+{
+   if (inValue.mPtr)
+   {
+      int type = inValue->__GetType();
+      if (type==vtClass)
+      {
+         inValue = inValue->__Field( HX_CSTRING("__s"), hx::paccNever );
+         if (inValue.mPtr==0)
+            return;
+         type = inValue->__GetType();
+      }
+
+      if (type==socketType) {
+         static_cast<SocketWrapper *>(inValue.mPtr)->socket = INVALID_SOCKET;
+         return;
+      }
+   }
+
+   hx::Throw(HX_CSTRING("Invalid socket handle"));
+}
+
+
+/**
+   <doc>
+   <h1>Socket</h1>
+   <p>
+   TCP and UDP sockets
+   </p>
+   </doc>
+**/
+
+static void block_error()
+{
+
+#ifdef NEKO_WINDOWS
+   int err = WSAGetLastError();
+   // call ExitGCFreeZone after WSAGetLastError, WSAGetLastError is just an alias for GetLastError and
+   // calling ExitGCFreeZone will on some cases clear the lastError code.
+   hx::ExitGCFreeZone();
+   if( err == WSAEWOULDBLOCK || err == WSAEALREADY )
+
+#else
+   hx::ExitGCFreeZone();
+   if( errno == EAGAIN || errno == EWOULDBLOCK || errno == EINPROGRESS || errno == EALREADY )
+#endif
+      hx::Throw(HX_CSTRING("Blocking"));
+    else {
+       hx::Throw(HX_CSTRING("EOF"));
+    }
+}
+
+}
+
+/**
+   socket_init : void -> void
+   <doc>
+   Initialize the socket API. Must be called at least once per process
+   before using any socket or host function.
+   </doc>
+**/
+void _hx_std_socket_init()
+{
+#ifdef NEKO_WINDOWS
+   if( !init_done ) {
+      WSAStartup(MAKEWORD(2,0),&init_data);
+      init_done = true;
+   }
+#endif
+}
+
+
+/**
+   socket_new : udp:bool -> 'socket
+   <doc>Create a new socket, TCP or UDP</doc>
+**/
+Dynamic _hx_std_socket_new( bool udp, bool ipv6 )
+{
+   if (!socketType)
+      socketType = hxcpp_alloc_kind();
+
+   SOCKET s;
+   int family = ipv6 ? AF_INET6 : AF_INET;
+   if( udp )
+      s = socket(family,SOCK_DGRAM,0);
+   else
+      s = socket(family,SOCK_STREAM,0);
+
+   if( s == INVALID_SOCKET )
+      return null();
+
+   #ifdef NEKO_MAC
+      int set = 1;
+      setsockopt(s,SOL_SOCKET,SO_NOSIGPIPE,(void *)&set, sizeof(int));
+   #endif
+
+   #ifdef NEKO_POSIX
+      // we don't want sockets to be inherited in case of exec
+      int old = fcntl(s,F_GETFD,0);
+      if( old >= 0 ) fcntl(s,F_SETFD,old|FD_CLOEXEC);
+   #endif
+
+   SocketWrapper *wrap = new SocketWrapper();
+   wrap->socket = s;
+   return wrap;
+}
+
+/**
+   socket_close : 'socket -> void
+   <doc>Close a socket. Any subsequent operation on this socket will fail</doc>
+**/
+void _hx_std_socket_close( Dynamic handle )
+{
+   SOCKET s = val_sock(handle);
+   POSIX_LABEL(close_again);
+   if( s != INVALID_SOCKET && closesocket(s) ) {
+      HANDLE_EINTR(close_again);
+   }
+   reset_sock(handle);
+}
+
+/**
+   socket_send_char : 'socket -> int -> void
+   <doc>Send a character over a connected socket. Must be in the range 0..255</doc>
+**/
+void _hx_std_socket_send_char( Dynamic o, int c )
+{
+   SOCKET sock = val_sock(o);
+   if( c < 0 || c > 255 )
+      return;
+
+   unsigned char cc = (unsigned char)c;
+
+   hx::EnterGCFreeZone();
+   POSIX_LABEL(send_char_again);
+   if( send(sock,(const char *)&cc,1,MSG_NOSIGNAL) == SOCKET_ERROR )
+   {
+      HANDLE_EINTR(send_char_again);
+      block_error();
+   }
+   hx::ExitGCFreeZone();
+}
+
+/**
+   socket_send : 'socket -> buf:string -> pos:int -> len:int -> int
+   <doc>Send up to [len] bytes from [buf] starting at [pos] over a connected socket.
+   Return the number of bytes sent.</doc>
+**/
+int _hx_std_socket_send( Dynamic o, Array<unsigned char> buf, int p, int l )
+{
+   SOCKET sock = val_sock(o);
+   int dlen = buf->length;
+   if( p < 0 || l < 0 || p > dlen || p + l > dlen )
+      return 0;
+
+   const char *base = (const char *)&buf[0];
+   hx::EnterGCFreeZone();
+   dlen = send(sock, base + p , l, MSG_NOSIGNAL);
+   if( dlen == SOCKET_ERROR )
+      block_error();
+   hx::ExitGCFreeZone();
+   return dlen;
+}
+
+/**
+   socket_recv : 'socket -> buf:string -> pos:int -> len:int -> int
+   <doc>Read up to [len] bytes from [buf] starting at [pos] from a connected socket.
+   Return the number of bytes readed.</doc>
+**/
+int _hx_std_socket_recv( Dynamic o, Array<unsigned char> buf, int p, int l )
+{
+   SOCKET sock = val_sock(o);
+   int dlen = buf->length;
+   if( p < 0 || l < 0 || p > dlen || p + l > dlen )
+      return 0;
+
+   char *base = (char *)&buf[0];
+   hx::EnterGCFreeZone();
+   POSIX_LABEL(recv_again);
+   dlen = recv(sock, base + p, l, MSG_NOSIGNAL);
+   if( dlen == SOCKET_ERROR )
+   {
+      HANDLE_EINTR(recv_again);
+      block_error();
+   }
+   hx::ExitGCFreeZone();
+   return dlen;
+}
+
+/**
+   socket_recv_char : 'socket -> int
+   <doc>Read a single char from a connected socket.</doc>
+**/
+int _hx_std_socket_recv_char( Dynamic o )
+{
+   SOCKET sock = val_sock(o);
+
+   hx::EnterGCFreeZone();
+   POSIX_LABEL(recv_char_again);
+   unsigned char cc = 0;
+   int ret = recv(sock,(char *)&cc,1,MSG_NOSIGNAL);
+   if( ret == SOCKET_ERROR )
+   {
+      HANDLE_EINTR(recv_char_again);
+      block_error();
+   }
+   hx::ExitGCFreeZone();
+   if( ret == 0 )
+      hx::Throw(HX_CSTRING("Connection closed"));
+   return cc;
+}
+
+
+/**
+   socket_write : 'socket -> string -> void
+   <doc>Send the whole content of a string over a connected socket.</doc>
+**/
+void _hx_std_socket_write( Dynamic o, Array<unsigned char> buf )
+{
+   SOCKET sock = val_sock(o);
+   int datalen = buf->length;
+   const char *cdata = (const char *)&buf[0];
+   int pos = 0;
+
+   hx::EnterGCFreeZone();
+   while( datalen > 0 )
+   {
+      POSIX_LABEL(write_again);
+      int slen = send(sock,cdata + pos,datalen,MSG_NOSIGNAL);
+      if( slen == SOCKET_ERROR ) {
+         HANDLE_EINTR(write_again);
+         block_error();
+      }
+      pos += slen;
+      datalen -= slen;
+   }
+   hx::ExitGCFreeZone();
+}
+
+
+/**
+   socket_read : 'socket -> string
+   <doc>Read the whole content of a the data available from a socket until the connection close.
+   If the socket hasn't been close by the other side, the function might block.
+   </doc>
+**/
+Array<unsigned char> _hx_std_socket_read( Dynamic o )
+{
+   SOCKET sock = val_sock(o);
+   Array<unsigned char> result = Array_obj<unsigned char>::__new();
+   char buf[256];
+
+   hx::EnterGCFreeZone();
+   while( true )
+   {
+      POSIX_LABEL(read_again);
+      int len = recv(sock,buf,256,MSG_NOSIGNAL);
+      if( len == SOCKET_ERROR ) {
+         HANDLE_EINTR(read_again);
+         block_error();
+      }
+      if( len == 0 )
+         break;
+
+      hx::ExitGCFreeZone();
+      result->memcpy(result->length, (unsigned char *)buf, len );
+      hx::EnterGCFreeZone();
+   }
+
+   hx::ExitGCFreeZone();
+   return result;
+}
+
+/**
+   host_resolve : string -> 'int32
+   <doc>Resolve the given host string into an IP address.</doc>
+**/
+int _hx_std_host_resolve( String host )
+{
+   unsigned int ip;
+
+   hx::EnterGCFreeZone();
+   hx::strbuf buf;
+   ip = inet_addr(host.utf8_str(&buf));
+   if( ip == INADDR_NONE )
+   {
+      struct hostent *h = 0;
+      hx::strbuf hostBuf;
+
+#   if defined(NEKO_WINDOWS) || defined(NEKO_MAC) || defined(BLACKBERRY) || defined(EMSCRIPTEN)
+      h = gethostbyname(host.utf8_str(&hostBuf));
+#   else
+      struct hostent hbase;
+      char buf[1024];
+      int errcode;
+      gethostbyname_r(host.utf8_str(&hostBuf),&hbase,buf,1024,&h,&errcode);
+#   endif
+      if( !h ) {
+         hx::ExitGCFreeZone();
+         return hx::Throw( HX_CSTRING("Unknown host:") + host );
+      }
+      ip = *((unsigned int*)h->h_addr);
+   }
+   hx::ExitGCFreeZone();
+   return ip;
+}
+
+#ifdef DYNAMIC_INET_FUNCS
+bool dynamic_inet_pton_tried = false;
+inet_pton_func dynamic_inet_pton = 0;
+#endif
+
+Array<unsigned char> _hx_std_host_resolve_ipv6( String host, bool )
+{
+   in6_addr ipv6;
+
+   hx::strbuf hostBuf;
+   const char *hostStr = host.utf8_str(&hostBuf);
+   #ifdef DYNAMIC_INET_FUNCS
+   if (!dynamic_inet_pton_tried)
+   {
+      dynamic_inet_pton_tried = true;
+      HMODULE module = LoadLibraryA("WS2_32.dll");
+      if (module)
+         dynamic_inet_pton = (inet_pton_func)GetProcAddress(module,"inet_pton");
+   }
+   int ok = dynamic_inet_pton ? dynamic_inet_pton(AF_INET6, hostStr, (void *)&ipv6) : 0;
+   #else
+   int ok = inet_pton(AF_INET6, hostStr, (void *)&ipv6);
+   #endif
+
+   if (!ok)
+   {
+      addrinfo hints;
+
+      memset(&hints, 0, sizeof(struct addrinfo));
+      hints.ai_family = AF_INET6;  //  IPv6
+      hints.ai_socktype = 0;  // any - SOCK_STREAM or SOCK_DGRAM
+      hints.ai_flags = AI_PASSIVE;  // For wildcard IP address
+      hints.ai_protocol = 0;        // Any protocol
+      hints.ai_canonname = 0;
+      hints.ai_addr = 0;
+      hints.ai_next = 0;
+
+      addrinfo *result = 0;
+      hx::EnterGCFreeZone();
+      int err =  getaddrinfo( hostStr, 0, &hints, &result);
+      hx::ExitGCFreeZone();
+      if (err==0)
+      {
+         for(addrinfo * rp = result; rp; rp = rp->ai_next)
+         {
+            if (rp->ai_family==AF_INET6)
+            {
+               sockaddr_in6 *s6 = (sockaddr_in6 *)rp->ai_addr;
+               ipv6 = s6->sin6_addr;
+               ok = true;
+               break;
+            }
+            else
+            {
+               freeaddrinfo(result);
+               hx::Throw( HX_CSTRING("Unkown ai_family") );
+            }
+         }
+         freeaddrinfo(result);
+      }
+      else
+      {
+         hx::Throw( host + HX_CSTRING(":") + String(gai_strerror(err)) );
+      }
+   }
+
+   if (!ok)
+      return null();
+
+   return Array_obj<unsigned char>::fromData( (unsigned char *)&ipv6, 16 );
+}
+
+
+
+/**
+   host_to_string : 'int32 -> string
+   <doc>Return a string representation of the IP address.</doc>
+**/
+String _hx_std_host_to_string( int ip )
+{
+   struct in_addr i;
+   *(int*)&i = ip;
+   return String( inet_ntoa(i) );
+}
+
+
+#ifdef DYNAMIC_INET_FUNCS
+bool dynamic_inet_ntop_tried = false;
+inet_ntop_func dynamic_inet_ntop = 0;
+#endif
+
+
+String _hx_std_host_to_string_ipv6( Array<unsigned char> ip )
+{
+   char buf[100];
+   #ifdef DYNAMIC_INET_FUNCS
+   if (!dynamic_inet_ntop_tried)
+   {
+      dynamic_inet_ntop_tried = true;
+      HMODULE module = LoadLibraryA("WS2_32.dll");
+      if (module)
+         dynamic_inet_ntop = (inet_ntop_func)GetProcAddress(module,"inet_ntop");
+   }
+   if (!dynamic_inet_ntop)
+      return String();
+   return String( dynamic_inet_ntop(AF_INET6, &ip[0], buf, 100) );
+   #else
+   return String( inet_ntop(AF_INET6, &ip[0], buf, 100) );
+   #endif
+}
+
+/**
+   host_reverse : 'int32 -> string
+   <doc>Reverse the DNS of the given IP address.</doc>
+**/
+String _hx_std_host_reverse( int host )
+{
+   struct hostent *h = 0;
+   unsigned int ip = host;
+   hx::EnterGCFreeZone();
+   #if defined(NEKO_WINDOWS) || defined(NEKO_MAC) || defined(ANDROID) || defined(BLACKBERRY) || defined(EMSCRIPTEN)
+   h = gethostbyaddr((char *)&ip,4,AF_INET);
+   #else
+   struct hostent htmp;
+   int errcode;
+   char buf[1024];
+   gethostbyaddr_r((char *)&ip,4,AF_INET,&htmp,buf,1024,&h,&errcode);
+   #endif
+   hx::ExitGCFreeZone();
+   if( !h )
+      return String();
+   return String( h->h_name );
+}
+
+String _hx_std_host_reverse_ipv6( Array<unsigned char> host )
+{
+   if (!host.mPtr || host->length!=16)
+      return String();
+
+   struct hostent *h = 0;
+   hx::EnterGCFreeZone();
+   #if defined(NEKO_WINDOWS) || defined(NEKO_MAC) || defined(ANDROID) || defined(BLACKBERRY) || defined(EMSCRIPTEN)
+   h = gethostbyaddr((char *)&host[0],16,AF_INET6);
+   #else
+   struct hostent htmp;
+   int errcode;
+   char buf[1024];
+   gethostbyaddr_r((char *)&host[0],16,AF_INET6,&htmp,buf,1024,&h,&errcode);
+   #endif
+   hx::ExitGCFreeZone();
+   if( !h )
+      return String();
+   return String( h->h_name );
+}
+
+
+/**
+   host_local : void -> string
+   <doc>Return the local host name.</doc>
+**/
+String _hx_std_host_local()
+{
+   char buf[256];
+   hx::EnterGCFreeZone();
+   if( gethostname(buf,256) == SOCKET_ERROR )
+   {
+      hx::ExitGCFreeZone();
+      return String();
+   }
+   hx::ExitGCFreeZone();
+   return String(buf);
+}
+
+/**
+   socket_connect : 'socket -> host:'int32 -> port:int -> void
+   <doc>Connect the socket the given [host] and [port]</doc>
+**/
+void _hx_std_socket_connect( Dynamic o, int host, int port )
+{
+   struct sockaddr_in addr;
+   memset(&addr,0,sizeof(addr));
+   addr.sin_family = AF_INET;
+   addr.sin_port = htons(port);
+   *(int*)&addr.sin_addr.s_addr = host;
+
+   hx::EnterGCFreeZone();
+   if( connect(val_sock(o),(struct sockaddr*)&addr,sizeof(addr)) == SOCKET_ERROR )
+   {
+      // This will throw a "Blocking" exception if the "error" was because
+      // it's a non-blocking socket with connection in progress, otherwise
+      // it will do nothing.
+      //
+      // - now it always throws
+      block_error();
+   }
+   hx::ExitGCFreeZone();
+}
+
+
+/**
+   socket_connect - to ipv6 host
+**/
+void _hx_std_socket_connect_ipv6( Dynamic o, Array<unsigned char> host, int port )
+{
+   struct sockaddr_in6 addr;
+   memset(&addr,0,sizeof(addr));
+   addr.sin6_family = AF_INET6;
+   addr.sin6_port = htons(port);
+   memcpy(&addr.sin6_addr,&host[0],16);
+
+   hx::EnterGCFreeZone();
+   if( connect(val_sock(o),(struct sockaddr*)&addr,sizeof(addr)) != 0 )
+   {
+      // This will throw a "Blocking" exception if the "error" was because
+      // it's a non-blocking socket with connection in progress, otherwise
+      // it will do nothing.
+      //
+      // - now it always throws
+      block_error();
+   }
+   hx::ExitGCFreeZone();
+}
+
+/**
+   socket_listen : 'socket -> int -> void
+   <doc>Listen for a number of connections</doc>
+**/
+void _hx_std_socket_listen( Dynamic o, int n )
+{
+   SOCKET sock = val_sock(o);
+   hx::EnterGCFreeZone();
+   if( listen(sock,n) == SOCKET_ERROR )
+   {
+      hx::ExitGCFreeZone();
+      return;
+   }
+   hx::ExitGCFreeZone();
+}
+
+static fd_set INVALID;
+
+static fd_set *make_socket_array( Array<Dynamic> a, fd_set *tmp, SOCKET *n )
+{
+   FD_ZERO(tmp);
+   if( !a.mPtr )
+      return tmp;
+
+   int len = a->length;
+   if( len > FD_SETSIZE )
+      hx::Throw(HX_CSTRING("Too many sockets in select"));
+
+   for(int i=0;i<len;i++)
+   {
+      // make sure it is a socket...
+      SOCKET sock = val_sock( a[i] );
+      if( sock > *n )
+         *n = sock;
+      FD_SET(sock,tmp);
+   }
+   return tmp;
+}
+
+static Array<Dynamic> make_array_result( Array<Dynamic> a, fd_set *tmp )
+{
+   if (!tmp || !a.mPtr)
+      return null();
+
+   int len = a->length;
+   Array<Dynamic> r = Array_obj<Dynamic>::__new();
+   for(int i=0;i<len;i++)
+   {
+      Dynamic s = a[i];
+      if( FD_ISSET(val_sock(s),tmp) )
+         r->push(s);
+   }
+   return r;
+}
+
+static void make_array_result_inplace(Array<Dynamic> a, fd_set *tmp)
+{
+    if (!a.mPtr)
+      return;
+
+    if (tmp == NULL)
+    {
+       a->__SetSize(0);
+       return;
+    }
+
+    int len = a->length;
+    int destPos = 0;
+    for(int i = 0; i < len; i++)
+    {
+       Dynamic s = a[i];
+       if (FD_ISSET(val_sock(s), tmp)) {
+           a[destPos++] = s;
+       }
+    }
+
+    a->__SetSize(destPos);
+}
+
+static struct timeval *init_timeval( double f, struct timeval *t ) {
+   if (f<0)
+      return 0;
+   t->tv_usec = (f - (int)f ) * 1000000;
+   t->tv_sec = (int)f;
+   return t;
+}
+
+/**
+   socket_select : read : 'socket array -> write : 'socket array -> others : 'socket array -> timeout:number? -> 'socket array array
+   <doc>Perform the [select] operation. Timeout is in seconds or [null] if infinite</doc>
+**/
+Array<Dynamic> _hx_std_socket_select( Array<Dynamic> rs, Array<Dynamic> ws, Array<Dynamic> es, Dynamic timeout )
+{
+   SOCKET n = 0;
+   fd_set rx, wx, ex;
+   fd_set *ra, *wa, *ea;
+
+   POSIX_LABEL(select_again);
+   ra = make_socket_array(rs,&rx,&n);
+   wa = make_socket_array(ws,&wx,&n);
+   ea = make_socket_array(es,&ex,&n);
+   if( ra == &INVALID || wa == &INVALID || ea == &INVALID )
+      hx::Throw( HX_CSTRING("No valid sockets") );
+
+   struct timeval tval;
+   struct timeval *tt = 0;
+   if( timeout.mPtr )
+      tt = init_timeval(timeout,&tval);
+
+   hx::EnterGCFreeZone();
+   if( select((int)(n+1),ra,wa,ea,tt) == SOCKET_ERROR )
+   {
+      hx::ExitGCFreeZone();
+      HANDLE_EINTR(select_again);
+      hx::Throw( HX_CSTRING("Select error ") + String((int)errno) );
+   }
+   hx::ExitGCFreeZone();
+
+   Array<Dynamic> r = Array_obj<Dynamic>::__new(3,3);
+   r[0] = make_array_result(rs,ra);
+   r[1] = make_array_result(ws,wa);
+   r[2] = make_array_result(es,ea);
+   return r;
+}
+
+/**
+   socket_select : read : 'socket array -> write : 'socket array -> others : 'socket array -> timeout:number?
+   <doc>Perform the [select] operation. Timeout is in seconds or [null] if infinite</doc>
+**/
+void _hx_std_socket_fast_select( Array<Dynamic> rs, Array<Dynamic> ws, Array<Dynamic> es, Dynamic timeout )
+{
+   SOCKET n = 0;
+   fd_set rx, wx, ex;
+   fd_set *ra, *wa, *ea;
+
+   POSIX_LABEL(select_again);
+   ra = make_socket_array(rs,&rx,&n);
+   wa = make_socket_array(ws,&wx,&n);
+   ea = make_socket_array(es,&ex,&n);
+
+   if( ra == &INVALID || wa == &INVALID || ea == &INVALID )
+      hx::Throw( HX_CSTRING("No valid sockets") );
+
+
+   struct timeval tval;
+   struct timeval *tt = 0;
+   if( timeout.mPtr )
+      tt = init_timeval(timeout,&tval);
+
+   hx::EnterGCFreeZone();
+   if( select((int)(n+1),ra,wa,ea,tt) == SOCKET_ERROR )
+   {
+      hx::ExitGCFreeZone();
+      HANDLE_EINTR(select_again);
+      #ifdef NEKO_WINDOWS
+      hx::Throw( HX_CSTRING("Select error ") + String((int)WSAGetLastError()) );
+      #else
+      hx::Throw( HX_CSTRING("Select error ") + String((int)errno) );
+      #endif
+   }
+
+   hx::ExitGCFreeZone();
+   make_array_result_inplace(rs, ra);
+   make_array_result_inplace(ws, wa);
+   make_array_result_inplace(es, ea);
+}
+
+/**
+   socket_bind : 'socket -> host : 'int -> port:int -> void
+   <doc>Bind the socket for server usage on the given host and port</doc>
+**/
+void _hx_std_socket_bind( Dynamic o, int host, int port )
+{
+   SOCKET sock = val_sock(o);
+
+   int opt = 1;
+   struct sockaddr_in addr;
+   memset(&addr,0,sizeof(addr));
+   addr.sin_family = AF_INET;
+   addr.sin_port = htons(port);
+   *(int*)&addr.sin_addr.s_addr = host;
+   #ifndef NEKO_WINDOWS
+   setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,(char*)&opt,sizeof(opt));
+   #endif
+
+   hx::EnterGCFreeZone();
+   if( bind(sock,(struct sockaddr*)&addr,sizeof(addr)) == SOCKET_ERROR )
+   {
+      hx::ExitGCFreeZone();
+      hx::Throw(HX_CSTRING("Bind failed"));
+   }
+   hx::ExitGCFreeZone();
+}
+
+
+/**
+   socket_bind - ipv6 version
+   <doc>Bind the socket for server usage on the given host and port</doc>
+**/
+void _hx_std_socket_bind_ipv6( Dynamic o, Array<unsigned char> host, int port )
+{
+   SOCKET sock = val_sock(o);
+
+   int opt = 1;
+
+   struct sockaddr_in6 addr;
+   memset(&addr,0,sizeof(addr));
+   addr.sin6_family = AF_INET6;
+   addr.sin6_port = htons(port);
+   memcpy(&addr.sin6_addr,&host[0], 16);
+   #ifndef NEKO_WINDOWS
+   setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,(char*)&opt,sizeof(opt));
+   #endif
+
+   hx::EnterGCFreeZone();
+   if( bind(sock,(struct sockaddr*)&addr,sizeof(addr)) == SOCKET_ERROR )
+   {
+      hx::ExitGCFreeZone();
+      hx::Throw(HX_CSTRING("Bind failed"));
+   }
+   hx::ExitGCFreeZone();
+}
+
+
+/**
+   socket_accept : 'socket -> 'socket
+   <doc>Accept an incoming connection request</doc>
+**/
+
+#ifdef _WIN32
+   typedef int SockLen;
+#elif defined(ANDROID)
+   typedef socklen_t SockLen;
+#else
+   typedef unsigned int SockLen;
+#endif
+
+Dynamic _hx_std_socket_accept( Dynamic o )
+{
+   SOCKET sock = val_sock(o);
+   struct sockaddr_in addr;
+   SockLen addrlen = sizeof(addr);
+   SOCKET s;
+   hx::EnterGCFreeZone();
+   s = accept(sock,(struct sockaddr*)&addr,&addrlen);
+   if( s == INVALID_SOCKET )
+      block_error();
+   hx::ExitGCFreeZone();
+
+   SocketWrapper *wrap = new SocketWrapper();
+   wrap->socket = s;
+   return wrap;
+}
+
+/**
+   socket_peer : 'socket -> #address
+   <doc>Return the socket connected peer address composed of an (host,port) array</doc>
+**/
+Array<int> _hx_std_socket_peer( Dynamic o )
+{
+   SOCKET sock = val_sock(o);
+   struct sockaddr_in addr;
+   SockLen addrlen = sizeof(addr);
+   hx::EnterGCFreeZone();
+   if( getpeername(sock,(struct sockaddr*)&addr,&addrlen) == SOCKET_ERROR )
+   {
+      hx::ExitGCFreeZone();
+      return null();
+   }
+   hx::ExitGCFreeZone();
+
+   Array<int> ret = Array_obj<int>::__new(2,2);
+   ret[0] = *(int*)&addr.sin_addr;
+   ret[1] = ntohs(addr.sin_port);
+   return ret;
+}
+
+/**
+   socket_host : 'socket -> #address
+   <doc>Return the socket local address composed of an (host,port) array</doc>
+**/
+Array<int> _hx_std_socket_host( Dynamic o )
+{
+   SOCKET sock = val_sock(o);
+   struct sockaddr_in addr;
+   SockLen addrlen = sizeof(addr);
+   hx::EnterGCFreeZone();
+   if( getsockname(sock,(struct sockaddr*)&addr,&addrlen) == SOCKET_ERROR )
+   {
+      hx::ExitGCFreeZone();
+      return null();
+   }
+   hx::ExitGCFreeZone();
+
+   Array<int> ret = Array_obj<int>::__new(2,2);
+   ret[0] = *(int*)&addr.sin_addr;
+   ret[1] = ntohs(addr.sin_port);
+   return ret;
+}
+
+/**
+   socket_set_timeout : 'socket -> timout:number? -> void
+   <doc>Set the socket send and recv timeout in seconds to the given value (or null for blocking)</doc>
+**/
+void _hx_std_socket_set_timeout( Dynamic o, Dynamic t )
+{
+   SOCKET sock = val_sock(o);
+
+#ifdef NEKO_WINDOWS
+   int time;
+   if( !t.mPtr )
+      time = 0;
+   else {
+      time = (int)((double)(t) * 1000);
+   }
+#else
+   struct timeval time;
+   if( t.mPtr==0 ) {
+      time.tv_usec = 0;
+      time.tv_sec = 0;
+   } else {
+      init_timeval(t,&time);
+   }
+#endif
+
+   hx::EnterGCFreeZone();
+   if( setsockopt(sock,SOL_SOCKET,SO_SNDTIMEO,(char*)&time,sizeof(time)) != 0 )
+   {
+      hx::ExitGCFreeZone();
+      return;
+   }
+   if( setsockopt(sock,SOL_SOCKET,SO_RCVTIMEO,(char*)&time,sizeof(time)) != 0 )
+   {
+      hx::ExitGCFreeZone();
+      return;
+   }
+   hx::ExitGCFreeZone();
+}
+
+/**
+   socket_shutdown : 'socket -> read:bool -> write:bool -> void
+   <doc>Prevent the socket from further reading or writing or both.</doc>
+**/
+void _hx_std_socket_shutdown( Dynamic o, bool r, bool w )
+{
+   SOCKET sock = val_sock(o);
+   if( !r && !w )
+      return;
+
+   hx::EnterGCFreeZone();
+   if( shutdown(sock,(r)?((w)?SHUT_RDWR:SHUT_RD):SHUT_WR) )
+   {
+      hx::ExitGCFreeZone();
+      return;
+   }
+   hx::ExitGCFreeZone();
+}
+
+/**
+   socket_set_blocking : 'socket -> bool -> void
+   <doc>Turn on/off the socket blocking mode.</doc>
+**/
+#include <stdlib.h>
+
+void _hx_std_socket_set_blocking( Dynamic o, bool b )
+{
+   SOCKET sock = val_sock(o);
+   hx::EnterGCFreeZone();
+#ifdef NEKO_WINDOWS
+   {
+      unsigned long arg = b?0:1;
+      if( ioctlsocket(sock,FIONBIO,&arg) != 0 )
+      {
+         hx::ExitGCFreeZone();
+         return;
+      }
+   }
+#else
+   {
+      int rights = fcntl(sock,F_GETFL);
+      if( rights == -1 )
+      {
+         hx::ExitGCFreeZone();
+         return;
+      }
+      if( b )
+         rights &= ~O_NONBLOCK;
+      else
+         rights |= O_NONBLOCK;
+      if( fcntl(sock,F_SETFL,rights) == -1 )
+      {
+         hx::ExitGCFreeZone();
+         return;
+      }
+   }
+#endif
+   hx::ExitGCFreeZone();
+   return;
+}
+
+
+void _hx_std_socket_set_fast_send( Dynamic o, bool b )
+{
+   SOCKET sock = val_sock(o);
+   int fast = (b);
+   hx::EnterGCFreeZone();
+   setsockopt(sock,IPPROTO_TCP,TCP_NODELAY,(char*)&fast,sizeof(fast));
+   hx::ExitGCFreeZone();
+}
+
+void _hx_std_socket_set_broadcast( Dynamic o, bool b )
+{
+   SOCKET sock = val_sock(o);
+   int broadcast = (b);
+   hx::EnterGCFreeZone();
+   setsockopt(sock,SOL_SOCKET,SO_BROADCAST,(char*)&broadcast,sizeof(broadcast));
+   hx::ExitGCFreeZone();
+}
+
+
+/**
+   socket_poll_alloc : int -> 'poll
+   <doc>Allocate memory to perform polling on a given number of sockets</doc>
+**/
+
+namespace
+{
+
+static int pollType = 0;
+
+struct polldata : public hx::Object
+{
+   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdPollData };
+
+   bool ok;
+   int max;
+   #ifdef NEKO_WINDOWS
+   struct fd_set *fdr;
+   struct fd_set *fdw;
+   struct fd_set *outr;
+   struct fd_set *outw;
+   #else
+   struct pollfd *fds;
+   int rcount;
+   int wcount;
+   #endif
+   Array<int> ridx;
+   Array<int> widx;
+
+   void create(int nsocks)
+   {
+      ok = true;
+      max = nsocks;
+      #ifdef NEKO_WINDOWS
+      fdr = (fd_set*)malloc(FDSIZE(max));
+      fdw = (fd_set*)malloc(FDSIZE(max));
+      outr = (fd_set*)malloc(FDSIZE(max));
+      outw = (fd_set*)malloc(FDSIZE(max));
+      fdr->fd_count = 0;
+      fdw->fd_count = 0;
+
+      #else
+      fds = (struct pollfd*)malloc(sizeof(struct pollfd) * max);
+      rcount = 0;
+      wcount = 0;
+      #endif
+
+      ridx = Array_obj<int>::__new(max+1,max+1);
+      HX_OBJ_WB_GET(this, ridx.mPtr);
+      widx = Array_obj<int>::__new(max+1,max+1);
+      HX_OBJ_WB_GET(this, widx.mPtr);
+      for(int i=0;i<=max;i++)
+      {
+         ridx[i] = -1;
+         widx[i] = -1;
+      }
+
+      _hx_set_finalizer(this, finalize);
+   }
+
+   void destroy()
+   {
+      if (ok)
+      {
+         ok = false;
+         #ifdef NEKO_WINDOWS
+         free(fdr);
+         free(fdw);
+         free(outr);
+         free(outw);
+         #else
+         // ???
+         free(fds);
+         #endif
+      }
+   }
+
+   void __Mark(hx::MarkContext *__inCtx) { HX_MARK_MEMBER(ridx); HX_MARK_MEMBER(widx); }
+   #ifdef HXCPP_VISIT_ALLOCS
+   void __Visit(hx::VisitContext *__inCtx) { HX_VISIT_MEMBER(ridx); HX_VISIT_MEMBER(widx); }
+   #endif
+
+   int __GetType() const { return pollType; }
+
+   static void finalize(Dynamic obj)
+   {
+      ((polldata *)(obj.mPtr))->destroy();
+   }
+
+   String toString() { return HX_CSTRING("polldata"); }
+};
+
+polldata *val_poll(Dynamic o)
+{
+   if (!o.mPtr || o->__GetType()!=pollType)
+      hx::Throw(HX_CSTRING("Invalid polldata:") + o);
+   return static_cast<polldata *>(o.mPtr);
+}
+
+
+} // end namespace
+
+
+
+Dynamic _hx_std_socket_poll_alloc( int nsocks )
+{
+   if( nsocks < 0 || nsocks > 1000000 )
+      return null();
+
+   if (pollType==0)
+      pollType = hxcpp_alloc_kind();
+
+   polldata *p = new polldata;
+   p->create(nsocks);
+   return p;
+}
+
+/**
+   socket_poll_prepare : 'poll -> read:'socket array -> write:'socket array -> int array array
+   <doc>
+   Prepare a poll for scanning events on sets of sockets.
+   </doc>
+**/
+Array<Dynamic> _hx_std_socket_poll_prepare( Dynamic pdata, Array<Dynamic> rsocks, Array<Dynamic> wsocks )
+{
+   polldata *p = val_poll(pdata);
+
+   int len = rsocks.mPtr ? rsocks->length : 0;
+   int wlen = wsocks.mPtr ? wsocks->length : 0;
+   if( len + wlen > p->max )
+      hx::Throw(HX_CSTRING("Too many sockets in poll"));
+
+   #ifdef NEKO_WINDOWS
+   for(int i=0;i<len;i++)
+      p->fdr->fd_array[i] = val_sock( rsocks[i] );
+   p->fdr->fd_count = len;
+
+   len = wlen;
+   for(int i=0;i<len;i++)
+      p->fdw->fd_array[i] = val_sock( wsocks[i]);
+   p->fdw->fd_count = len;
+
+   #else
+
+   for(int i=0;i<len;i++)
+   {
+      p->fds[i].fd = val_sock( rsocks[i] );
+      p->fds[i].events = POLLIN;
+      p->fds[i].revents = 0;
+   }
+   p->rcount = len;
+   len = wlen;
+   for(int i=0;i<len;i++)
+   {
+      int k = i + p->rcount;
+      p->fds[k].fd = val_sock(wsocks[i]);
+      p->fds[k].events = POLLOUT;
+      p->fds[k].revents = 0;
+   }
+   p->wcount = len;
+
+   #endif
+
+   Array<Dynamic> a = Array_obj<Dynamic>::__new(2,2);
+   a[0] = p->ridx;
+   a[1] = p->widx;
+   return a;
+}
+
+
+/**
+   socket_poll_events : 'poll -> timeout:float -> void
+   <doc>
+   Update the read/write flags arrays that were created with [socket_poll_prepare].
+   </doc>
+**/
+void _hx_std_socket_poll_events( Dynamic pdata, double timeout )
+{
+   polldata *p = val_poll(pdata);
+
+   #ifdef NEKO_WINDOWS
+   memcpy(p->outr,p->fdr,FDSIZE(p->fdr->fd_count));
+   memcpy(p->outw,p->fdw,FDSIZE(p->fdw->fd_count));
+
+   struct timeval t;
+   struct timeval *tt = init_timeval(timeout,&t);
+
+   hx::EnterGCFreeZone();
+   if( select(0/* Ignored */, p->fdr->fd_count ? p->outr : 0, p->fdw->fd_count ?p->outw : 0,NULL,tt) == SOCKET_ERROR )
+   {
+      hx::ExitGCFreeZone();
+      return;
+   }
+   hx::ExitGCFreeZone();
+
+   int k = 0;
+   for(int i=0;i<p->fdr->fd_count;i++)
+      if( FD_ISSET(p->fdr->fd_array[i],p->outr) )
+         p->ridx[k++] = i;
+   p->ridx[k] = -1;
+
+   k = 0;
+   for(int i=0;i<p->fdw->fd_count;i++)
+      if( FD_ISSET(p->fdw->fd_array[i],p->outw) )
+         p->widx[k++] = i;
+   p->widx[k] = -1;
+
+   #else
+
+   int tot = p->rcount + p->wcount;
+   hx::EnterGCFreeZone();
+   POSIX_LABEL(poll_events_again);
+   if( poll(p->fds,tot,(int)(timeout * 1000)) < 0 )
+   {
+      HANDLE_EINTR(poll_events_again);
+      hx::ExitGCFreeZone();
+      return;
+   }
+   hx::ExitGCFreeZone();
+
+   int k = 0;
+   int i = 0;
+   for(i=0;i<p->rcount;i++)
+      if( p->fds[i].revents & (POLLIN|POLLHUP) )
+         p->ridx[k++] = i;
+   p->ridx[k] = -1;
+   k = 0;
+   for(;i<tot;i++)
+      if( p->fds[i].revents & (POLLOUT|POLLHUP) )
+         p->widx[k++] = i - p->rcount;
+   p->widx[k] = -1;
+   #endif
+}
+
+
+/**
+   socket_poll : 'socket array -> 'poll -> timeout:float -> 'socket array
+   <doc>
+   Perform a polling for data available over a given set of sockets. This is similar to [socket_select]
+   except that [socket_select] is limited to a given number of simultaneous sockets to check.
+   </doc>
+**/
+Array<Dynamic> _hx_std_socket_poll( Array<Dynamic> socks, Dynamic pdata, double timeout )
+{
+   polldata *p = val_poll(pdata);
+
+   _hx_std_socket_poll_prepare(pdata,socks,null());
+
+   _hx_std_socket_poll_events(pdata,timeout);
+
+   int rcount = 0;
+   while( p->ridx[rcount] != -1 )
+      rcount++;
+
+   Array<Dynamic> a = Array_obj<Dynamic>::__new(rcount,rcount);
+   for(int i=0;i<rcount;i++)
+      a[i] = socks[p->ridx[i]];
+   return a;
+}
+
+
+
+/**
+   socket_send_to : 'socket -> buf:string -> pos:int -> length:int -> addr:{host:'int32,port:int} -> int
+   <doc>
+   Send data from an unconnected UDP socket to the given address.
+   </doc>
+**/
+int _hx_std_socket_send_to( Dynamic o, Array<unsigned char> buf, int p, int l, Dynamic inAddr )
+{
+   SOCKET sock = val_sock(o);
+
+   const char *cdata = (const char *)&buf[0];
+   int dlen = buf->length;
+   if( p < 0 || l < 0 || p > dlen || p + l > dlen )
+      hx::Throw(HX_CSTRING("Invalid data position"));
+
+
+   int host = inAddr->__Field(HX_CSTRING("host"), hx::paccDynamic);
+   int port = inAddr->__Field(HX_CSTRING("port"), hx::paccDynamic);
+   struct sockaddr_in addr;
+   memset(&addr,0,sizeof(addr));
+   addr.sin_family = AF_INET;
+   addr.sin_port = htons(port);
+   *(int*)&addr.sin_addr.s_addr = host;
+
+
+   hx::EnterGCFreeZone();
+   POSIX_LABEL(send_again);
+   dlen = sendto(sock, cdata + p , l, MSG_NOSIGNAL, (struct sockaddr*)&addr, sizeof(addr));
+   if( dlen == SOCKET_ERROR ) {
+      HANDLE_EINTR(send_again);
+      block_error();
+   }
+   hx::ExitGCFreeZone();
+   return dlen;
+}
+
+/**
+   socket_recv_from : 'socket -> buf:string -> pos:int -> length:int -> addr:{host:'int32,port:int} -> int
+   <doc>
+   Read data from an unconnected UDP socket, store the address from which we received data in addr.
+   </doc>
+**/
+#define NRETRYS   20
+int _hx_std_socket_recv_from( Dynamic o, Array<unsigned char> buf, int p, int l, Dynamic outAddr)
+{
+   int retry = 0;
+   SOCKET sock = val_sock(o);
+
+   char *data = (char *)&buf[0];
+   int dlen = buf->length;
+   if( p < 0 || l < 0 || p > dlen || p + l > dlen )
+      hx::Throw(HX_CSTRING("Invalid data position"));
+
+   struct sockaddr_in saddr;
+   SockLen slen = sizeof(saddr);
+
+   int ret = 0;
+   hx::EnterGCFreeZone();
+   POSIX_LABEL(recv_from_again);
+   if( retry++ > NRETRYS ) {
+      ret = recv(sock,data+p,l,MSG_NOSIGNAL);
+   } else
+      ret = recvfrom(sock, data + p , l, MSG_NOSIGNAL, (struct sockaddr*)&saddr, &slen);
+   if( ret == SOCKET_ERROR ) {
+      HANDLE_EINTR(recv_from_again);
+      block_error();
+   }
+
+   hx::ExitGCFreeZone();
+   outAddr->__SetField(HX_CSTRING("host"),*(int*)&saddr.sin_addr, hx::paccDynamic);
+   outAddr->__SetField(HX_CSTRING("port"),ntohs(saddr.sin_port), hx::paccDynamic);
+
+   return ret;
+}
+
+
+#else // !HX_WINRT
+// TODO: WinRT StreamSocket port
+#endif // HX_WINRT
+
diff --git a/Sources/c_snikket/src/hx/libs/std/Sys.cpp b/Sources/c_snikket/src/hx/libs/std/Sys.cpp
new file mode 100644
index 0000000..371addf
--- /dev/null
+++ b/Sources/c_snikket/src/hx/libs/std/Sys.cpp
@@ -0,0 +1,908 @@
+#include <hxcpp.h>
+#include <hx/OS.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+
+#ifndef EPPC
+#include <sys/types.h>
+#include <sys/stat.h>
+#endif
+
+
+
+#ifdef NEKO_WINDOWS
+   #include <windows.h>
+   #include <direct.h>
+   #include <conio.h>
+   #include <locale.h>
+#else
+   #include <errno.h>
+   #ifndef EPPC
+      #include <unistd.h>
+      #include <dirent.h>
+      #include <termios.h>
+      #include <sys/time.h>
+      #include <sys/times.h>
+   #endif
+   #include <limits.h>
+   #ifndef ANDROID
+      #include <locale.h>
+      #if !defined(BLACKBERRY) && !defined(EPPC) && !defined(GCW0) && !defined(__GLIBC__)
+         #include <xlocale.h>
+      #endif
+   #endif
+#endif
+
+#ifdef EMSCRIPTEN
+   #include <sys/wait.h>
+#endif
+
+#if !defined(IPHONE) && !defined(APPLETV) && !defined(HX_APPLEWATCH)
+   #ifdef NEKO_MAC
+      #include <sys/syslimits.h>
+      #include <limits.h>
+      #include <mach-o/dyld.h>
+   #endif
+#endif
+
+#if defined(HX_WINRT) && !defined(_XBOX_ONE)
+   #include <string>
+#endif
+
+#ifdef HX_ANDROID
+ #include <sys/wait.h>
+#endif
+
+#ifndef CLK_TCK
+   #define CLK_TCK   100
+#endif
+
+
+/**
+   <doc>
+   <h1>System</h1>
+   <p>
+   Interactions with the operating system.
+   </p>
+   </doc>
+**/
+
+/**
+   get_env : string -> string?
+   <doc>Get some environment variable if exists</doc>
+**/
+
+String _hx_std_get_env( String v )
+{
+   #ifdef HX_WINRT
+      return String();
+   #else
+      #if defined(NEKO_WINDOWS) && defined(HX_SMART_STRINGS)
+         hx::strbuf wbuf;
+         return String::create( _wgetenv( v.wchar_str(&wbuf) ) );
+      #else
+         hx::strbuf buf;
+         return String::create( getenv(v.utf8_str(&buf)) );
+      #endif
+   #endif
+}
+
+/**
+   put_env : var:string -> val:string -> void
+   <doc>Set some environment variable value</doc>
+**/
+void _hx_std_put_env( String e, String v )
+{
+#ifdef HX_WINRT
+   // Do nothing
+#elif defined(NEKO_WINDOWS)
+   String set = e + HX_CSTRING("=") + (v != null()?v:"");
+
+   #ifdef HX_SMART_STRINGS
+   if (set.isUTF16Encoded())
+      _wputenv(set.wchar_str());
+   else
+   #endif
+      putenv(set.utf8_str());
+#else
+   if (v == null())
+      unsetenv(e.utf8_str());
+   else
+      setenv(e.utf8_str(),v.utf8_str(),1);
+#endif
+}
+
+/**
+   sys_sleep : number -> void
+   <doc>Sleep a given number of seconds</doc>
+**/
+
+void _hx_std_sys_sleep( double f )
+{
+   hx::EnterGCFreeZone();
+#if defined(NEKO_WINDOWS)
+   Sleep((DWORD)(f * 1000));
+#elif defined(EPPC)
+//TODO: Implement sys_sleep for EPPC
+#else
+   {
+      struct timespec t;
+      struct timespec tmp;
+      t.tv_sec = (int)(f);
+      t.tv_nsec = (int)(((f) - t.tv_sec) * 1e9);
+      while( nanosleep(&t,&tmp) == -1 )
+      {
+         if( errno != EINTR )
+         {
+            hx::ExitGCFreeZone();
+            return;
+         }
+         t = tmp;
+      }
+   }
+#endif
+   hx::ExitGCFreeZone();
+}
+
+/**
+   set_time_locale : string -> bool
+   <doc>Set the locale for LC_TIME, returns true on success</doc>
+**/
+bool _hx_std_set_time_locale( String l )
+{
+#if defined(ANDROID) || defined(GCW0)
+    return false;
+#else
+
+#ifdef NEKO_POSIX
+   locale_t lc, old;
+   lc = newlocale(LC_TIME_MASK,l.utf8_str(),NULL);
+   if( !lc )
+      return false;
+   old = uselocale(lc);
+   if( !old )
+   {
+      freelocale(lc);
+      return false;
+   }
+   if( old != LC_GLOBAL_LOCALE )
+      freelocale(old);
+   return true;
+#else
+   #if defined(NEKO_WINDOWS) && defined(HX_SMART_STRINGS)
+   if (l.isUTF16Encoded())
+      return _wsetlocale(LC_TIME,l.wchar_str());
+   #endif
+   return setlocale(LC_TIME,l.utf8_str());
+#endif
+
+#endif // !Android
+}
+
+/**
+   get_cwd : void -> string
+   <doc>Return current working directory</doc>
+**/
+String _hx_std_get_cwd()
+{
+   #ifdef HX_WINRT
+   return HX_CSTRING("ms-appdata:///local/");
+   #elif defined(EPPC)
+   return String();
+   #else
+#ifdef NEKO_WINDOWS
+   wchar_t buf[261];
+   int l;
+   if( !GetCurrentDirectoryW(260,buf) )
+      return String();
+   l = (int)wcslen(buf);
+   if( buf[l-1] != '/' && buf[l-1] != '\\' ) {
+      buf[l] = '/';
+      buf[l+1] = 0;
+   }
+#else
+   char buf[1025];
+   int l;
+   if( getcwd(buf,1024) == NULL )
+      return String();
+   l = (int)strlen(buf);
+   if( buf[l-1] != '/' && buf[l-1] != '\\' ) {
+      buf[l] = '/';
+      buf[l+1] = 0;
+   }
+#endif
+   return String::create(buf);
+   #endif
+}
+
+/**
+   set_cwd : string -> void
+   <doc>Set current working directory</doc>
+**/
+bool _hx_std_set_cwd( String d )
+{
+   #if !defined(HX_WINRT) && !defined(EPPC)
+#ifdef NEKO_WINDOWS
+   return SetCurrentDirectoryW(d.wchar_str()) == 0;
+#else
+   return chdir(d.utf8_str()) == 0;
+#endif
+   #else
+   return false;
+   #endif
+}
+
+
+/**
+   sys_string : void -> string
+   <doc>
+   Return the local system string. The current value are possible :
+   <ul>
+   <li>[Windows]</li>
+   <li>[Linux]</li>
+   <li>[BSD]</li>
+   <li>[Mac]</li>
+   </ul>
+   </doc>
+**/
+String _hx_std_sys_string()
+{
+#if defined(HX_WINRT)
+   return HX_CSTRING("WinRT");
+#elif defined(NEKO_WINDOWS)
+   return HX_CSTRING("Windows");
+#elif defined(NEKO_GNUKBSD)
+   return HX_CSTRING("GNU/kFreeBSD");
+#elif defined(NEKO_LINUX)
+   return HX_CSTRING("Linux");
+#elif defined(NEKO_BSD)
+   return HX_CSTRING("BSD");
+#elif defined(NEKO_MAC)
+   return HX_CSTRING("Mac");
+#elif defined(ANDROID)
+   return HX_CSTRING("Android");
+#elif defined(BLACKBERRY)
+   return HX_CSTRING("BlackBerry");
+#elif defined(EMSCRIPTEN)
+   return HX_CSTRING("Emscripten");
+#elif defined(EPPC)
+   return HX_CSTRING("EPPC");
+#else
+#error Unknow system string
+#endif
+}
+
+/**
+   sys_is64 : void -> bool
+   <doc>
+   Returns true if we are on a 64-bit system
+   </doc>
+**/
+bool _hx_std_sys_is64()
+{
+#ifdef NEKO_64BITS
+   return true;
+#else
+   return false;
+#endif
+}
+
+/**
+   sys_command : string -> int
+   <doc>Run the shell command and return exit code</doc>
+**/
+int _hx_std_sys_command( String cmd )
+{
+   #if defined(HX_WINRT) || defined(EMSCRIPTEN) || defined(EPPC) || defined(IPHONE) || defined(APPLETV) || defined(HX_APPLEWATCH)
+   return -1;
+   #else
+   if( !cmd.raw_ptr() || !cmd.length )
+      return -1;
+
+#ifdef NEKO_WINDOWS
+   int result = 0;
+   hx::EnterGCFreeZone();
+
+   #ifdef HX_SMART_STRINGS
+   if (!cmd.isUTF16Encoded())
+      result = system(cmd.raw_ptr());
+   else
+   #endif
+   {
+      hx::strbuf wbuf;
+      result = _wsystem(cmd.wchar_str(&wbuf));
+   }
+#else
+   hx::strbuf buf;
+   hx::EnterGCFreeZone();
+   int result = system(cmd.utf8_str(&buf));
+#endif
+   hx::ExitGCFreeZone();
+
+   #if !defined(NEKO_WINDOWS)
+   result = WEXITSTATUS(result) | (WTERMSIG(result) << 8);
+   #endif
+
+   return result;
+   #endif
+}
+
+
+/**
+   sys_exit : int -> void
+   <doc>Exit with the given errorcode. Never returns.</doc>
+**/
+void _hx_std_sys_exit( int code )
+{
+   exit(code);
+}
+
+/**
+   sys_exists : string -> bool
+   <doc>Returns true if the file or directory exists.</doc>
+**/
+bool _hx_std_sys_exists( String path )
+{
+   #ifdef EPPC
+   return true;
+   #else
+
+#ifdef NEKO_WINDOWS
+   const wchar_t * wpath = path.wchar_str();
+   hx::EnterGCFreeZone();
+   bool result = GetFileAttributesW(wpath) != INVALID_FILE_ATTRIBUTES;
+#else
+   struct stat st;
+   hx::EnterGCFreeZone();
+   hx::strbuf buf;
+   bool result = stat(path.utf8_str(&buf),&st) == 0;
+#endif
+   hx::ExitGCFreeZone();
+
+   return result;
+   #endif
+}
+
+/**
+   file_delete : string -> void
+   <doc>Delete the file. Exception on error.</doc>
+**/
+void _hx_std_file_delete( String path )
+{
+   #ifndef EPPC
+   hx::EnterGCFreeZone();
+
+   bool err = false;
+   #if defined(NEKO_WINDOWS) && defined(HX_SMART_STRINGS)
+   if (path.isUTF16Encoded())
+      err = _wunlink(path.wchar_str());
+   else
+   #endif
+   {
+      hx::strbuf buf;
+      err = unlink(path.utf8_str(&buf));
+   }
+
+   hx::ExitGCFreeZone();
+
+   if (err)
+      hx::Throw( HX_CSTRING("Could not delete ") + path );
+   #endif
+}
+
+/**
+   sys_rename : from:string -> to:string -> void
+   <doc>Rename the file or directory. Exception on error.</doc>
+**/
+void  _hx_std_sys_rename( String path, String newname )
+{
+   hx::EnterGCFreeZone();
+
+   hx::strbuf buf0;
+   hx::strbuf buf1;
+   #ifdef NEKO_WINDOWS
+   bool err = _wrename(path.wchar_str(&buf0),newname.wchar_str(&buf1));
+   #else
+   bool err = rename(path.utf8_str(&buf0),newname.utf8_str(&buf1));
+   #endif
+
+   hx::ExitGCFreeZone();
+
+   if (err)
+      hx::Throw(HX_CSTRING("Could not rename"));
+}
+
+#define STATF(f) o->Add(HX_CSTRING(#f),(int)(s.st_##f))
+
+/**
+   sys_stat : string -> {
+      gid => int,
+      uid => int,
+      atime => 'int,
+      mtime => 'int,
+      ctime => 'int,
+      dev => int,
+      ino => int,
+      nlink => int,
+      rdev => int,
+      mode => int,
+      size => int
+   }
+   <doc>Run the [stat] command on the given file or directory.</doc>
+**/
+Dynamic _hx_std_sys_stat( String path )
+{
+   #ifdef EPPC
+   return alloc_null();
+   #else
+   hx::EnterGCFreeZone();
+   bool err = false;
+   #if defined(NEKO_WINDOWS)
+      struct _stat s;
+      #if defined(HX_SMART_STRINGS)
+      if (path.isUTF16Encoded())
+      {
+         hx::strbuf buf;
+         err = _wstat(path.wchar_str(&buf),&s);
+      }
+      else
+      #endif
+      {
+         hx::strbuf buf;
+         err = _stat(path.utf8_str(&buf),&s);
+      }
+   #else
+      struct stat s;
+      hx::strbuf buf;
+      err = stat(path.utf8_str(&buf),&s);
+   #endif
+
+   hx::ExitGCFreeZone();
+   if (err)
+      return null();
+   hx::Anon o = hx::Anon_obj::Create();
+
+   STATF(gid);
+   STATF(uid);
+   STATF(atime);
+   STATF(mtime);
+   STATF(ctime);
+   STATF(dev);
+   STATF(ino);
+   STATF(mode);
+   STATF(nlink);
+   STATF(rdev);
+   STATF(size);
+   STATF(mode);
+
+   return o;
+   #endif
+}
+
+/**
+   sys_file_type : string -> string
+   <doc>
+   Return the type of the file. The current values are possible :
+   <ul>
+   <li>[file]</li>
+   <li>[dir]</li>
+   <li>[symlink]</li>
+   <li>[sock]</li>
+   <li>[char]</li>
+   <li>[block]</li>
+   <li>[fifo]</li>
+   </ul>
+   </doc>
+**/
+String _hx_std_sys_file_type( String path )
+{
+   if (path==null())
+      return String();
+   #ifdef EPPC
+   return String();
+   #else
+   hx::EnterGCFreeZone();
+   bool err = false;
+   #if defined(NEKO_WINDOWS)
+      struct _stat s;
+      #if defined(HX_SMART_STRINGS)
+      if (path.isUTF16Encoded())
+      {
+         hx::strbuf buf;
+         err = _wstat(path.wchar_str(&buf),&s);
+      }
+      else
+      #endif
+      {
+         hx::strbuf buf;
+         err = _stat(path.utf8_str(&buf),&s);
+      }
+   #else
+      struct stat s;
+      hx::strbuf buf;
+      err = stat(path.utf8_str(&buf),&s);
+   #endif
+   hx::ExitGCFreeZone();
+   if (err)
+      return String();
+
+   if( s.st_mode & S_IFREG )
+      return HX_CSTRING("file");
+   if( s.st_mode & S_IFDIR )
+      return HX_CSTRING("dir");
+   if( s.st_mode & S_IFCHR )
+      return HX_CSTRING("char");
+#ifndef NEKO_WINDOWS
+   if( s.st_mode & S_IFLNK )
+      return HX_CSTRING("symlink");
+   if( s.st_mode & S_IFBLK )
+      return HX_CSTRING("block");
+   if( s.st_mode & S_IFIFO )
+      return HX_CSTRING("fifo");
+   if( s.st_mode & S_IFSOCK )
+      return HX_CSTRING("sock");
+#endif
+   return String();
+   #endif
+}
+
+/**
+   sys_create_dir : string -> mode:int -> void
+   <doc>Create a directory with the specified rights</doc>
+**/
+bool _hx_std_sys_create_dir( String path, int mode )
+{
+   #ifdef EPPC
+   return true;
+   #else
+#ifdef NEKO_WINDOWS
+   const wchar_t * wpath = path.wchar_str();
+   hx::EnterGCFreeZone();
+   bool err = _wmkdir(wpath);
+#else
+   hx::EnterGCFreeZone();
+   hx::strbuf buf;
+   bool err = mkdir(path.utf8_str(&buf), mode);
+#endif
+   hx::ExitGCFreeZone();
+   return !err;
+   #endif
+}
+
+/**
+   sys_remove_dir : string -> void
+   <doc>Remove a directory. Exception on error</doc>
+**/
+void _hx_std_sys_remove_dir( String path )
+{
+   #ifdef EPPC
+   return true;
+   #else
+   hx::EnterGCFreeZone();
+
+   bool ok = false;
+
+   #if defined(NEKO_WINDOWS) && defined(HX_SMART_STRINGS)
+   if (path.isUTF16Encoded())
+   {
+      ok = _wrmdir(path.wchar_str()) == 0;
+   }
+   else
+   #endif
+   {
+      hx::strbuf buf;
+      ok = rmdir(path.utf8_str(&buf)) == 0;
+   }
+
+
+   hx::ExitGCFreeZone();
+   if (!ok)
+      hx::Throw(HX_CSTRING("Could not remove directory"));
+   #endif
+}
+
+/**
+   sys_time : void -> float
+   <doc>Return an accurate local time stamp in seconds since Jan 1 1970</doc>
+**/
+double _hx_std_sys_time()
+{
+#ifdef NEKO_WINDOWS
+#define EPOCH_DIFF   (134774*24*60*60.0)
+   SYSTEMTIME t;
+   FILETIME ft;
+    ULARGE_INTEGER ui;
+   GetSystemTime(&t);
+   if( !SystemTimeToFileTime(&t,&ft) )
+      return 0;
+    ui.LowPart = ft.dwLowDateTime;
+    ui.HighPart = ft.dwHighDateTime;
+   return ( ((double)ui.QuadPart) / 10000000.0 - EPOCH_DIFF );
+#elif defined(EPPC)
+   time_t tod;
+   time(&tod);
+   return ((double)tod);
+#else
+   struct timeval tv;
+   if( gettimeofday(&tv,NULL) != 0 )
+      return 0;
+   return ( tv.tv_sec + ((double)tv.tv_usec) / 1000000.0 );
+#endif
+}
+
+/**
+   sys_cpu_time : void -> float
+   <doc>Return the most accurate CPU time spent since the process started (in seconds)</doc>
+**/
+double _hx_std_sys_cpu_time()
+{
+#if defined(HX_WINRT) && !defined(_XBOX_ONE)
+    return ((double)GetTickCount64()/1000.0);
+#elif defined(NEKO_WINDOWS)
+   FILETIME unused;
+   FILETIME stime;
+   FILETIME utime;
+   if( !GetProcessTimes(GetCurrentProcess(),&unused,&unused,&stime,&utime) )
+      return 0;
+   return ( ((double)(utime.dwHighDateTime+stime.dwHighDateTime)) * 65.536 * 6.5536 + (((double)utime.dwLowDateTime + (double)stime.dwLowDateTime) / 10000000) );
+#elif defined(EPPC)
+    return ((double)clock()/(double)CLOCKS_PER_SEC);
+#else
+   struct tms t;
+   times(&t);
+   return ( ((double)(t.tms_utime + t.tms_stime)) / CLK_TCK );
+#endif
+}
+
+/**
+   sys_read_dir : string -> string list
+   <doc>Return the content of a directory</doc>
+**/
+Array<String> _hx_std_sys_read_dir( String p )
+{
+   Array<String> result = Array_obj<String>::__new();
+
+#if defined(NEKO_WINDOWS)
+   const wchar_t *path = p.wchar_str();
+   size_t len = wcslen(path);
+   if (len>MAX_PATH)
+      hx::Throw(HX_CSTRING("Invalid directory"));
+
+   WIN32_FIND_DATAW d;
+   HANDLE handle;
+  #if defined(HX_WINRT) && !defined(_XBOX_ONE)
+   std::wstring tempWStr(path);
+   std::string searchPath(tempWStr.begin(), tempWStr.end());
+  #else
+   wchar_t searchPath[ MAX_PATH + 4 ];
+   memcpy(searchPath,path, len*sizeof(wchar_t));
+  #endif
+
+
+   if( len && path[len-1] != '/' && path[len-1] != '\\' )
+      searchPath[len++] = '/';
+   searchPath[len++] = '*';
+   searchPath[len++] = '.';
+   searchPath[len++] = '*';
+   searchPath[len] = '\0';
+
+   hx::EnterGCFreeZone();
+  #if defined(HX_WINRT) && !defined(_XBOX_ONE)
+   handle = FindFirstFileEx(searchPath.c_str(), FindExInfoStandard, &d, FindExSearchNameMatch, NULL, 0);
+  #else
+   handle = FindFirstFileW(searchPath,&d);
+  #endif
+   if( handle == INVALID_HANDLE_VALUE )
+   {
+      hx::ExitGCFreeZone();
+      hx::Throw(HX_CSTRING("Invalid directory"));
+   }
+   while( true )
+   {
+      // skip magic dirs
+      if( d.cFileName[0] != '.' || (d.cFileName[1] != 0 && (d.cFileName[1] != '.' || d.cFileName[2] != 0)) )
+      {
+         hx::ExitGCFreeZone();
+         result->push(String::create(d.cFileName));
+         hx::EnterGCFreeZone();
+      }
+      if( !FindNextFileW(handle,&d) )
+         break;
+   }
+   FindClose(handle);
+#elif !defined(EPPC)
+   const char *name = p.utf8_str();
+   hx::EnterGCFreeZone();
+   DIR *d = opendir(name);
+   if( d == NULL )
+   {
+      hx::ExitGCFreeZone();
+      hx::Throw(HX_CSTRING("Invalid directory"));
+   }
+   while( true )
+   {
+      struct dirent *e = readdir(d);
+      if( e == NULL )
+         break;
+      // skip magic dirs
+      if( e->d_name[0] == '.' && (e->d_name[1] == 0 || (e->d_name[1] == '.' && e->d_name[2] == 0)) )
+         continue;
+      hx::ExitGCFreeZone();
+      result->push( String::create(e->d_name) );
+      hx::EnterGCFreeZone();
+   }
+   closedir(d);
+#endif
+   hx::ExitGCFreeZone();
+
+   return result;
+}
+
+/**
+   file_full_path : string -> string
+   <doc>Return an absolute path from a relative one. The file or directory must exists</doc>
+**/
+String _hx_std_file_full_path( String path )
+{
+#if defined(HX_WINRT)
+   return path;
+#elif defined(NEKO_WINDOWS)
+   wchar_t buf[MAX_PATH+1];
+   hx::strbuf wbuf;
+   if( GetFullPathNameW(path.wchar_str(&wbuf),MAX_PATH+1,buf,NULL) == 0 )
+      return null();
+   return String::create(buf);
+#elif defined(EPPC)
+   return path;
+#else
+   char buf[PATH_MAX];
+   hx::strbuf ubuf;
+   if( realpath(path.utf8_str(&ubuf),buf) == NULL )
+      return null();
+   return String::create(buf);
+#endif
+}
+
+/**
+   sys_exe_path : void -> string
+   <doc>Return the path of the executable</doc>
+**/
+String _hx_std_sys_exe_path()
+{
+#if defined(HX_WINRT) && defined(__cplusplus_winrt)
+   Windows::ApplicationModel::Package^ package = Windows::ApplicationModel::Package::Current;
+   Windows::Storage::StorageFolder^ installedLocation = package->InstalledLocation;
+   return(String::create(installedLocation->Path->Data()));
+#elif defined(NEKO_WINDOWS)
+   wchar_t path[MAX_PATH];
+   if( GetModuleFileNameW(NULL,path,MAX_PATH) == 0 )
+      return null();
+   return String::create(path);
+#elif defined(NEKO_MAC) && !defined(IPHONE) && !defined(APPLETV) && !defined(HX_APPLEWATCH)
+   char path[PATH_MAX+1];
+   uint32_t path_len = PATH_MAX;
+   if( _NSGetExecutablePath(path, &path_len) )
+      return null();
+   return String::create(path);
+#elif defined(EPPC)
+   return HX_CSTRING("");
+#else
+   {
+      char path[PATH_MAX];
+      int length = readlink("/proc/self/exe", path, sizeof(path));
+      if( length < 0 )
+      {
+         const char *p = getenv("_");
+         if (p)
+            return String::create(p);
+         return null();
+      }
+       path[length] = '\0';
+      return String::create(path);
+   }
+#endif
+}
+
+#if !defined(IPHONE) && !defined(APPLETV) && !defined(HX_APPLEWATCH)
+#ifdef NEKO_MAC
+#include <crt_externs.h>
+#   define environ (*_NSGetEnviron())
+#endif
+#endif
+
+#ifndef NEKO_WINDOWS
+extern char **environ;
+#endif
+
+/**
+   sys_env : void -> #list
+   <doc>Return all the (key,value) pairs in the environment as a chained list</doc>
+**/
+Array<String> _hx_std_sys_env()
+{
+   Array<String> result = Array_obj<String>::__new();
+   #ifndef HX_WINRT
+   char **e = environ;
+   while( *e )
+   {
+      char *x = strchr(*e,'=');
+      if( x == NULL )
+      {
+         e++;
+         continue;
+      }
+      result->push(String::create(*e,(int)(x-*e)));
+      result->push(String::create(x+1));
+      e++;
+   }
+   #endif
+   return result;
+}
+
+#ifdef HX_ANDROID
+   #define tcsetattr(fd,opt,s) ioctl(fd,opt,s)
+   #define tcgetattr(fd,s) ioctl(fd,TCGETS,s)
+
+   static __inline__ void inline_cfmakeraw(struct termios *s)
+   {
+       s->c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
+       s->c_oflag &= ~OPOST;
+       s->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
+       s->c_cflag &= ~(CSIZE|PARENB);
+       s->c_cflag |= CS8;
+   }
+
+   #define cfmakeraw inline_cfmakeraw
+
+#endif
+
+/**
+   sys_getch : bool -> int
+   <doc>Read a character from stdin with or without echo</doc>
+**/
+int _hx_std_sys_getch( bool b )
+{
+#if defined(HX_WINRT) || defined(EMSCRIPTEN) || defined(EPPC)
+   return 0;
+#elif defined(NEKO_WINDOWS)
+   hx::EnterGCFreeZone();
+   int result = b?getche():getch();
+   hx::ExitGCFreeZone();
+
+   return result;
+#else
+   // took some time to figure out how to do that
+   // without relying on ncurses, which clear the
+   // terminal on initscr()
+   int c;
+   struct termios term, old;
+   hx::EnterGCFreeZone();
+   tcgetattr(fileno(stdin), &old);
+   term = old;
+   cfmakeraw(&term);
+   tcsetattr(fileno(stdin), 0, &term);
+   c = getchar();
+   tcsetattr(fileno(stdin), 0, &old);
+   if( b ) fputc(c,stdout);
+   hx::ExitGCFreeZone();
+   return c;
+#   endif
+}
+
+/**
+   sys_get_pid : void -> int
+   <doc>Returns the current process identifier</doc>
+**/
+int _hx_std_sys_get_pid()
+{
+#   ifdef NEKO_WINDOWS
+   return (int)(GetCurrentProcessId());
+#elif defined(EPPC)
+   return (1);
+#   else
+   return (getpid());
+#   endif
+}
diff --git a/Sources/c_snikket/src/hx/strings/RandomStrings.cpp b/Sources/c_snikket/src/hx/strings/RandomStrings.cpp
new file mode 100644
index 0000000..30dbd80
--- /dev/null
+++ b/Sources/c_snikket/src/hx/strings/RandomStrings.cpp
@@ -0,0 +1,312 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_95f339a1d026d52c
+#define INCLUDED_95f339a1d026d52c
+#include "hxMath.h"
+#endif
+#ifndef INCLUDED_StringTools
+#include <StringTools.h>
+#endif
+#ifndef INCLUDED_hx_strings_RandomStrings
+#include <hx/strings/RandomStrings.h>
+#endif
+#ifndef INCLUDED_hx_strings_StringBuilder
+#include <hx/strings/StringBuilder.h>
+#endif
+#ifndef INCLUDED_hx_strings_Strings
+#include <hx/strings/Strings.h>
+#endif
+#ifndef INCLUDED_hx_strings_internal__Either2__Either2
+#include <hx/strings/internal/_Either2/_Either2.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_935183b2282eb90a_20__genAsciiAlpha,"hx.strings.RandomStrings","_genAsciiAlpha",0x19b4d5b7,"hx.strings.RandomStrings._genAsciiAlpha","hx/strings/RandomStrings.hx",20,0xcc1efb0b)
+HX_LOCAL_STACK_FRAME(_hx_pos_935183b2282eb90a_89_random,"hx.strings.RandomStrings","random",0x24aa257c,"hx.strings.RandomStrings.random","hx/strings/RandomStrings.hx",89,0xcc1efb0b)
+HX_LOCAL_STACK_FRAME(_hx_pos_935183b2282eb90a_160_randomUUIDv4,"hx.strings.RandomStrings","randomUUIDv4",0xdc92f875,"hx.strings.RandomStrings.randomUUIDv4","hx/strings/RandomStrings.hx",160,0xcc1efb0b)
+HX_LOCAL_STACK_FRAME(_hx_pos_935183b2282eb90a_18_boot,"hx.strings.RandomStrings","boot",0x7f84876b,"hx.strings.RandomStrings.boot","hx/strings/RandomStrings.hx",18,0xcc1efb0b)
+HX_LOCAL_STACK_FRAME(_hx_pos_935183b2282eb90a_29_boot,"hx.strings.RandomStrings","boot",0x7f84876b,"hx.strings.RandomStrings.boot","hx/strings/RandomStrings.hx",29,0xcc1efb0b)
+HX_LOCAL_STACK_FRAME(_hx_pos_935183b2282eb90a_30_boot,"hx.strings.RandomStrings","boot",0x7f84876b,"hx.strings.RandomStrings.boot","hx/strings/RandomStrings.hx",30,0xcc1efb0b)
+namespace hx{
+namespace strings{
+
+void RandomStrings_obj::__construct() { }
+
+Dynamic RandomStrings_obj::__CreateEmpty() { return new RandomStrings_obj; }
+
+void *RandomStrings_obj::_hx_vtable = 0;
+
+Dynamic RandomStrings_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< RandomStrings_obj > _hx_result = new RandomStrings_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool RandomStrings_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x48d6a291;
+}
+
+::Array< int > RandomStrings_obj::DIGITS;
+
+::Array< int > RandomStrings_obj::_genAsciiAlpha(){
+            	HX_STACKFRAME(&_hx_pos_935183b2282eb90a_20__genAsciiAlpha)
+HXLINE(  21)		::Array< int > chars = ::Array_obj< int >::__new();
+HXLINE(  22)		{
+HXLINE(  23)			chars->push(65);
+HXDLIN(  23)			chars->push(66);
+HXDLIN(  23)			chars->push(67);
+HXDLIN(  23)			chars->push(68);
+HXDLIN(  23)			chars->push(69);
+HXDLIN(  23)			chars->push(70);
+HXDLIN(  23)			chars->push(71);
+HXDLIN(  23)			chars->push(72);
+HXDLIN(  23)			chars->push(73);
+HXDLIN(  23)			chars->push(74);
+HXDLIN(  23)			chars->push(75);
+HXDLIN(  23)			chars->push(76);
+HXDLIN(  23)			chars->push(77);
+HXDLIN(  23)			chars->push(78);
+HXDLIN(  23)			chars->push(79);
+HXDLIN(  23)			chars->push(80);
+HXDLIN(  23)			chars->push(81);
+HXDLIN(  23)			chars->push(82);
+HXDLIN(  23)			chars->push(83);
+HXDLIN(  23)			chars->push(84);
+HXDLIN(  23)			chars->push(85);
+HXDLIN(  23)			chars->push(86);
+HXDLIN(  23)			chars->push(87);
+HXDLIN(  23)			chars->push(88);
+HXDLIN(  23)			chars->push(89);
+HXDLIN(  23)			chars->push(90);
+            		}
+HXLINE(  24)		{
+HXLINE(  25)			chars->push(97);
+HXDLIN(  25)			chars->push(98);
+HXDLIN(  25)			chars->push(99);
+HXDLIN(  25)			chars->push(100);
+HXDLIN(  25)			chars->push(101);
+HXDLIN(  25)			chars->push(102);
+HXDLIN(  25)			chars->push(103);
+HXDLIN(  25)			chars->push(104);
+HXDLIN(  25)			chars->push(105);
+HXDLIN(  25)			chars->push(106);
+HXDLIN(  25)			chars->push(107);
+HXDLIN(  25)			chars->push(108);
+HXDLIN(  25)			chars->push(109);
+HXDLIN(  25)			chars->push(110);
+HXDLIN(  25)			chars->push(111);
+HXDLIN(  25)			chars->push(112);
+HXDLIN(  25)			chars->push(113);
+HXDLIN(  25)			chars->push(114);
+HXDLIN(  25)			chars->push(115);
+HXDLIN(  25)			chars->push(116);
+HXDLIN(  25)			chars->push(117);
+HXDLIN(  25)			chars->push(118);
+HXDLIN(  25)			chars->push(119);
+HXDLIN(  25)			chars->push(120);
+HXDLIN(  25)			chars->push(121);
+HXDLIN(  25)			chars->push(122);
+            		}
+HXLINE(  26)		return chars;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC0(RandomStrings_obj,_genAsciiAlpha,return )
+
+::Array< int > RandomStrings_obj::ASCII_ALPHA;
+
+::Array< int > RandomStrings_obj::ASCII_ALPHA_NUMERIC;
+
+::String RandomStrings_obj::random(int length, ::hx::strings::internal::_Either2::_Either2 chars){
+            	HX_GC_STACKFRAME(&_hx_pos_935183b2282eb90a_89_random)
+HXLINE(  90)		if ((length == 0)) {
+HXLINE(  91)			return HX_("",00,00,00,00);
+            		}
+HXLINE(  93)		if ((length < 0)) {
+HXLINE(  94)			HX_STACK_DO_THROW(HX_("[count] must be positive value",a7,d2,38,15));
+            		}
+HXLINE(  96)		if (::hx::IsNull( chars )) {
+HXLINE(  97)			HX_STACK_DO_THROW(HX_("[chars] must not be null",a5,53,b7,f5));
+            		}
+HXLINE(  99)		::Array< int > charsArray;
+HXDLIN(  99)		 ::hx::strings::internal::_Either2::_Either2 _g = chars;
+HXDLIN(  99)		switch((int)(_g->_hx_getIndex())){
+            			case (int)0: {
+HXLINE( 100)				::String str = ( (::String)(_g->_hx_getObject(0)) );
+HXLINE(  99)				charsArray = ::hx::strings::Strings_obj::toChars(str);
+            			}
+            			break;
+            			case (int)1: {
+HXLINE( 101)				::Array< int > chars1 = ( (::Array< int >)(_g->_hx_getObject(0)) );
+HXLINE(  99)				charsArray = chars1;
+            			}
+            			break;
+            		}
+HXLINE( 104)		if ((charsArray->length == 0)) {
+HXLINE( 105)			HX_STACK_DO_THROW(HX_("[chars] must not be empty",af,ff,cf,d6));
+            		}
+HXLINE( 107)		 ::hx::strings::StringBuilder result =  ::hx::strings::StringBuilder_obj::__alloc( HX_CTX ,null());
+HXLINE( 108)		{
+HXLINE( 108)			int _g1 = 0;
+HXDLIN( 108)			int _g2 = length;
+HXDLIN( 108)			while((_g1 < _g2)){
+HXLINE( 108)				_g1 = (_g1 + 1);
+HXDLIN( 108)				int i = (_g1 - 1);
+HXLINE( 109)				result->addChar(charsArray->__get(::Math_obj::floor((( (Float)(charsArray->length) ) * ::Math_obj::random()))));
+            			}
+            		}
+HXLINE( 111)		return result->toString();
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(RandomStrings_obj,random,return )
+
+::String RandomStrings_obj::randomUUIDv4(::String __o_separator){
+            		::String separator = __o_separator;
+            		if (::hx::IsNull(__o_separator)) separator = HX_("-",2d,00,00,00);
+            	HX_STACKFRAME(&_hx_pos_935183b2282eb90a_160_randomUUIDv4)
+HXLINE( 161)		if (::hx::IsNull( separator )) {
+HXLINE( 162)			HX_STACK_DO_THROW(HX_("[separator] must not be null",ad,ff,54,c9));
+            		}
+HXLINE( 165)		int variantByte = ::Math_obj::floor((::Math_obj::random() * ( (Float)(16) )));
+HXLINE( 166)		variantByte = (variantByte | 8);
+HXLINE( 167)		variantByte = (variantByte & -5);
+HXLINE( 170)		::String _hx_tmp = ::StringTools_obj::hex(::Math_obj::floor((::Math_obj::random() * ( (Float)(65536) ))),4);
+HXDLIN( 170)		::String _hx_tmp1 = ((_hx_tmp + ::StringTools_obj::hex(::Math_obj::floor((::Math_obj::random() * ( (Float)(65536) ))),4)) + separator);
+HXDLIN( 170)		::String _hx_tmp2 = (((_hx_tmp1 + ::StringTools_obj::hex(::Math_obj::floor((::Math_obj::random() * ( (Float)(65536) ))),4)) + separator) + HX_("4",34,00,00,00));
+HXDLIN( 170)		::String _hx_tmp3 = ((_hx_tmp2 + ::StringTools_obj::hex(::Math_obj::floor((::Math_obj::random() * ( (Float)(4096) ))),3)) + separator);
+HXDLIN( 170)		::String _hx_tmp4 = (_hx_tmp3 + ::StringTools_obj::hex(variantByte,null()));
+HXDLIN( 170)		::String _hx_tmp5 = ((_hx_tmp4 + ::StringTools_obj::hex(::Math_obj::floor((::Math_obj::random() * ( (Float)(4096) ))),3)) + separator);
+HXDLIN( 170)		::String _hx_tmp6 = (_hx_tmp5 + ::StringTools_obj::hex(::Math_obj::floor((::Math_obj::random() * ( (Float)(65536) ))),4));
+HXDLIN( 170)		::String _hx_tmp7 = (_hx_tmp6 + ::StringTools_obj::hex(::Math_obj::floor((::Math_obj::random() * ( (Float)(65536) ))),4));
+HXLINE( 169)		return (_hx_tmp7 + ::StringTools_obj::hex(::Math_obj::floor((::Math_obj::random() * ( (Float)(65536) ))),4)).toLowerCase();
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(RandomStrings_obj,randomUUIDv4,return )
+
+
+RandomStrings_obj::RandomStrings_obj()
+{
+}
+
+bool RandomStrings_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 6:
+		if (HX_FIELD_EQ(inName,"DIGITS") ) { outValue = ( DIGITS ); return true; }
+		if (HX_FIELD_EQ(inName,"random") ) { outValue = random_dyn(); return true; }
+		break;
+	case 11:
+		if (HX_FIELD_EQ(inName,"ASCII_ALPHA") ) { outValue = ( ASCII_ALPHA ); return true; }
+		break;
+	case 12:
+		if (HX_FIELD_EQ(inName,"randomUUIDv4") ) { outValue = randomUUIDv4_dyn(); return true; }
+		break;
+	case 14:
+		if (HX_FIELD_EQ(inName,"_genAsciiAlpha") ) { outValue = _genAsciiAlpha_dyn(); return true; }
+		break;
+	case 19:
+		if (HX_FIELD_EQ(inName,"ASCII_ALPHA_NUMERIC") ) { outValue = ( ASCII_ALPHA_NUMERIC ); return true; }
+	}
+	return false;
+}
+
+bool RandomStrings_obj::__SetStatic(const ::String &inName,Dynamic &ioValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 6:
+		if (HX_FIELD_EQ(inName,"DIGITS") ) { DIGITS=ioValue.Cast< ::Array< int > >(); return true; }
+		break;
+	case 11:
+		if (HX_FIELD_EQ(inName,"ASCII_ALPHA") ) { ASCII_ALPHA=ioValue.Cast< ::Array< int > >(); return true; }
+		break;
+	case 19:
+		if (HX_FIELD_EQ(inName,"ASCII_ALPHA_NUMERIC") ) { ASCII_ALPHA_NUMERIC=ioValue.Cast< ::Array< int > >(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *RandomStrings_obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo RandomStrings_obj_sStaticStorageInfo[] = {
+	{::hx::fsObject /* ::Array< int > */ ,(void *) &RandomStrings_obj::DIGITS,HX_("DIGITS",26,b6,aa,67)},
+	{::hx::fsObject /* ::Array< int > */ ,(void *) &RandomStrings_obj::ASCII_ALPHA,HX_("ASCII_ALPHA",70,22,3a,0c)},
+	{::hx::fsObject /* ::Array< int > */ ,(void *) &RandomStrings_obj::ASCII_ALPHA_NUMERIC,HX_("ASCII_ALPHA_NUMERIC",9e,22,17,95)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+#endif
+
+static void RandomStrings_obj_sMarkStatics(HX_MARK_PARAMS) {
+	HX_MARK_MEMBER_NAME(RandomStrings_obj::DIGITS,"DIGITS");
+	HX_MARK_MEMBER_NAME(RandomStrings_obj::ASCII_ALPHA,"ASCII_ALPHA");
+	HX_MARK_MEMBER_NAME(RandomStrings_obj::ASCII_ALPHA_NUMERIC,"ASCII_ALPHA_NUMERIC");
+};
+
+#ifdef HXCPP_VISIT_ALLOCS
+static void RandomStrings_obj_sVisitStatics(HX_VISIT_PARAMS) {
+	HX_VISIT_MEMBER_NAME(RandomStrings_obj::DIGITS,"DIGITS");
+	HX_VISIT_MEMBER_NAME(RandomStrings_obj::ASCII_ALPHA,"ASCII_ALPHA");
+	HX_VISIT_MEMBER_NAME(RandomStrings_obj::ASCII_ALPHA_NUMERIC,"ASCII_ALPHA_NUMERIC");
+};
+
+#endif
+
+::hx::Class RandomStrings_obj::__mClass;
+
+static ::String RandomStrings_obj_sStaticFields[] = {
+	HX_("DIGITS",26,b6,aa,67),
+	HX_("_genAsciiAlpha",3e,31,44,11),
+	HX_("ASCII_ALPHA",70,22,3a,0c),
+	HX_("ASCII_ALPHA_NUMERIC",9e,22,17,95),
+	HX_("random",03,22,8f,b7),
+	HX_("randomUUIDv4",3c,94,2e,c1),
+	::String(null())
+};
+
+void RandomStrings_obj::__register()
+{
+	RandomStrings_obj _hx_dummy;
+	RandomStrings_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("hx.strings.RandomStrings",d5,27,9c,7d);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &RandomStrings_obj::__GetStatic;
+	__mClass->mSetStaticField = &RandomStrings_obj::__SetStatic;
+	__mClass->mMarkFunc = RandomStrings_obj_sMarkStatics;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(RandomStrings_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< RandomStrings_obj >;
+#ifdef HXCPP_VISIT_ALLOCS
+	__mClass->mVisitFunc = RandomStrings_obj_sVisitStatics;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = RandomStrings_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = RandomStrings_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+void RandomStrings_obj::__boot()
+{
+{
+            	HX_STACKFRAME(&_hx_pos_935183b2282eb90a_18_boot)
+HXDLIN(  18)		DIGITS = ::hx::strings::Strings_obj::toChars(HX_("0123456789",05,7a,73,55));
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_935183b2282eb90a_29_boot)
+HXDLIN(  29)		ASCII_ALPHA = ::hx::strings::RandomStrings_obj::_genAsciiAlpha();
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_935183b2282eb90a_30_boot)
+HXDLIN(  30)		ASCII_ALPHA_NUMERIC = ::hx::strings::RandomStrings_obj::DIGITS->concat(::hx::strings::RandomStrings_obj::ASCII_ALPHA);
+            	}
+}
+
+} // end namespace hx
+} // end namespace strings
diff --git a/Sources/c_snikket/src/hx/strings/StringBuilder.cpp b/Sources/c_snikket/src/hx/strings/StringBuilder.cpp
new file mode 100644
index 0000000..5ecc7f1
--- /dev/null
+++ b/Sources/c_snikket/src/hx/strings/StringBuilder.cpp
@@ -0,0 +1,298 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Std
+#include <Std.h>
+#endif
+#ifndef INCLUDED_StringBuf
+#include <StringBuf.h>
+#endif
+#ifndef INCLUDED_hx_strings_StringBuilder
+#include <hx/strings/StringBuilder.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_b646f356da37ac48_21_new,"hx.strings.StringBuilder","new",0xee97d452,"hx.strings.StringBuilder.new","hx/strings/StringBuilder.hx",21,0x236fa860)
+HX_LOCAL_STACK_FRAME(_hx_pos_b646f356da37ac48_68_add,"hx.strings.StringBuilder","add",0xee8df613,"hx.strings.StringBuilder.add","hx/strings/StringBuilder.hx",68,0x236fa860)
+HX_LOCAL_STACK_FRAME(_hx_pos_b646f356da37ac48_85_addChar,"hx.strings.StringBuilder","addChar",0x68f68689,"hx.strings.StringBuilder.addChar","hx/strings/StringBuilder.hx",85,0x236fa860)
+HX_LOCAL_STACK_FRAME(_hx_pos_b646f356da37ac48_129_clear,"hx.strings.StringBuilder","clear",0x529dd5ff,"hx.strings.StringBuilder.clear","hx/strings/StringBuilder.hx",129,0x236fa860)
+HX_LOCAL_STACK_FRAME(_hx_pos_b646f356da37ac48_440_toString,"hx.strings.StringBuilder","toString",0xe81d3f7a,"hx.strings.StringBuilder.toString","hx/strings/StringBuilder.hx",440,0x236fa860)
+HX_LOCAL_STACK_FRAME(_hx_pos_b646f356da37ac48_21_boot,"hx.strings.StringBuilder","boot",0xce5af400,"hx.strings.StringBuilder.boot","hx/strings/StringBuilder.hx",21,0x236fa860)
+namespace hx{
+namespace strings{
+
+void StringBuilder_obj::__construct(::String initialContent){
+            	HX_GC_STACKFRAME(&_hx_pos_b646f356da37ac48_21_new)
+HXLINE(  27)		this->len = 0;
+HXLINE(  26)		this->pre = null();
+HXLINE(  23)		this->sb =  ::StringBuf_obj::__alloc( HX_CTX );
+HXLINE(  33)		if (::hx::IsNotNull( initialContent )) {
+HXLINE(  34)			this->add(initialContent);
+            		}
+            	}
+
+Dynamic StringBuilder_obj::__CreateEmpty() { return new StringBuilder_obj; }
+
+void *StringBuilder_obj::_hx_vtable = 0;
+
+Dynamic StringBuilder_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< StringBuilder_obj > _hx_result = new StringBuilder_obj();
+	_hx_result->__construct(inArgs[0]);
+	return _hx_result;
+}
+
+bool StringBuilder_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x32066fb8;
+}
+
+ ::hx::strings::StringBuilder StringBuilder_obj::add(::String item){
+            	HX_STACKFRAME(&_hx_pos_b646f356da37ac48_68_add)
+HXLINE(  69)		{
+HXLINE(  69)			 ::StringBuf _this = this->sb;
+HXDLIN(  69)			::String x;
+HXDLIN(  69)			if (::hx::IsNull( item )) {
+HXLINE(  69)				x = HX_("null",87,9e,0e,49);
+            			}
+            			else {
+HXLINE(  69)				x = item;
+            			}
+HXDLIN(  69)			if (::hx::IsNotNull( _this->charBuf )) {
+HXLINE(  69)				_this->flush();
+            			}
+HXDLIN(  69)			if (::hx::IsNull( _this->b )) {
+HXLINE(  69)				_this->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(x));
+            			}
+            			else {
+HXLINE(  69)				::Array< ::String > _this1 = _this->b;
+HXDLIN(  69)				_this1->push(::Std_obj::string(x));
+            			}
+            		}
+HXLINE(  71)		 ::hx::strings::StringBuilder _hx_tmp = ::hx::ObjectPtr<OBJ_>(this);
+HXDLIN(  71)		int _hx_tmp1;
+HXDLIN(  71)		if (::hx::IsNull( item )) {
+HXLINE(  71)			_hx_tmp1 = 0;
+            		}
+            		else {
+HXLINE(  71)			_hx_tmp1 = item.length;
+            		}
+HXDLIN(  71)		_hx_tmp->len = (_hx_tmp->len + _hx_tmp1);
+HXLINE(  73)		return ::hx::ObjectPtr<OBJ_>(this);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(StringBuilder_obj,add,return )
+
+ ::hx::strings::StringBuilder StringBuilder_obj::addChar(int ch){
+            	HX_STACKFRAME(&_hx_pos_b646f356da37ac48_85_addChar)
+HXLINE(  89)		bool _hx_tmp;
+HXDLIN(  89)		if ((ch > -1)) {
+HXLINE(  89)			_hx_tmp = (ch < 128);
+            		}
+            		else {
+HXLINE(  89)			_hx_tmp = false;
+            		}
+HXDLIN(  89)		if (_hx_tmp) {
+HXLINE(  90)			 ::StringBuf _this = this->sb;
+HXDLIN(  90)			int c = ch;
+HXDLIN(  90)			if ((c >= 127)) {
+HXLINE(  90)				::String x = ::String::fromCharCode(c);
+HXDLIN(  90)				if (::hx::IsNotNull( _this->charBuf )) {
+HXLINE(  90)					_this->flush();
+            				}
+HXDLIN(  90)				if (::hx::IsNull( _this->b )) {
+HXLINE(  90)					_this->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(x));
+            				}
+            				else {
+HXLINE(  90)					::Array< ::String > _this1 = _this->b;
+HXDLIN(  90)					_this1->push(::Std_obj::string(x));
+            				}
+            			}
+            			else {
+HXLINE(  90)				if (::hx::IsNull( _this->charBuf )) {
+HXLINE(  90)					_this->charBuf = ::Array_obj< char >::__new();
+            				}
+HXDLIN(  90)				_this->charBuf->push(c);
+            			}
+            		}
+            		else {
+HXLINE(  92)			 ::StringBuf _this2 = this->sb;
+HXDLIN(  92)			::String x1 = ::String::fromCharCode(ch);
+HXDLIN(  92)			if (::hx::IsNotNull( _this2->charBuf )) {
+HXLINE(  92)				_this2->flush();
+            			}
+HXDLIN(  92)			if (::hx::IsNull( _this2->b )) {
+HXLINE(  92)				_this2->b = ::Array_obj< ::String >::__new(1)->init(0,::Std_obj::string(x1));
+            			}
+            			else {
+HXLINE(  92)				::Array< ::String > _this3 = _this2->b;
+HXDLIN(  92)				_this3->push(::Std_obj::string(x1));
+            			}
+            		}
+HXLINE(  96)		this->len++;
+HXLINE(  98)		return ::hx::ObjectPtr<OBJ_>(this);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(StringBuilder_obj,addChar,return )
+
+ ::hx::strings::StringBuilder StringBuilder_obj::clear(){
+            	HX_GC_STACKFRAME(&_hx_pos_b646f356da37ac48_129_clear)
+HXLINE( 135)		this->pre = null();
+HXLINE( 136)		this->sb =  ::StringBuf_obj::__alloc( HX_CTX );
+HXLINE( 137)		this->len = 0;
+HXLINE( 139)		return ::hx::ObjectPtr<OBJ_>(this);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(StringBuilder_obj,clear,return )
+
+::String StringBuilder_obj::toString(){
+            	HX_STACKFRAME(&_hx_pos_b646f356da37ac48_440_toString)
+HXLINE( 444)		if (::hx::IsNull( this->pre )) {
+HXLINE( 445)			return this->sb->toString();
+            		}
+HXLINE( 446)		::String str = this->pre->join(HX_("",00,00,00,00));
+HXDLIN( 446)		::String str1 = (str + this->sb->toString());
+HXLINE( 447)		this->clear();
+HXLINE( 448)		this->add(str1);
+HXLINE( 449)		return str1;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(StringBuilder_obj,toString,return )
+
+
+::hx::ObjectPtr< StringBuilder_obj > StringBuilder_obj::__new(::String initialContent) {
+	::hx::ObjectPtr< StringBuilder_obj > __this = new StringBuilder_obj();
+	__this->__construct(initialContent);
+	return __this;
+}
+
+::hx::ObjectPtr< StringBuilder_obj > StringBuilder_obj::__alloc(::hx::Ctx *_hx_ctx,::String initialContent) {
+	StringBuilder_obj *__this = (StringBuilder_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(StringBuilder_obj), true, "hx.strings.StringBuilder"));
+	*(void **)__this = StringBuilder_obj::_hx_vtable;
+	__this->__construct(initialContent);
+	return __this;
+}
+
+StringBuilder_obj::StringBuilder_obj()
+{
+}
+
+void StringBuilder_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(StringBuilder);
+	HX_MARK_MEMBER_NAME(sb,"sb");
+	HX_MARK_MEMBER_NAME(pre,"pre");
+	HX_MARK_MEMBER_NAME(len,"len");
+	HX_MARK_END_CLASS();
+}
+
+void StringBuilder_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(sb,"sb");
+	HX_VISIT_MEMBER_NAME(pre,"pre");
+	HX_VISIT_MEMBER_NAME(len,"len");
+}
+
+::hx::Val StringBuilder_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 2:
+		if (HX_FIELD_EQ(inName,"sb") ) { return ::hx::Val( sb ); }
+		break;
+	case 3:
+		if (HX_FIELD_EQ(inName,"pre") ) { return ::hx::Val( pre ); }
+		if (HX_FIELD_EQ(inName,"len") ) { return ::hx::Val( len ); }
+		if (HX_FIELD_EQ(inName,"add") ) { return ::hx::Val( add_dyn() ); }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"clear") ) { return ::hx::Val( clear_dyn() ); }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"addChar") ) { return ::hx::Val( addChar_dyn() ); }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"toString") ) { return ::hx::Val( toString_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val StringBuilder_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 2:
+		if (HX_FIELD_EQ(inName,"sb") ) { sb=inValue.Cast<  ::StringBuf >(); return inValue; }
+		break;
+	case 3:
+		if (HX_FIELD_EQ(inName,"pre") ) { pre=inValue.Cast< ::Array< ::String > >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"len") ) { len=inValue.Cast< int >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void StringBuilder_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("sb",8f,64,00,00));
+	outFields->push(HX_("pre",23,60,55,00));
+	outFields->push(HX_("len",d5,4b,52,00));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo StringBuilder_obj_sMemberStorageInfo[] = {
+	{::hx::fsObject /*  ::StringBuf */ ,(int)offsetof(StringBuilder_obj,sb),HX_("sb",8f,64,00,00)},
+	{::hx::fsObject /* ::Array< ::String > */ ,(int)offsetof(StringBuilder_obj,pre),HX_("pre",23,60,55,00)},
+	{::hx::fsInt,(int)offsetof(StringBuilder_obj,len),HX_("len",d5,4b,52,00)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *StringBuilder_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String StringBuilder_obj_sMemberFields[] = {
+	HX_("sb",8f,64,00,00),
+	HX_("pre",23,60,55,00),
+	HX_("len",d5,4b,52,00),
+	HX_("add",21,f2,49,00),
+	HX_("addChar",97,a1,fc,7d),
+	HX_("clear",8d,71,5b,48),
+	HX_("toString",ac,d0,6e,38),
+	::String(null()) };
+
+::hx::Class StringBuilder_obj::__mClass;
+
+void StringBuilder_obj::__register()
+{
+	StringBuilder_obj _hx_dummy;
+	StringBuilder_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("hx.strings.StringBuilder",60,03,27,b6);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(StringBuilder_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< StringBuilder_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = StringBuilder_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = StringBuilder_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+void StringBuilder_obj::__boot()
+{
+{
+            	HX_STACKFRAME(&_hx_pos_b646f356da37ac48_21_boot)
+HXDLIN(  21)		__mClass->__meta__ =  ::Dynamic(::hx::Anon_obj::Create(1)
+            			->setFixed(0,HX_("obj",f7,8f,54,00), ::Dynamic(::hx::Anon_obj::Create(1)
+            				->setFixed(0,HX_("notThreadSafe",2a,64,46,1e),null()))));
+            	}
+}
+
+} // end namespace hx
+} // end namespace strings
diff --git a/Sources/c_snikket/src/hx/strings/Strings.cpp b/Sources/c_snikket/src/hx/strings/Strings.cpp
new file mode 100644
index 0000000..eff51e7
--- /dev/null
+++ b/Sources/c_snikket/src/hx/strings/Strings.cpp
@@ -0,0 +1,110 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_hx_strings_Strings
+#include <hx/strings/Strings.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_fd0a69697a336cdd_3475_toChars,"hx.strings.Strings","toChars",0x51e23a0c,"hx.strings.Strings.toChars","hx/strings/Strings.hx",3475,0x74f74a28)
+namespace hx{
+namespace strings{
+
+void Strings_obj::__construct() { }
+
+Dynamic Strings_obj::__CreateEmpty() { return new Strings_obj; }
+
+void *Strings_obj::_hx_vtable = 0;
+
+Dynamic Strings_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Strings_obj > _hx_result = new Strings_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool Strings_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x0e5b539c;
+}
+
+::Array< int > Strings_obj::toChars(::String str){
+            	HX_STACKFRAME(&_hx_pos_fd0a69697a336cdd_3475_toChars)
+HXLINE(3476)		if (::hx::IsNull( str )) {
+HXLINE(3478)			return null();
+            		}
+HXLINE(3480)		int strLen;
+HXDLIN(3480)		if (::hx::IsNull( str )) {
+HXLINE(3480)			strLen = 0;
+            		}
+            		else {
+HXLINE(3480)			strLen = str.length;
+            		}
+HXLINE(3482)		if ((strLen == 0)) {
+HXLINE(3483)			return ::Array_obj< int >::__new(0);
+            		}
+HXLINE(3485)		::Array< int > _g = ::Array_obj< int >::__new(0);
+HXDLIN(3485)		{
+HXLINE(3485)			int _g1 = 0;
+HXDLIN(3485)			int _g2 = strLen;
+HXDLIN(3485)			while((_g1 < _g2)){
+HXLINE(3485)				_g1 = (_g1 + 1);
+HXDLIN(3485)				int i = (_g1 - 1);
+HXDLIN(3485)				_g->push(( (int)(str.charCodeAt(i)) ));
+            			}
+            		}
+HXDLIN(3485)		return _g;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Strings_obj,toChars,return )
+
+
+Strings_obj::Strings_obj()
+{
+}
+
+bool Strings_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 7:
+		if (HX_FIELD_EQ(inName,"toChars") ) { outValue = toChars_dyn(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *Strings_obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo *Strings_obj_sStaticStorageInfo = 0;
+#endif
+
+::hx::Class Strings_obj::__mClass;
+
+static ::String Strings_obj_sStaticFields[] = {
+	HX_("toChars",62,e9,37,12),
+	::String(null())
+};
+
+void Strings_obj::__register()
+{
+	Strings_obj _hx_dummy;
+	Strings_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("hx.strings.Strings",18,f7,a8,5d);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &Strings_obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(Strings_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< Strings_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Strings_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Strings_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace hx
+} // end namespace strings
diff --git a/Sources/c_snikket/src/hx/strings/internal/_Either2/_Either2.cpp b/Sources/c_snikket/src/hx/strings/internal/_Either2/_Either2.cpp
new file mode 100644
index 0000000..83c29e4
--- /dev/null
+++ b/Sources/c_snikket/src/hx/strings/internal/_Either2/_Either2.cpp
@@ -0,0 +1,90 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_hx_strings_internal__Either2__Either2
+#include <hx/strings/internal/_Either2/_Either2.h>
+#endif
+namespace hx{
+namespace strings{
+namespace internal{
+namespace _Either2{
+
+::hx::strings::internal::_Either2::_Either2 _Either2_obj::a( ::Dynamic v)
+{
+	return ::hx::CreateEnum< _Either2_obj >(HX_("a",61,00,00,00),0,1)->_hx_init(0,v);
+}
+
+::hx::strings::internal::_Either2::_Either2 _Either2_obj::b( ::Dynamic v)
+{
+	return ::hx::CreateEnum< _Either2_obj >(HX_("b",62,00,00,00),1,1)->_hx_init(0,v);
+}
+
+bool _Either2_obj::__GetStatic(const ::String &inName, ::Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	if (inName==HX_("a",61,00,00,00)) { outValue = _Either2_obj::a_dyn(); return true; }
+	if (inName==HX_("b",62,00,00,00)) { outValue = _Either2_obj::b_dyn(); return true; }
+	return super::__GetStatic(inName, outValue, inCallProp);
+}
+
+HX_DEFINE_CREATE_ENUM(_Either2_obj)
+
+int _Either2_obj::__FindIndex(::String inName)
+{
+	if (inName==HX_("a",61,00,00,00)) return 0;
+	if (inName==HX_("b",62,00,00,00)) return 1;
+	return super::__FindIndex(inName);
+}
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(_Either2_obj,a,return)
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(_Either2_obj,b,return)
+
+int _Either2_obj::__FindArgCount(::String inName)
+{
+	if (inName==HX_("a",61,00,00,00)) return 1;
+	if (inName==HX_("b",62,00,00,00)) return 1;
+	return super::__FindArgCount(inName);
+}
+
+::hx::Val _Either2_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	if (inName==HX_("a",61,00,00,00)) return a_dyn();
+	if (inName==HX_("b",62,00,00,00)) return b_dyn();
+	return super::__Field(inName,inCallProp);
+}
+
+static ::String _Either2_obj_sStaticFields[] = {
+	HX_("a",61,00,00,00),
+	HX_("b",62,00,00,00),
+	::String(null())
+};
+
+::hx::Class _Either2_obj::__mClass;
+
+Dynamic __Create__Either2_obj() { return new _Either2_obj; }
+
+void _Either2_obj::__register()
+{
+
+::hx::Static(__mClass) = ::hx::_hx_RegisterClass(HX_("hx.strings.internal._Either2._Either2",07,08,e6,82), ::hx::TCanCast< _Either2_obj >,_Either2_obj_sStaticFields,0,
+	&__Create__Either2_obj, &__Create,
+	&super::__SGetClass(), &Create_Either2_obj, 0
+#ifdef HXCPP_VISIT_ALLOCS
+    , 0
+#endif
+#ifdef HXCPP_SCRIPTABLE
+    , 0
+#endif
+);
+	__mClass->mGetStaticField = &_Either2_obj::__GetStatic;
+}
+
+void _Either2_obj::__boot()
+{
+}
+
+
+} // end namespace hx
+} // end namespace strings
+} // end namespace internal
+} // end namespace _Either2
diff --git a/Sources/c_snikket/src/sha/Hash.cpp b/Sources/c_snikket/src/sha/Hash.cpp
new file mode 100644
index 0000000..6212b6c
--- /dev/null
+++ b/Sources/c_snikket/src/sha/Hash.cpp
@@ -0,0 +1,223 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Std
+#include <Std.h>
+#endif
+#ifndef INCLUDED_haxe_io_Bytes
+#include <haxe/io/Bytes.h>
+#endif
+#ifndef INCLUDED_sha_Hash
+#include <sha/Hash.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_a9cd7e4aca9fcb58_10_new,"sha.Hash","new",0x7a36a662,"sha.Hash.new","sha/Hash.hx",10,0x66842d6d)
+HX_LOCAL_STACK_FRAME(_hx_pos_a9cd7e4aca9fcb58_28_update,"sha.Hash","update",0x5b5edd47,"sha.Hash.update","sha/Hash.hx",28,0x66842d6d)
+HX_LOCAL_STACK_FRAME(_hx_pos_a9cd7e4aca9fcb58_52_digest,"sha.Hash","digest",0x897e5782,"sha.Hash.digest","sha/Hash.hx",52,0x66842d6d)
+namespace sha{
+
+void Hash_obj::__construct(int blockSize,int finalSize){
+            	HX_STACKFRAME(&_hx_pos_a9cd7e4aca9fcb58_10_new)
+HXLINE(  11)		this->finalSize = finalSize;
+HXLINE(  12)		this->block = ::haxe::io::Bytes_obj::alloc(blockSize);
+HXLINE(  13)		this->length = 0;
+            	}
+
+bool Hash_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x49a7eb1a;
+}
+
+ ::sha::Hash Hash_obj::update( ::haxe::io::Bytes data){
+            	HX_STACKFRAME(&_hx_pos_a9cd7e4aca9fcb58_28_update)
+HXLINE(  29)		int accum = this->length;
+HXLINE(  31)		int offset = 0;
+HXLINE(  32)		while((offset < data->length)){
+HXLINE(  33)			int assigned = ::hx::Mod(accum,this->block->length);
+HXLINE(  34)			int a = (data->length - offset);
+HXDLIN(  34)			int b = (this->block->length - assigned);
+HXDLIN(  34)			int remainder;
+HXDLIN(  34)			if ((a < b)) {
+HXLINE(  34)				remainder = a;
+            			}
+            			else {
+HXLINE(  34)				remainder = b;
+            			}
+HXLINE(  36)			{
+HXLINE(  36)				int _g = 0;
+HXDLIN(  36)				int _g1 = remainder;
+HXDLIN(  36)				while((_g < _g1)){
+HXLINE(  36)					_g = (_g + 1);
+HXDLIN(  36)					int i = (_g - 1);
+HXLINE(  37)					this->block->b[(assigned + i)] = data->b->__get((offset + i));
+            				}
+            			}
+HXLINE(  40)			accum = (accum + remainder);
+HXLINE(  41)			offset = (offset + remainder);
+HXLINE(  43)			if ((::hx::Mod(accum,this->block->length) == 0)) {
+HXLINE(  44)				this->_update(this->block);
+            			}
+            		}
+HXLINE(  48)		 ::sha::Hash _hx_tmp = ::hx::ObjectPtr<OBJ_>(this);
+HXDLIN(  48)		_hx_tmp->length = (_hx_tmp->length + data->length);
+HXLINE(  49)		return ::hx::ObjectPtr<OBJ_>(this);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Hash_obj,update,return )
+
+ ::haxe::io::Bytes Hash_obj::digest(){
+            	HX_STACKFRAME(&_hx_pos_a9cd7e4aca9fcb58_52_digest)
+HXLINE(  53)		int rem = ::hx::Mod(this->length,this->block->length);
+HXLINE(  55)		this->block->b[rem] = ( (unsigned char)(128) );
+HXLINE(  57)		this->block->fill((rem + 1),(this->block->length - (rem + 1)),0);
+HXLINE(  59)		if ((rem >= this->finalSize)) {
+HXLINE(  60)			this->_update(this->block);
+HXLINE(  61)			this->block->fill(0,this->block->length,0);
+            		}
+HXLINE(  64)		int bits = (this->length * 8);
+HXLINE(  66)		if ((bits <= -1)) {
+HXLINE(  67)			 ::haxe::io::Bytes b = this->block;
+HXDLIN(  67)			int pos = (this->block->length - 4);
+HXDLIN(  67)			b->b[pos] = ( (unsigned char)((bits >> 24)) );
+HXDLIN(  67)			b->b[(pos + 1)] = ( (unsigned char)(((bits >> 16) & 255)) );
+HXDLIN(  67)			b->b[(pos + 2)] = ( (unsigned char)(((bits >> 8) & 255)) );
+HXDLIN(  67)			b->b[(pos + 3)] = ( (unsigned char)((bits & 255)) );
+            		}
+            		else {
+HXLINE(  69)			int lowBits = ::hx::UShr((bits & -1),0);
+HXLINE(  70)			int highBits = ::Std_obj::_hx_int((( (Float)((bits - lowBits)) ) / ((Float)4294967296)));
+HXLINE(  72)			{
+HXLINE(  72)				 ::haxe::io::Bytes b1 = this->block;
+HXDLIN(  72)				int pos1 = (this->block->length - 8);
+HXDLIN(  72)				b1->b[pos1] = ( (unsigned char)((highBits >> 24)) );
+HXDLIN(  72)				b1->b[(pos1 + 1)] = ( (unsigned char)(((highBits >> 16) & 255)) );
+HXDLIN(  72)				b1->b[(pos1 + 2)] = ( (unsigned char)(((highBits >> 8) & 255)) );
+HXDLIN(  72)				b1->b[(pos1 + 3)] = ( (unsigned char)((highBits & 255)) );
+            			}
+HXLINE(  73)			{
+HXLINE(  73)				 ::haxe::io::Bytes b2 = this->block;
+HXDLIN(  73)				int pos2 = (this->block->length - 4);
+HXDLIN(  73)				b2->b[pos2] = ( (unsigned char)((lowBits >> 24)) );
+HXDLIN(  73)				b2->b[(pos2 + 1)] = ( (unsigned char)(((lowBits >> 16) & 255)) );
+HXDLIN(  73)				b2->b[(pos2 + 2)] = ( (unsigned char)(((lowBits >> 8) & 255)) );
+HXDLIN(  73)				b2->b[(pos2 + 3)] = ( (unsigned char)((lowBits & 255)) );
+            			}
+            		}
+HXLINE(  76)		this->_update(this->block);
+HXLINE(  78)		return this->_hash();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Hash_obj,digest,return )
+
+HX_DEFINE_DYNAMIC_FUNC1(Hash_obj,_update,(void))
+
+HX_DEFINE_DYNAMIC_FUNC0(Hash_obj,_hash,return )
+
+
+Hash_obj::Hash_obj()
+{
+}
+
+void Hash_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(Hash);
+	HX_MARK_MEMBER_NAME(finalSize,"finalSize");
+	HX_MARK_MEMBER_NAME(length,"length");
+	HX_MARK_MEMBER_NAME(block,"block");
+	HX_MARK_END_CLASS();
+}
+
+void Hash_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(finalSize,"finalSize");
+	HX_VISIT_MEMBER_NAME(length,"length");
+	HX_VISIT_MEMBER_NAME(block,"block");
+}
+
+::hx::Val Hash_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 5:
+		if (HX_FIELD_EQ(inName,"block") ) { return ::hx::Val( block ); }
+		if (HX_FIELD_EQ(inName,"_hash") ) { return ::hx::Val( _hash_dyn() ); }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"length") ) { return ::hx::Val( length ); }
+		if (HX_FIELD_EQ(inName,"update") ) { return ::hx::Val( update_dyn() ); }
+		if (HX_FIELD_EQ(inName,"digest") ) { return ::hx::Val( digest_dyn() ); }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"_update") ) { return ::hx::Val( _update_dyn() ); }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"finalSize") ) { return ::hx::Val( finalSize ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val Hash_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 5:
+		if (HX_FIELD_EQ(inName,"block") ) { block=inValue.Cast<  ::haxe::io::Bytes >(); return inValue; }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"length") ) { length=inValue.Cast< int >(); return inValue; }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"finalSize") ) { finalSize=inValue.Cast< int >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void Hash_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("finalSize",57,1f,2b,8f));
+	outFields->push(HX_("length",e6,94,07,9f));
+	outFields->push(HX_("block",4d,75,fc,b4));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo Hash_obj_sMemberStorageInfo[] = {
+	{::hx::fsInt,(int)offsetof(Hash_obj,finalSize),HX_("finalSize",57,1f,2b,8f)},
+	{::hx::fsInt,(int)offsetof(Hash_obj,length),HX_("length",e6,94,07,9f)},
+	{::hx::fsObject /*  ::haxe::io::Bytes */ ,(int)offsetof(Hash_obj,block),HX_("block",4d,75,fc,b4)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *Hash_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String Hash_obj_sMemberFields[] = {
+	HX_("finalSize",57,1f,2b,8f),
+	HX_("length",e6,94,07,9f),
+	HX_("block",4d,75,fc,b4),
+	HX_("update",09,86,05,87),
+	HX_("digest",44,00,25,b5),
+	HX_("_update",a8,97,7c,f5),
+	HX_("_hash",ad,4b,19,f8),
+	::String(null()) };
+
+::hx::Class Hash_obj::__mClass;
+
+void Hash_obj::__register()
+{
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("sha.Hash",70,8d,4f,0b);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(Hash_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< Hash_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Hash_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Hash_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace sha
diff --git a/Sources/c_snikket/src/sha/SHA256.cpp b/Sources/c_snikket/src/sha/SHA256.cpp
new file mode 100644
index 0000000..da7ca3c
--- /dev/null
+++ b/Sources/c_snikket/src/sha/SHA256.cpp
@@ -0,0 +1,406 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_io_Bytes
+#include <haxe/io/Bytes.h>
+#endif
+#ifndef INCLUDED_sha_Hash
+#include <sha/Hash.h>
+#endif
+#ifndef INCLUDED_sha_SHA256
+#include <sha/SHA256.h>
+#endif
+#ifndef INCLUDED_sha__SHA256_SHA256_Fields_
+#include <sha/_SHA256/SHA256_Fields_.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_6226bdf42cc6cc66_24_new,"sha.SHA256","new",0x93e2e3fb,"sha.SHA256.new","sha/SHA256.hx",24,0xdc816bb4)
+HX_LOCAL_STACK_FRAME(_hx_pos_6226bdf42cc6cc66_40_sigma0,"sha.SHA256","sigma0",0x79d84b30,"sha.SHA256.sigma0","sha/SHA256.hx",40,0xdc816bb4)
+HX_LOCAL_STACK_FRAME(_hx_pos_6226bdf42cc6cc66_44_sigma1,"sha.SHA256","sigma1",0x79d84b31,"sha.SHA256.sigma1","sha/SHA256.hx",44,0xdc816bb4)
+HX_LOCAL_STACK_FRAME(_hx_pos_6226bdf42cc6cc66_48_gamma0,"sha.SHA256","gamma0",0x16529a6e,"sha.SHA256.gamma0","sha/SHA256.hx",48,0xdc816bb4)
+HX_LOCAL_STACK_FRAME(_hx_pos_6226bdf42cc6cc66_52_gamma1,"sha.SHA256","gamma1",0x16529a6f,"sha.SHA256.gamma1","sha/SHA256.hx",52,0xdc816bb4)
+HX_LOCAL_STACK_FRAME(_hx_pos_6226bdf42cc6cc66_56_ch,"sha.SHA256","ch",0x1c36ef6a,"sha.SHA256.ch","sha/SHA256.hx",56,0xdc816bb4)
+HX_LOCAL_STACK_FRAME(_hx_pos_6226bdf42cc6cc66_60_maj,"sha.SHA256","maj",0x93e21e31,"sha.SHA256.maj","sha/SHA256.hx",60,0xdc816bb4)
+HX_LOCAL_STACK_FRAME(_hx_pos_6226bdf42cc6cc66_63__update,"sha.SHA256","_update",0xd8ad14c3,"sha.SHA256._update","sha/SHA256.hx",63,0xdc816bb4)
+HX_LOCAL_STACK_FRAME(_hx_pos_6226bdf42cc6cc66_107__hash,"sha.SHA256","_hash",0xdc48bc08,"sha.SHA256._hash","sha/SHA256.hx",107,0xdc816bb4)
+namespace sha{
+
+void SHA256_obj::__construct(){
+            	HX_STACKFRAME(&_hx_pos_6226bdf42cc6cc66_24_new)
+HXLINE(  33)		this->_w = ::Array_obj< int >::__new(0);
+HXLINE(  32)		this->_h = (int)1541459225;
+HXLINE(  31)		this->_g = 528734635;
+HXLINE(  30)		this->_f = (int)-1694144372;
+HXLINE(  29)		this->_e = (int)1359893119;
+HXLINE(  28)		this->_d = (int)-1521486534;
+HXLINE(  27)		this->_c = (int)1013904242;
+HXLINE(  26)		this->_b = (int)-1150833019;
+HXLINE(  25)		this->_a = (int)1779033703;
+HXLINE(  36)		super::__construct(64,56);
+            	}
+
+Dynamic SHA256_obj::__CreateEmpty() { return new SHA256_obj; }
+
+void *SHA256_obj::_hx_vtable = 0;
+
+Dynamic SHA256_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< SHA256_obj > _hx_result = new SHA256_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool SHA256_obj::_hx_isInstanceOf(int inClassId) {
+	if (inClassId<=(int)0x0251ab23) {
+		return inClassId==(int)0x00000001 || inClassId==(int)0x0251ab23;
+	} else {
+		return inClassId==(int)0x49a7eb1a;
+	}
+}
+
+int SHA256_obj::sigma0(int x){
+            	HX_STACKFRAME(&_hx_pos_6226bdf42cc6cc66_40_sigma0)
+HXDLIN(  40)		return (((::hx::UShr(x,2) | (x << 30)) ^ (::hx::UShr(x,13) | (x << 19))) ^ (::hx::UShr(x,22) | (x << 10)));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(SHA256_obj,sigma0,return )
+
+int SHA256_obj::sigma1(int x){
+            	HX_STACKFRAME(&_hx_pos_6226bdf42cc6cc66_44_sigma1)
+HXDLIN(  44)		return (((::hx::UShr(x,6) | (x << 26)) ^ (::hx::UShr(x,11) | (x << 21))) ^ (::hx::UShr(x,25) | (x << 7)));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(SHA256_obj,sigma1,return )
+
+int SHA256_obj::gamma0(int x){
+            	HX_STACKFRAME(&_hx_pos_6226bdf42cc6cc66_48_gamma0)
+HXDLIN(  48)		return (((::hx::UShr(x,7) | (x << 25)) ^ (::hx::UShr(x,18) | (x << 14))) ^ ::hx::UShr(x,3));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(SHA256_obj,gamma0,return )
+
+int SHA256_obj::gamma1(int x){
+            	HX_STACKFRAME(&_hx_pos_6226bdf42cc6cc66_52_gamma1)
+HXDLIN(  52)		return (((::hx::UShr(x,17) | (x << 15)) ^ (::hx::UShr(x,19) | (x << 13))) ^ ::hx::UShr(x,10));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(SHA256_obj,gamma1,return )
+
+int SHA256_obj::ch(int x,int y,int z){
+            	HX_STACKFRAME(&_hx_pos_6226bdf42cc6cc66_56_ch)
+HXDLIN(  56)		return (z ^ (x & (y ^ z)));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC3(SHA256_obj,ch,return )
+
+int SHA256_obj::maj(int x,int y,int z){
+            	HX_STACKFRAME(&_hx_pos_6226bdf42cc6cc66_60_maj)
+HXDLIN(  60)		return ((x & y) | (z & (x | y)));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC3(SHA256_obj,maj,return )
+
+void SHA256_obj::_update( ::haxe::io::Bytes data){
+            	HX_STACKFRAME(&_hx_pos_6226bdf42cc6cc66_63__update)
+HXLINE(  64)		::Array< int > W = this->_w;
+HXLINE(  66)		int a = (this->_a | 0);
+HXLINE(  67)		int b = (this->_b | 0);
+HXLINE(  68)		int c = (this->_c | 0);
+HXLINE(  69)		int d = (this->_d | 0);
+HXLINE(  70)		int e = (this->_e | 0);
+HXLINE(  71)		int f = (this->_f | 0);
+HXLINE(  72)		int g = (this->_g | 0);
+HXLINE(  73)		int h = (this->_h | 0);
+HXLINE(  75)		{
+HXLINE(  75)			int _g = 0;
+HXDLIN(  75)			while((_g < 16)){
+HXLINE(  75)				_g = (_g + 1);
+HXDLIN(  75)				int i = (_g - 1);
+HXLINE(  76)				W[i] = ((((( (int)(data->b->__get((i * 4))) ) << 24) | (( (int)(data->b->__get(((i * 4) + 1))) ) << 16)) | (( (int)(data->b->__get(((i * 4) + 2))) ) << 8)) | ( (int)(data->b->__get(((i * 4) + 3))) ));
+            			}
+            		}
+HXLINE(  79)		{
+HXLINE(  79)			int _g1 = 16;
+HXDLIN(  79)			while((_g1 < 64)){
+HXLINE(  79)				_g1 = (_g1 + 1);
+HXDLIN(  79)				int i1 = (_g1 - 1);
+HXLINE(  80)				int _hx_tmp = this->gamma1(W->__get((i1 - 2)));
+HXDLIN(  80)				int _hx_tmp1 = (_hx_tmp + W->__get((i1 - 7)));
+HXDLIN(  80)				int _hx_tmp2 = (_hx_tmp1 + this->gamma0(W->__get((i1 - 15))));
+HXDLIN(  80)				W[i1] = ((_hx_tmp2 + W->__get((i1 - 16))) | 0);
+            			}
+            		}
+HXLINE(  83)		{
+HXLINE(  83)			int _g2 = 0;
+HXDLIN(  83)			while((_g2 < 64)){
+HXLINE(  83)				_g2 = (_g2 + 1);
+HXDLIN(  83)				int j = (_g2 - 1);
+HXLINE(  84)				int T1 = (h + this->sigma1(e));
+HXDLIN(  84)				int T11 = (T1 + this->ch(e,f,g));
+HXDLIN(  84)				int T12 = (((T11 + ::sha::_SHA256::SHA256_Fields__obj::K->__get(j)) + W->__get(j)) | 0);
+HXLINE(  85)				int T2 = this->sigma0(a);
+HXDLIN(  85)				int T21 = ((T2 + this->maj(a,b,c)) | 0);
+HXLINE(  87)				h = g;
+HXLINE(  88)				g = f;
+HXLINE(  89)				f = e;
+HXLINE(  90)				e = ((d + T12) | 0);
+HXLINE(  91)				d = c;
+HXLINE(  92)				c = b;
+HXLINE(  93)				b = a;
+HXLINE(  94)				a = ((T12 + T21) | 0);
+            			}
+            		}
+HXLINE(  97)		this->_a = ((a + this->_a) | 0);
+HXLINE(  98)		this->_b = ((b + this->_b) | 0);
+HXLINE(  99)		this->_c = ((c + this->_c) | 0);
+HXLINE( 100)		this->_d = ((d + this->_d) | 0);
+HXLINE( 101)		this->_e = ((e + this->_e) | 0);
+HXLINE( 102)		this->_f = ((f + this->_f) | 0);
+HXLINE( 103)		this->_g = ((g + this->_g) | 0);
+HXLINE( 104)		this->_h = ((h + this->_h) | 0);
+            	}
+
+
+ ::haxe::io::Bytes SHA256_obj::_hash(){
+            	HX_STACKFRAME(&_hx_pos_6226bdf42cc6cc66_107__hash)
+HXLINE( 108)		 ::haxe::io::Bytes b = ::haxe::io::Bytes_obj::alloc(32);
+HXLINE( 110)		{
+HXLINE( 110)			int i = this->_a;
+HXDLIN( 110)			b->b[0] = ( (unsigned char)((i >> 24)) );
+HXDLIN( 110)			b->b[1] = ( (unsigned char)(((i >> 16) & 255)) );
+HXDLIN( 110)			b->b[2] = ( (unsigned char)(((i >> 8) & 255)) );
+HXDLIN( 110)			b->b[3] = ( (unsigned char)((i & 255)) );
+            		}
+HXLINE( 111)		{
+HXLINE( 111)			int i1 = this->_b;
+HXDLIN( 111)			b->b[4] = ( (unsigned char)((i1 >> 24)) );
+HXDLIN( 111)			b->b[5] = ( (unsigned char)(((i1 >> 16) & 255)) );
+HXDLIN( 111)			b->b[6] = ( (unsigned char)(((i1 >> 8) & 255)) );
+HXDLIN( 111)			b->b[7] = ( (unsigned char)((i1 & 255)) );
+            		}
+HXLINE( 112)		{
+HXLINE( 112)			int i2 = this->_c;
+HXDLIN( 112)			b->b[8] = ( (unsigned char)((i2 >> 24)) );
+HXDLIN( 112)			b->b[9] = ( (unsigned char)(((i2 >> 16) & 255)) );
+HXDLIN( 112)			b->b[10] = ( (unsigned char)(((i2 >> 8) & 255)) );
+HXDLIN( 112)			b->b[11] = ( (unsigned char)((i2 & 255)) );
+            		}
+HXLINE( 113)		{
+HXLINE( 113)			int i3 = this->_d;
+HXDLIN( 113)			b->b[12] = ( (unsigned char)((i3 >> 24)) );
+HXDLIN( 113)			b->b[13] = ( (unsigned char)(((i3 >> 16) & 255)) );
+HXDLIN( 113)			b->b[14] = ( (unsigned char)(((i3 >> 8) & 255)) );
+HXDLIN( 113)			b->b[15] = ( (unsigned char)((i3 & 255)) );
+            		}
+HXLINE( 114)		{
+HXLINE( 114)			int i4 = this->_e;
+HXDLIN( 114)			b->b[16] = ( (unsigned char)((i4 >> 24)) );
+HXDLIN( 114)			b->b[17] = ( (unsigned char)(((i4 >> 16) & 255)) );
+HXDLIN( 114)			b->b[18] = ( (unsigned char)(((i4 >> 8) & 255)) );
+HXDLIN( 114)			b->b[19] = ( (unsigned char)((i4 & 255)) );
+            		}
+HXLINE( 115)		{
+HXLINE( 115)			int i5 = this->_f;
+HXDLIN( 115)			b->b[20] = ( (unsigned char)((i5 >> 24)) );
+HXDLIN( 115)			b->b[21] = ( (unsigned char)(((i5 >> 16) & 255)) );
+HXDLIN( 115)			b->b[22] = ( (unsigned char)(((i5 >> 8) & 255)) );
+HXDLIN( 115)			b->b[23] = ( (unsigned char)((i5 & 255)) );
+            		}
+HXLINE( 116)		{
+HXLINE( 116)			int i6 = this->_g;
+HXDLIN( 116)			b->b[24] = ( (unsigned char)((i6 >> 24)) );
+HXDLIN( 116)			b->b[25] = ( (unsigned char)(((i6 >> 16) & 255)) );
+HXDLIN( 116)			b->b[26] = ( (unsigned char)(((i6 >> 8) & 255)) );
+HXDLIN( 116)			b->b[27] = ( (unsigned char)((i6 & 255)) );
+            		}
+HXLINE( 117)		{
+HXLINE( 117)			int i7 = this->_h;
+HXDLIN( 117)			b->b[28] = ( (unsigned char)((i7 >> 24)) );
+HXDLIN( 117)			b->b[29] = ( (unsigned char)(((i7 >> 16) & 255)) );
+HXDLIN( 117)			b->b[30] = ( (unsigned char)(((i7 >> 8) & 255)) );
+HXDLIN( 117)			b->b[31] = ( (unsigned char)((i7 & 255)) );
+            		}
+HXLINE( 119)		return b;
+            	}
+
+
+
+::hx::ObjectPtr< SHA256_obj > SHA256_obj::__new() {
+	::hx::ObjectPtr< SHA256_obj > __this = new SHA256_obj();
+	__this->__construct();
+	return __this;
+}
+
+::hx::ObjectPtr< SHA256_obj > SHA256_obj::__alloc(::hx::Ctx *_hx_ctx) {
+	SHA256_obj *__this = (SHA256_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(SHA256_obj), true, "sha.SHA256"));
+	*(void **)__this = SHA256_obj::_hx_vtable;
+	__this->__construct();
+	return __this;
+}
+
+SHA256_obj::SHA256_obj()
+{
+}
+
+void SHA256_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(SHA256);
+	HX_MARK_MEMBER_NAME(_a,"_a");
+	HX_MARK_MEMBER_NAME(_b,"_b");
+	HX_MARK_MEMBER_NAME(_c,"_c");
+	HX_MARK_MEMBER_NAME(_d,"_d");
+	HX_MARK_MEMBER_NAME(_e,"_e");
+	HX_MARK_MEMBER_NAME(_f,"_f");
+	HX_MARK_MEMBER_NAME(_g,"_g");
+	HX_MARK_MEMBER_NAME(_h,"_h");
+	HX_MARK_MEMBER_NAME(_w,"_w");
+	 ::sha::Hash_obj::__Mark(HX_MARK_ARG);
+	HX_MARK_END_CLASS();
+}
+
+void SHA256_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(_a,"_a");
+	HX_VISIT_MEMBER_NAME(_b,"_b");
+	HX_VISIT_MEMBER_NAME(_c,"_c");
+	HX_VISIT_MEMBER_NAME(_d,"_d");
+	HX_VISIT_MEMBER_NAME(_e,"_e");
+	HX_VISIT_MEMBER_NAME(_f,"_f");
+	HX_VISIT_MEMBER_NAME(_g,"_g");
+	HX_VISIT_MEMBER_NAME(_h,"_h");
+	HX_VISIT_MEMBER_NAME(_w,"_w");
+	 ::sha::Hash_obj::__Visit(HX_VISIT_ARG);
+}
+
+::hx::Val SHA256_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 2:
+		if (HX_FIELD_EQ(inName,"_a") ) { return ::hx::Val( _a ); }
+		if (HX_FIELD_EQ(inName,"_b") ) { return ::hx::Val( _b ); }
+		if (HX_FIELD_EQ(inName,"_c") ) { return ::hx::Val( _c ); }
+		if (HX_FIELD_EQ(inName,"_d") ) { return ::hx::Val( _d ); }
+		if (HX_FIELD_EQ(inName,"_e") ) { return ::hx::Val( _e ); }
+		if (HX_FIELD_EQ(inName,"_f") ) { return ::hx::Val( _f ); }
+		if (HX_FIELD_EQ(inName,"_g") ) { return ::hx::Val( _g ); }
+		if (HX_FIELD_EQ(inName,"_h") ) { return ::hx::Val( _h ); }
+		if (HX_FIELD_EQ(inName,"_w") ) { return ::hx::Val( _w ); }
+		if (HX_FIELD_EQ(inName,"ch") ) { return ::hx::Val( ch_dyn() ); }
+		break;
+	case 3:
+		if (HX_FIELD_EQ(inName,"maj") ) { return ::hx::Val( maj_dyn() ); }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"_hash") ) { return ::hx::Val( _hash_dyn() ); }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"sigma0") ) { return ::hx::Val( sigma0_dyn() ); }
+		if (HX_FIELD_EQ(inName,"sigma1") ) { return ::hx::Val( sigma1_dyn() ); }
+		if (HX_FIELD_EQ(inName,"gamma0") ) { return ::hx::Val( gamma0_dyn() ); }
+		if (HX_FIELD_EQ(inName,"gamma1") ) { return ::hx::Val( gamma1_dyn() ); }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"_update") ) { return ::hx::Val( _update_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val SHA256_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 2:
+		if (HX_FIELD_EQ(inName,"_a") ) { _a=inValue.Cast< int >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"_b") ) { _b=inValue.Cast< int >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"_c") ) { _c=inValue.Cast< int >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"_d") ) { _d=inValue.Cast< int >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"_e") ) { _e=inValue.Cast< int >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"_f") ) { _f=inValue.Cast< int >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"_g") ) { _g=inValue.Cast< int >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"_h") ) { _h=inValue.Cast< int >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"_w") ) { _w=inValue.Cast< ::Array< int > >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void SHA256_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("_a",22,53,00,00));
+	outFields->push(HX_("_b",23,53,00,00));
+	outFields->push(HX_("_c",24,53,00,00));
+	outFields->push(HX_("_d",25,53,00,00));
+	outFields->push(HX_("_e",26,53,00,00));
+	outFields->push(HX_("_f",27,53,00,00));
+	outFields->push(HX_("_g",28,53,00,00));
+	outFields->push(HX_("_h",29,53,00,00));
+	outFields->push(HX_("_w",38,53,00,00));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo SHA256_obj_sMemberStorageInfo[] = {
+	{::hx::fsInt,(int)offsetof(SHA256_obj,_a),HX_("_a",22,53,00,00)},
+	{::hx::fsInt,(int)offsetof(SHA256_obj,_b),HX_("_b",23,53,00,00)},
+	{::hx::fsInt,(int)offsetof(SHA256_obj,_c),HX_("_c",24,53,00,00)},
+	{::hx::fsInt,(int)offsetof(SHA256_obj,_d),HX_("_d",25,53,00,00)},
+	{::hx::fsInt,(int)offsetof(SHA256_obj,_e),HX_("_e",26,53,00,00)},
+	{::hx::fsInt,(int)offsetof(SHA256_obj,_f),HX_("_f",27,53,00,00)},
+	{::hx::fsInt,(int)offsetof(SHA256_obj,_g),HX_("_g",28,53,00,00)},
+	{::hx::fsInt,(int)offsetof(SHA256_obj,_h),HX_("_h",29,53,00,00)},
+	{::hx::fsObject /* ::Array< int > */ ,(int)offsetof(SHA256_obj,_w),HX_("_w",38,53,00,00)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *SHA256_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String SHA256_obj_sMemberFields[] = {
+	HX_("_a",22,53,00,00),
+	HX_("_b",23,53,00,00),
+	HX_("_c",24,53,00,00),
+	HX_("_d",25,53,00,00),
+	HX_("_e",26,53,00,00),
+	HX_("_f",27,53,00,00),
+	HX_("_g",28,53,00,00),
+	HX_("_h",29,53,00,00),
+	HX_("_w",38,53,00,00),
+	HX_("sigma0",eb,6b,85,b4),
+	HX_("sigma1",ec,6b,85,b4),
+	HX_("gamma0",29,bb,ff,50),
+	HX_("gamma1",2a,bb,ff,50),
+	HX_("ch",a5,56,00,00),
+	HX_("maj",96,0a,53,00),
+	HX_("_update",a8,97,7c,f5),
+	HX_("_hash",ad,4b,19,f8),
+	::String(null()) };
+
+::hx::Class SHA256_obj::__mClass;
+
+void SHA256_obj::__register()
+{
+	SHA256_obj _hx_dummy;
+	SHA256_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("sha.SHA256",89,ca,14,08);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(SHA256_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< SHA256_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = SHA256_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = SHA256_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace sha
diff --git a/Sources/c_snikket/src/sha/_SHA256/SHA256_Fields_.cpp b/Sources/c_snikket/src/sha/_SHA256/SHA256_Fields_.cpp
new file mode 100644
index 0000000..edd16c6
--- /dev/null
+++ b/Sources/c_snikket/src/sha/_SHA256/SHA256_Fields_.cpp
@@ -0,0 +1,119 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_sha__SHA256_SHA256_Fields_
+#include <sha/_SHA256/SHA256_Fields_.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_28eeb24f2f42c3b1_5_boot,"sha._SHA256.SHA256_Fields_","boot",0x84d19c68,"sha._SHA256.SHA256_Fields_.boot","sha/SHA256.hx",5,0xdc816bb4)
+static const int _hx_array_data_510133f8_1[] = {
+	(int)1116352408,(int)1899447441,(int)-1245643825,(int)-373957723,(int)961987163,(int)1508970993,(int)-1841331548,(int)-1424204075,(int)-670586216,(int)310598401,(int)607225278,(int)1426881987,(int)1925078388,(int)-2132889090,(int)-1680079193,(int)-1046744716,(int)-459576895,(int)-272742522,(int)264347078,(int)604807628,(int)770255983,(int)1249150122,(int)1555081692,(int)1996064986,(int)-1740746414,(int)-1473132947,(int)-1341970488,(int)-1084653625,(int)-958395405,(int)-710438585,(int)113926993,(int)338241895,(int)666307205,(int)773529912,(int)1294757372,(int)1396182291,(int)1695183700,(int)1986661051,(int)-2117940946,(int)-1838011259,(int)-1564481375,(int)-1474664885,(int)-1035236496,(int)-949202525,(int)-778901479,(int)-694614492,(int)-200395387,(int)275423344,(int)430227734,(int)506948616,(int)659060556,(int)883997877,(int)958139571,(int)1322822218,(int)1537002063,(int)1747873779,(int)1955562222,(int)2024104815,(int)-2067236844,(int)-1933114872,(int)-1866530822,(int)-1538233109,(int)-1090935817,(int)-965641998,
+};
+namespace sha{
+namespace _SHA256{
+
+void SHA256_Fields__obj::__construct() { }
+
+Dynamic SHA256_Fields__obj::__CreateEmpty() { return new SHA256_Fields__obj; }
+
+void *SHA256_Fields__obj::_hx_vtable = 0;
+
+Dynamic SHA256_Fields__obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< SHA256_Fields__obj > _hx_result = new SHA256_Fields__obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool SHA256_Fields__obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x07d39014;
+}
+
+::Array< int > SHA256_Fields__obj::K;
+
+
+SHA256_Fields__obj::SHA256_Fields__obj()
+{
+}
+
+bool SHA256_Fields__obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 1:
+		if (HX_FIELD_EQ(inName,"K") ) { outValue = ( K ); return true; }
+	}
+	return false;
+}
+
+bool SHA256_Fields__obj::__SetStatic(const ::String &inName,Dynamic &ioValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 1:
+		if (HX_FIELD_EQ(inName,"K") ) { K=ioValue.Cast< ::Array< int > >(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *SHA256_Fields__obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo SHA256_Fields__obj_sStaticStorageInfo[] = {
+	{::hx::fsObject /* ::Array< int > */ ,(void *) &SHA256_Fields__obj::K,HX_("K",4b,00,00,00)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+#endif
+
+static void SHA256_Fields__obj_sMarkStatics(HX_MARK_PARAMS) {
+	HX_MARK_MEMBER_NAME(SHA256_Fields__obj::K,"K");
+};
+
+#ifdef HXCPP_VISIT_ALLOCS
+static void SHA256_Fields__obj_sVisitStatics(HX_VISIT_PARAMS) {
+	HX_VISIT_MEMBER_NAME(SHA256_Fields__obj::K,"K");
+};
+
+#endif
+
+::hx::Class SHA256_Fields__obj::__mClass;
+
+static ::String SHA256_Fields__obj_sStaticFields[] = {
+	HX_("K",4b,00,00,00),
+	::String(null())
+};
+
+void SHA256_Fields__obj::__register()
+{
+	SHA256_Fields__obj _hx_dummy;
+	SHA256_Fields__obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("sha._SHA256.SHA256_Fields_",f8,33,01,51);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &SHA256_Fields__obj::__GetStatic;
+	__mClass->mSetStaticField = &SHA256_Fields__obj::__SetStatic;
+	__mClass->mMarkFunc = SHA256_Fields__obj_sMarkStatics;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(SHA256_Fields__obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< SHA256_Fields__obj >;
+#ifdef HXCPP_VISIT_ALLOCS
+	__mClass->mVisitFunc = SHA256_Fields__obj_sVisitStatics;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = SHA256_Fields__obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = SHA256_Fields__obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+void SHA256_Fields__obj::__boot()
+{
+{
+            	HX_STACKFRAME(&_hx_pos_28eeb24f2f42c3b1_5_boot)
+HXDLIN(   5)		K = ::Array_obj< int >::fromData( _hx_array_data_510133f8_1,64);
+            	}
+}
+
+} // end namespace sha
+} // end namespace _SHA256
diff --git a/Sources/c_snikket/src/snikket/AttachmentSource.cpp b/Sources/c_snikket/src/snikket/AttachmentSource.cpp
new file mode 100644
index 0000000..49b7eeb
--- /dev/null
+++ b/Sources/c_snikket/src/snikket/AttachmentSource.cpp
@@ -0,0 +1,275 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_haxe_io_Bytes
+#include <haxe/io/Bytes.h>
+#endif
+#ifndef INCLUDED_haxe_io_Input
+#include <haxe/io/Input.h>
+#endif
+#ifndef INCLUDED_haxe_io_Path
+#include <haxe/io/Path.h>
+#endif
+#ifndef INCLUDED_snikket_AttachmentSource
+#include <snikket/AttachmentSource.h>
+#endif
+#ifndef INCLUDED_sys_FileSystem
+#include <sys/FileSystem.h>
+#endif
+#ifndef INCLUDED_sys_io_File
+#include <sys/io/File.h>
+#endif
+#ifndef INCLUDED_sys_io_FileInput
+#include <sys/io/FileInput.h>
+#endif
+#ifndef INCLUDED_tink_io_WorkerObject
+#include <tink/io/WorkerObject.h>
+#endif
+#ifndef INCLUDED_tink_io__Worker_Worker_Impl_
+#include <tink/io/_Worker/Worker_Impl_.h>
+#endif
+#ifndef INCLUDED_tink_io_std_InputSource
+#include <tink/io/std/InputSource.h>
+#endif
+#ifndef INCLUDED_tink_streams_Generator
+#include <tink/streams/Generator.h>
+#endif
+#ifndef INCLUDED_tink_streams_StreamBase
+#include <tink/streams/StreamBase.h>
+#endif
+#ifndef INCLUDED_tink_streams_StreamObject
+#include <tink/streams/StreamObject.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_1589e03dacb7e96d_18_new,"snikket.AttachmentSource","new",0xbdfe18c1,"snikket.AttachmentSource.new","snikket/AttachmentSource.cpp.hx",18,0x88ae23d9)
+HX_LOCAL_STACK_FRAME(_hx_pos_178ee577f3d4b8ba_307_path__fromC,"snikket.AttachmentSource","path__fromC",0xcaffcad5,"snikket.AttachmentSource.path__fromC","HaxeCBridge.hx",307,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_178ee577f3d4b8ba_307_type__fromC,"snikket.AttachmentSource","type__fromC",0xde17ba60,"snikket.AttachmentSource.type__fromC","HaxeCBridge.hx",307,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_178ee577f3d4b8ba_307_name__fromC,"snikket.AttachmentSource","name__fromC",0x5911beef,"snikket.AttachmentSource.name__fromC","HaxeCBridge.hx",307,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_178ee577f3d4b8ba_307_size__fromC,"snikket.AttachmentSource","size__fromC",0x95ffeb39,"snikket.AttachmentSource.size__fromC","HaxeCBridge.hx",307,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_1589e03dacb7e96d_27_tinkSource,"snikket.AttachmentSource","tinkSource",0x8a7a292c,"snikket.AttachmentSource.tinkSource","snikket/AttachmentSource.cpp.hx",27,0x88ae23d9)
+HX_LOCAL_STACK_FRAME(_hx_pos_1589e03dacb7e96d_12_boot,"snikket.AttachmentSource","boot",0x787090b1,"snikket.AttachmentSource.boot","snikket/AttachmentSource.cpp.hx",12,0x88ae23d9)
+namespace snikket{
+
+void AttachmentSource_obj::__construct(::String path,::String mime){
+            	HX_STACKFRAME(&_hx_pos_1589e03dacb7e96d_18_new)
+HXLINE(  19)		this->name = ::haxe::io::Path_obj::withoutDirectory(path);
+HXLINE(  20)		this->path = ::sys::FileSystem_obj::fullPath(path);
+HXLINE(  21)		this->size = ( (int)(::sys::FileSystem_obj::stat(this->path)->__Field(HX_("size",c1,a0,53,4c),::hx::paccDynamic)) );
+HXLINE(  22)		this->type = mime;
+            	}
+
+Dynamic AttachmentSource_obj::__CreateEmpty() { return new AttachmentSource_obj; }
+
+void *AttachmentSource_obj::_hx_vtable = 0;
+
+Dynamic AttachmentSource_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< AttachmentSource_obj > _hx_result = new AttachmentSource_obj();
+	_hx_result->__construct(inArgs[0],inArgs[1]);
+	return _hx_result;
+}
+
+bool AttachmentSource_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x3b403b17;
+}
+
+::String AttachmentSource_obj::path__fromC(){
+            	HX_STACKFRAME(&_hx_pos_178ee577f3d4b8ba_307_path__fromC)
+HXDLIN( 307)		return this->path;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(AttachmentSource_obj,path__fromC,return )
+
+::String AttachmentSource_obj::type__fromC(){
+            	HX_STACKFRAME(&_hx_pos_178ee577f3d4b8ba_307_type__fromC)
+HXDLIN( 307)		return this->type;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(AttachmentSource_obj,type__fromC,return )
+
+::String AttachmentSource_obj::name__fromC(){
+            	HX_STACKFRAME(&_hx_pos_178ee577f3d4b8ba_307_name__fromC)
+HXDLIN( 307)		return this->name;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(AttachmentSource_obj,name__fromC,return )
+
+int AttachmentSource_obj::size__fromC(){
+            	HX_STACKFRAME(&_hx_pos_178ee577f3d4b8ba_307_size__fromC)
+HXDLIN( 307)		return this->size;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(AttachmentSource_obj,size__fromC,return )
+
+::Dynamic AttachmentSource_obj::tinkSource(){
+            	HX_GC_STACKFRAME(&_hx_pos_1589e03dacb7e96d_27_tinkSource)
+HXDLIN(  27)		::String name = this->name;
+HXDLIN(  27)		 ::haxe::io::Input input = ::sys::io::File_obj::read(this->path,null());
+HXDLIN(  27)		 ::Dynamic options = null();
+HXDLIN(  27)		if (::hx::IsNull( options )) {
+HXDLIN(  27)			options =  ::Dynamic(::hx::Anon_obj::Create(0));
+            		}
+HXDLIN(  27)		::Dynamic _hx_tmp = ::tink::io::_Worker::Worker_Impl__obj::ensure( ::Dynamic(options->__Field(HX_("worker",7e,30,9e,c9),::hx::paccDynamic)));
+HXDLIN(  27)		 ::Dynamic _g = options->__Field(HX_("chunkSize",ce,cd,77,9f),::hx::paccDynamic);
+HXDLIN(  27)		int _hx_tmp1;
+HXDLIN(  27)		if (::hx::IsNull( _g )) {
+HXDLIN(  27)			_hx_tmp1 = 65536;
+            		}
+            		else {
+HXDLIN(  27)			 ::Dynamic v = _g;
+HXDLIN(  27)			_hx_tmp1 = ( (int)(v) );
+            		}
+HXDLIN(  27)		return  ::tink::io::std::InputSource_obj::__alloc( HX_CTX ,name,input,_hx_tmp,::haxe::io::Bytes_obj::alloc(_hx_tmp1),0);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(AttachmentSource_obj,tinkSource,return )
+
+
+::hx::ObjectPtr< AttachmentSource_obj > AttachmentSource_obj::__new(::String path,::String mime) {
+	::hx::ObjectPtr< AttachmentSource_obj > __this = new AttachmentSource_obj();
+	__this->__construct(path,mime);
+	return __this;
+}
+
+::hx::ObjectPtr< AttachmentSource_obj > AttachmentSource_obj::__alloc(::hx::Ctx *_hx_ctx,::String path,::String mime) {
+	AttachmentSource_obj *__this = (AttachmentSource_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(AttachmentSource_obj), true, "snikket.AttachmentSource"));
+	*(void **)__this = AttachmentSource_obj::_hx_vtable;
+	__this->__construct(path,mime);
+	return __this;
+}
+
+AttachmentSource_obj::AttachmentSource_obj()
+{
+}
+
+void AttachmentSource_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(AttachmentSource);
+	HX_MARK_MEMBER_NAME(path,"path");
+	HX_MARK_MEMBER_NAME(type,"type");
+	HX_MARK_MEMBER_NAME(name,"name");
+	HX_MARK_MEMBER_NAME(size,"size");
+	HX_MARK_END_CLASS();
+}
+
+void AttachmentSource_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(path,"path");
+	HX_VISIT_MEMBER_NAME(type,"type");
+	HX_VISIT_MEMBER_NAME(name,"name");
+	HX_VISIT_MEMBER_NAME(size,"size");
+}
+
+::hx::Val AttachmentSource_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"path") ) { return ::hx::Val( path ); }
+		if (HX_FIELD_EQ(inName,"type") ) { return ::hx::Val( type ); }
+		if (HX_FIELD_EQ(inName,"name") ) { return ::hx::Val( name ); }
+		if (HX_FIELD_EQ(inName,"size") ) { return ::hx::Val( size ); }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"tinkSource") ) { return ::hx::Val( tinkSource_dyn() ); }
+		break;
+	case 11:
+		if (HX_FIELD_EQ(inName,"path__fromC") ) { return ::hx::Val( path__fromC_dyn() ); }
+		if (HX_FIELD_EQ(inName,"type__fromC") ) { return ::hx::Val( type__fromC_dyn() ); }
+		if (HX_FIELD_EQ(inName,"name__fromC") ) { return ::hx::Val( name__fromC_dyn() ); }
+		if (HX_FIELD_EQ(inName,"size__fromC") ) { return ::hx::Val( size__fromC_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val AttachmentSource_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"path") ) { path=inValue.Cast< ::String >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"type") ) { type=inValue.Cast< ::String >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"name") ) { name=inValue.Cast< ::String >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"size") ) { size=inValue.Cast< int >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void AttachmentSource_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("path",a5,e5,51,4a));
+	outFields->push(HX_("type",ba,f2,08,4d));
+	outFields->push(HX_("name",4b,72,ff,48));
+	outFields->push(HX_("size",c1,a0,53,4c));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo AttachmentSource_obj_sMemberStorageInfo[] = {
+	{::hx::fsString,(int)offsetof(AttachmentSource_obj,path),HX_("path",a5,e5,51,4a)},
+	{::hx::fsString,(int)offsetof(AttachmentSource_obj,type),HX_("type",ba,f2,08,4d)},
+	{::hx::fsString,(int)offsetof(AttachmentSource_obj,name),HX_("name",4b,72,ff,48)},
+	{::hx::fsInt,(int)offsetof(AttachmentSource_obj,size),HX_("size",c1,a0,53,4c)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *AttachmentSource_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String AttachmentSource_obj_sMemberFields[] = {
+	HX_("path",a5,e5,51,4a),
+	HX_("path__fromC",74,b9,54,80),
+	HX_("type",ba,f2,08,4d),
+	HX_("type__fromC",ff,a8,6c,93),
+	HX_("name",4b,72,ff,48),
+	HX_("name__fromC",8e,ad,66,0e),
+	HX_("size",c1,a0,53,4c),
+	HX_("size__fromC",d8,d9,54,4b),
+	HX_("tinkSource",6d,33,ae,02),
+	::String(null()) };
+
+::hx::Class AttachmentSource_obj::__mClass;
+
+void AttachmentSource_obj::__register()
+{
+	AttachmentSource_obj _hx_dummy;
+	AttachmentSource_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("snikket.AttachmentSource",4f,a4,78,4f);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(AttachmentSource_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< AttachmentSource_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = AttachmentSource_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = AttachmentSource_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+void AttachmentSource_obj::__boot()
+{
+{
+            	HX_STACKFRAME(&_hx_pos_1589e03dacb7e96d_12_boot)
+HXDLIN(  12)		__mClass->__meta__ =  ::Dynamic(::hx::Anon_obj::Create(1)
+            			->setFixed(0,HX_("fields",79,8e,8e,80), ::Dynamic(::hx::Anon_obj::Create(4)
+            				->setFixed(0,HX_("path__fromC",74,b9,54,80), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("HaxeCBridge.wrapper",8b,ea,27,d4),null())))
+            				->setFixed(1,HX_("type__fromC",ff,a8,6c,93), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("HaxeCBridge.wrapper",8b,ea,27,d4),null())))
+            				->setFixed(2,HX_("name__fromC",8e,ad,66,0e), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("HaxeCBridge.wrapper",8b,ea,27,d4),null())))
+            				->setFixed(3,HX_("size__fromC",d8,d9,54,4b), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("HaxeCBridge.wrapper",8b,ea,27,d4),null()))))));
+            	}
+}
+
+} // end namespace snikket
diff --git a/Sources/c_snikket/src/snikket/Autolink.cpp b/Sources/c_snikket/src/snikket/Autolink.cpp
new file mode 100644
index 0000000..02b59de
--- /dev/null
+++ b/Sources/c_snikket/src/snikket/Autolink.cpp
@@ -0,0 +1,573 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_EReg
+#include <EReg.h>
+#endif
+#ifndef INCLUDED_Lambda
+#include <Lambda.h>
+#endif
+#ifndef INCLUDED_snikket_Autolink
+#include <snikket/Autolink.h>
+#endif
+#ifndef INCLUDED_snikket_Node
+#include <snikket/Node.h>
+#endif
+#ifndef INCLUDED_snikket_Stanza
+#include <snikket/Stanza.h>
+#endif
+#ifndef INCLUDED_snikket__Stanza_NodeInterface
+#include <snikket/_Stanza/NodeInterface.h>
+#endif
+
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_341_one,"snikket.Autolink","one",0x4e62ad12,"snikket.Autolink.one","snikket/Autolink.hx",341,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_342_one,"snikket.Autolink","one",0x4e62ad12,"snikket.Autolink.one","snikket/Autolink.hx",342,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_334_one,"snikket.Autolink","one",0x4e62ad12,"snikket.Autolink.one","snikket/Autolink.hx",334,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_345_match,"snikket.Autolink","match",0x7edc5ef1,"snikket.Autolink.match","snikket/Autolink.hx",345,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_28_boot,"snikket.Autolink","boot",0x3f5dc806,"snikket.Autolink.boot","snikket/Autolink.hx",28,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_40_boot,"snikket.Autolink","boot",0x3f5dc806,"snikket.Autolink.boot","snikket/Autolink.hx",40,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_162_boot,"snikket.Autolink","boot",0x3f5dc806,"snikket.Autolink.boot","snikket/Autolink.hx",162,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_164_boot,"snikket.Autolink","boot",0x3f5dc806,"snikket.Autolink.boot","snikket/Autolink.hx",164,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_181_boot,"snikket.Autolink","boot",0x3f5dc806,"snikket.Autolink.boot","snikket/Autolink.hx",181,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_202_boot,"snikket.Autolink","boot",0x3f5dc806,"snikket.Autolink.boot","snikket/Autolink.hx",202,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_224_boot,"snikket.Autolink","boot",0x3f5dc806,"snikket.Autolink.boot","snikket/Autolink.hx",224,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_233_boot,"snikket.Autolink","boot",0x3f5dc806,"snikket.Autolink.boot","snikket/Autolink.hx",233,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_237_boot,"snikket.Autolink","boot",0x3f5dc806,"snikket.Autolink.boot","snikket/Autolink.hx",237,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_242_boot,"snikket.Autolink","boot",0x3f5dc806,"snikket.Autolink.boot","snikket/Autolink.hx",242,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_244_boot,"snikket.Autolink","boot",0x3f5dc806,"snikket.Autolink.boot","snikket/Autolink.hx",244,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_245_boot,"snikket.Autolink","boot",0x3f5dc806,"snikket.Autolink.boot","snikket/Autolink.hx",245,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_248_boot,"snikket.Autolink","boot",0x3f5dc806,"snikket.Autolink.boot","snikket/Autolink.hx",248,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_249_boot,"snikket.Autolink","boot",0x3f5dc806,"snikket.Autolink.boot","snikket/Autolink.hx",249,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_252_boot,"snikket.Autolink","boot",0x3f5dc806,"snikket.Autolink.boot","snikket/Autolink.hx",252,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_269_boot,"snikket.Autolink","boot",0x3f5dc806,"snikket.Autolink.boot","snikket/Autolink.hx",269,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_274_boot,"snikket.Autolink","boot",0x3f5dc806,"snikket.Autolink.boot","snikket/Autolink.hx",274,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_281_boot,"snikket.Autolink","boot",0x3f5dc806,"snikket.Autolink.boot","snikket/Autolink.hx",281,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_286_boot,"snikket.Autolink","boot",0x3f5dc806,"snikket.Autolink.boot","snikket/Autolink.hx",286,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_291_boot,"snikket.Autolink","boot",0x3f5dc806,"snikket.Autolink.boot","snikket/Autolink.hx",291,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_304_boot,"snikket.Autolink","boot",0x3f5dc806,"snikket.Autolink.boot","snikket/Autolink.hx",304,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_321_boot,"snikket.Autolink","boot",0x3f5dc806,"snikket.Autolink.boot","snikket/Autolink.hx",321,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_324_boot,"snikket.Autolink","boot",0x3f5dc806,"snikket.Autolink.boot","snikket/Autolink.hx",324,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_327_boot,"snikket.Autolink","boot",0x3f5dc806,"snikket.Autolink.boot","snikket/Autolink.hx",327,0x041baf83)
+HX_LOCAL_STACK_FRAME(_hx_pos_e03e81a8315e14a8_329_boot,"snikket.Autolink","boot",0x3f5dc806,"snikket.Autolink.boot","snikket/Autolink.hx",329,0x041baf83)
+namespace snikket{
+
+void Autolink_obj::__construct() { }
+
+Dynamic Autolink_obj::__CreateEmpty() { return new Autolink_obj; }
+
+void *Autolink_obj::_hx_vtable = 0;
+
+Dynamic Autolink_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Autolink_obj > _hx_result = new Autolink_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool Autolink_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x257fedc6;
+}
+
+::String Autolink_obj::IANA_TOP_LEVEL_DOMAINS;
+
+::String Autolink_obj::GOOD_IRI_CHAR;
+
+::String Autolink_obj::IP_ADDRESS;
+
+::String Autolink_obj::IP6_ADDRESS;
+
+::String Autolink_obj::UCS_CHAR;
+
+::String Autolink_obj::LABEL_CHAR;
+
+::String Autolink_obj::IRI_LABEL;
+
+::String Autolink_obj::PUNYCODE_TLD;
+
+::String Autolink_obj::PROTOCOL;
+
+::String Autolink_obj::WORD_BOUNDARY;
+
+::String Autolink_obj::USER_INFO;
+
+::String Autolink_obj::PORT_NUMBER;
+
+::String Autolink_obj::PATH_CHAR;
+
+::String Autolink_obj::PATH_AND_QUERY;
+
+::String Autolink_obj::STRICT_TLD;
+
+::String Autolink_obj::STRICT_HOST_NAME;
+
+::String Autolink_obj::STRICT_DOMAIN_NAME;
+
+::String Autolink_obj::RELAXED_DOMAIN_NAME;
+
+::String Autolink_obj::WEB_URL_WITHOUT_PROTOCOL;
+
+::String Autolink_obj::WEB_URL_WITH_PROTOCOL;
+
+::String Autolink_obj::AUTOLINK_WEB_URL;
+
+::String Autolink_obj::TEL_URI;
+
+::String Autolink_obj::SMS_URI;
+
+::String Autolink_obj::XMPP_URI;
+
+ ::Dynamic Autolink_obj::one(::String s,int start){
+            		HX_BEGIN_LOCAL_FUNC_S0(::hx::LocalFunc,_hx_Closure_0) HXARGC(2)
+            		int _hx_run( ::Dynamic x, ::Dynamic y){
+            			HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_341_one)
+HXLINE( 341)			return (( (int)(x->__Field(HX_("start",62,74,0b,84),::hx::paccDynamic)) ) - ( (int)(y->__Field(HX_("start",62,74,0b,84),::hx::paccDynamic)) ));
+            		}
+            		HX_END_LOCAL_FUNC2(return)
+
+            		HX_BEGIN_LOCAL_FUNC_S0(::hx::LocalFunc,_hx_Closure_1) HXARGC(1)
+            		bool _hx_run( ::Dynamic match){
+            			HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_342_one)
+HXLINE( 342)			return ::hx::IsNotNull( match->__Field(HX_("span",ca,da,58,4c),::hx::paccDynamic) );
+            		}
+            		HX_END_LOCAL_FUNC1(return)
+
+            	HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_334_one)
+HXLINE( 336)		 ::Dynamic matches = ::snikket::Autolink_obj::match(s,start,::snikket::Autolink_obj::XMPP_URI,false);
+HXLINE( 337)		 ::Dynamic matches1 = ::snikket::Autolink_obj::match(s,start,::snikket::Autolink_obj::TEL_URI,false);
+HXLINE( 338)		 ::Dynamic matches2 = ::snikket::Autolink_obj::match(s,start,::snikket::Autolink_obj::SMS_URI,false);
+HXLINE( 335)		::Array< ::Dynamic> matches3 = ::Array_obj< ::Dynamic>::__new(4)->init(0,matches)->init(1,matches1)->init(2,matches2)->init(3,::snikket::Autolink_obj::match(s,start,::snikket::Autolink_obj::AUTOLINK_WEB_URL,true));
+HXLINE( 341)		matches3->sort( ::Dynamic(new _hx_Closure_0()));
+HXLINE( 342)		 ::Dynamic tmp = ::Lambda_obj::find(matches3, ::Dynamic(new _hx_Closure_1()));
+HXDLIN( 342)		if (::hx::IsNotNull( tmp )) {
+HXLINE( 342)			return tmp;
+            		}
+            		else {
+HXLINE( 342)			return matches3->__get(0);
+            		}
+HXDLIN( 342)		return null();
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(Autolink_obj,one,return )
+
+ ::Dynamic Autolink_obj::match(::String s,int start,::String pattern,bool addHttps){
+            	HX_GC_STACKFRAME(&_hx_pos_e03e81a8315e14a8_345_match)
+HXLINE( 347)		 ::EReg pattern1 =  ::EReg_obj::__alloc( HX_CTX ,pattern,HX_("u",75,00,00,00));
+HXLINE( 348)		if (pattern1->matchSub(s,start,null())) {
+HXLINE( 349)			 ::Dynamic pos = pattern1->matchedPos();
+HXLINE( 350)			::String link = pattern1->matched(0);
+HXLINE( 351)			::String uri;
+HXDLIN( 351)			bool uri1;
+HXDLIN( 351)			if (addHttps) {
+HXLINE( 351)				uri1 = (link.indexOf(HX_("://",da,2b,2c,00),null()) != -1);
+            			}
+            			else {
+HXLINE( 351)				uri1 = true;
+            			}
+HXDLIN( 351)			if (uri1) {
+HXLINE( 351)				uri = link;
+            			}
+            			else {
+HXLINE( 351)				uri = (HX_("https://",cf,b4,ae,3e) + link);
+            			}
+HXLINE( 353)			 ::snikket::Node _hx_tmp = ::snikket::Node_obj::Element( ::snikket::Stanza_obj::__alloc( HX_CTX ,HX_("a",61,00,00,00), ::Dynamic(::hx::Anon_obj::Create(1)
+            				->setFixed(0,HX_("href",eb,09,15,45),uri)))->text(link));
+HXDLIN( 353)			return  ::Dynamic(::hx::Anon_obj::Create(3)
+            				->setFixed(0,HX_("start",62,74,0b,84), ::Dynamic(pos->__Field(HX_("pos",94,5d,55,00),::hx::paccDynamic)))
+            				->setFixed(1,HX_("end",db,03,4d,00), ::Dynamic((pos->__Field(HX_("pos",94,5d,55,00),::hx::paccDynamic) + pos->__Field(HX_("len",d5,4b,52,00),::hx::paccDynamic))))
+            				->setFixed(2,HX_("span",ca,da,58,4c),_hx_tmp));
+            		}
+            		else {
+HXLINE( 355)			return  ::Dynamic(::hx::Anon_obj::Create(3)
+            				->setFixed(0,HX_("start",62,74,0b,84),s.length)
+            				->setFixed(1,HX_("end",db,03,4d,00),s.length)
+            				->setFixed(2,HX_("span",ca,da,58,4c),null()));
+            		}
+HXLINE( 348)		return null();
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC4(Autolink_obj,match,return )
+
+
+Autolink_obj::Autolink_obj()
+{
+}
+
+bool Autolink_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"one") ) { outValue = one_dyn(); return true; }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"match") ) { outValue = match_dyn(); return true; }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"TEL_URI") ) { outValue = ( TEL_URI ); return true; }
+		if (HX_FIELD_EQ(inName,"SMS_URI") ) { outValue = ( SMS_URI ); return true; }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"UCS_CHAR") ) { outValue = ( UCS_CHAR ); return true; }
+		if (HX_FIELD_EQ(inName,"PROTOCOL") ) { outValue = ( PROTOCOL ); return true; }
+		if (HX_FIELD_EQ(inName,"XMPP_URI") ) { outValue = ( XMPP_URI ); return true; }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"IRI_LABEL") ) { outValue = ( IRI_LABEL ); return true; }
+		if (HX_FIELD_EQ(inName,"USER_INFO") ) { outValue = ( USER_INFO ); return true; }
+		if (HX_FIELD_EQ(inName,"PATH_CHAR") ) { outValue = ( PATH_CHAR ); return true; }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"IP_ADDRESS") ) { outValue = ( IP_ADDRESS ); return true; }
+		if (HX_FIELD_EQ(inName,"LABEL_CHAR") ) { outValue = ( LABEL_CHAR ); return true; }
+		if (HX_FIELD_EQ(inName,"STRICT_TLD") ) { outValue = ( STRICT_TLD ); return true; }
+		break;
+	case 11:
+		if (HX_FIELD_EQ(inName,"IP6_ADDRESS") ) { outValue = ( IP6_ADDRESS ); return true; }
+		if (HX_FIELD_EQ(inName,"PORT_NUMBER") ) { outValue = ( PORT_NUMBER ); return true; }
+		break;
+	case 12:
+		if (HX_FIELD_EQ(inName,"PUNYCODE_TLD") ) { outValue = ( PUNYCODE_TLD ); return true; }
+		break;
+	case 13:
+		if (HX_FIELD_EQ(inName,"GOOD_IRI_CHAR") ) { outValue = ( GOOD_IRI_CHAR ); return true; }
+		if (HX_FIELD_EQ(inName,"WORD_BOUNDARY") ) { outValue = ( WORD_BOUNDARY ); return true; }
+		break;
+	case 14:
+		if (HX_FIELD_EQ(inName,"PATH_AND_QUERY") ) { outValue = ( PATH_AND_QUERY ); return true; }
+		break;
+	case 16:
+		if (HX_FIELD_EQ(inName,"STRICT_HOST_NAME") ) { outValue = ( STRICT_HOST_NAME ); return true; }
+		if (HX_FIELD_EQ(inName,"AUTOLINK_WEB_URL") ) { outValue = ( AUTOLINK_WEB_URL ); return true; }
+		break;
+	case 18:
+		if (HX_FIELD_EQ(inName,"STRICT_DOMAIN_NAME") ) { outValue = ( STRICT_DOMAIN_NAME ); return true; }
+		break;
+	case 19:
+		if (HX_FIELD_EQ(inName,"RELAXED_DOMAIN_NAME") ) { outValue = ( RELAXED_DOMAIN_NAME ); return true; }
+		break;
+	case 21:
+		if (HX_FIELD_EQ(inName,"WEB_URL_WITH_PROTOCOL") ) { outValue = ( WEB_URL_WITH_PROTOCOL ); return true; }
+		break;
+	case 22:
+		if (HX_FIELD_EQ(inName,"IANA_TOP_LEVEL_DOMAINS") ) { outValue = ( IANA_TOP_LEVEL_DOMAINS ); return true; }
+		break;
+	case 24:
+		if (HX_FIELD_EQ(inName,"WEB_URL_WITHOUT_PROTOCOL") ) { outValue = ( WEB_URL_WITHOUT_PROTOCOL ); return true; }
+	}
+	return false;
+}
+
+bool Autolink_obj::__SetStatic(const ::String &inName,Dynamic &ioValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 7:
+		if (HX_FIELD_EQ(inName,"TEL_URI") ) { TEL_URI=ioValue.Cast< ::String >(); return true; }
+		if (HX_FIELD_EQ(inName,"SMS_URI") ) { SMS_URI=ioValue.Cast< ::String >(); return true; }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"UCS_CHAR") ) { UCS_CHAR=ioValue.Cast< ::String >(); return true; }
+		if (HX_FIELD_EQ(inName,"PROTOCOL") ) { PROTOCOL=ioValue.Cast< ::String >(); return true; }
+		if (HX_FIELD_EQ(inName,"XMPP_URI") ) { XMPP_URI=ioValue.Cast< ::String >(); return true; }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"IRI_LABEL") ) { IRI_LABEL=ioValue.Cast< ::String >(); return true; }
+		if (HX_FIELD_EQ(inName,"USER_INFO") ) { USER_INFO=ioValue.Cast< ::String >(); return true; }
+		if (HX_FIELD_EQ(inName,"PATH_CHAR") ) { PATH_CHAR=ioValue.Cast< ::String >(); return true; }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"IP_ADDRESS") ) { IP_ADDRESS=ioValue.Cast< ::String >(); return true; }
+		if (HX_FIELD_EQ(inName,"LABEL_CHAR") ) { LABEL_CHAR=ioValue.Cast< ::String >(); return true; }
+		if (HX_FIELD_EQ(inName,"STRICT_TLD") ) { STRICT_TLD=ioValue.Cast< ::String >(); return true; }
+		break;
+	case 11:
+		if (HX_FIELD_EQ(inName,"IP6_ADDRESS") ) { IP6_ADDRESS=ioValue.Cast< ::String >(); return true; }
+		if (HX_FIELD_EQ(inName,"PORT_NUMBER") ) { PORT_NUMBER=ioValue.Cast< ::String >(); return true; }
+		break;
+	case 12:
+		if (HX_FIELD_EQ(inName,"PUNYCODE_TLD") ) { PUNYCODE_TLD=ioValue.Cast< ::String >(); return true; }
+		break;
+	case 13:
+		if (HX_FIELD_EQ(inName,"GOOD_IRI_CHAR") ) { GOOD_IRI_CHAR=ioValue.Cast< ::String >(); return true; }
+		if (HX_FIELD_EQ(inName,"WORD_BOUNDARY") ) { WORD_BOUNDARY=ioValue.Cast< ::String >(); return true; }
+		break;
+	case 14:
+		if (HX_FIELD_EQ(inName,"PATH_AND_QUERY") ) { PATH_AND_QUERY=ioValue.Cast< ::String >(); return true; }
+		break;
+	case 16:
+		if (HX_FIELD_EQ(inName,"STRICT_HOST_NAME") ) { STRICT_HOST_NAME=ioValue.Cast< ::String >(); return true; }
+		if (HX_FIELD_EQ(inName,"AUTOLINK_WEB_URL") ) { AUTOLINK_WEB_URL=ioValue.Cast< ::String >(); return true; }
+		break;
+	case 18:
+		if (HX_FIELD_EQ(inName,"STRICT_DOMAIN_NAME") ) { STRICT_DOMAIN_NAME=ioValue.Cast< ::String >(); return true; }
+		break;
+	case 19:
+		if (HX_FIELD_EQ(inName,"RELAXED_DOMAIN_NAME") ) { RELAXED_DOMAIN_NAME=ioValue.Cast< ::String >(); return true; }
+		break;
+	case 21:
+		if (HX_FIELD_EQ(inName,"WEB_URL_WITH_PROTOCOL") ) { WEB_URL_WITH_PROTOCOL=ioValue.Cast< ::String >(); return true; }
+		break;
+	case 22:
+		if (HX_FIELD_EQ(inName,"IANA_TOP_LEVEL_DOMAINS") ) { IANA_TOP_LEVEL_DOMAINS=ioValue.Cast< ::String >(); return true; }
+		break;
+	case 24:
+		if (HX_FIELD_EQ(inName,"WEB_URL_WITHOUT_PROTOCOL") ) { WEB_URL_WITHOUT_PROTOCOL=ioValue.Cast< ::String >(); return true; }
+	}
+	return false;
+}
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo *Autolink_obj_sMemberStorageInfo = 0;
+static ::hx::StaticInfo Autolink_obj_sStaticStorageInfo[] = {
+	{::hx::fsString,(void *) &Autolink_obj::IANA_TOP_LEVEL_DOMAINS,HX_("IANA_TOP_LEVEL_DOMAINS",76,8c,95,2a)},
+	{::hx::fsString,(void *) &Autolink_obj::GOOD_IRI_CHAR,HX_("GOOD_IRI_CHAR",f7,b8,57,73)},
+	{::hx::fsString,(void *) &Autolink_obj::IP_ADDRESS,HX_("IP_ADDRESS",fc,9d,44,17)},
+	{::hx::fsString,(void *) &Autolink_obj::IP6_ADDRESS,HX_("IP6_ADDRESS",84,d0,35,ac)},
+	{::hx::fsString,(void *) &Autolink_obj::UCS_CHAR,HX_("UCS_CHAR",50,2e,0e,ef)},
+	{::hx::fsString,(void *) &Autolink_obj::LABEL_CHAR,HX_("LABEL_CHAR",61,5c,62,dc)},
+	{::hx::fsString,(void *) &Autolink_obj::IRI_LABEL,HX_("IRI_LABEL",55,e9,22,3e)},
+	{::hx::fsString,(void *) &Autolink_obj::PUNYCODE_TLD,HX_("PUNYCODE_TLD",0a,3e,93,39)},
+	{::hx::fsString,(void *) &Autolink_obj::PROTOCOL,HX_("PROTOCOL",58,e6,e8,59)},
+	{::hx::fsString,(void *) &Autolink_obj::WORD_BOUNDARY,HX_("WORD_BOUNDARY",3f,bd,f5,47)},
+	{::hx::fsString,(void *) &Autolink_obj::USER_INFO,HX_("USER_INFO",22,92,9c,77)},
+	{::hx::fsString,(void *) &Autolink_obj::PORT_NUMBER,HX_("PORT_NUMBER",07,db,d1,b4)},
+	{::hx::fsString,(void *) &Autolink_obj::PATH_CHAR,HX_("PATH_CHAR",f0,fe,8d,bf)},
+	{::hx::fsString,(void *) &Autolink_obj::PATH_AND_QUERY,HX_("PATH_AND_QUERY",c6,8d,28,99)},
+	{::hx::fsString,(void *) &Autolink_obj::STRICT_TLD,HX_("STRICT_TLD",96,e8,bf,23)},
+	{::hx::fsString,(void *) &Autolink_obj::STRICT_HOST_NAME,HX_("STRICT_HOST_NAME",0c,82,05,83)},
+	{::hx::fsString,(void *) &Autolink_obj::STRICT_DOMAIN_NAME,HX_("STRICT_DOMAIN_NAME",30,25,e6,f0)},
+	{::hx::fsString,(void *) &Autolink_obj::RELAXED_DOMAIN_NAME,HX_("RELAXED_DOMAIN_NAME",b6,71,df,1f)},
+	{::hx::fsString,(void *) &Autolink_obj::WEB_URL_WITHOUT_PROTOCOL,HX_("WEB_URL_WITHOUT_PROTOCOL",aa,4d,e7,46)},
+	{::hx::fsString,(void *) &Autolink_obj::WEB_URL_WITH_PROTOCOL,HX_("WEB_URL_WITH_PROTOCOL",f6,04,a9,cf)},
+	{::hx::fsString,(void *) &Autolink_obj::AUTOLINK_WEB_URL,HX_("AUTOLINK_WEB_URL",2e,ec,59,4b)},
+	{::hx::fsString,(void *) &Autolink_obj::TEL_URI,HX_("TEL_URI",88,ff,2a,3d)},
+	{::hx::fsString,(void *) &Autolink_obj::SMS_URI,HX_("SMS_URI",46,7b,3e,4e)},
+	{::hx::fsString,(void *) &Autolink_obj::XMPP_URI,HX_("XMPP_URI",02,45,f3,76)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+#endif
+
+static void Autolink_obj_sMarkStatics(HX_MARK_PARAMS) {
+	HX_MARK_MEMBER_NAME(Autolink_obj::IANA_TOP_LEVEL_DOMAINS,"IANA_TOP_LEVEL_DOMAINS");
+	HX_MARK_MEMBER_NAME(Autolink_obj::GOOD_IRI_CHAR,"GOOD_IRI_CHAR");
+	HX_MARK_MEMBER_NAME(Autolink_obj::IP_ADDRESS,"IP_ADDRESS");
+	HX_MARK_MEMBER_NAME(Autolink_obj::IP6_ADDRESS,"IP6_ADDRESS");
+	HX_MARK_MEMBER_NAME(Autolink_obj::UCS_CHAR,"UCS_CHAR");
+	HX_MARK_MEMBER_NAME(Autolink_obj::LABEL_CHAR,"LABEL_CHAR");
+	HX_MARK_MEMBER_NAME(Autolink_obj::IRI_LABEL,"IRI_LABEL");
+	HX_MARK_MEMBER_NAME(Autolink_obj::PUNYCODE_TLD,"PUNYCODE_TLD");
+	HX_MARK_MEMBER_NAME(Autolink_obj::PROTOCOL,"PROTOCOL");
+	HX_MARK_MEMBER_NAME(Autolink_obj::WORD_BOUNDARY,"WORD_BOUNDARY");
+	HX_MARK_MEMBER_NAME(Autolink_obj::USER_INFO,"USER_INFO");
+	HX_MARK_MEMBER_NAME(Autolink_obj::PORT_NUMBER,"PORT_NUMBER");
+	HX_MARK_MEMBER_NAME(Autolink_obj::PATH_CHAR,"PATH_CHAR");
+	HX_MARK_MEMBER_NAME(Autolink_obj::PATH_AND_QUERY,"PATH_AND_QUERY");
+	HX_MARK_MEMBER_NAME(Autolink_obj::STRICT_TLD,"STRICT_TLD");
+	HX_MARK_MEMBER_NAME(Autolink_obj::STRICT_HOST_NAME,"STRICT_HOST_NAME");
+	HX_MARK_MEMBER_NAME(Autolink_obj::STRICT_DOMAIN_NAME,"STRICT_DOMAIN_NAME");
+	HX_MARK_MEMBER_NAME(Autolink_obj::RELAXED_DOMAIN_NAME,"RELAXED_DOMAIN_NAME");
+	HX_MARK_MEMBER_NAME(Autolink_obj::WEB_URL_WITHOUT_PROTOCOL,"WEB_URL_WITHOUT_PROTOCOL");
+	HX_MARK_MEMBER_NAME(Autolink_obj::WEB_URL_WITH_PROTOCOL,"WEB_URL_WITH_PROTOCOL");
+	HX_MARK_MEMBER_NAME(Autolink_obj::AUTOLINK_WEB_URL,"AUTOLINK_WEB_URL");
+	HX_MARK_MEMBER_NAME(Autolink_obj::TEL_URI,"TEL_URI");
+	HX_MARK_MEMBER_NAME(Autolink_obj::SMS_URI,"SMS_URI");
+	HX_MARK_MEMBER_NAME(Autolink_obj::XMPP_URI,"XMPP_URI");
+};
+
+#ifdef HXCPP_VISIT_ALLOCS
+static void Autolink_obj_sVisitStatics(HX_VISIT_PARAMS) {
+	HX_VISIT_MEMBER_NAME(Autolink_obj::IANA_TOP_LEVEL_DOMAINS,"IANA_TOP_LEVEL_DOMAINS");
+	HX_VISIT_MEMBER_NAME(Autolink_obj::GOOD_IRI_CHAR,"GOOD_IRI_CHAR");
+	HX_VISIT_MEMBER_NAME(Autolink_obj::IP_ADDRESS,"IP_ADDRESS");
+	HX_VISIT_MEMBER_NAME(Autolink_obj::IP6_ADDRESS,"IP6_ADDRESS");
+	HX_VISIT_MEMBER_NAME(Autolink_obj::UCS_CHAR,"UCS_CHAR");
+	HX_VISIT_MEMBER_NAME(Autolink_obj::LABEL_CHAR,"LABEL_CHAR");
+	HX_VISIT_MEMBER_NAME(Autolink_obj::IRI_LABEL,"IRI_LABEL");
+	HX_VISIT_MEMBER_NAME(Autolink_obj::PUNYCODE_TLD,"PUNYCODE_TLD");
+	HX_VISIT_MEMBER_NAME(Autolink_obj::PROTOCOL,"PROTOCOL");
+	HX_VISIT_MEMBER_NAME(Autolink_obj::WORD_BOUNDARY,"WORD_BOUNDARY");
+	HX_VISIT_MEMBER_NAME(Autolink_obj::USER_INFO,"USER_INFO");
+	HX_VISIT_MEMBER_NAME(Autolink_obj::PORT_NUMBER,"PORT_NUMBER");
+	HX_VISIT_MEMBER_NAME(Autolink_obj::PATH_CHAR,"PATH_CHAR");
+	HX_VISIT_MEMBER_NAME(Autolink_obj::PATH_AND_QUERY,"PATH_AND_QUERY");
+	HX_VISIT_MEMBER_NAME(Autolink_obj::STRICT_TLD,"STRICT_TLD");
+	HX_VISIT_MEMBER_NAME(Autolink_obj::STRICT_HOST_NAME,"STRICT_HOST_NAME");
+	HX_VISIT_MEMBER_NAME(Autolink_obj::STRICT_DOMAIN_NAME,"STRICT_DOMAIN_NAME");
+	HX_VISIT_MEMBER_NAME(Autolink_obj::RELAXED_DOMAIN_NAME,"RELAXED_DOMAIN_NAME");
+	HX_VISIT_MEMBER_NAME(Autolink_obj::WEB_URL_WITHOUT_PROTOCOL,"WEB_URL_WITHOUT_PROTOCOL");
+	HX_VISIT_MEMBER_NAME(Autolink_obj::WEB_URL_WITH_PROTOCOL,"WEB_URL_WITH_PROTOCOL");
+	HX_VISIT_MEMBER_NAME(Autolink_obj::AUTOLINK_WEB_URL,"AUTOLINK_WEB_URL");
+	HX_VISIT_MEMBER_NAME(Autolink_obj::TEL_URI,"TEL_URI");
+	HX_VISIT_MEMBER_NAME(Autolink_obj::SMS_URI,"SMS_URI");
+	HX_VISIT_MEMBER_NAME(Autolink_obj::XMPP_URI,"XMPP_URI");
+};
+
+#endif
+
+::hx::Class Autolink_obj::__mClass;
+
+static ::String Autolink_obj_sStaticFields[] = {
+	HX_("IANA_TOP_LEVEL_DOMAINS",76,8c,95,2a),
+	HX_("GOOD_IRI_CHAR",f7,b8,57,73),
+	HX_("IP_ADDRESS",fc,9d,44,17),
+	HX_("IP6_ADDRESS",84,d0,35,ac),
+	HX_("UCS_CHAR",50,2e,0e,ef),
+	HX_("LABEL_CHAR",61,5c,62,dc),
+	HX_("IRI_LABEL",55,e9,22,3e),
+	HX_("PUNYCODE_TLD",0a,3e,93,39),
+	HX_("PROTOCOL",58,e6,e8,59),
+	HX_("WORD_BOUNDARY",3f,bd,f5,47),
+	HX_("USER_INFO",22,92,9c,77),
+	HX_("PORT_NUMBER",07,db,d1,b4),
+	HX_("PATH_CHAR",f0,fe,8d,bf),
+	HX_("PATH_AND_QUERY",c6,8d,28,99),
+	HX_("STRICT_TLD",96,e8,bf,23),
+	HX_("STRICT_HOST_NAME",0c,82,05,83),
+	HX_("STRICT_DOMAIN_NAME",30,25,e6,f0),
+	HX_("RELAXED_DOMAIN_NAME",b6,71,df,1f),
+	HX_("WEB_URL_WITHOUT_PROTOCOL",aa,4d,e7,46),
+	HX_("WEB_URL_WITH_PROTOCOL",f6,04,a9,cf),
+	HX_("AUTOLINK_WEB_URL",2e,ec,59,4b),
+	HX_("TEL_URI",88,ff,2a,3d),
+	HX_("SMS_URI",46,7b,3e,4e),
+	HX_("XMPP_URI",02,45,f3,76),
+	HX_("one",66,9a,54,00),
+	HX_("match",45,49,23,03),
+	::String(null())
+};
+
+void Autolink_obj::__register()
+{
+	Autolink_obj _hx_dummy;
+	Autolink_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("snikket.Autolink",1a,ad,e0,f4);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &Autolink_obj::__GetStatic;
+	__mClass->mSetStaticField = &Autolink_obj::__SetStatic;
+	__mClass->mMarkFunc = Autolink_obj_sMarkStatics;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(Autolink_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
+	__mClass->mCanCast = ::hx::TCanCast< Autolink_obj >;
+#ifdef HXCPP_VISIT_ALLOCS
+	__mClass->mVisitFunc = Autolink_obj_sVisitStatics;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Autolink_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Autolink_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+void Autolink_obj::__boot()
+{
+{
+            	HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_28_boot)
+HXDLIN(  28)		__mClass->__meta__ =  ::Dynamic(::hx::Anon_obj::Create(1)
+            			->setFixed(0,HX_("statics",05,3c,65,36), ::Dynamic(::hx::Anon_obj::Create(1)
+            				->setFixed(0,HX_("GOOD_IRI_CHAR",f7,b8,57,73), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("Deprecated",93,03,d4,7a),null()))))));
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_40_boot)
+HXDLIN(  40)		IANA_TOP_LEVEL_DOMAINS = ((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((HX_("(?:",43,91,1e,00) + HX_("(?:aaa|aarp|abb|abbott|abogado|academy|accenture|accountant|accountants|aco|active",90,12,72,e0)) + HX_("|actor|ads|adult|aeg|aero|afl|agency|aig|airforce|airtel|allfinanz|alsace|amica|amsterdam",4b,e1,62,2e)) + HX_("|android|apartments|app|apple|aquarelle|aramco|archi|army|arpa|arte|asia|associates",8f,9a,6b,09)) + HX_("|attorney|auction|audio|auto|autos|axa|azure|a[cdefgilmoqrstuwxz])",ff,35,8a,a6)) + HX_("|(?:band|bank|bar|barcelona|barclaycard|barclays|bargains|bauhaus|bayern|bbc|bbva",fa,5a,d9,ba)) + HX_("|bcn|beats|beer|bentley|berlin|best|bet|bharti|bible|bid|bike|bing|bingo|bio|biz|black",cd,34,df,8a)) + HX_("|blackfriday|bloomberg|blue|bms|bmw|bnl|bnpparibas|boats|bom|bond|boo|boots|boutique",a0,59,71,55)) + HX_("|bradesco|bridgestone|broadway|broker|brother|brussels|budapest|build|builders|business",d2,de,1e,e1)) + HX_("|buzz|bzh|b[abdefghijmnorstvwyz])",87,31,5b,fc)) + HX_("|(?:cab|cafe|cal|camera|camp|cancerresearch|canon|capetown|capital|car|caravan|cards",26,5e,8c,48)) + HX_("|care|career|careers|cars|cartier|casa|cash|casino|cat|catering|cba|cbn|ceb|center|ceo",7f,64,bf,5f)) + HX_("|cern|cfa|cfd|chanel|channel|chat|cheap|chloe|christmas|chrome|church|cipriani|cisco",f4,85,3e,a7)) + HX_("|citic|city|cityeats|claims|cleaning|click|clinic|clothing|cloud|club|clubmed|coach",fc,f4,94,ae)) + HX_("|codes|coffee|college|cologne|com|commbank|community|company|computer|comsec|condos",4c,80,70,64)) + HX_("|construction|consulting|contractors|cooking|cool|coop|corsica|country|coupons|courses",ce,0a,99,55)) + HX_("|credit|creditcard|creditunion|cricket|crown|crs|cruises|csc|cuisinella|cymru|cyou|c[acdfghiklmnoruvwxyz])",40,d2,44,eb)) + HX_("|(?:dabur|dad|dance|date|dating|datsun|day|dclk|deals|degree|delivery|dell|delta",23,e0,18,1d)) + HX_("|democrat|dental|dentist|desi|design|dev|diamonds|diet|digital|direct|directory|discount",0c,44,48,a2)) + HX_("|dnp|docs|dog|doha|domains|doosan|download|drive|durban|dvag|d[ejkmoz])",47,96,49,b1)) + HX_("|(?:earth|eat|edu|education|email|emerck|energy|engineer|engineering|enterprises",48,37,7e,b3)) + HX_("|epson|equipment|erni|esq|estate|eurovision|eus|events|everbank|exchange|expert|exposed",ea,8d,a9,49)) + HX_("|express|e[cegrstu])",95,df,9a,c7)) + HX_("|(?:fage|fail|fairwinds|faith|family|fan|fans|farm|fashion|feedback|ferrero|film",b6,d0,f7,65)) + HX_("|final|finance|financial|firmdale|fish|fishing|fit|fitness|flights|florist|flowers|flsmidth",cb,ea,89,98)) + HX_("|fly|foo|football|forex|forsale|forum|foundation|frl|frogans|fund|furniture|futbol|fyi",31,b9,85,c5)) + HX_("|f[ijkmor])",03,5c,5e,87)) + HX_("|(?:gal|gallery|game|garden|gbiz|gdn|gea|gent|genting|ggee|gift|gifts|gives|giving",cb,a8,f7,39)) + HX_("|glass|gle|global|globo|gmail|gmo|gmx|gold|goldpoint|golf|goo|goog|google|gop|gov|grainger",2a,8a,a8,8e)) + HX_("|graphics|gratis|green|gripe|group|gucci|guge|guide|guitars|guru|g[abdefghilmnpqrstuwy])",1f,1b,e4,52)) + HX_("|(?:hamburg|hangout|haus|healthcare|help|here|hermes|hiphop|hitachi|hiv|hockey|holdings",2e,43,06,62)) + HX_("|holiday|homedepot|homes|honda|horse|host|hosting|hoteles|hotmail|house|how|hsbc|hyundai",9c,5b,64,3e)) + HX_("|h[kmnrtu])",c2,e7,7b,0e)) + HX_("|(?:ibm|icbc|ice|icu|ifm|iinet|immo|immobilien|industries|infiniti|info|ing|ink|institute",3d,b0,f2,8e)) + HX_("|insure|int|international|investments|ipiranga|irish|ist|istanbul|itau|iwc|i[delmnoqrst])",2e,f1,11,5d)) + HX_("|(?:jaguar|java|jcb|jetzt|jewelry|jlc|jll|jobs|joburg|jprs|juegos|j[emop])",bb,82,cb,ba)) + HX_("|(?:kaufen|kddi|kia|kim|kinder|kitchen|kiwi|koeln|komatsu|krd|kred|kyoto|k[eghimnprwyz])",46,a6,bf,15)) + HX_("|(?:lacaixa|lancaster|land|landrover|lasalle|lat|latrobe|law|lawyer|lds|lease|leclerc",fe,35,4b,75)) + HX_("|legal|lexus|lgbt|liaison|lidl|life|lifestyle|lighting|limited|limo|linde|link|live",29,e6,bf,f7)) + HX_("|lixil|loan|loans|lol|london|lotte|lotto|love|ltd|ltda|lupin|luxe|luxury|l[abcikrstuvy])",50,fd,87,80)) + HX_("|(?:madrid|maif|maison|man|management|mango|market|marketing|markets|marriott|mba",00,a2,ea,8e)) + HX_("|media|meet|melbourne|meme|memorial|men|menu|meo|miami|microsoft|mil|mini|mma|mobi|moda",07,7c,ba,11)) + HX_("|moe|moi|mom|monash|money|montblanc|mormon|mortgage|moscow|motorcycles|mov|movie|movistar",ac,41,4a,c3)) + HX_("|mtn|mtpc|mtr|museum|mutuelle|m[acdeghklmnopqrstuvwxyz])",b1,03,a3,ca)) + HX_("|(?:nadex|nagoya|name|navy|nec|net|netbank|network|neustar|new|news|nexus|ngo|nhk",fc,80,12,90)) + HX_("|nico|ninja|nissan|nokia|nra|nrw|ntt|nyc|n[acefgilopruz])",e5,7d,53,82)) + HX_("|(?:obi|office|okinawa|omega|one|ong|onl|online|ooo|oracle|orange|org|organic|osaka",5d,86,2b,53)) + HX_("|otsuka|ovh|om)",0d,48,d1,07)) + HX_("|(?:page|panerai|paris|partners|parts|party|pet|pharmacy|philips|photo|photography",be,5b,5c,40)) + HX_("|photos|physio|piaget|pics|pictet|pictures|ping|pink|pizza|place|play|playstation|plumbing",65,ea,54,41)) + HX_("|plus|pohl|poker|porn|post|praxi|press|pro|prod|productions|prof|properties|property",3d,f7,19,81)) + HX_("|protection|pub|p[aefghklmnrstwy])",6d,00,62,8f)) + HX_("|(?:qpon|quebec|qa)",d3,62,8c,00)) + HX_("|(?:racing|realtor|realty|recipes|red|redstone|rehab|reise|reisen|reit|ren|rent|rentals",e6,72,5b,c0)) + HX_("|repair|report|republican|rest|restaurant|review|reviews|rich|ricoh|rio|rip|rocher|rocks",4f,a5,81,71)) + HX_("|rodeo|rsvp|ruhr|run|rwe|ryukyu|r[eosuw])",0d,f8,7c,93)) + HX_("|(?:saarland|sakura|sale|samsung|sandvik|sandvikcoromant|sanofi|sap|sapo|sarl|saxo",b4,fd,07,1b)) + HX_("|sbs|sca|scb|schmidt|scholarships|school|schule|schwarz|science|scor|scot|seat|security",e7,bf,c7,9c)) + HX_("|seek|sener|services|seven|sew|sex|sexy|shiksha|shoes|show|shriram|singles|site|ski",b1,33,76,93)) + HX_("|sky|skype|sncf|soccer|social|software|sohu|solar|solutions|sony|soy|space|spiegel|spreadbetting",73,b6,26,86)) + HX_("|srl|stada|starhub|statoil|stc|stcgroup|stockholm|studio|study|style|sucks|supplies",e2,19,59,1c)) + HX_("|supply|support|surf|surgery|suzuki|swatch|swiss|sydney|systems|s[abcdeghijklmnortuvxyz])",27,0f,08,e0)) + HX_("|(?:tab|taipei|tatamotors|tatar|tattoo|tax|taxi|team|tech|technology|tel|telefonica",06,b2,cb,da)) + HX_("|temasek|tennis|thd|theater|theatre|tickets|tienda|tips|tires|tirol|today|tokyo|tools",46,a4,93,59)) + HX_("|top|toray|toshiba|tours|town|toyota|toys|trade|trading|training|travel|trust|tui|t[cdfghjklmnortvwz])",4a,a8,cf,d8)) + HX_("|(?:ubs|university|uno|uol|u[agksyz])",62,2b,28,35)) + HX_("|(?:vacations|vana|vegas|ventures|versicherung|vet|viajes|video|villas|vin|virgin",89,ce,ff,38)) + HX_("|vision|vista|vistaprint|viva|vlaanderen|vodka|vote|voting|voto|voyage|v[aceginu])",8f,f6,66,49)) + HX_("|(?:wales|walter|wang|watch|webcam|website|wed|wedding|weir|whoswho|wien|wiki|williamhill",55,25,7c,0c)) + HX_("|win|windows|wine|wme|work|works|world|wtc|wtf|w[fs])",8a,06,13,28)) + HX_W(u"|(?:\u03b5\u03bb|\u0431\u0435\u043b|\u0434\u0435\u0442\u0438|\u043a\u043e\u043c|\u043c\u043a\u0434",20c2,d82d)) + HX_W(u"|\u043c\u043e\u043d|\u043c\u043e\u0441\u043a\u0432\u0430|\u043e\u043d\u043b\u0430\u0439\u043d",af29,60d6)) + HX_W(u"|\u043e\u0440\u0433|\u0440\u0443\u0441|\u0440\u0444|\u0441\u0430\u0439\u0442|\u0441\u0440\u0431",8703,6750)) + HX_W(u"|\u0443\u043a\u0440|\u049b\u0430\u0437|\u0570\u0561\u0575|\u05e7\u05d5\u05dd|\u0627\u0631\u0627\u0645\u0643\u0648",d486,b572)) + HX_W(u"|\u0627\u0644\u0627\u0631\u062f\u0646|\u0627\u0644\u062c\u0632\u0627\u0626\u0631|\u0627\u0644\u0633\u0639\u0648\u062f\u064a\u0629",ea02,31c4)) + HX_W(u"|\u0627\u0644\u0645\u063a\u0631\u0628|\u0627\u0645\u0627\u0631\u0627\u062a|\u0627\u06cc\u0631\u0627\u0646",a05e,3858)) + HX_W(u"|\u0628\u0627\u0632\u0627\u0631|\u0628\u06be\u0627\u0631\u062a|\u062a\u0648\u0646\u0633",ae38,f5ba)) + HX_W(u"|\u0633\u0648\u062f\u0627\u0646|\u0633\u0648\u0631\u064a\u0629|\u0634\u0628\u0643\u0629",54db,e7f3)) + HX_W(u"|\u0639\u0631\u0627\u0642|\u0639\u0645\u0627\u0646|\u0641\u0644\u0633\u0637\u064a\u0646",bc90,2d48)) + HX_W(u"|\u0642\u0637\u0631|\u0643\u0648\u0645|\u0645\u0635\u0631|\u0645\u0644\u064a\u0633\u064a\u0627",b1a5,4ee2)) + HX_W(u"|\u0645\u0648\u0642\u0639|\u0915\u0949\u092e|\u0928\u0947\u091f|\u092d\u093e\u0930\u0924",8084,0878)) + HX_W(u"|\u0938\u0902\u0917\u0920\u0928|\u09ad\u09be\u09b0\u09a4|\u0a2d\u0a3e\u0a30\u0a24|\u0aad\u0abe\u0ab0\u0aa4",0d0c,87cd)) + HX_W(u"|\u0b87\u0ba8\u0bcd\u0ba4\u0bbf\u0baf\u0bbe|\u0b87\u0bb2\u0b99\u0bcd\u0b95\u0bc8|\u0b9a\u0bbf\u0b99\u0bcd\u0b95\u0baa\u0bcd\u0baa\u0bc2\u0bb0\u0bcd",9669,715f)) + HX_W(u"|\u0c2d\u0c3e\u0c30\u0c24\u0c4d|\u0dbd\u0d82\u0d9a\u0dcf|\u0e04\u0e2d\u0e21|\u0e44\u0e17\u0e22",c9f8,03d8)) + HX_W(u"|\u10d2\u10d4|\u307f\u3093\u306a|\u30b0\u30fc\u30b0\u30eb|\u30b3\u30e0|\u4e16\u754c",3e56,d9f4)) + HX_W(u"|\u4e2d\u4fe1|\u4e2d\u56fd|\u4e2d\u570b|\u4e2d\u6587\u7f51|\u4f01\u4e1a|\u4f5b\u5c71",98dd,a513)) + HX_W(u"|\u4fe1\u606f|\u5065\u5eb7|\u516b\u5366|\u516c\u53f8|\u516c\u76ca|\u53f0\u6e7e|\u53f0\u7063",726a,464b)) + HX_W(u"|\u5546\u57ce|\u5546\u5e97|\u5546\u6807|\u5728\u7ebf|\u5927\u62ff|\u5a31\u4e50|\u5de5\u884c",9c2f,d387)) + HX_W(u"|\u5e7f\u4e1c|\u6148\u5584|\u6211\u7231\u4f60|\u624b\u673a|\u653f\u52a1|\u653f\u5e9c",628c,454d)) + HX_W(u"|\u65b0\u52a0\u5761|\u65b0\u95fb|\u65f6\u5c1a|\u673a\u6784|\u6de1\u9a6c\u9521|\u6e38\u620f",7310,b961)) + HX_W(u"|\u70b9\u770b|\u79fb\u52a8|\u7ec4\u7ec7\u673a\u6784|\u7f51\u5740|\u7f51\u5e97|\u7f51\u7edc",a798,3a2c)) + HX_W(u"|\u8c37\u6b4c|\u96c6\u56e2|\u98de\u5229\u6d66|\u9910\u5385|\u9999\u6e2f|\ub2f7\ub137",68ee,8358)) + HX_W(u"|\ub2f7\ucef4|\uc0bc\uc131|\ud55c\uad6d|xbox",e96a,311e)) + HX_("|xerox|xin|xn\\-\\-11b4c3d|xn\\-\\-1qqw23a|xn\\-\\-30rr7y|xn\\-\\-3bst00m|xn\\-\\-3ds443g",57,7e,62,ed)) + HX_("|xn\\-\\-3e0b707e|xn\\-\\-3pxu8k|xn\\-\\-42c2d9a|xn\\-\\-45brj9c|xn\\-\\-45q11c|xn\\-\\-4gbrim",d0,1e,fc,bc)) + HX_("|xn\\-\\-55qw42g|xn\\-\\-55qx5d|xn\\-\\-6frz82g|xn\\-\\-6qq986b3xl|xn\\-\\-80adxhks",69,cd,8a,d8)) + HX_("|xn\\-\\-80ao21a|xn\\-\\-80asehdb|xn\\-\\-80aswg|xn\\-\\-90a3ac|xn\\-\\-90ais|xn\\-\\-9dbq2a",15,39,69,5f)) + HX_("|xn\\-\\-9et52u|xn\\-\\-b4w605ferd|xn\\-\\-c1avg|xn\\-\\-c2br7g|xn\\-\\-cg4bki|xn\\-\\-clchc0ea0b2g2a9gcd",48,af,c0,fd)) + HX_("|xn\\-\\-czr694b|xn\\-\\-czrs0t|xn\\-\\-czru2d|xn\\-\\-d1acj3b|xn\\-\\-d1alf|xn\\-\\-efvy88h",88,69,2a,f4)) + HX_("|xn\\-\\-estv75g|xn\\-\\-fhbei|xn\\-\\-fiq228c5hs|xn\\-\\-fiq64b|xn\\-\\-fiqs8s|xn\\-\\-fiqz9s",2a,cc,fa,7f)) + HX_("|xn\\-\\-fjq720a|xn\\-\\-flw351e|xn\\-\\-fpcrj9c3d|xn\\-\\-fzc2c9e2c|xn\\-\\-gecrj9c",6c,32,a5,ee)) + HX_("|xn\\-\\-h2brj9c|xn\\-\\-hxt814e|xn\\-\\-i1b6b1a6a2e|xn\\-\\-imr513n|xn\\-\\-io0a7i",2c,7e,dd,fd)) + HX_("|xn\\-\\-j1aef|xn\\-\\-j1amh|xn\\-\\-j6w193g|xn\\-\\-kcrx77d1x4a|xn\\-\\-kprw13d|xn\\-\\-kpry57d",c7,1f,00,ba)) + HX_("|xn\\-\\-kput3i|xn\\-\\-l1acc|xn\\-\\-lgbbat1ad8j|xn\\-\\-mgb9awbf|xn\\-\\-mgba3a3ejt",b2,56,7b,5e)) + HX_("|xn\\-\\-mgba3a4f16a|xn\\-\\-mgbaam7a8h|xn\\-\\-mgbab2bd|xn\\-\\-mgbayh7gpa|xn\\-\\-mgbbh1a71e",ff,4d,c9,1b)) + HX_("|xn\\-\\-mgbc0a9azcg|xn\\-\\-mgberp4a5d4ar|xn\\-\\-mgbpl2fh|xn\\-\\-mgbtx2b|xn\\-\\-mgbx4cd0ab",44,2b,3c,25)) + HX_("|xn\\-\\-mk1bu44c|xn\\-\\-mxtq1m|xn\\-\\-ngbc5azd|xn\\-\\-node|xn\\-\\-nqv7f|xn\\-\\-nqv7fs00ema",7b,d7,30,dc)) + HX_("|xn\\-\\-nyqy26a|xn\\-\\-o3cw4h|xn\\-\\-ogbpf8fl|xn\\-\\-p1acf|xn\\-\\-p1ai|xn\\-\\-pgbs0dh",7e,50,60,09)) + HX_("|xn\\-\\-pssy2u|xn\\-\\-q9jyb4c|xn\\-\\-qcka1pmc|xn\\-\\-qxam|xn\\-\\-rhqv96g|xn\\-\\-s9brj9c",81,31,e0,2c)) + HX_("|xn\\-\\-ses554g|xn\\-\\-t60b56a|xn\\-\\-tckwe|xn\\-\\-unup4y|xn\\-\\-vermgensberater\\-ctb",53,43,3d,7f)) + HX_("|xn\\-\\-vermgensberatung\\-pwb|xn\\-\\-vhquv|xn\\-\\-vuq861b|xn\\-\\-wgbh1c|xn\\-\\-wgbl6a",93,33,8f,07)) + HX_("|xn\\-\\-xhq521b|xn\\-\\-xkc2al3hye2a|xn\\-\\-xkc2dl3a5ee0h|xn\\-\\-y9a3aq|xn\\-\\-yfro4i67o",9a,35,82,bc)) + HX_("|xn\\-\\-ygbi2ammx|xn\\-\\-zfr164b|xperia|xxx|xyz)",dc,3c,8a,29)) + HX_("|(?:yachts|yamaxun|yandex|yodobashi|yoga|yokohama|youtube|y[et])",a2,ef,ff,21)) + HX_("|(?:zara|zip|zone|zuerich|z[amw]))",9f,cf,ff,38));
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_162_boot)
+HXDLIN( 162)		GOOD_IRI_CHAR = HX_W(u"a-zA-Z0-9\u00a0-\ud7ff\uf900-\ufdcf\ufdf0-\uffef",428f,00c6);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_164_boot)
+HXDLIN( 164)		IP_ADDRESS = (((HX_("((25[0-5]|2[0-4][0-9]|[0-1][0-9]{2}|[1-9][0-9]|[1-9])\\.(25[0-5]|2[0-4]",77,34,c5,07) + HX_("[0-9]|[0-1][0-9]{2}|[1-9][0-9]|[1-9]|0)\\.(25[0-5]|2[0-4][0-9]|[0-1]",27,09,31,49)) + HX_("[0-9]{2}|[1-9][0-9]|[1-9]|0)\\.(25[0-5]|2[0-4][0-9]|[0-1][0-9]{2}",8d,b1,49,66)) + HX_("|[1-9][0-9]|[0-9]))",fd,a4,5b,ea));
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_181_boot)
+HXDLIN( 181)		IP6_ADDRESS = (((((((((((((((((HX_("\\[",7f,50,00,00) + HX_("(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|",95,9e,ad,bb)) + HX_("([0-9a-fA-F]{1,4}:){1,7}:|",24,ce,ee,30)) + HX_("([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|",a2,da,a4,21)) + HX_("([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|",4b,b7,dc,9c)) + HX_("([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|",4b,bc,50,d7)) + HX_("([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|",4b,c1,c4,11)) + HX_("([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|",4b,c6,38,4c)) + HX_("[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|",4d,77,45,e4)) + HX_(":((:[0-9a-fA-F]{1,4}){1,7}|:)|",27,df,3d,33)) + HX_("fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|",ee,41,f7,25)) + HX_("::(ffff(:0{1,4}){0,1}:){0,1}",b1,6f,8b,25)) + HX_("((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}",34,d9,ed,ae)) + HX_("(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|",97,b1,d5,90)) + HX_("([0-9a-fA-F]{1,4}:){1,4}:",95,58,1a,e8)) + HX_("((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}",34,d9,ed,ae)) + HX_("(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))",44,b1,d5,90)) + HX_("\\]",81,50,00,00));
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_202_boot)
+HXDLIN( 202)		UCS_CHAR = (((HX_("[",5b,00,00,00) + HX_("\\x{00A0}-\\x{D7FF}",29,32,b0,f1)) + HX_("\\x{F900}-\\x{FDCF}",9f,26,06,f2)) + HX_("\\x{FDF0}-\\x{FFEF}",94,e8,12,99));
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_224_boot)
+HXDLIN( 224)		LABEL_CHAR = (HX_("a-zA-Z0-9",1c,c7,6d,ee) + ::snikket::Autolink_obj::UCS_CHAR);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_233_boot)
+HXDLIN( 233)		IRI_LABEL = ((((((HX_("[",5b,00,00,00) + ::snikket::Autolink_obj::LABEL_CHAR) + HX_("](?:[",95,7c,e4,a6)) + ::snikket::Autolink_obj::LABEL_CHAR) + HX_("\\-]{0,61}[",84,06,f0,9b)) + ::snikket::Autolink_obj::LABEL_CHAR) + HX_("]){0,1}",77,15,13,72));
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_237_boot)
+HXDLIN( 237)		PUNYCODE_TLD = HX_("xn\\-\\-[\\w\\-]{0,58}\\w",0c,c7,30,ad);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_242_boot)
+HXDLIN( 242)		PROTOCOL = HX_("(?:http|https|rtsp):\\/\\/",38,1d,38,84);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_244_boot)
+HXDLIN( 244)		WORD_BOUNDARY = HX_("(?:\\b|$|^)",36,7d,03,89);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_245_boot)
+HXDLIN( 245)		USER_INFO = ((HX_("(?:[a-zA-Z0-9\\$\\-\\_\\.\\+\\!\\*\\'\\(\\)",98,4a,e0,1a) + HX_("\\,\\;\\?\\&\\=]|(?:\\%[a-fA-F0-9]{2})){1,64}(?:\\:(?:[a-zA-Z0-9\\$\\-\\_",82,eb,76,e5)) + HX_("\\.\\+\\!\\*\\'\\(\\)\\,\\;\\?\\&\\=]|(?:\\%[a-fA-F0-9]{2})){1,25})?\\@",60,f3,93,36));
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_248_boot)
+HXDLIN( 248)		PORT_NUMBER = HX_("\\:\\d{1,5}",18,ba,64,a4);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_249_boot)
+HXDLIN( 249)		PATH_CHAR = (((HX_("(?:(?:[",7b,78,b4,2f) + ::snikket::Autolink_obj::LABEL_CHAR) + HX_("\\;\\/\\?\\:\\@\\&\\=\\#\\~",6b,f2,13,64)) + HX_("\\-\\.\\+\\!\\*\\'\\(\\)\\,\\_\\$])|(?:\\%[a-fA-F0-9]{2}))",ca,f2,2d,5c));
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_252_boot)
+HXDLIN( 252)		PATH_AND_QUERY = ((HX_("\\/",53,50,00,00) + ::snikket::Autolink_obj::PATH_CHAR) + HX_("*",2a,00,00,00));
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_269_boot)
+HXDLIN( 269)		STRICT_TLD = ((((HX_("(?:",43,91,1e,00) + ::snikket::Autolink_obj::IANA_TOP_LEVEL_DOMAINS) + HX_("|",7c,00,00,00)) + ::snikket::Autolink_obj::PUNYCODE_TLD) + HX_(")",29,00,00,00));
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_274_boot)
+HXDLIN( 274)		STRICT_HOST_NAME = ((((HX_("(?:(?:",e0,eb,f9,6a) + ::snikket::Autolink_obj::IRI_LABEL) + HX_("\\.)+",b4,ac,f2,3c)) + ::snikket::Autolink_obj::STRICT_TLD) + HX_(")",29,00,00,00));
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_281_boot)
+HXDLIN( 281)		STRICT_DOMAIN_NAME = ((((((HX_("(?:",43,91,1e,00) + ::snikket::Autolink_obj::STRICT_HOST_NAME) + HX_("|",7c,00,00,00)) + ::snikket::Autolink_obj::IP_ADDRESS) + HX_("|",7c,00,00,00)) + ::snikket::Autolink_obj::IP6_ADDRESS) + HX_(")",29,00,00,00));
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_286_boot)
+HXDLIN( 286)		RELAXED_DOMAIN_NAME = (((((((((HX_("(?:",43,91,1e,00) + HX_("(?:",43,91,1e,00)) + ::snikket::Autolink_obj::IRI_LABEL) + HX_("(?:\\.(?=\\S))",a8,58,ad,af)) + HX_("?)+",e1,f1,2f,00)) + HX_("|",7c,00,00,00)) + ::snikket::Autolink_obj::IP_ADDRESS) + HX_("|",7c,00,00,00)) + ::snikket::Autolink_obj::IP6_ADDRESS) + HX_(")",29,00,00,00));
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_291_boot)
+HXDLIN( 291)		WEB_URL_WITHOUT_PROTOCOL = ((((((((((((((HX_("(",28,00,00,00) + ::snikket::Autolink_obj::WORD_BOUNDARY) + HX_("(?<!:\\/\\/)",c5,eb,09,02)) + HX_("(",28,00,00,00)) + HX_("(?:",43,91,1e,00)) + ::snikket::Autolink_obj::STRICT_DOMAIN_NAME) + HX_(")",29,00,00,00)) + HX_("(?:",43,91,1e,00)) + ::snikket::Autolink_obj::PORT_NUMBER) + HX_(")?",f6,23,00,00)) + HX_(")",29,00,00,00)) + HX_("(?:",43,91,1e,00)) + ::snikket::Autolink_obj::PATH_AND_QUERY) + HX_(")?",f6,23,00,00)) + HX_(")",29,00,00,00));
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_304_boot)
+HXDLIN( 304)		WEB_URL_WITH_PROTOCOL = (((((((((((((((((((HX_("(",28,00,00,00) + ::snikket::Autolink_obj::WORD_BOUNDARY) + HX_("(?:",43,91,1e,00)) + HX_("(?:",43,91,1e,00)) + ::snikket::Autolink_obj::PROTOCOL) + HX_("(?:",43,91,1e,00)) + ::snikket::Autolink_obj::USER_INFO) + HX_(")?",f6,23,00,00)) + HX_(")",29,00,00,00)) + HX_("(?:",43,91,1e,00)) + ::snikket::Autolink_obj::RELAXED_DOMAIN_NAME) + HX_(")?",f6,23,00,00)) + HX_("(?:",43,91,1e,00)) + ::snikket::Autolink_obj::PORT_NUMBER) + HX_(")?",f6,23,00,00)) + HX_(")",29,00,00,00)) + HX_("(?:",43,91,1e,00)) + ::snikket::Autolink_obj::PATH_AND_QUERY) + HX_(")?",f6,23,00,00)) + HX_(")",29,00,00,00));
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_321_boot)
+HXDLIN( 321)		AUTOLINK_WEB_URL = (((((HX_("(",28,00,00,00) + ::snikket::Autolink_obj::WEB_URL_WITH_PROTOCOL) + HX_("|",7c,00,00,00)) + ::snikket::Autolink_obj::WEB_URL_WITHOUT_PROTOCOL) + HX_(")",29,00,00,00)) + ::snikket::Autolink_obj::WORD_BOUNDARY);
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_324_boot)
+HXDLIN( 324)		TEL_URI = ((HX_("tel:(?:(?:\\+\\d+)|(?:\\d+;phone-context=",00,31,ab,3d) + ::snikket::Autolink_obj::PATH_CHAR) + HX_("+))",cb,c4,20,00));
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_327_boot)
+HXDLIN( 327)		SMS_URI = ((HX_("sms:(?:(?:\\+\\d+)|(?:\\d+;phone-context=",02,3f,54,78) + ::snikket::Autolink_obj::PATH_CHAR) + HX_("+))",cb,c4,20,00));
+            	}
+{
+            	HX_STACKFRAME(&_hx_pos_e03e81a8315e14a8_329_boot)
+HXDLIN( 329)		XMPP_URI = (((HX_("xmpp\\:(?:(?:[",08,ef,83,26) + ::snikket::Autolink_obj::GOOD_IRI_CHAR) + HX_("\\;\\/\\?\\@\\&\\=\\#\\~\\-\\.\\+\\!\\*\\'\\(\\)\\,\\_])",75,2a,04,95)) + HX_("|(?:\\%[a-fA-F0-9]{2}))+",d1,f8,1c,37));
+            	}
+}
+
+} // end namespace snikket
diff --git a/Sources/c_snikket/src/snikket/AvailableChat.cpp b/Sources/c_snikket/src/snikket/AvailableChat.cpp
new file mode 100644
index 0000000..567be00
--- /dev/null
+++ b/Sources/c_snikket/src/snikket/AvailableChat.cpp
@@ -0,0 +1,223 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_snikket_AvailableChat
+#include <snikket/AvailableChat.h>
+#endif
+#ifndef INCLUDED_snikket_Caps
+#include <snikket/Caps.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_eb4b7fa35bcf9ef4_1546_new,"snikket.AvailableChat","new",0xe206b262,"snikket.AvailableChat.new","snikket/Chat.hx",1546,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_84f492ff0c9cb600_307_chatId__fromC,"snikket.AvailableChat","chatId__fromC",0xa5503488,"snikket.AvailableChat.chatId__fromC","HaxeCBridge.hx",307,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_84f492ff0c9cb600_307_displayName__fromC,"snikket.AvailableChat","displayName__fromC",0x0c214eaa,"snikket.AvailableChat.displayName__fromC","HaxeCBridge.hx",307,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_84f492ff0c9cb600_307_note__fromC,"snikket.AvailableChat","note__fromC",0xff5acec9,"snikket.AvailableChat.note__fromC","HaxeCBridge.hx",307,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_eb4b7fa35bcf9ef4_1542_isChannel,"snikket.AvailableChat","isChannel",0x4a03cd7b,"snikket.AvailableChat.isChannel","snikket/Chat.hx",1542,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_eb4b7fa35bcf9ef4_1522_boot,"snikket.AvailableChat","boot",0xdbee63f0,"snikket.AvailableChat.boot","snikket/Chat.hx",1522,0x18616bf4)
+namespace snikket{
+
+void AvailableChat_obj::__construct(::String chatId,::String displayName,::String note, ::snikket::Caps caps){
+            	HX_STACKFRAME(&_hx_pos_eb4b7fa35bcf9ef4_1546_new)
+HXLINE(1547)		this->chatId = chatId;
+HXLINE(1548)		this->displayName = displayName;
+HXLINE(1549)		this->note = note;
+HXLINE(1550)		this->caps = caps;
+            	}
+
+Dynamic AvailableChat_obj::__CreateEmpty() { return new AvailableChat_obj; }
+
+void *AvailableChat_obj::_hx_vtable = 0;
+
+Dynamic AvailableChat_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< AvailableChat_obj > _hx_result = new AvailableChat_obj();
+	_hx_result->__construct(inArgs[0],inArgs[1],inArgs[2],inArgs[3]);
+	return _hx_result;
+}
+
+bool AvailableChat_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x7aa46944;
+}
+
+::String AvailableChat_obj::chatId__fromC(){
+            	HX_STACKFRAME(&_hx_pos_84f492ff0c9cb600_307_chatId__fromC)
+HXDLIN( 307)		return this->chatId;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(AvailableChat_obj,chatId__fromC,return )
+
+::String AvailableChat_obj::displayName__fromC(){
+            	HX_STACKFRAME(&_hx_pos_84f492ff0c9cb600_307_displayName__fromC)
+HXDLIN( 307)		return this->displayName;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(AvailableChat_obj,displayName__fromC,return )
+
+::String AvailableChat_obj::note__fromC(){
+            	HX_STACKFRAME(&_hx_pos_84f492ff0c9cb600_307_note__fromC)
+HXDLIN( 307)		return this->note;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(AvailableChat_obj,note__fromC,return )
+
+bool AvailableChat_obj::isChannel(){
+            	HX_STACKFRAME(&_hx_pos_eb4b7fa35bcf9ef4_1542_isChannel)
+HXDLIN(1542)		return this->caps->isChannel(this->chatId);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(AvailableChat_obj,isChannel,return )
+
+
+::hx::ObjectPtr< AvailableChat_obj > AvailableChat_obj::__new(::String chatId,::String displayName,::String note, ::snikket::Caps caps) {
+	::hx::ObjectPtr< AvailableChat_obj > __this = new AvailableChat_obj();
+	__this->__construct(chatId,displayName,note,caps);
+	return __this;
+}
+
+::hx::ObjectPtr< AvailableChat_obj > AvailableChat_obj::__alloc(::hx::Ctx *_hx_ctx,::String chatId,::String displayName,::String note, ::snikket::Caps caps) {
+	AvailableChat_obj *__this = (AvailableChat_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(AvailableChat_obj), true, "snikket.AvailableChat"));
+	*(void **)__this = AvailableChat_obj::_hx_vtable;
+	__this->__construct(chatId,displayName,note,caps);
+	return __this;
+}
+
+AvailableChat_obj::AvailableChat_obj()
+{
+}
+
+void AvailableChat_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(AvailableChat);
+	HX_MARK_MEMBER_NAME(chatId,"chatId");
+	HX_MARK_MEMBER_NAME(displayName,"displayName");
+	HX_MARK_MEMBER_NAME(note,"note");
+	HX_MARK_MEMBER_NAME(caps,"caps");
+	HX_MARK_END_CLASS();
+}
+
+void AvailableChat_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(chatId,"chatId");
+	HX_VISIT_MEMBER_NAME(displayName,"displayName");
+	HX_VISIT_MEMBER_NAME(note,"note");
+	HX_VISIT_MEMBER_NAME(caps,"caps");
+}
+
+::hx::Val AvailableChat_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"note") ) { return ::hx::Val( note ); }
+		if (HX_FIELD_EQ(inName,"caps") ) { return ::hx::Val( caps ); }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"chatId") ) { return ::hx::Val( chatId ); }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"isChannel") ) { return ::hx::Val( isChannel_dyn() ); }
+		break;
+	case 11:
+		if (HX_FIELD_EQ(inName,"displayName") ) { return ::hx::Val( displayName ); }
+		if (HX_FIELD_EQ(inName,"note__fromC") ) { return ::hx::Val( note__fromC_dyn() ); }
+		break;
+	case 13:
+		if (HX_FIELD_EQ(inName,"chatId__fromC") ) { return ::hx::Val( chatId__fromC_dyn() ); }
+		break;
+	case 18:
+		if (HX_FIELD_EQ(inName,"displayName__fromC") ) { return ::hx::Val( displayName__fromC_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val AvailableChat_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"note") ) { note=inValue.Cast< ::String >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"caps") ) { caps=inValue.Cast<  ::snikket::Caps >(); return inValue; }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"chatId") ) { chatId=inValue.Cast< ::String >(); return inValue; }
+		break;
+	case 11:
+		if (HX_FIELD_EQ(inName,"displayName") ) { displayName=inValue.Cast< ::String >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void AvailableChat_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("chatId",d3,04,77,b7));
+	outFields->push(HX_("displayName",ad,11,f2,30));
+	outFields->push(HX_("note",f2,17,0a,49));
+	outFields->push(HX_("caps",21,1c,ba,41));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo AvailableChat_obj_sMemberStorageInfo[] = {
+	{::hx::fsString,(int)offsetof(AvailableChat_obj,chatId),HX_("chatId",d3,04,77,b7)},
+	{::hx::fsString,(int)offsetof(AvailableChat_obj,displayName),HX_("displayName",ad,11,f2,30)},
+	{::hx::fsString,(int)offsetof(AvailableChat_obj,note),HX_("note",f2,17,0a,49)},
+	{::hx::fsObject /*  ::snikket::Caps */ ,(int)offsetof(AvailableChat_obj,caps),HX_("caps",21,1c,ba,41)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *AvailableChat_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String AvailableChat_obj_sMemberFields[] = {
+	HX_("chatId",d3,04,77,b7),
+	HX_("chatId__fromC",06,fc,b1,94),
+	HX_("displayName",ad,11,f2,30),
+	HX_("displayName__fromC",6c,9e,e5,22),
+	HX_("note",f2,17,0a,49),
+	HX_("note__fromC",c7,1a,13,57),
+	HX_("caps",21,1c,ba,41),
+	HX_("isChannel",f9,7d,d0,d0),
+	::String(null()) };
+
+::hx::Class AvailableChat_obj::__mClass;
+
+void AvailableChat_obj::__register()
+{
+	AvailableChat_obj _hx_dummy;
+	AvailableChat_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("snikket.AvailableChat",70,99,29,af);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(AvailableChat_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< AvailableChat_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = AvailableChat_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = AvailableChat_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+void AvailableChat_obj::__boot()
+{
+{
+            	HX_STACKFRAME(&_hx_pos_eb4b7fa35bcf9ef4_1522_boot)
+HXDLIN(1522)		__mClass->__meta__ =  ::Dynamic(::hx::Anon_obj::Create(1)
+            			->setFixed(0,HX_("fields",79,8e,8e,80), ::Dynamic(::hx::Anon_obj::Create(3)
+            				->setFixed(0,HX_("chatId__fromC",06,fc,b1,94), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("HaxeCBridge.wrapper",8b,ea,27,d4),null())))
+            				->setFixed(1,HX_("displayName__fromC",6c,9e,e5,22), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("HaxeCBridge.wrapper",8b,ea,27,d4),null())))
+            				->setFixed(2,HX_("note__fromC",c7,1a,13,57), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("HaxeCBridge.wrapper",8b,ea,27,d4),null()))))));
+            	}
+}
+
+} // end namespace snikket
diff --git a/Sources/c_snikket/src/snikket/Builder.cpp b/Sources/c_snikket/src/snikket/Builder.cpp
new file mode 100644
index 0000000..cb6b08f
--- /dev/null
+++ b/Sources/c_snikket/src/snikket/Builder.cpp
@@ -0,0 +1,338 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_snikket_Builder
+#include <snikket/Builder.h>
+#endif
+#ifndef INCLUDED_snikket_Emoji
+#include <snikket/Emoji.h>
+#endif
+#ifndef INCLUDED_snikket_EmojiUtil
+#include <snikket/EmojiUtil.h>
+#endif
+#ifndef INCLUDED_snikket_Other
+#include <snikket/Other.h>
+#endif
+#ifndef INCLUDED_snikket_Symbol
+#include <snikket/Symbol.h>
+#endif
+#ifndef INCLUDED_snikket_UnicodeBlocks
+#include <snikket/UnicodeBlocks.h>
+#endif
+#ifndef INCLUDED_snikket_UnicodeRange
+#include <snikket/UnicodeRange.h>
+#endif
+#ifndef INCLUDED_snikket_UnicodeSet
+#include <snikket/UnicodeSet.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_ac332627541f656c_155_new,"snikket.Builder","new",0xc6a387fc,"snikket.Builder.new","snikket/EmojiUtil.hx",155,0x30de6948)
+HX_LOCAL_STACK_FRAME(_hx_pos_ac332627541f656c_159_offer,"snikket.Builder","offer",0xf095bc38,"snikket.Builder.offer","snikket/EmojiUtil.hx",159,0x30de6948)
+HX_LOCAL_STACK_FRAME(_hx_pos_ac332627541f656c_203_build,"snikket.Builder","build",0x7e4cb1ca,"snikket.Builder.build","snikket/EmojiUtil.hx",203,0x30de6948)
+HX_LOCAL_STACK_FRAME(_hx_pos_ac332627541f656c_200_isMerger,"snikket.Builder","isMerger",0x0a768d28,"snikket.Builder.isMerger","snikket/EmojiUtil.hx",200,0x30de6948)
+namespace snikket{
+
+void Builder_obj::__construct(){
+            	HX_STACKFRAME(&_hx_pos_ac332627541f656c_155_new)
+HXDLIN( 155)		this->codepoints = ::Array_obj< int >::__new(0);
+            	}
+
+Dynamic Builder_obj::__CreateEmpty() { return new Builder_obj; }
+
+void *Builder_obj::_hx_vtable = 0;
+
+Dynamic Builder_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Builder_obj > _hx_result = new Builder_obj();
+	_hx_result->__construct();
+	return _hx_result;
+}
+
+bool Builder_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x7b0e9a2a;
+}
+
+bool Builder_obj::offer(int codepoint){
+            	HX_STACKFRAME(&_hx_pos_ac332627541f656c_159_offer)
+HXLINE( 160)		bool add = false;
+HXLINE( 161)		if ((this->codepoints->length == 0)) {
+HXLINE( 162)			if (::snikket::EmojiUtil_obj::SYMBOLIZE->contains(codepoint)) {
+HXLINE( 163)				add = true;
+            			}
+            			else {
+HXLINE( 164)				if (::snikket::EmojiUtil_obj::REGIONAL_INDICATORS->contains(codepoint)) {
+HXLINE( 165)					add = true;
+            				}
+            				else {
+HXLINE( 166)					bool _hx_tmp;
+HXDLIN( 166)					bool _hx_tmp1;
+HXDLIN( 166)					if (::snikket::EmojiUtil_obj::EMOJIS->contains(codepoint)) {
+HXLINE( 166)						_hx_tmp1 = !(::snikket::EmojiUtil_obj::FITZPATRICK->contains(codepoint));
+            					}
+            					else {
+HXLINE( 166)						_hx_tmp1 = false;
+            					}
+HXDLIN( 166)					if (_hx_tmp1) {
+HXLINE( 166)						_hx_tmp = (codepoint != ::snikket::EmojiUtil_obj::ZWJ);
+            					}
+            					else {
+HXLINE( 166)						_hx_tmp = false;
+            					}
+HXDLIN( 166)					if (_hx_tmp) {
+HXLINE( 167)						add = true;
+            					}
+            				}
+            			}
+            		}
+            		else {
+HXLINE( 170)			int previous = this->codepoints->__get((this->codepoints->length - 1));
+HXLINE( 171)			if ((this->codepoints->__get(0) == ::snikket::EmojiUtil_obj::BLACK_FLAG)) {
+HXLINE( 172)				add = ::snikket::EmojiUtil_obj::TAGS->contains(codepoint);
+            			}
+            			else {
+HXLINE( 173)				if ((::snikket::EmojiUtil_obj::COMBINING_ENCLOSING_KEYCAP == codepoint)) {
+HXLINE( 174)					if (!(::snikket::EmojiUtil_obj::KEYCAP_COMBINEABLE->contains(previous))) {
+HXLINE( 174)						add = (previous == ::snikket::EmojiUtil_obj::VARIATION_16);
+            					}
+            					else {
+HXLINE( 174)						add = true;
+            					}
+            				}
+            				else {
+HXLINE( 175)					if (::snikket::EmojiUtil_obj::SYMBOLIZE->contains(previous)) {
+HXLINE( 176)						add = (codepoint == ::snikket::EmojiUtil_obj::VARIATION_16);
+            					}
+            					else {
+HXLINE( 177)						bool _hx_tmp2;
+HXDLIN( 177)						if (::snikket::EmojiUtil_obj::REGIONAL_INDICATORS->contains(previous)) {
+HXLINE( 177)							_hx_tmp2 = ::snikket::EmojiUtil_obj::REGIONAL_INDICATORS->contains(codepoint);
+            						}
+            						else {
+HXLINE( 177)							_hx_tmp2 = false;
+            						}
+HXDLIN( 177)						if (_hx_tmp2) {
+HXLINE( 178)							add = (this->codepoints->length == 1);
+            						}
+            						else {
+HXLINE( 179)							if ((previous == ::snikket::EmojiUtil_obj::VARIATION_16)) {
+HXLINE( 180)								if (!(::snikket::Builder_obj::isMerger(codepoint))) {
+HXLINE( 180)									add = (codepoint == ::snikket::EmojiUtil_obj::VARIATION_16);
+            								}
+            								else {
+HXLINE( 180)									add = true;
+            								}
+            							}
+            							else {
+HXLINE( 181)								if (::snikket::EmojiUtil_obj::FITZPATRICK->contains(previous)) {
+HXLINE( 182)									add = (codepoint == ::snikket::EmojiUtil_obj::ZWJ);
+            								}
+            								else {
+HXLINE( 183)									if ((::snikket::EmojiUtil_obj::ZWJ == previous)) {
+HXLINE( 184)										add = ::snikket::EmojiUtil_obj::EMOJIS->contains(codepoint);
+            									}
+            									else {
+HXLINE( 185)										if (::snikket::Builder_obj::isMerger(codepoint)) {
+HXLINE( 186)											add = true;
+            										}
+            										else {
+HXLINE( 187)											bool _hx_tmp3;
+HXDLIN( 187)											if ((codepoint == ::snikket::EmojiUtil_obj::VARIATION_16)) {
+HXLINE( 187)												_hx_tmp3 = ::snikket::EmojiUtil_obj::EMOJIS->contains(previous);
+            											}
+            											else {
+HXLINE( 187)												_hx_tmp3 = false;
+            											}
+HXDLIN( 187)											if (_hx_tmp3) {
+HXLINE( 188)												add = true;
+            											}
+            										}
+            									}
+            								}
+            							}
+            						}
+            					}
+            				}
+            			}
+            		}
+HXLINE( 191)		if (add) {
+HXLINE( 192)			this->codepoints->push(codepoint);
+HXLINE( 193)			return true;
+            		}
+            		else {
+HXLINE( 195)			return false;
+            		}
+HXLINE( 191)		return false;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Builder_obj,offer,return )
+
+ ::snikket::Symbol Builder_obj::build(){
+            	HX_GC_STACKFRAME(&_hx_pos_ac332627541f656c_203_build)
+HXLINE( 204)		bool _hx_tmp;
+HXDLIN( 204)		if ((this->codepoints->length > 0)) {
+HXLINE( 204)			_hx_tmp = ::snikket::EmojiUtil_obj::SYMBOLIZE->contains(this->codepoints->__get((this->codepoints->length - 1)));
+            		}
+            		else {
+HXLINE( 204)			_hx_tmp = false;
+            		}
+HXDLIN( 204)		if (_hx_tmp) {
+HXLINE( 205)			return  ::snikket::Other_obj::__alloc( HX_CTX ,this->codepoints);
+            		}
+            		else {
+HXLINE( 206)			bool _hx_tmp1;
+HXDLIN( 206)			bool _hx_tmp2;
+HXDLIN( 206)			if ((this->codepoints->length > 1)) {
+HXLINE( 206)				_hx_tmp2 = ::snikket::EmojiUtil_obj::KEYCAP_COMBINEABLE->contains(this->codepoints->__get(0));
+            			}
+            			else {
+HXLINE( 206)				_hx_tmp2 = false;
+            			}
+HXDLIN( 206)			if (_hx_tmp2) {
+HXLINE( 206)				_hx_tmp1 = (this->codepoints->__get((this->codepoints->length - 1)) != ::snikket::EmojiUtil_obj::COMBINING_ENCLOSING_KEYCAP);
+            			}
+            			else {
+HXLINE( 206)				_hx_tmp1 = false;
+            			}
+HXDLIN( 206)			if (_hx_tmp1) {
+HXLINE( 207)				return  ::snikket::Other_obj::__alloc( HX_CTX ,this->codepoints);
+            			}
+            		}
+HXLINE( 209)		if ((this->codepoints->length == 0)) {
+HXLINE( 209)			return  ::snikket::Other_obj::__alloc( HX_CTX ,this->codepoints);
+            		}
+            		else {
+HXLINE( 209)			return  ::snikket::Emoji_obj::__alloc( HX_CTX ,this->codepoints);
+            		}
+HXDLIN( 209)		return null();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Builder_obj,build,return )
+
+bool Builder_obj::isMerger(int codepoint){
+            	HX_STACKFRAME(&_hx_pos_ac332627541f656c_200_isMerger)
+HXDLIN( 200)		if ((codepoint != ::snikket::EmojiUtil_obj::ZWJ)) {
+HXDLIN( 200)			return ::snikket::EmojiUtil_obj::FITZPATRICK->contains(codepoint);
+            		}
+            		else {
+HXDLIN( 200)			return true;
+            		}
+HXDLIN( 200)		return false;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC1(Builder_obj,isMerger,return )
+
+
+::hx::ObjectPtr< Builder_obj > Builder_obj::__new() {
+	::hx::ObjectPtr< Builder_obj > __this = new Builder_obj();
+	__this->__construct();
+	return __this;
+}
+
+::hx::ObjectPtr< Builder_obj > Builder_obj::__alloc(::hx::Ctx *_hx_ctx) {
+	Builder_obj *__this = (Builder_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Builder_obj), true, "snikket.Builder"));
+	*(void **)__this = Builder_obj::_hx_vtable;
+	__this->__construct();
+	return __this;
+}
+
+Builder_obj::Builder_obj()
+{
+}
+
+void Builder_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(Builder);
+	HX_MARK_MEMBER_NAME(codepoints,"codepoints");
+	HX_MARK_END_CLASS();
+}
+
+void Builder_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(codepoints,"codepoints");
+}
+
+::hx::Val Builder_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 5:
+		if (HX_FIELD_EQ(inName,"offer") ) { return ::hx::Val( offer_dyn() ); }
+		if (HX_FIELD_EQ(inName,"build") ) { return ::hx::Val( build_dyn() ); }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"codepoints") ) { return ::hx::Val( codepoints ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+bool Builder_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 8:
+		if (HX_FIELD_EQ(inName,"isMerger") ) { outValue = isMerger_dyn(); return true; }
+	}
+	return false;
+}
+
+::hx::Val Builder_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 10:
+		if (HX_FIELD_EQ(inName,"codepoints") ) { codepoints=inValue.Cast< ::Array< int > >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void Builder_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("codepoints",10,63,53,8a));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo Builder_obj_sMemberStorageInfo[] = {
+	{::hx::fsObject /* ::Array< int > */ ,(int)offsetof(Builder_obj,codepoints),HX_("codepoints",10,63,53,8a)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *Builder_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String Builder_obj_sMemberFields[] = {
+	HX_("codepoints",10,63,53,8a),
+	HX_("offer",9c,e5,33,2d),
+	HX_("build",2e,db,ea,ba),
+	::String(null()) };
+
+::hx::Class Builder_obj::__mClass;
+
+static ::String Builder_obj_sStaticFields[] = {
+	HX_("isMerger",44,5a,71,60),
+	::String(null())
+};
+
+void Builder_obj::__register()
+{
+	Builder_obj _hx_dummy;
+	Builder_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("snikket.Builder",0a,1a,51,7e);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &Builder_obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(Builder_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(Builder_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< Builder_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Builder_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Builder_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace snikket
diff --git a/Sources/c_snikket/src/snikket/Caps.cpp b/Sources/c_snikket/src/snikket/Caps.cpp
new file mode 100644
index 0000000..e058fc4
--- /dev/null
+++ b/Sources/c_snikket/src/snikket/Caps.cpp
@@ -0,0 +1,446 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Lambda
+#include <Lambda.h>
+#endif
+#ifndef INCLUDED_haxe_io_Bytes
+#include <haxe/io/Bytes.h>
+#endif
+#ifndef INCLUDED_haxe_io_Encoding
+#include <haxe/io/Encoding.h>
+#endif
+#ifndef INCLUDED_snikket_Caps
+#include <snikket/Caps.h>
+#endif
+#ifndef INCLUDED_snikket_Hash
+#include <snikket/Hash.h>
+#endif
+#ifndef INCLUDED_snikket_Identity
+#include <snikket/Identity.h>
+#endif
+#ifndef INCLUDED_snikket_Stanza
+#include <snikket/Stanza.h>
+#endif
+#ifndef INCLUDED_snikket__Stanza_NodeInterface
+#include <snikket/_Stanza/NodeInterface.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_a541ea7d0210a2a3_10_new,"snikket.Caps","new",0xb2cdb3c4,"snikket.Caps.new","snikket/Caps.hx",10,0xee3b624b)
+HX_LOCAL_STACK_FRAME(_hx_pos_a541ea7d0210a2a3_53_isChannel,"snikket.Caps","isChannel",0xeab9045d,"snikket.Caps.isChannel","snikket/Caps.hx",53,0xee3b624b)
+HX_LOCAL_STACK_FRAME(_hx_pos_a541ea7d0210a2a3_55_isChannel,"snikket.Caps","isChannel",0xeab9045d,"snikket.Caps.isChannel","snikket/Caps.hx",55,0xee3b624b)
+HX_LOCAL_STACK_FRAME(_hx_pos_a541ea7d0210a2a3_58_discoReply,"snikket.Caps","discoReply",0xd5aeac6c,"snikket.Caps.discoReply","snikket/Caps.hx",58,0xee3b624b)
+HX_LOCAL_STACK_FRAME(_hx_pos_a541ea7d0210a2a3_69_addC,"snikket.Caps","addC",0xb896ff1e,"snikket.Caps.addC","snikket/Caps.hx",69,0xee3b624b)
+HX_LOCAL_STACK_FRAME(_hx_pos_a541ea7d0210a2a3_80_computeVer,"snikket.Caps","computeVer",0xc6252848,"snikket.Caps.computeVer","snikket/Caps.hx",80,0xee3b624b)
+HX_LOCAL_STACK_FRAME(_hx_pos_a541ea7d0210a2a3_81_computeVer,"snikket.Caps","computeVer",0xc6252848,"snikket.Caps.computeVer","snikket/Caps.hx",81,0xee3b624b)
+HX_LOCAL_STACK_FRAME(_hx_pos_a541ea7d0210a2a3_79_computeVer,"snikket.Caps","computeVer",0xc6252848,"snikket.Caps.computeVer","snikket/Caps.hx",79,0xee3b624b)
+HX_LOCAL_STACK_FRAME(_hx_pos_a541ea7d0210a2a3_92_verRaw,"snikket.Caps","verRaw",0x4ddd5e61,"snikket.Caps.verRaw","snikket/Caps.hx",92,0xee3b624b)
+HX_LOCAL_STACK_FRAME(_hx_pos_a541ea7d0210a2a3_98_ver,"snikket.Caps","ver",0xb2d3c5c7,"snikket.Caps.ver","snikket/Caps.hx",98,0xee3b624b)
+HX_LOCAL_STACK_FRAME(_hx_pos_a541ea7d0210a2a3_18_withIdentity,"snikket.Caps","withIdentity",0xadb07d80,"snikket.Caps.withIdentity","snikket/Caps.hx",18,0xee3b624b)
+HX_LOCAL_STACK_FRAME(_hx_pos_a541ea7d0210a2a3_33_withFeature,"snikket.Caps","withFeature",0x4980f8b4,"snikket.Caps.withFeature","snikket/Caps.hx",33,0xee3b624b)
+namespace snikket{
+
+void Caps_obj::__construct(::String node,::Array< ::Dynamic> identities,::Array< ::String > features){
+            	HX_STACKFRAME(&_hx_pos_a541ea7d0210a2a3_10_new)
+HXLINE(  14)		this->_ver = null();
+HXLINE(  48)		this->node = node;
+HXLINE(  49)		this->identities = identities;
+HXLINE(  50)		this->features = features;
+            	}
+
+Dynamic Caps_obj::__CreateEmpty() { return new Caps_obj; }
+
+void *Caps_obj::_hx_vtable = 0;
+
+Dynamic Caps_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Caps_obj > _hx_result = new Caps_obj();
+	_hx_result->__construct(inArgs[0],inArgs[1],inArgs[2]);
+	return _hx_result;
+}
+
+bool Caps_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x02663c7e;
+}
+
+bool Caps_obj::isChannel(::String chatId){
+            	HX_STACKFRAME(&_hx_pos_a541ea7d0210a2a3_53_isChannel)
+HXLINE(  54)		if ((chatId.indexOf(HX_("@",40,00,00,00),null()) < 0)) {
+HXLINE(  54)			return false;
+            		}
+HXLINE(  55)		if (this->features->contains(HX_("http://jabber.org/protocol/muc",07,b2,7f,c6))) {
+            			HX_BEGIN_LOCAL_FUNC_S0(::hx::LocalFunc,_hx_Closure_0) HXARGC(1)
+            			bool _hx_run( ::snikket::Identity identity){
+            				HX_STACKFRAME(&_hx_pos_a541ea7d0210a2a3_55_isChannel)
+HXLINE(  55)				return (identity->category == HX_("conference",1c,2b,83,41));
+            			}
+            			HX_END_LOCAL_FUNC1(return)
+
+HXLINE(  55)			return ::hx::IsNotNull( ::Lambda_obj::find(this->identities, ::Dynamic(new _hx_Closure_0())) );
+            		}
+            		else {
+HXLINE(  55)			return false;
+            		}
+HXDLIN(  55)		return false;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Caps_obj,isChannel,return )
+
+ ::snikket::Stanza Caps_obj::discoReply(){
+            	HX_GC_STACKFRAME(&_hx_pos_a541ea7d0210a2a3_58_discoReply)
+HXLINE(  59)		 ::snikket::Stanza query =  ::snikket::Stanza_obj::__alloc( HX_CTX ,HX_("query",08,8b,ea,5d), ::Dynamic(::hx::Anon_obj::Create(1)
+            			->setFixed(0,HX_("xmlns",dc,31,74,60),HX_("http://jabber.org/protocol/disco#info",cb,2b,7f,0b))));
+HXLINE(  60)		{
+HXLINE(  60)			int _g = 0;
+HXDLIN(  60)			::Array< ::Dynamic> _g1 = this->identities;
+HXDLIN(  60)			while((_g < _g1->length)){
+HXLINE(  60)				 ::snikket::Identity identity = _g1->__get(_g).StaticCast<  ::snikket::Identity >();
+HXDLIN(  60)				_g = (_g + 1);
+HXLINE(  61)				identity->addToDisco(query);
+            			}
+            		}
+HXLINE(  63)		{
+HXLINE(  63)			int _g2 = 0;
+HXDLIN(  63)			::Array< ::String > _g3 = this->features;
+HXDLIN(  63)			while((_g2 < _g3->length)){
+HXLINE(  63)				::String feature = _g3->__get(_g2);
+HXDLIN(  63)				_g2 = (_g2 + 1);
+HXLINE(  64)				query->tag(HX_("feature",b6,f2,7c,1a), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("var",e7,de,59,00),feature)))->up();
+            			}
+            		}
+HXLINE(  66)		return query;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Caps_obj,discoReply,return )
+
+ ::snikket::Stanza Caps_obj::addC( ::snikket::Stanza stanza){
+            	HX_STACKFRAME(&_hx_pos_a541ea7d0210a2a3_69_addC)
+HXLINE(  73)		::String _hx_tmp = this->node;
+HXLINE(  70)		stanza->tag(HX_("c",63,00,00,00), ::Dynamic(::hx::Anon_obj::Create(4)
+            			->setFixed(0,HX_("ver",63,e2,59,00),this->ver())
+            			->setFixed(1,HX_("hash",ce,2f,08,45),HX_("sha-1",90,a8,1c,7c))
+            			->setFixed(2,HX_("node",02,0a,0a,49),_hx_tmp)
+            			->setFixed(3,HX_("xmlns",dc,31,74,60),HX_("http://jabber.org/protocol/caps",95,d0,90,e2))))->up();
+HXLINE(  76)		return stanza;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Caps_obj,addC,return )
+
+ ::snikket::Hash Caps_obj::computeVer(){
+            		HX_BEGIN_LOCAL_FUNC_S0(::hx::LocalFunc,_hx_Closure_0) HXARGC(2)
+            		int _hx_run(::String x,::String y){
+            			HX_STACKFRAME(&_hx_pos_a541ea7d0210a2a3_80_computeVer)
+HXLINE(  80)			if ((x == y)) {
+HXLINE(  80)				return 0;
+            			}
+            			else {
+HXLINE(  80)				if ((x < y)) {
+HXLINE(  80)					return -1;
+            				}
+            				else {
+HXLINE(  80)					return 1;
+            				}
+            			}
+HXDLIN(  80)			return 0;
+            		}
+            		HX_END_LOCAL_FUNC2(return)
+
+            		HX_BEGIN_LOCAL_FUNC_S0(::hx::LocalFunc,_hx_Closure_1) HXARGC(2)
+            		int _hx_run( ::snikket::Identity x, ::snikket::Identity y){
+            			HX_STACKFRAME(&_hx_pos_a541ea7d0210a2a3_81_computeVer)
+HXLINE(  81)			::String _hx_tmp = x->ver();
+HXDLIN(  81)			if ((_hx_tmp == y->ver())) {
+HXLINE(  81)				return 0;
+            			}
+            			else {
+HXLINE(  81)				::String _hx_tmp1 = x->ver();
+HXDLIN(  81)				if ((_hx_tmp1 < y->ver())) {
+HXLINE(  81)					return -1;
+            				}
+            				else {
+HXLINE(  81)					return 1;
+            				}
+            			}
+HXDLIN(  81)			return 0;
+            		}
+            		HX_END_LOCAL_FUNC2(return)
+
+            	HX_STACKFRAME(&_hx_pos_a541ea7d0210a2a3_79_computeVer)
+HXLINE(  80)		this->features->sort( ::Dynamic(new _hx_Closure_0()));
+HXLINE(  81)		this->identities->sort( ::Dynamic(new _hx_Closure_1()));
+HXLINE(  82)		::String s = HX_("",00,00,00,00);
+HXLINE(  83)		{
+HXLINE(  83)			int _g = 0;
+HXDLIN(  83)			::Array< ::Dynamic> _g1 = this->identities;
+HXDLIN(  83)			while((_g < _g1->length)){
+HXLINE(  83)				 ::snikket::Identity identity = _g1->__get(_g).StaticCast<  ::snikket::Identity >();
+HXDLIN(  83)				_g = (_g + 1);
+HXLINE(  84)				s = (s + (identity->ver() + HX_("<",3c,00,00,00)));
+            			}
+            		}
+HXLINE(  86)		{
+HXLINE(  86)			int _g2 = 0;
+HXDLIN(  86)			::Array< ::String > _g3 = this->features;
+HXDLIN(  86)			while((_g2 < _g3->length)){
+HXLINE(  86)				::String feature = _g3->__get(_g2);
+HXDLIN(  86)				_g2 = (_g2 + 1);
+HXLINE(  87)				s = (s + (feature + HX_("<",3c,00,00,00)));
+            			}
+            		}
+HXLINE(  89)		return ::snikket::Hash_obj::sha1(::haxe::io::Bytes_obj::ofString(s,null()));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Caps_obj,computeVer,return )
+
+ ::snikket::Hash Caps_obj::verRaw(){
+            	HX_STACKFRAME(&_hx_pos_a541ea7d0210a2a3_92_verRaw)
+HXLINE(  93)		if (::hx::IsNull( this->_ver )) {
+HXLINE(  93)			this->_ver = this->computeVer();
+            		}
+HXLINE(  94)		return this->_ver;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Caps_obj,verRaw,return )
+
+::String Caps_obj::ver(){
+            	HX_STACKFRAME(&_hx_pos_a541ea7d0210a2a3_98_ver)
+HXDLIN(  98)		return this->verRaw()->toBase64();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Caps_obj,ver,return )
+
+::Array< ::String > Caps_obj::withIdentity( ::Dynamic caps,::String category,::String type){
+            	HX_STACKFRAME(&_hx_pos_a541ea7d0210a2a3_18_withIdentity)
+HXLINE(  19)		::Array< ::String > result = ::Array_obj< ::String >::__new(0);
+HXLINE(  20)		{
+HXLINE(  20)			 ::Dynamic cap = caps;
+HXDLIN(  20)			while(( (bool)(cap->__Field(HX_("hasNext",6d,a5,46,18),::hx::paccDynamic)()) )){
+HXLINE(  20)				 ::Dynamic cap1 = cap->__Field(HX_("next",f3,84,02,49),::hx::paccDynamic)();
+HXLINE(  21)				if (::hx::IsNotNull( cap1->__Field(HX_("value",71,7f,b8,31),::hx::paccDynamic) )) {
+HXLINE(  22)					int _g = 0;
+HXDLIN(  22)					::Array< ::Dynamic> _g1 = ( ( ::snikket::Caps)(cap1->__Field(HX_("value",71,7f,b8,31),::hx::paccDynamic)) )->identities;
+HXDLIN(  22)					while((_g < _g1->length)){
+HXLINE(  22)						 ::snikket::Identity identity = _g1->__get(_g).StaticCast<  ::snikket::Identity >();
+HXDLIN(  22)						_g = (_g + 1);
+HXLINE(  23)						bool _hx_tmp;
+HXDLIN(  23)						bool _hx_tmp1;
+HXDLIN(  23)						if (::hx::IsNotNull( category )) {
+HXLINE(  23)							_hx_tmp1 = (category == identity->category);
+            						}
+            						else {
+HXLINE(  23)							_hx_tmp1 = true;
+            						}
+HXDLIN(  23)						if (_hx_tmp1) {
+HXLINE(  23)							if (::hx::IsNotNull( type )) {
+HXLINE(  23)								_hx_tmp = (type == identity->type);
+            							}
+            							else {
+HXLINE(  23)								_hx_tmp = true;
+            							}
+            						}
+            						else {
+HXLINE(  23)							_hx_tmp = false;
+            						}
+HXDLIN(  23)						if (_hx_tmp) {
+HXLINE(  24)							result->push( ::Dynamic(cap1->__Field(HX_("key",9f,89,51,00),::hx::paccDynamic)));
+            						}
+            					}
+            				}
+            			}
+            		}
+HXLINE(  29)		return result;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC3(Caps_obj,withIdentity,return )
+
+::Array< ::String > Caps_obj::withFeature( ::Dynamic caps,::String feature){
+            	HX_STACKFRAME(&_hx_pos_a541ea7d0210a2a3_33_withFeature)
+HXLINE(  34)		::Array< ::String > result = ::Array_obj< ::String >::__new(0);
+HXLINE(  35)		{
+HXLINE(  35)			 ::Dynamic cap = caps;
+HXDLIN(  35)			while(( (bool)(cap->__Field(HX_("hasNext",6d,a5,46,18),::hx::paccDynamic)()) )){
+HXLINE(  35)				 ::Dynamic cap1 = cap->__Field(HX_("next",f3,84,02,49),::hx::paccDynamic)();
+HXLINE(  36)				if (::hx::IsNotNull( cap1->__Field(HX_("value",71,7f,b8,31),::hx::paccDynamic) )) {
+HXLINE(  37)					int _g = 0;
+HXDLIN(  37)					::Array< ::String > _g1 = ( ( ::snikket::Caps)(cap1->__Field(HX_("value",71,7f,b8,31),::hx::paccDynamic)) )->features;
+HXDLIN(  37)					while((_g < _g1->length)){
+HXLINE(  37)						::String feat = _g1->__get(_g);
+HXDLIN(  37)						_g = (_g + 1);
+HXLINE(  38)						if ((feature == feat)) {
+HXLINE(  39)							result->push( ::Dynamic(cap1->__Field(HX_("key",9f,89,51,00),::hx::paccDynamic)));
+            						}
+            					}
+            				}
+            			}
+            		}
+HXLINE(  44)		return result;
+            	}
+
+
+STATIC_HX_DEFINE_DYNAMIC_FUNC2(Caps_obj,withFeature,return )
+
+
+::hx::ObjectPtr< Caps_obj > Caps_obj::__new(::String node,::Array< ::Dynamic> identities,::Array< ::String > features) {
+	::hx::ObjectPtr< Caps_obj > __this = new Caps_obj();
+	__this->__construct(node,identities,features);
+	return __this;
+}
+
+::hx::ObjectPtr< Caps_obj > Caps_obj::__alloc(::hx::Ctx *_hx_ctx,::String node,::Array< ::Dynamic> identities,::Array< ::String > features) {
+	Caps_obj *__this = (Caps_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Caps_obj), true, "snikket.Caps"));
+	*(void **)__this = Caps_obj::_hx_vtable;
+	__this->__construct(node,identities,features);
+	return __this;
+}
+
+Caps_obj::Caps_obj()
+{
+}
+
+void Caps_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(Caps);
+	HX_MARK_MEMBER_NAME(node,"node");
+	HX_MARK_MEMBER_NAME(identities,"identities");
+	HX_MARK_MEMBER_NAME(features,"features");
+	HX_MARK_MEMBER_NAME(_ver,"_ver");
+	HX_MARK_END_CLASS();
+}
+
+void Caps_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(node,"node");
+	HX_VISIT_MEMBER_NAME(identities,"identities");
+	HX_VISIT_MEMBER_NAME(features,"features");
+	HX_VISIT_MEMBER_NAME(_ver,"_ver");
+}
+
+::hx::Val Caps_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 3:
+		if (HX_FIELD_EQ(inName,"ver") ) { return ::hx::Val( ver_dyn() ); }
+		break;
+	case 4:
+		if (HX_FIELD_EQ(inName,"node") ) { return ::hx::Val( node ); }
+		if (HX_FIELD_EQ(inName,"_ver") ) { return ::hx::Val( _ver ); }
+		if (HX_FIELD_EQ(inName,"addC") ) { return ::hx::Val( addC_dyn() ); }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"verRaw") ) { return ::hx::Val( verRaw_dyn() ); }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"features") ) { return ::hx::Val( features ); }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"isChannel") ) { return ::hx::Val( isChannel_dyn() ); }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"identities") ) { return ::hx::Val( identities ); }
+		if (HX_FIELD_EQ(inName,"discoReply") ) { return ::hx::Val( discoReply_dyn() ); }
+		if (HX_FIELD_EQ(inName,"computeVer") ) { return ::hx::Val( computeVer_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+bool Caps_obj::__GetStatic(const ::String &inName, Dynamic &outValue, ::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 11:
+		if (HX_FIELD_EQ(inName,"withFeature") ) { outValue = withFeature_dyn(); return true; }
+		break;
+	case 12:
+		if (HX_FIELD_EQ(inName,"withIdentity") ) { outValue = withIdentity_dyn(); return true; }
+	}
+	return false;
+}
+
+::hx::Val Caps_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"node") ) { node=inValue.Cast< ::String >(); return inValue; }
+		if (HX_FIELD_EQ(inName,"_ver") ) { _ver=inValue.Cast<  ::snikket::Hash >(); return inValue; }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"features") ) { features=inValue.Cast< ::Array< ::String > >(); return inValue; }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"identities") ) { identities=inValue.Cast< ::Array< ::Dynamic> >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void Caps_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("node",02,0a,0a,49));
+	outFields->push(HX_("identities",1c,c5,6d,d7));
+	outFields->push(HX_("features",fd,6c,d7,12));
+	outFields->push(HX_("_ver",64,27,25,3f));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo Caps_obj_sMemberStorageInfo[] = {
+	{::hx::fsString,(int)offsetof(Caps_obj,node),HX_("node",02,0a,0a,49)},
+	{::hx::fsObject /* ::Array< ::Dynamic> */ ,(int)offsetof(Caps_obj,identities),HX_("identities",1c,c5,6d,d7)},
+	{::hx::fsObject /* ::Array< ::String > */ ,(int)offsetof(Caps_obj,features),HX_("features",fd,6c,d7,12)},
+	{::hx::fsObject /*  ::snikket::Hash */ ,(int)offsetof(Caps_obj,_ver),HX_("_ver",64,27,25,3f)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *Caps_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String Caps_obj_sMemberFields[] = {
+	HX_("node",02,0a,0a,49),
+	HX_("identities",1c,c5,6d,d7),
+	HX_("features",fd,6c,d7,12),
+	HX_("_ver",64,27,25,3f),
+	HX_("isChannel",f9,7d,d0,d0),
+	HX_("discoReply",50,9b,21,44),
+	HX_("addC",02,eb,69,40),
+	HX_("computeVer",2c,17,98,34),
+	HX_("verRaw",45,0b,2e,a1),
+	HX_("ver",63,e2,59,00),
+	::String(null()) };
+
+::hx::Class Caps_obj::__mClass;
+
+static ::String Caps_obj_sStaticFields[] = {
+	HX_("withIdentity",64,ed,e7,d1),
+	HX_("withFeature",50,11,9f,7f),
+	::String(null())
+};
+
+void Caps_obj::__register()
+{
+	Caps_obj _hx_dummy;
+	Caps_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("snikket.Caps",d2,c1,77,4c);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &Caps_obj::__GetStatic;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(Caps_obj_sStaticFields);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(Caps_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< Caps_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Caps_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Caps_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+} // end namespace snikket
diff --git a/Sources/c_snikket/src/snikket/Channel.cpp b/Sources/c_snikket/src/snikket/Channel.cpp
new file mode 100644
index 0000000..9f34407
--- /dev/null
+++ b/Sources/c_snikket/src/snikket/Channel.cpp
@@ -0,0 +1,1750 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Date
+#include <Date.h>
+#endif
+#ifndef INCLUDED_Lambda
+#include <Lambda.h>
+#endif
+#ifndef INCLUDED_Reflect
+#include <Reflect.h>
+#endif
+#ifndef INCLUDED_Std
+#include <Std.h>
+#endif
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+#ifndef INCLUDED_haxe_Log
+#include <haxe/Log.h>
+#endif
+#ifndef INCLUDED_haxe_Timer
+#include <haxe/Timer.h>
+#endif
+#ifndef INCLUDED_haxe_ds_StringMap
+#include <haxe/ds/StringMap.h>
+#endif
+#ifndef INCLUDED_snikket_Caps
+#include <snikket/Caps.h>
+#endif
+#ifndef INCLUDED_snikket_Channel
+#include <snikket/Channel.h>
+#endif
+#ifndef INCLUDED_snikket_Chat
+#include <snikket/Chat.h>
+#endif
+#ifndef INCLUDED_snikket_ChatMessage
+#include <snikket/ChatMessage.h>
+#endif
+#ifndef INCLUDED_snikket_ChatMessageBuilder
+#include <snikket/ChatMessageBuilder.h>
+#endif
+#ifndef INCLUDED_snikket_Client
+#include <snikket/Client.h>
+#endif
+#ifndef INCLUDED_snikket_Color
+#include <snikket/Color.h>
+#endif
+#ifndef INCLUDED_snikket_CustomEmojiReaction
+#include <snikket/CustomEmojiReaction.h>
+#endif
+#ifndef INCLUDED_snikket_Date
+#include <snikket/Date.h>
+#endif
+#ifndef INCLUDED_snikket_DirectChat
+#include <snikket/DirectChat.h>
+#endif
+#ifndef INCLUDED_snikket_EventEmitter
+#include <snikket/EventEmitter.h>
+#endif
+#ifndef INCLUDED_snikket_EventResult
+#include <snikket/EventResult.h>
+#endif
+#ifndef INCLUDED_snikket_GenericStream
+#include <snikket/GenericStream.h>
+#endif
+#ifndef INCLUDED_snikket_Hash
+#include <snikket/Hash.h>
+#endif
+#ifndef INCLUDED_snikket_ID
+#include <snikket/ID.h>
+#endif
+#ifndef INCLUDED_snikket_Identity
+#include <snikket/Identity.h>
+#endif
+#ifndef INCLUDED_snikket_JID
+#include <snikket/JID.h>
+#endif
+#ifndef INCLUDED_snikket_Message
+#include <snikket/Message.h>
+#endif
+#ifndef INCLUDED_snikket_MessageStanza
+#include <snikket/MessageStanza.h>
+#endif
+#ifndef INCLUDED_snikket_MessageSync
+#include <snikket/MessageSync.h>
+#endif
+#ifndef INCLUDED_snikket_ModerationAction
+#include <snikket/ModerationAction.h>
+#endif
+#ifndef INCLUDED_snikket_Participant
+#include <snikket/Participant.h>
+#endif
+#ifndef INCLUDED_snikket_Persistence
+#include <snikket/Persistence.h>
+#endif
+#ifndef INCLUDED_snikket_Presence
+#include <snikket/Presence.h>
+#endif
+#ifndef INCLUDED_snikket_Reaction
+#include <snikket/Reaction.h>
+#endif
+#ifndef INCLUDED_snikket_ReactionUpdate
+#include <snikket/ReactionUpdate.h>
+#endif
+#ifndef INCLUDED_snikket_Stanza
+#include <snikket/Stanza.h>
+#endif
+#ifndef INCLUDED_snikket__Stanza_NodeInterface
+#include <snikket/_Stanza/NodeInterface.h>
+#endif
+#ifndef INCLUDED_snikket_queries_DiscoInfoGet
+#include <snikket/queries/DiscoInfoGet.h>
+#endif
+#ifndef INCLUDED_snikket_queries_GenericQuery
+#include <snikket/queries/GenericQuery.h>
+#endif
+#ifndef INCLUDED_thenshim_PromiseTools
+#include <thenshim/PromiseTools.h>
+#endif
+#ifndef INCLUDED_thenshim_Thenable
+#include <thenshim/Thenable.h>
+#endif
+#ifndef INCLUDED_thenshim__Promise_Promise_Impl_
+#include <thenshim/_Promise/Promise_Impl_.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_5e4df8d46126c981_975_new,"snikket.Channel","new",0x8a02a1a4,"snikket.Channel.new","snikket/Chat.hx",975,0x18616bf4)
+static const ::String _hx_array_data_db683fb2_1[] = {
+	HX_("http://jabber.org/protocol/muc",07,b2,7f,c6),
+};
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1018_selfPing,"snikket.Channel","selfPing",0x9e7c785a,"snikket.Channel.selfPing","snikket/Chat.hx",1018,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1008_selfPing,"snikket.Channel","selfPing",0x9e7c785a,"snikket.Channel.selfPing","snikket/Chat.hx",1008,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_996_selfPing,"snikket.Channel","selfPing",0x9e7c785a,"snikket.Channel.selfPing","snikket/Chat.hx",996,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1000_selfPing,"snikket.Channel","selfPing",0x9e7c785a,"snikket.Channel.selfPing","snikket/Chat.hx",1000,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1042_join,"snikket.Channel","join",0x35ad7e26,"snikket.Channel.join","snikket/Chat.hx",1042,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1034_join,"snikket.Channel","join",0x35ad7e26,"snikket.Channel.join","snikket/Chat.hx",1034,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1053_selfPingSuccess,"snikket.Channel","selfPingSuccess",0xafddf489,"snikket.Channel.selfPingSuccess","snikket/Chat.hx",1053,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1064_setPresence,"snikket.Channel","setPresence",0x9dbfd141,"snikket.Channel.setPresence","snikket/Chat.hx",1064,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1065_setPresence,"snikket.Channel","setPresence",0x9dbfd141,"snikket.Channel.setPresence","snikket/Chat.hx",1065,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1073_setPresence,"snikket.Channel","setPresence",0x9dbfd141,"snikket.Channel.setPresence","snikket/Chat.hx",1073,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1080_setPresence,"snikket.Channel","setPresence",0x9dbfd141,"snikket.Channel.setPresence","snikket/Chat.hx",1080,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1103_doSync,"snikket.Channel","doSync",0xa5ffb0c2,"snikket.Channel.doSync","snikket/Chat.hx",1103,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1132_doSync,"snikket.Channel","doSync",0xa5ffb0c2,"snikket.Channel.doSync","snikket/Chat.hx",1132,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1134_doSync,"snikket.Channel","doSync",0xa5ffb0c2,"snikket.Channel.doSync","snikket/Chat.hx",1134,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1163_doSync,"snikket.Channel","doSync",0xa5ffb0c2,"snikket.Channel.doSync","snikket/Chat.hx",1163,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1109_doSync,"snikket.Channel","doSync",0xa5ffb0c2,"snikket.Channel.doSync","snikket/Chat.hx",1109,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1125_doSync,"snikket.Channel","doSync",0xa5ffb0c2,"snikket.Channel.doSync","snikket/Chat.hx",1125,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1121_doSync,"snikket.Channel","doSync",0xa5ffb0c2,"snikket.Channel.doSync","snikket/Chat.hx",1121,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1173_doSync,"snikket.Channel","doSync",0xa5ffb0c2,"snikket.Channel.doSync","snikket/Chat.hx",1173,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1086_doSync,"snikket.Channel","doSync",0xa5ffb0c2,"snikket.Channel.doSync","snikket/Chat.hx",1086,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1186_isTrusted,"snikket.Channel","isTrusted",0x2c7a5171,"snikket.Channel.isTrusted","snikket/Chat.hx",1186,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1190_isPrivate,"snikket.Channel","isPrivate",0x9f42c67d,"snikket.Channel.isPrivate","snikket/Chat.hx",1190,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1196_refreshDisco,"snikket.Channel","refreshDisco",0x9d89e5db,"snikket.Channel.refreshDisco","snikket/Chat.hx",1196,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1194_refreshDisco,"snikket.Channel","refreshDisco",0x9d89e5db,"snikket.Channel.refreshDisco","snikket/Chat.hx",1194,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1209_preview,"snikket.Channel","preview",0x1b05a34c,"snikket.Channel.preview","snikket/Chat.hx",1209,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1216_livePresence,"snikket.Channel","livePresence",0x644ddf83,"snikket.Channel.livePresence","snikket/Chat.hx",1216,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1223_syncing,"snikket.Channel","syncing",0x8651c0ab,"snikket.Channel.syncing","snikket/Chat.hx",1223,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1227_canAudioCall,"snikket.Channel","canAudioCall",0x94c730a0,"snikket.Channel.canAudioCall","snikket/Chat.hx",1227,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1231_canVideoCall,"snikket.Channel","canVideoCall",0x9aca02c5,"snikket.Channel.canVideoCall","snikket/Chat.hx",1231,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1235_nickInUse,"snikket.Channel","nickInUse",0x59744703,"snikket.Channel.nickInUse","snikket/Chat.hx",1235,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1239_getFullJid,"snikket.Channel","getFullJid",0xa835e1bc,"snikket.Channel.getFullJid","snikket/Chat.hx",1239,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1245_getParticipants,"snikket.Channel","getParticipants",0x390cb25a,"snikket.Channel.getParticipants","snikket/Chat.hx",1245,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1243_getParticipants,"snikket.Channel","getParticipants",0x390cb25a,"snikket.Channel.getParticipants","snikket/Chat.hx",1243,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1250_getParticipantDetails,"snikket.Channel","getParticipantDetails",0xdfad9dc9,"snikket.Channel.getParticipantDetails","snikket/Chat.hx",1250,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1263_getMessagesBefore,"snikket.Channel","getMessagesBefore",0xefb5f1e5,"snikket.Channel.getMessagesBefore","snikket/Chat.hx",1263,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1269_getMessagesBefore,"snikket.Channel","getMessagesBefore",0xefb5f1e5,"snikket.Channel.getMessagesBefore","snikket/Chat.hx",1269,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1261_getMessagesBefore,"snikket.Channel","getMessagesBefore",0xefb5f1e5,"snikket.Channel.getMessagesBefore","snikket/Chat.hx",1261,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1286_getMessagesAfter,"snikket.Channel","getMessagesAfter",0x103df776,"snikket.Channel.getMessagesAfter","snikket/Chat.hx",1286,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1292_getMessagesAfter,"snikket.Channel","getMessagesAfter",0x103df776,"snikket.Channel.getMessagesAfter","snikket/Chat.hx",1292,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1280_getMessagesAfter,"snikket.Channel","getMessagesAfter",0x103df776,"snikket.Channel.getMessagesAfter","snikket/Chat.hx",1280,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1305_getMessagesAround,"snikket.Channel","getMessagesAround",0x0b8795b3,"snikket.Channel.getMessagesAround","snikket/Chat.hx",1305,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1304_getMessagesAround,"snikket.Channel","getMessagesAround",0x0b8795b3,"snikket.Channel.getMessagesAround","snikket/Chat.hx",1304,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1315_prepareIncomingMessage,"snikket.Channel","prepareIncomingMessage",0x3bfa74f6,"snikket.Channel.prepareIncomingMessage","snikket/Chat.hx",1315,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1326_prepareOutgoingMessage,"snikket.Channel","prepareOutgoingMessage",0xa2273a30,"snikket.Channel.prepareOutgoingMessage","snikket/Chat.hx",1326,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1344_correctMessage,"snikket.Channel","correctMessage",0x4d2d23b9,"snikket.Channel.correctMessage","snikket/Chat.hx",1344,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1339_correctMessage,"snikket.Channel","correctMessage",0x4d2d23b9,"snikket.Channel.correctMessage","snikket/Chat.hx",1339,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1357_sendMessage,"snikket.Channel","sendMessage",0x2aa53ea3,"snikket.Channel.sendMessage","snikket/Chat.hx",1357,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1373_sendMessage,"snikket.Channel","sendMessage",0x2aa53ea3,"snikket.Channel.sendMessage","snikket/Chat.hx",1373,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1380_sendMessage,"snikket.Channel","sendMessage",0x2aa53ea3,"snikket.Channel.sendMessage","snikket/Chat.hx",1380,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1411_removeReaction,"snikket.Channel","removeReaction",0x19751149,"snikket.Channel.removeReaction","snikket/Chat.hx",1411,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1391_removeReaction,"snikket.Channel","removeReaction",0x19751149,"snikket.Channel.removeReaction","snikket/Chat.hx",1391,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1406_removeReaction,"snikket.Channel","removeReaction",0x19751149,"snikket.Channel.removeReaction","snikket/Chat.hx",1406,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1421_lastMessageId,"snikket.Channel","lastMessageId",0xa72b1e90,"snikket.Channel.lastMessageId","snikket/Chat.hx",1421,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1426_markReadUpTo,"snikket.Channel","markReadUpTo",0x9e644e95,"snikket.Channel.markReadUpTo","snikket/Chat.hx",1426,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1425_markReadUpTo,"snikket.Channel","markReadUpTo",0x9e644e95,"snikket.Channel.markReadUpTo","snikket/Chat.hx",1425,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1461_bookmark,"snikket.Channel","bookmark",0x9931a4f2,"snikket.Channel.bookmark","snikket/Chat.hx",1461,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1479_bookmark,"snikket.Channel","bookmark",0x9931a4f2,"snikket.Channel.bookmark","snikket/Chat.hx",1479,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1440_bookmark,"snikket.Channel","bookmark",0x9931a4f2,"snikket.Channel.bookmark","snikket/Chat.hx",1440,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1490_sendChatState,"snikket.Channel","sendChatState",0xee67aff5,"snikket.Channel.sendChatState","snikket/Chat.hx",1490,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_1506_close,"snikket.Channel","close",0xb85bc1fc,"snikket.Channel.close","snikket/Chat.hx",1506,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_5e4df8d46126c981_975_boot,"snikket.Channel","boot",0x3063ce6e,"snikket.Channel.boot","snikket/Chat.hx",975,0x18616bf4)
+namespace snikket{
+
+void Channel_obj::__construct( ::snikket::Client client, ::snikket::GenericStream stream,::Dynamic persistence,::String chatId,::hx::Null< int >  __o_uiState,::hx::Null< bool >  __o_isBlocked, ::snikket::Stanza extensions,::String readUpToId,::String readUpToBy, ::snikket::Caps disco){
+            		int uiState = __o_uiState.Default(1);
+            		bool isBlocked = __o_isBlocked.Default(false);
+            	HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_975_new)
+HXLINE( 981)		this->_nickInUse = null();
+HXLINE( 980)		this->forceLive = false;
+HXLINE( 979)		this->sync = null();
+HXLINE( 978)		this->inSync = true;
+HXLINE( 977)		this->disco =  ::snikket::Caps_obj::__alloc( HX_CTX ,HX_("",00,00,00,00),::Array_obj< ::Dynamic>::__new(0),::Array_obj< ::String >::fromData( _hx_array_data_db683fb2_1,1));
+HXLINE( 985)		super::__construct(client,stream,persistence,chatId,uiState,isBlocked,extensions,readUpToId,readUpToBy);
+HXLINE( 986)		if (::hx::IsNotNull( disco )) {
+HXLINE( 987)			this->disco = disco;
+HXLINE( 988)			if (!(disco->features->contains(HX_("http://jabber.org/protocol/muc",07,b2,7f,c6)))) {
+HXLINE( 990)				this->forceLive = true;
+            			}
+            		}
+            	}
+
+Dynamic Channel_obj::__CreateEmpty() { return new Channel_obj; }
+
+void *Channel_obj::_hx_vtable = 0;
+
+Dynamic Channel_obj::__Create(::hx::DynamicArray inArgs)
+{
+	::hx::ObjectPtr< Channel_obj > _hx_result = new Channel_obj();
+	_hx_result->__construct(inArgs[0],inArgs[1],inArgs[2],inArgs[3],inArgs[4],inArgs[5],inArgs[6],inArgs[7],inArgs[8],inArgs[9]);
+	return _hx_result;
+}
+
+bool Channel_obj::_hx_isInstanceOf(int inClassId) {
+	if (inClassId<=(int)0x026b7f35) {
+		return inClassId==(int)0x00000001 || inClassId==(int)0x026b7f35;
+	} else {
+		return inClassId==(int)0x23f2b886;
+	}
+}
+
+void Channel_obj::selfPing(bool refresh){
+            		HX_BEGIN_LOCAL_FUNC_S1(::hx::LocalFunc,_hx_Closure_3, ::snikket::Channel,_gthis) HXARGC(0)
+            		void _hx_run(){
+            			HX_BEGIN_LOCAL_FUNC_S1(::hx::LocalFunc,_hx_Closure_2, ::snikket::Channel,_gthis) HXARGC(1)
+            			void _hx_run( ::snikket::Stanza response){
+            				HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1018_selfPing)
+HXLINE(1018)				if ((( (::String)(::Reflect_obj::field(response->attr,HX_("type",ba,f2,08,4d))) ) == HX_("error",c8,cb,29,73))) {
+HXLINE(1019)					 ::snikket::Stanza tmp = response->getChild(HX_("error",c8,cb,29,73),null());
+HXDLIN(1019)					 ::snikket::Stanza err;
+HXDLIN(1019)					if (::hx::IsNotNull( tmp )) {
+HXLINE(1019)						err = tmp->getChild(null(),HX_("urn:ietf:params:xml:ns:xmpp-stanzas",27,f2,3d,30));
+            					}
+            					else {
+HXLINE(1019)						err = null();
+            					}
+HXLINE(1020)					bool _hx_tmp;
+HXDLIN(1020)					if ((err->name != HX_("service-unavailable",f8,3c,11,1c))) {
+HXLINE(1020)						_hx_tmp = (err->name == HX_("feature-not-implemented",71,20,2e,96));
+            					}
+            					else {
+HXLINE(1020)						_hx_tmp = true;
+            					}
+HXDLIN(1020)					if (_hx_tmp) {
+HXLINE(1020)						_gthis->selfPingSuccess();
+HXDLIN(1020)						return;
+            					}
+HXLINE(1021)					bool _hx_tmp1;
+HXDLIN(1021)					if ((err->name != HX_("remote-server-not-found",e5,4f,ca,aa))) {
+HXLINE(1021)						_hx_tmp1 = (err->name == HX_("remote-server-timeout",fe,b0,ee,1a));
+            					}
+            					else {
+HXLINE(1021)						_hx_tmp1 = true;
+            					}
+HXDLIN(1021)					if (_hx_tmp1) {
+HXLINE(1021)						_gthis->selfPingSuccess();
+HXDLIN(1021)						return;
+            					}
+HXLINE(1022)					if ((err->name == HX_("item-not-found",4e,b5,9b,5b))) {
+HXLINE(1022)						_gthis->selfPingSuccess();
+HXDLIN(1022)						return;
+            					}
+HXLINE(1023)					::haxe::Log_obj::trace(HX_("SYNC: self-ping fail, join",ea,45,f2,f0), ::Dynamic(::hx::Anon_obj::Create(5)
+            						->setFixed(0,HX_("className",a3,92,3d,dc),HX_("snikket.Channel",b2,3f,68,db))
+            						->setFixed(1,HX_("customParams",d7,51,18,ed),::cpp::VirtualArray_obj::__new(1)->init(0,_gthis->chatId))
+            						->setFixed(2,HX_("methodName",cc,19,0f,12),HX_("selfPing",1e,60,3c,38))
+            						->setFixed(3,HX_("fileName",e7,5a,43,62),HX_("snikket/Chat.hx",f4,6b,61,18))
+            						->setFixed(4,HX_("lineNumber",dd,81,22,76),1023)));
+HXLINE(1024)					_gthis->join();
+            				}
+            				else {
+HXLINE(1026)					_gthis->selfPingSuccess();
+            				}
+            			}
+            			HX_END_LOCAL_FUNC1((void))
+
+            			HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1008_selfPing)
+HXLINE(1009)			if (!(_gthis->disco->features->contains(HX_("http://jabber.org/protocol/muc",07,b2,7f,c6)))) {
+HXLINE(1011)				_gthis->forceLive = true;
+HXLINE(1012)				return;
+            			}
+HXLINE(1014)			 ::snikket::GenericStream _gthis1 = _gthis->stream;
+HXLINE(1015)			::String _hx_tmp = _gthis->getFullJid()->asString();
+HXLINE(1014)			_gthis1->sendIq( ::snikket::Stanza_obj::__alloc( HX_CTX ,HX_("iq",e8,5b,00,00), ::Dynamic(::hx::Anon_obj::Create(2)
+            				->setFixed(0,HX_("to",7b,65,00,00),_hx_tmp)
+            				->setFixed(1,HX_("type",ba,f2,08,4d),HX_("get",96,80,4e,00))))->tag(HX_("ping",72,f2,57,4a), ::Dynamic(::hx::Anon_obj::Create(1)
+            				->setFixed(0,HX_("xmlns",dc,31,74,60),HX_("urn:xmpp:ping",8e,30,3f,fd))))->up(), ::Dynamic(new _hx_Closure_2(_gthis)));
+            		}
+            		HX_END_LOCAL_FUNC0((void))
+
+            	HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_996_selfPing)
+HXDLIN( 996)		 ::snikket::Channel _gthis = ::hx::ObjectPtr<OBJ_>(this);
+HXLINE( 997)		if ((this->uiState == 2)) {
+            			HX_BEGIN_LOCAL_FUNC_S0(::hx::LocalFunc,_hx_Closure_0) HXARGC(1)
+            			 ::snikket::Stanza _hx_run( ::snikket::Stanza stanza){
+            				HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1000_selfPing)
+HXLINE(1001)				::Reflect_obj::setField(stanza->attr,HX_("type",ba,f2,08,4d),HX_("unavailable",50,e0,29,fd));
+HXLINE(1002)				return stanza;
+            			}
+            			HX_END_LOCAL_FUNC1(return)
+
+HXLINE( 998)			 ::snikket::Client _hx_tmp = this->client;
+HXDLIN( 998)			_hx_tmp->sendPresence(this->getFullJid()->asString(), ::Dynamic(new _hx_Closure_0()));
+HXLINE(1005)			return;
+            		}
+HXLINE(1008)		 ::Dynamic _hx_tmp1;
+HXDLIN(1008)		if (refresh) {
+HXLINE(1008)			_hx_tmp1 = this->refreshDisco_dyn();
+            		}
+            		else {
+            			HX_BEGIN_LOCAL_FUNC_S0(::hx::LocalFunc,_hx_Closure_1) HXARGC(1)
+            			void _hx_run( ::Dynamic cb){
+            				HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1008_selfPing)
+HXLINE(1008)				cb();
+            			}
+            			HX_END_LOCAL_FUNC1((void))
+
+HXLINE(1008)			_hx_tmp1 =  ::Dynamic(new _hx_Closure_1());
+            		}
+HXDLIN(1008)		_hx_tmp1( ::Dynamic(new _hx_Closure_3(_gthis)));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Channel_obj,selfPing,(void))
+
+void Channel_obj::join(){
+            		HX_BEGIN_LOCAL_FUNC_S1(::hx::LocalFunc,_hx_Closure_0, ::snikket::Channel,_gthis) HXARGC(1)
+            		 ::snikket::Stanza _hx_run( ::snikket::Stanza stanza){
+            			HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1042_join)
+HXLINE(1043)			stanza->tag(HX_("x",78,00,00,00), ::Dynamic(::hx::Anon_obj::Create(1)
+            				->setFixed(0,HX_("xmlns",dc,31,74,60),HX_("http://jabber.org/protocol/muc",07,b2,7f,c6))));
+HXLINE(1044)			if (_gthis->disco->features->contains(HX_("urn:xmpp:mam:2",f5,ef,8c,da))) {
+HXLINE(1044)				stanza->tag(HX_("history",54,35,47,64), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("maxchars",b9,7f,a3,5c),HX_("0",30,00,00,00))))->up();
+            			}
+HXLINE(1046)			stanza->up();
+HXLINE(1047)			return stanza;
+            		}
+            		HX_END_LOCAL_FUNC1(return)
+
+            	HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1034_join)
+HXDLIN(1034)		 ::snikket::Channel _gthis = ::hx::ObjectPtr<OBJ_>(this);
+HXLINE(1035)		this->presence =  ::haxe::ds::StringMap_obj::__alloc( HX_CTX );
+HXLINE(1036)		this->_nickInUse = null();
+HXLINE(1037)		this->inSync = false;
+HXLINE(1038)		this->client->trigger(HX_("chats/update",3d,8e,1d,14),::cpp::VirtualArray_obj::__new(1)->init(0,::hx::ObjectPtr<OBJ_>(this)));
+HXLINE(1039)		 ::snikket::JID desiredFullJid = ::snikket::JID_obj::parse(this->chatId);
+HXDLIN(1039)		 ::snikket::JID desiredFullJid1 = desiredFullJid->withResource(this->client->displayName());
+HXLINE(1040)		 ::snikket::Client _hx_tmp = this->client;
+HXDLIN(1040)		_hx_tmp->sendPresence(desiredFullJid1->asString(), ::Dynamic(new _hx_Closure_0(_gthis)));
+HXLINE(1050)		::Dynamic _hx_tmp1 = this->persistence;
+HXDLIN(1050)		::String _hx_tmp2 = this->client->accountId();
+HXDLIN(1050)		::snikket::Persistence_obj::lastId(_hx_tmp1,_hx_tmp2,this->chatId,this->doSync_dyn());
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Channel_obj,join,(void))
+
+void Channel_obj::selfPingSuccess(){
+            	HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1053_selfPingSuccess)
+HXLINE(1054)		::String _hx_tmp = this->nickInUse();
+HXDLIN(1054)		if ((_hx_tmp != this->client->displayName())) {
+HXLINE(1055)			 ::snikket::JID desiredFullJid = ::snikket::JID_obj::parse(this->chatId);
+HXDLIN(1055)			 ::snikket::JID desiredFullJid1 = desiredFullJid->withResource(this->client->displayName());
+HXLINE(1056)			 ::snikket::Client _hx_tmp1 = this->client;
+HXDLIN(1056)			_hx_tmp1->sendPresence(desiredFullJid1->asString(),null());
+            		}
+HXLINE(1060)		this->inSync = false;
+HXLINE(1061)		::Dynamic _hx_tmp2 = this->persistence;
+HXDLIN(1061)		::String _hx_tmp3 = this->client->accountId();
+HXDLIN(1061)		::snikket::Persistence_obj::lastId(_hx_tmp2,_hx_tmp3,this->chatId,this->doSync_dyn());
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Channel_obj,selfPingSuccess,(void))
+
+void Channel_obj::setPresence(::String resource, ::snikket::Presence presence){
+            	HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1064_setPresence)
+HXLINE(1065)		 ::snikket::Stanza tmp;
+HXDLIN(1065)		if (::hx::IsNotNull( presence )) {
+HXLINE(1065)			tmp = presence->mucUser;
+            		}
+            		else {
+HXLINE(1065)			tmp = null();
+            		}
+HXDLIN(1065)		 ::snikket::Stanza oneTen;
+HXDLIN(1065)		if (::hx::IsNotNull( tmp )) {
+            			HX_BEGIN_LOCAL_FUNC_S0(::hx::LocalFunc,_hx_Closure_0) HXARGC(1)
+            			bool _hx_run( ::snikket::Stanza status){
+            				HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1065_setPresence)
+HXLINE(1065)				return (( (::String)(::Reflect_obj::field(status->attr,HX_("code",2d,b1,c4,41))) ) == HX_("110",50,59,25,00));
+            			}
+            			HX_END_LOCAL_FUNC1(return)
+
+HXLINE(1065)			oneTen = ( ( ::snikket::Stanza)(::Lambda_obj::find(tmp->allTags(HX_("status",32,e7,fb,05),null()), ::Dynamic(new _hx_Closure_0()))) );
+            		}
+            		else {
+HXLINE(1065)			oneTen = null();
+            		}
+HXLINE(1066)		if (::hx::IsNotNull( oneTen )) {
+HXLINE(1067)			this->_nickInUse = resource;
+            		}
+            		else {
+HXLINE(1068)			if ((resource == this->_nickInUse)) {
+HXLINE(1069)				this->_nickInUse = null();
+            			}
+            		}
+HXLINE(1071)		bool _hx_tmp;
+HXDLIN(1071)		bool _hx_tmp1;
+HXDLIN(1071)		if (::hx::IsNotNull( presence )) {
+HXLINE(1071)			_hx_tmp1 = ::hx::IsNotNull( presence->mucUser );
+            		}
+            		else {
+HXLINE(1071)			_hx_tmp1 = false;
+            		}
+HXDLIN(1071)		if (_hx_tmp1) {
+HXLINE(1071)			_hx_tmp = ::hx::IsNull( oneTen );
+            		}
+            		else {
+HXLINE(1071)			_hx_tmp = false;
+            		}
+HXDLIN(1071)		if (_hx_tmp) {
+HXLINE(1072)			 ::snikket::Presence existing = ( ( ::snikket::Presence)(this->presence->get(resource)) );
+HXLINE(1073)			bool _hx_tmp2;
+HXDLIN(1073)			if (::hx::IsNotNull( existing )) {
+HXLINE(1073)				 ::snikket::Stanza tmp1;
+HXDLIN(1073)				if (::hx::IsNotNull( existing )) {
+HXLINE(1073)					tmp1 = existing->mucUser;
+            				}
+            				else {
+HXLINE(1073)					tmp1 = null();
+            				}
+HXDLIN(1073)				 ::snikket::Stanza _hx_tmp3;
+HXDLIN(1073)				if (::hx::IsNotNull( tmp1 )) {
+            					HX_BEGIN_LOCAL_FUNC_S0(::hx::LocalFunc,_hx_Closure_1) HXARGC(1)
+            					bool _hx_run( ::snikket::Stanza status){
+            						HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1073_setPresence)
+HXLINE(1073)						return (( (::String)(::Reflect_obj::field(status->attr,HX_("code",2d,b1,c4,41))) ) == HX_("110",50,59,25,00));
+            					}
+            					HX_END_LOCAL_FUNC1(return)
+
+HXLINE(1073)					_hx_tmp3 = ( ( ::snikket::Stanza)(::Lambda_obj::find(tmp1->allTags(HX_("status",32,e7,fb,05),null()), ::Dynamic(new _hx_Closure_1()))) );
+            				}
+            				else {
+HXLINE(1073)					_hx_tmp3 = null();
+            				}
+HXDLIN(1073)				_hx_tmp2 = ::hx::IsNotNull( _hx_tmp3 );
+            			}
+            			else {
+HXLINE(1073)				_hx_tmp2 = false;
+            			}
+HXDLIN(1073)			if (_hx_tmp2) {
+HXLINE(1074)				presence->mucUser->tag(HX_("status",32,e7,fb,05), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("code",2d,b1,c4,41),HX_("110",50,59,25,00))));
+HXLINE(1075)				this->setPresence(resource,presence);
+HXLINE(1076)				return;
+            			}
+            		}
+HXLINE(1079)		this->super::setPresence(resource,presence);
+HXLINE(1080)		 ::snikket::Stanza tmp2;
+HXDLIN(1080)		if (::hx::IsNotNull( presence )) {
+HXLINE(1080)			tmp2 = presence->mucUser;
+            		}
+            		else {
+HXLINE(1080)			tmp2 = null();
+            		}
+HXDLIN(1080)		 ::snikket::Stanza tripleThree;
+HXDLIN(1080)		if (::hx::IsNotNull( tmp2 )) {
+            			HX_BEGIN_LOCAL_FUNC_S0(::hx::LocalFunc,_hx_Closure_2) HXARGC(1)
+            			bool _hx_run( ::snikket::Stanza status){
+            				HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1080_setPresence)
+HXLINE(1080)				return (( (::String)(::Reflect_obj::field(status->attr,HX_("code",2d,b1,c4,41))) ) == HX_("333",93,df,26,00));
+            			}
+            			HX_END_LOCAL_FUNC1(return)
+
+HXLINE(1080)			tripleThree = ( ( ::snikket::Stanza)(::Lambda_obj::find(tmp2->allTags(HX_("status",32,e7,fb,05),null()), ::Dynamic(new _hx_Closure_2()))) );
+            		}
+            		else {
+HXLINE(1080)			tripleThree = null();
+            		}
+HXLINE(1081)		bool _hx_tmp4;
+HXDLIN(1081)		if (::hx::IsNotNull( oneTen )) {
+HXLINE(1081)			_hx_tmp4 = ::hx::IsNotNull( tripleThree );
+            		}
+            		else {
+HXLINE(1081)			_hx_tmp4 = false;
+            		}
+HXDLIN(1081)		if (_hx_tmp4) {
+HXLINE(1082)			this->selfPing(true);
+            		}
+            	}
+
+
+void Channel_obj::doSync(::String lastId){
+            		HX_BEGIN_LOCAL_FUNC_S1(::hx::LocalFunc,_hx_Closure_0, ::snikket::Channel,_gthis) HXARGC(2)
+            		 ::snikket::ChatMessageBuilder _hx_run( ::snikket::ChatMessageBuilder builder, ::snikket::Stanza stanza){
+            			HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1103_doSync)
+HXLINE(1104)			builder = _gthis->prepareIncomingMessage(builder,stanza);
+HXLINE(1105)			builder->syncPoint = true;
+HXLINE(1106)			return builder;
+            		}
+            		HX_END_LOCAL_FUNC2(return)
+
+            		HX_BEGIN_LOCAL_FUNC_S2(::hx::LocalFunc,_hx_Closure_8, ::snikket::Channel,_gthis,::Array< ::Dynamic>,chatMessages) HXARGC(1)
+            		void _hx_run( ::Dynamic messageList){
+            			HX_BEGIN_LOCAL_FUNC_S2(::hx::LocalFunc,_hx_Closure_5, ::snikket::Channel,_gthis,::Array< ::Dynamic>,pageChatMessages) HXARGC(2)
+            			void _hx_run( ::Dynamic resolve, ::Dynamic reject){
+            				HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1132_doSync)
+HXLINE(1132)				_gthis->client->storeMessages(pageChatMessages,resolve);
+            			}
+            			HX_END_LOCAL_FUNC2((void))
+
+            			HX_BEGIN_LOCAL_FUNC_S2(::hx::LocalFunc,_hx_Closure_7, ::snikket::Channel,_gthis,::Array< ::Dynamic>,chatMessages) HXARGC(1)
+            			void _hx_run(::Array< ::Dynamic> stored){
+            				HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1134_doSync)
+HXLINE(1135)				{
+HXLINE(1135)					int _g = 0;
+HXDLIN(1135)					while((_g < stored->length)){
+HXLINE(1135)						::Array< ::Dynamic> messages = stored->__get(_g).StaticCast< ::Array< ::Dynamic> >();
+HXDLIN(1135)						_g = (_g + 1);
+HXLINE(1136)						if (::hx::IsNotNull( messages )) {
+HXLINE(1137)							int _g1 = 0;
+HXDLIN(1137)							while((_g1 < messages->length)){
+HXLINE(1137)								 ::snikket::ChatMessage message = messages->__get(_g1).StaticCast<  ::snikket::ChatMessage >();
+HXDLIN(1137)								_g1 = (_g1 + 1);
+HXLINE(1138)								_gthis->client->notifySyncMessageHandlers(message);
+HXLINE(1139)								bool _hx_tmp;
+HXDLIN(1139)								if (::hx::IsNotNull( message )) {
+HXLINE(1139)									::String _hx_tmp1 = message->chatId();
+HXDLIN(1139)									_hx_tmp = (_hx_tmp1 == _gthis->chatId);
+            								}
+            								else {
+HXLINE(1139)									_hx_tmp = false;
+            								}
+HXDLIN(1139)								if (_hx_tmp) {
+HXLINE(1139)									chatMessages->push(message);
+            								}
+HXLINE(1140)								if ((chatMessages->length > 1000)) {
+HXLINE(1140)									chatMessages->shift().StaticCast<  ::snikket::ChatMessage >();
+            								}
+            							}
+            						}
+            					}
+            				}
+HXLINE(1144)				if (_gthis->sync->hasMore()) {
+HXLINE(1145)					_gthis->sync->fetchNext();
+            				}
+            				else {
+            					HX_BEGIN_LOCAL_FUNC_S1(::hx::LocalFunc,_hx_Closure_6, ::snikket::Channel,_gthis) HXARGC(1)
+            					bool _hx_run( ::snikket::ChatMessage m){
+            						HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1163_doSync)
+HXLINE(1163)						::String m1 = m->serverId;
+HXDLIN(1163)						if ((m1 != _gthis->readUpTo())) {
+HXLINE(1163)							return !(m->isIncoming());
+            						}
+            						else {
+HXLINE(1163)							return true;
+            						}
+HXDLIN(1163)						return false;
+            					}
+            					HX_END_LOCAL_FUNC1(return)
+
+HXLINE(1147)					_gthis->inSync = true;
+HXLINE(1148)					_gthis->sync = null();
+HXLINE(1149)					 ::snikket::ChatMessage lastFromSync = chatMessages->__get((chatMessages->length - 1)).StaticCast<  ::snikket::ChatMessage >();
+HXLINE(1150)					bool _hx_tmp2;
+HXDLIN(1150)					if (::hx::IsNotNull( lastFromSync )) {
+HXLINE(1150)						if (::hx::IsNotNull( _gthis->lastMessageTimestamp() )) {
+HXLINE(1150)							::String lastFromSync1 = lastFromSync->timestamp;
+HXDLIN(1150)							_hx_tmp2 = (::Reflect_obj::compare(lastFromSync1,_gthis->lastMessageTimestamp()) > 0);
+            						}
+            						else {
+HXLINE(1150)							_hx_tmp2 = true;
+            						}
+            					}
+            					else {
+HXLINE(1150)						_hx_tmp2 = false;
+            					}
+HXDLIN(1150)					if (_hx_tmp2) {
+HXLINE(1151)						_gthis->setLastMessage(lastFromSync);
+HXLINE(1152)						_gthis->client->sortChats();
+            					}
+HXLINE(1154)					 ::haxe::ds::StringMap serverIds =  ::haxe::ds::StringMap_obj::__alloc( HX_CTX );
+HXLINE(1155)					::Array< ::Dynamic> dedupedMessages = ::Array_obj< ::Dynamic>::__new(0);
+HXLINE(1156)					chatMessages->reverse();
+HXLINE(1157)					{
+HXLINE(1157)						int _g2 = 0;
+HXDLIN(1157)						while((_g2 < chatMessages->length)){
+HXLINE(1157)							 ::snikket::ChatMessage m = chatMessages->__get(_g2).StaticCast<  ::snikket::ChatMessage >();
+HXDLIN(1157)							_g2 = (_g2 + 1);
+HXLINE(1158)							 ::Dynamic tmp = serverIds->get(m->serverId);
+HXDLIN(1158)							bool _hx_tmp3;
+HXDLIN(1158)							if (::hx::IsNotNull( tmp )) {
+HXLINE(1158)								_hx_tmp3 = ( (bool)(tmp) );
+            							}
+            							else {
+HXLINE(1158)								_hx_tmp3 = false;
+            							}
+HXDLIN(1158)							if (!(_hx_tmp3)) {
+HXLINE(1159)								dedupedMessages->unshift(m);
+HXLINE(1160)								serverIds->set(m->serverId,true);
+            							}
+            						}
+            					}
+HXLINE(1163)					int readIndex = ::Lambda_obj::findIndex(dedupedMessages, ::Dynamic(new _hx_Closure_6(_gthis)));
+HXLINE(1164)					if ((readIndex < 0)) {
+HXLINE(1165)						 ::snikket::Channel _gthis1 = _gthis;
+HXDLIN(1165)						int _hx_tmp4 = _gthis->unreadCount();
+HXDLIN(1165)						_gthis1->setUnreadCount((_hx_tmp4 + dedupedMessages->length));
+            					}
+            					else {
+HXLINE(1167)						_gthis->setUnreadCount(((dedupedMessages->length - readIndex) - 1));
+            					}
+HXLINE(1169)					_gthis->client->trigger(HX_("chats/update",3d,8e,1d,14),::cpp::VirtualArray_obj::__new(1)->init(0,_gthis));
+            				}
+            			}
+            			HX_END_LOCAL_FUNC1((void))
+
+            			HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1109_doSync)
+HXLINE(1110)			::Array< ::Dynamic> promises = ::Array_obj< ::Dynamic>::__new(0);
+HXLINE(1111)			::Array< ::Dynamic> pageChatMessages = ::Array_obj< ::Dynamic>::__new(0);
+HXLINE(1112)			{
+HXLINE(1112)				int _g = 0;
+HXDLIN(1112)				::Array< ::Dynamic> _g1 = ( (::Array< ::Dynamic>)(messageList->__Field(HX_("messages",cc,d8,fd,34),::hx::paccDynamic)) );
+HXDLIN(1112)				while((_g < _g1->length)){
+HXLINE(1112)					 ::snikket::MessageStanza m = _g1->__get(_g).StaticCast<  ::snikket::MessageStanza >();
+HXDLIN(1112)					_g = (_g + 1);
+HXLINE(1113)					switch((int)(m->_hx_getIndex())){
+            						case (int)1: {
+HXLINE(1114)							 ::snikket::ChatMessage message = m->_hx_getObject(0).StaticCast<  ::snikket::ChatMessage >();
+HXDLIN(1114)							{
+HXLINE(1115)								{
+HXLINE(1115)									int _g2 = 0;
+HXDLIN(1115)									::Array< ::Dynamic> _g3 = message->inlineHashReferences();
+HXDLIN(1115)									while((_g2 < _g3->length)){
+HXLINE(1115)										 ::snikket::Hash hash = _g3->__get(_g2).StaticCast<  ::snikket::Hash >();
+HXDLIN(1115)										_g2 = (_g2 + 1);
+HXLINE(1116)										_gthis->client->fetchMediaByHash(::Array_obj< ::Dynamic>::__new(1)->init(0,hash),::Array_obj< ::Dynamic>::__new(1)->init(0,message->from));
+            									}
+            								}
+HXLINE(1118)								pageChatMessages->push(message);
+            							}
+            						}
+            						break;
+            						case (int)2: {
+            							HX_BEGIN_LOCAL_FUNC_S2(::hx::LocalFunc,_hx_Closure_2, ::snikket::Channel,_gthis, ::snikket::ModerationAction,action) HXARGC(2)
+            							void _hx_run( ::Dynamic resolve, ::Dynamic reject){
+            								HX_BEGIN_LOCAL_FUNC_S1(::hx::LocalFunc,_hx_Closure_1, ::Dynamic,resolve) HXARGC(1)
+            								void _hx_run( ::snikket::ChatMessage _){
+            									HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1125_doSync)
+HXLINE(1125)									resolve(null());
+            								}
+            								HX_END_LOCAL_FUNC1((void))
+
+            								HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1125_doSync)
+HXLINE(1125)								::thenshim::_Promise::Promise_Impl__obj::then(_gthis->client->moderateMessage(action), ::Dynamic(new _hx_Closure_1(resolve)),null());
+            							}
+            							HX_END_LOCAL_FUNC2((void))
+
+HXLINE(1123)							 ::snikket::ModerationAction action = m->_hx_getObject(0).StaticCast<  ::snikket::ModerationAction >();
+HXLINE(1124)							promises->push(::thenshim::_Promise::Promise_Impl__obj::_new( ::Dynamic(new _hx_Closure_2(_gthis,action))));
+            						}
+            						break;
+            						case (int)3: {
+            							HX_BEGIN_LOCAL_FUNC_S2(::hx::LocalFunc,_hx_Closure_4, ::snikket::Channel,_gthis, ::snikket::ReactionUpdate,update) HXARGC(2)
+            							void _hx_run( ::Dynamic resolve, ::Dynamic reject){
+            								HX_BEGIN_LOCAL_FUNC_S1(::hx::LocalFunc,_hx_Closure_3, ::Dynamic,resolve) HXARGC(1)
+            								void _hx_run( ::snikket::ChatMessage _){
+            									HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1121_doSync)
+HXLINE(1121)									resolve(null());
+            								}
+            								HX_END_LOCAL_FUNC1((void))
+
+            								HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1121_doSync)
+HXLINE(1121)								::Dynamic _gthis1 = _gthis->persistence;
+HXDLIN(1121)								::String _hx_tmp = _gthis->client->accountId();
+HXDLIN(1121)								::snikket::Persistence_obj::storeReaction(_gthis1,_hx_tmp,update, ::Dynamic(new _hx_Closure_3(resolve)));
+            							}
+            							HX_END_LOCAL_FUNC2((void))
+
+HXLINE(1119)							 ::snikket::ReactionUpdate update = m->_hx_getObject(0).StaticCast<  ::snikket::ReactionUpdate >();
+HXLINE(1120)							promises->push(::thenshim::_Promise::Promise_Impl__obj::_new( ::Dynamic(new _hx_Closure_4(_gthis,update))));
+            						}
+            						break;
+            						default:{
+            						}
+            					}
+            				}
+            			}
+HXLINE(1131)			promises->push(::thenshim::_Promise::Promise_Impl__obj::_new( ::Dynamic(new _hx_Closure_5(_gthis,pageChatMessages))));
+HXLINE(1134)			::thenshim::_Promise::Promise_Impl__obj::then(::thenshim::PromiseTools_obj::all(promises), ::Dynamic(new _hx_Closure_7(_gthis,chatMessages)),null());
+            		}
+            		HX_END_LOCAL_FUNC1((void))
+
+            		HX_BEGIN_LOCAL_FUNC_S2(::hx::LocalFunc,_hx_Closure_9, ::snikket::Channel,_gthis,::String,lastId) HXARGC(1)
+            		void _hx_run( ::snikket::Stanza stanza){
+            			HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1173_doSync)
+HXLINE(1174)			_gthis->sync = null();
+HXLINE(1175)			if (::hx::IsNotNull( lastId )) {
+HXLINE(1177)				_gthis->doSync(null());
+            			}
+            			else {
+HXLINE(1179)				::haxe::Log_obj::trace(HX_("SYNC failed",e2,ec,6f,fa), ::Dynamic(::hx::Anon_obj::Create(5)
+            					->setFixed(0,HX_("className",a3,92,3d,dc),HX_("snikket.Channel",b2,3f,68,db))
+            					->setFixed(1,HX_("customParams",d7,51,18,ed),::cpp::VirtualArray_obj::__new(2)->init(0,_gthis->chatId)->init(1,stanza))
+            					->setFixed(2,HX_("methodName",cc,19,0f,12),HX_("doSync",86,5f,63,1c))
+            					->setFixed(3,HX_("fileName",e7,5a,43,62),HX_("snikket/Chat.hx",f4,6b,61,18))
+            					->setFixed(4,HX_("lineNumber",dd,81,22,76),1179)));
+            			}
+            		}
+            		HX_END_LOCAL_FUNC1((void))
+
+            	HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1086_doSync)
+HXDLIN(1086)		 ::snikket::Channel _gthis = ::hx::ObjectPtr<OBJ_>(this);
+HXLINE(1087)		if (!(this->disco->features->contains(HX_("urn:xmpp:mam:2",f5,ef,8c,da)))) {
+HXLINE(1088)			this->inSync = true;
+HXLINE(1089)			return;
+            		}
+HXLINE(1091)		if (::hx::IsNotNull( this->sync )) {
+HXLINE(1091)			return;
+            		}
+HXLINE(1093)		::String threeDaysAgo = ::snikket::Date_obj::format(::Date_obj::fromTime((::Date_obj::now()->getTime() + ((Float)-259200000.))));
+HXLINE(1099)		 ::Dynamic _hx_tmp;
+HXDLIN(1099)		if (::hx::IsNull( lastId )) {
+HXLINE(1099)			_hx_tmp =  ::Dynamic(::hx::Anon_obj::Create(1)
+            				->setFixed(0,HX_("startTime",8f,45,f0,05),threeDaysAgo));
+            		}
+            		else {
+HXLINE(1099)			_hx_tmp =  ::Dynamic(::hx::Anon_obj::Create(1)
+            				->setFixed(0,HX_("page",4f,da,51,4a), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("after",1c,66,a2,1d),lastId))));
+            		}
+HXLINE(1096)		this->sync =  ::snikket::MessageSync_obj::__alloc( HX_CTX ,this->client,this->stream,_hx_tmp,this->chatId);
+HXLINE(1102)		this->sync->setNewestPageFirst(false);
+HXLINE(1103)		this->sync->addContext( ::Dynamic(new _hx_Closure_0(_gthis)));
+HXLINE(1108)		::Array< ::Dynamic> chatMessages = ::Array_obj< ::Dynamic>::__new(0);
+HXLINE(1109)		this->sync->onMessages( ::Dynamic(new _hx_Closure_8(_gthis,chatMessages)));
+HXLINE(1173)		this->sync->onError( ::Dynamic(new _hx_Closure_9(_gthis,lastId)));
+HXLINE(1182)		this->sync->fetchNext();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Channel_obj,doSync,(void))
+
+bool Channel_obj::isTrusted(){
+            	HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1186_isTrusted)
+HXDLIN(1186)		return (this->uiState != 2);
+            	}
+
+
+bool Channel_obj::isPrivate(){
+            	HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1190_isPrivate)
+HXDLIN(1190)		return this->disco->features->contains(HX_("muc_membersonly",41,e9,70,b7));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Channel_obj,isPrivate,return )
+
+void Channel_obj::refreshDisco( ::Dynamic callback){
+            		HX_BEGIN_LOCAL_FUNC_S3(::hx::LocalFunc,_hx_Closure_0, ::snikket::Channel,_gthis, ::snikket::queries::DiscoInfoGet,discoGet, ::Dynamic,callback) HXARGC(0)
+            		void _hx_run(){
+            			HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1196_refreshDisco)
+HXLINE(1197)			if (::hx::IsNotNull( discoGet->getResult() )) {
+HXLINE(1198)				bool setupNotifications;
+HXDLIN(1198)				if (::hx::IsNull( _gthis->disco )) {
+HXLINE(1198)					setupNotifications = ::hx::IsNull( _gthis->notificationSettings );
+            				}
+            				else {
+HXLINE(1198)					setupNotifications = false;
+            				}
+HXLINE(1199)				_gthis->disco = discoGet->getResult();
+HXLINE(1200)				bool _hx_tmp;
+HXDLIN(1200)				if (setupNotifications) {
+HXLINE(1200)					_hx_tmp = !(_gthis->isPrivate());
+            				}
+            				else {
+HXLINE(1200)					_hx_tmp = false;
+            				}
+HXDLIN(1200)				if (_hx_tmp) {
+HXLINE(1200)					_gthis->notificationSettings =  ::Dynamic(::hx::Anon_obj::Create(2)
+            						->setFixed(0,HX_("mention",ea,9e,bf,b9),true)
+            						->setFixed(1,HX_("reply",2a,09,c6,e6),false));
+            				}
+HXLINE(1201)				::Dynamic _gthis1 = _gthis->persistence;
+HXDLIN(1201)				::snikket::Persistence_obj::storeCaps(_gthis1,discoGet->getResult());
+HXLINE(1202)				::Dynamic _gthis2 = _gthis->persistence;
+HXDLIN(1202)				::String _hx_tmp1 = _gthis->client->accountId();
+HXDLIN(1202)				::snikket::Persistence_obj::storeChats(_gthis2,_hx_tmp1,::Array_obj< ::Dynamic>::__new(1)->init(0,_gthis));
+            			}
+HXLINE(1204)			if (::hx::IsNotNull( callback )) {
+HXLINE(1204)				callback();
+            			}
+            		}
+            		HX_END_LOCAL_FUNC0((void))
+
+            	HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1194_refreshDisco)
+HXDLIN(1194)		 ::snikket::Channel _gthis = ::hx::ObjectPtr<OBJ_>(this);
+HXLINE(1195)		 ::snikket::queries::DiscoInfoGet discoGet =  ::snikket::queries::DiscoInfoGet_obj::__alloc( HX_CTX ,this->chatId,null());
+HXLINE(1196)		discoGet->onFinished( ::Dynamic(new _hx_Closure_0(_gthis,discoGet,callback)));
+HXLINE(1206)		this->client->sendQuery(discoGet);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Channel_obj,refreshDisco,(void))
+
+::String Channel_obj::preview(){
+            	HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1209_preview)
+HXLINE(1210)		if (::hx::IsNull( this->lastMessage )) {
+HXLINE(1210)			return this->super::preview();
+            		}
+HXLINE(1212)		::String _hx_tmp = (this->getParticipantDetails(this->lastMessage->senderId)->displayName + HX_(": ",a6,32,00,00));
+HXDLIN(1212)		return (_hx_tmp + this->super::preview());
+            	}
+
+
+bool Channel_obj::livePresence(){
+            	HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1216_livePresence)
+HXLINE(1217)		if (this->forceLive) {
+HXLINE(1217)			return true;
+            		}
+HXLINE(1219)		return ::hx::IsNotNull( this->_nickInUse );
+            	}
+
+
+bool Channel_obj::syncing(){
+            	HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1223_syncing)
+HXDLIN(1223)		if (this->inSync) {
+HXDLIN(1223)			return !(this->livePresence());
+            		}
+            		else {
+HXDLIN(1223)			return true;
+            		}
+HXDLIN(1223)		return false;
+            	}
+
+
+bool Channel_obj::canAudioCall(){
+            	HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1227_canAudioCall)
+HXDLIN(1227)		 ::snikket::Caps tmp = this->disco;
+HXDLIN(1227)		::Array< ::String > tmp1;
+HXDLIN(1227)		if (::hx::IsNotNull( tmp )) {
+HXDLIN(1227)			tmp1 = tmp->features;
+            		}
+            		else {
+HXDLIN(1227)			tmp1 = null();
+            		}
+HXDLIN(1227)		 ::Dynamic tmp2;
+HXDLIN(1227)		if (::hx::IsNotNull( tmp1 )) {
+HXDLIN(1227)			tmp2 = tmp1->contains(HX_("urn:xmpp:jingle:apps:rtp:audio",0f,8b,54,6c));
+            		}
+            		else {
+HXDLIN(1227)			tmp2 = null();
+            		}
+HXDLIN(1227)		if (::hx::IsNotNull( tmp2 )) {
+HXDLIN(1227)			return ( (bool)(tmp2) );
+            		}
+            		else {
+HXDLIN(1227)			return false;
+            		}
+HXDLIN(1227)		return false;
+            	}
+
+
+bool Channel_obj::canVideoCall(){
+            	HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1231_canVideoCall)
+HXDLIN(1231)		 ::snikket::Caps tmp = this->disco;
+HXDLIN(1231)		::Array< ::String > tmp1;
+HXDLIN(1231)		if (::hx::IsNotNull( tmp )) {
+HXDLIN(1231)			tmp1 = tmp->features;
+            		}
+            		else {
+HXDLIN(1231)			tmp1 = null();
+            		}
+HXDLIN(1231)		 ::Dynamic tmp2;
+HXDLIN(1231)		if (::hx::IsNotNull( tmp1 )) {
+HXDLIN(1231)			tmp2 = tmp1->contains(HX_("urn:xmpp:jingle:apps:rtp:video",b4,26,d0,7b));
+            		}
+            		else {
+HXDLIN(1231)			tmp2 = null();
+            		}
+HXDLIN(1231)		if (::hx::IsNotNull( tmp2 )) {
+HXDLIN(1231)			return ( (bool)(tmp2) );
+            		}
+            		else {
+HXDLIN(1231)			return false;
+            		}
+HXDLIN(1231)		return false;
+            	}
+
+
+::String Channel_obj::nickInUse(){
+            	HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1235_nickInUse)
+HXDLIN(1235)		::String tmp = this->_nickInUse;
+HXDLIN(1235)		if (::hx::IsNotNull( tmp )) {
+HXDLIN(1235)			return tmp;
+            		}
+            		else {
+HXDLIN(1235)			return this->client->displayName();
+            		}
+HXDLIN(1235)		return null();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Channel_obj,nickInUse,return )
+
+ ::snikket::JID Channel_obj::getFullJid(){
+            	HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1239_getFullJid)
+HXDLIN(1239)		 ::snikket::JID _hx_tmp = ::snikket::JID_obj::parse(this->chatId);
+HXDLIN(1239)		return _hx_tmp->withResource(this->nickInUse());
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Channel_obj,getFullJid,return )
+
+::Array< ::String > Channel_obj::getParticipants(){
+            		HX_BEGIN_LOCAL_FUNC_S1(::hx::LocalFunc,_hx_Closure_0, ::snikket::Channel,_gthis) HXARGC(0)
+            		 ::Dynamic _hx_run(){
+            			HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1245_getParticipants)
+HXLINE(1245)			return _gthis->presence->keys();
+            		}
+            		HX_END_LOCAL_FUNC0(return)
+
+            		HX_BEGIN_LOCAL_FUNC_S0(::hx::LocalFunc,_hx_Closure_1) HXARGC(1)
+            		bool _hx_run(::String resource){
+            			HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1245_getParticipants)
+HXLINE(1245)			return ::hx::IsNotNull( resource );
+            		}
+            		HX_END_LOCAL_FUNC1(return)
+
+            	HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1243_getParticipants)
+HXDLIN(1243)		 ::snikket::Channel _gthis = ::hx::ObjectPtr<OBJ_>(this);
+HXLINE(1244)		 ::snikket::JID jid = ::snikket::JID_obj::parse(this->chatId);
+HXLINE(1245)		::Array< ::String > _this = ::Lambda_obj::filter( ::Dynamic(::hx::Anon_obj::Create(1)
+            			->setFixed(0,HX_("iterator",ee,49,9a,93), ::Dynamic(new _hx_Closure_0(_gthis)))), ::Dynamic(new _hx_Closure_1()));
+HXDLIN(1245)		::Array< ::String > result = ::Array_obj< ::String >::__new(_this->length);
+HXDLIN(1245)		{
+HXLINE(1245)			int _g = 0;
+HXDLIN(1245)			int _g1 = _this->length;
+HXDLIN(1245)			while((_g < _g1)){
+HXLINE(1245)				_g = (_g + 1);
+HXDLIN(1245)				int i = (_g - 1);
+HXDLIN(1245)				{
+HXLINE(1245)					::String resource = ( (::String)(_hx_array_unsafe_get(_this,i)) );
+HXDLIN(1245)					::String inValue =  ::snikket::JID_obj::__alloc( HX_CTX ,jid->node,jid->domain,resource)->asString();
+HXDLIN(1245)					result->__unsafe_set(i,inValue);
+            				}
+            			}
+            		}
+HXDLIN(1245)		return result;
+            	}
+
+
+ ::snikket::Participant Channel_obj::getParticipantDetails(::String participantId){
+            	HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1250_getParticipantDetails)
+HXDLIN(1250)		if ((participantId == this->getFullJid()->asString())) {
+HXLINE(1251)			 ::snikket::Client chat = this->client;
+HXDLIN(1251)			 ::snikket::DirectChat chat1 = chat->getDirectChat(this->client->accountId(),false);
+HXLINE(1252)			::String _hx_tmp = this->client->displayName();
+HXDLIN(1252)			::String _hx_tmp1 = chat1->getPhoto();
+HXDLIN(1252)			return  ::snikket::Participant_obj::__alloc( HX_CTX ,_hx_tmp,_hx_tmp1,chat1->getPlaceholder(),true);
+            		}
+            		else {
+HXLINE(1254)			::String nick = ::snikket::JID_obj::parse(participantId)->resource;
+HXLINE(1255)			::String placeholderUri;
+HXDLIN(1255)			if (::hx::IsNull( nick )) {
+HXLINE(1255)				placeholderUri = HX_(" ",20,00,00,00);
+            			}
+            			else {
+HXLINE(1255)				placeholderUri = nick.charAt(0);
+            			}
+HXDLIN(1255)			::String placeholderUri1 = ::snikket::Color_obj::defaultPhoto(participantId,placeholderUri);
+HXLINE(1256)			return  ::snikket::Participant_obj::__alloc( HX_CTX ,nick,null(),placeholderUri1,false);
+            		}
+HXLINE(1250)		return null();
+            	}
+
+
+void Channel_obj::getMessagesBefore(::String beforeId,::String beforeTime, ::Dynamic handler){
+            		HX_BEGIN_LOCAL_FUNC_S3(::hx::LocalFunc,_hx_Closure_1, ::snikket::Channel,_gthis,::String,beforeId, ::Dynamic,handler) HXARGC(1)
+            		void _hx_run(::Array< ::Dynamic> messages){
+            			HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1263_getMessagesBefore)
+HXLINE(1263)			if ((messages->length > 0)) {
+HXLINE(1264)				handler(messages);
+            			}
+            			else {
+            				HX_BEGIN_LOCAL_FUNC_S1(::hx::LocalFunc,_hx_Closure_0, ::snikket::Channel,_gthis) HXARGC(2)
+            				 ::snikket::ChatMessageBuilder _hx_run( ::snikket::ChatMessageBuilder builder, ::snikket::Stanza stanza){
+            					HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1269_getMessagesBefore)
+HXLINE(1270)					builder = _gthis->prepareIncomingMessage(builder,stanza);
+HXLINE(1271)					builder->syncPoint = false;
+HXLINE(1272)					return builder;
+            				}
+            				HX_END_LOCAL_FUNC2(return)
+
+HXLINE(1266)				 ::Dynamic filter =  ::Dynamic(::hx::Anon_obj::Create(0));
+HXLINE(1267)				if (::hx::IsNotNull( beforeId )) {
+HXLINE(1267)					filter->__SetField(HX_("page",4f,da,51,4a), ::Dynamic(::hx::Anon_obj::Create(1)
+            						->setFixed(0,HX_("before",7f,54,32,9a),beforeId)),::hx::paccDynamic);
+            				}
+HXLINE(1268)				 ::snikket::MessageSync sync =  ::snikket::MessageSync_obj::__alloc( HX_CTX ,_gthis->client,_gthis->stream,filter,_gthis->chatId);
+HXLINE(1269)				sync->addContext( ::Dynamic(new _hx_Closure_0(_gthis)));
+HXLINE(1274)				_gthis->fetchFromSync(sync,handler);
+            			}
+            		}
+            		HX_END_LOCAL_FUNC1((void))
+
+            	HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1261_getMessagesBefore)
+HXDLIN(1261)		 ::snikket::Channel _gthis = ::hx::ObjectPtr<OBJ_>(this);
+HXLINE(1262)		::Dynamic _hx_tmp = this->persistence;
+HXDLIN(1262)		::String _hx_tmp1 = this->client->accountId();
+HXDLIN(1262)		::snikket::Persistence_obj::getMessagesBefore(_hx_tmp,_hx_tmp1,this->chatId,beforeId,beforeTime, ::Dynamic(new _hx_Closure_1(_gthis,beforeId,handler)));
+            	}
+
+
+void Channel_obj::getMessagesAfter(::String afterId,::String afterTime, ::Dynamic handler){
+            		HX_BEGIN_LOCAL_FUNC_S3(::hx::LocalFunc,_hx_Closure_1, ::snikket::Channel,_gthis,::String,afterId, ::Dynamic,handler) HXARGC(1)
+            		void _hx_run(::Array< ::Dynamic> messages){
+            			HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1286_getMessagesAfter)
+HXLINE(1286)			if ((messages->length > 0)) {
+HXLINE(1287)				handler(messages);
+            			}
+            			else {
+            				HX_BEGIN_LOCAL_FUNC_S1(::hx::LocalFunc,_hx_Closure_0, ::snikket::Channel,_gthis) HXARGC(2)
+            				 ::snikket::ChatMessageBuilder _hx_run( ::snikket::ChatMessageBuilder builder, ::snikket::Stanza stanza){
+            					HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1292_getMessagesAfter)
+HXLINE(1293)					builder = _gthis->prepareIncomingMessage(builder,stanza);
+HXLINE(1294)					builder->syncPoint = false;
+HXLINE(1295)					return builder;
+            				}
+            				HX_END_LOCAL_FUNC2(return)
+
+HXLINE(1289)				 ::Dynamic filter =  ::Dynamic(::hx::Anon_obj::Create(0));
+HXLINE(1290)				if (::hx::IsNotNull( afterId )) {
+HXLINE(1290)					filter->__SetField(HX_("page",4f,da,51,4a), ::Dynamic(::hx::Anon_obj::Create(1)
+            						->setFixed(0,HX_("after",1c,66,a2,1d),afterId)),::hx::paccDynamic);
+            				}
+HXLINE(1291)				 ::snikket::MessageSync sync =  ::snikket::MessageSync_obj::__alloc( HX_CTX ,_gthis->client,_gthis->stream,filter,_gthis->chatId);
+HXLINE(1292)				sync->addContext( ::Dynamic(new _hx_Closure_0(_gthis)));
+HXLINE(1297)				_gthis->fetchFromSync(sync,handler);
+            			}
+            		}
+            		HX_END_LOCAL_FUNC1((void))
+
+            	HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1280_getMessagesAfter)
+HXDLIN(1280)		 ::snikket::Channel _gthis = ::hx::ObjectPtr<OBJ_>(this);
+HXLINE(1281)		bool _hx_tmp;
+HXDLIN(1281)		::String afterId1 = afterId;
+HXDLIN(1281)		if ((afterId1 == this->lastMessageId())) {
+HXLINE(1281)			_hx_tmp = !(this->syncing());
+            		}
+            		else {
+HXLINE(1281)			_hx_tmp = false;
+            		}
+HXDLIN(1281)		if (_hx_tmp) {
+HXLINE(1282)			handler(::Array_obj< ::Dynamic>::__new(0));
+HXLINE(1283)			return;
+            		}
+HXLINE(1285)		::Dynamic _hx_tmp1 = this->persistence;
+HXDLIN(1285)		::String _hx_tmp2 = this->client->accountId();
+HXDLIN(1285)		::snikket::Persistence_obj::getMessagesAfter(_hx_tmp1,_hx_tmp2,this->chatId,afterId,afterTime, ::Dynamic(new _hx_Closure_1(_gthis,afterId,handler)));
+            	}
+
+
+void Channel_obj::getMessagesAround(::String aroundId,::String aroundTime, ::Dynamic handler){
+            		HX_BEGIN_LOCAL_FUNC_S1(::hx::LocalFunc,_hx_Closure_0, ::Dynamic,handler) HXARGC(1)
+            		void _hx_run(::Array< ::Dynamic> messages){
+            			HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1305_getMessagesAround)
+HXLINE(1305)			if ((messages->length > 0)) {
+HXLINE(1306)				handler(messages);
+            			}
+            			else {
+HXLINE(1309)				handler(::Array_obj< ::Dynamic>::__new(0));
+            			}
+            		}
+            		HX_END_LOCAL_FUNC1((void))
+
+            	HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1304_getMessagesAround)
+HXDLIN(1304)		::Dynamic _hx_tmp = this->persistence;
+HXDLIN(1304)		::String _hx_tmp1 = this->client->accountId();
+HXDLIN(1304)		::snikket::Persistence_obj::getMessagesAround(_hx_tmp,_hx_tmp1,this->chatId,aroundId,aroundTime, ::Dynamic(new _hx_Closure_0(handler)));
+            	}
+
+
+ ::snikket::ChatMessageBuilder Channel_obj::prepareIncomingMessage( ::snikket::ChatMessageBuilder message, ::snikket::Stanza stanza){
+            	HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1315_prepareIncomingMessage)
+HXLINE(1316)		message->syncPoint = !(this->syncing());
+HXLINE(1317)		if ((message->type == 0)) {
+HXLINE(1317)			message->type = 3;
+            		}
+HXLINE(1318)		message->senderId = ( (::String)(::Reflect_obj::field(stanza->attr,HX_("from",6a,a5,c2,43))) );
+HXLINE(1319)		::String _hx_tmp = message->get_senderId();
+HXDLIN(1319)		if ((_hx_tmp == this->getFullJid()->asString())) {
+HXLINE(1320)			message->recipients = message->replyTo;
+HXLINE(1321)			message->direction = 1;
+            		}
+HXLINE(1323)		return message;
+            	}
+
+
+ ::snikket::ChatMessageBuilder Channel_obj::prepareOutgoingMessage( ::snikket::ChatMessageBuilder message){
+            	HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1326_prepareOutgoingMessage)
+HXLINE(1327)		message->type = 2;
+HXLINE(1328)		::String tmp = message->timestamp;
+HXDLIN(1328)		::String _hx_tmp;
+HXDLIN(1328)		if (::hx::IsNotNull( tmp )) {
+HXLINE(1328)			_hx_tmp = tmp;
+            		}
+            		else {
+HXLINE(1328)			_hx_tmp = ::snikket::Date_obj::format(::Date_obj::now());
+            		}
+HXDLIN(1328)		message->timestamp = _hx_tmp;
+HXLINE(1329)		message->direction = 1;
+HXLINE(1330)		message->from = this->client->jid;
+HXLINE(1331)		message->sender = this->getFullJid();
+HXLINE(1332)		message->replyTo = ::Array_obj< ::Dynamic>::__new(1)->init(0,message->sender);
+HXLINE(1333)		message->to = ::snikket::JID_obj::parse(this->chatId);
+HXLINE(1334)		message->recipients = ::Array_obj< ::Dynamic>::__new(1)->init(0,message->to);
+HXLINE(1335)		return message;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Channel_obj,prepareOutgoingMessage,return )
+
+void Channel_obj::correctMessage(::String localId, ::snikket::ChatMessageBuilder message){
+            		HX_BEGIN_LOCAL_FUNC_S4(::hx::LocalFunc,_hx_Closure_0, ::snikket::Channel,_gthis,::Array< ::Dynamic>,message1,::String,localId,::String,toSendId) HXARGC(1)
+            		void _hx_run(::Array< ::Dynamic> corrected){
+            			HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1344_correctMessage)
+HXLINE(1345)			::Array< ::Dynamic> _hx_tmp;
+HXDLIN(1345)			if ((corrected->__get(0).StaticCast<  ::snikket::ChatMessage >()->localId == localId)) {
+HXLINE(1345)				_hx_tmp = corrected->__get(0).StaticCast<  ::snikket::ChatMessage >()->versions;
+            			}
+            			else {
+HXLINE(1345)				_hx_tmp = ::Array_obj< ::Dynamic>::__new(1)->init(0,message1->__get(0).StaticCast<  ::snikket::ChatMessageBuilder >()->build());
+            			}
+HXDLIN(1345)			message1->__get(0).StaticCast<  ::snikket::ChatMessageBuilder >()->versions = _hx_tmp;
+HXLINE(1346)			message1->__get(0).StaticCast<  ::snikket::ChatMessageBuilder >()->localId = toSendId;
+HXLINE(1347)			 ::snikket::Client _gthis1 = _gthis->client;
+HXDLIN(1347)			_gthis1->sendStanza(message1->__get(0).StaticCast<  ::snikket::ChatMessageBuilder >()->build()->asStanza());
+HXLINE(1348)			_gthis->client->notifyMessageHandlers(corrected->__get(0).StaticCast<  ::snikket::ChatMessage >(),1);
+HXLINE(1349)			 ::snikket::ChatMessage tmp = _gthis->lastMessage;
+HXDLIN(1349)			::String _hx_tmp1;
+HXDLIN(1349)			if (::hx::IsNotNull( tmp )) {
+HXLINE(1349)				_hx_tmp1 = tmp->localId;
+            			}
+            			else {
+HXLINE(1349)				_hx_tmp1 = null();
+            			}
+HXDLIN(1349)			if ((localId == _hx_tmp1)) {
+HXLINE(1350)				_gthis->setLastMessage(corrected->__get(0).StaticCast<  ::snikket::ChatMessage >());
+HXLINE(1351)				_gthis->client->trigger(HX_("chats/update",3d,8e,1d,14),::cpp::VirtualArray_obj::__new(1)->init(0,_gthis));
+            			}
+            		}
+            		HX_END_LOCAL_FUNC1((void))
+
+            	HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1339_correctMessage)
+HXDLIN(1339)		::Array< ::Dynamic> message1 = ::Array_obj< ::Dynamic>::__new(1)->init(0,message);
+HXDLIN(1339)		 ::snikket::Channel _gthis = ::hx::ObjectPtr<OBJ_>(this);
+HXLINE(1340)		::String toSendId = message1->__get(0).StaticCast<  ::snikket::ChatMessageBuilder >()->localId;
+HXLINE(1341)		message1[0] = this->prepareOutgoingMessage(message1->__get(0).StaticCast<  ::snikket::ChatMessageBuilder >());
+HXLINE(1342)		 ::snikket::ChatMessage _hx_tmp = message1->__get(0).StaticCast<  ::snikket::ChatMessageBuilder >()->build();
+HXDLIN(1342)		message1->__get(0).StaticCast<  ::snikket::ChatMessageBuilder >()->versions = ::Array_obj< ::Dynamic>::__new(1)->init(0,_hx_tmp);
+HXLINE(1343)		message1->__get(0).StaticCast<  ::snikket::ChatMessageBuilder >()->localId = localId;
+HXLINE(1344)		 ::snikket::Client _hx_tmp1 = this->client;
+HXDLIN(1344)		_hx_tmp1->storeMessages(::Array_obj< ::Dynamic>::__new(1)->init(0,message1->__get(0).StaticCast<  ::snikket::ChatMessageBuilder >()->build()), ::Dynamic(new _hx_Closure_0(_gthis,message1,localId,toSendId)));
+            	}
+
+
+void Channel_obj::sendMessage( ::snikket::ChatMessageBuilder message){
+            	HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1357_sendMessage)
+HXDLIN(1357)		 ::snikket::Channel _gthis = ::hx::ObjectPtr<OBJ_>(this);
+HXLINE(1358)		if (::hx::IsNotNull( this->typingTimer )) {
+HXLINE(1358)			this->typingTimer->stop();
+            		}
+HXLINE(1359)		this->client->chatActivity(::hx::ObjectPtr<OBJ_>(this),null());
+HXLINE(1360)		message = this->prepareOutgoingMessage(message);
+HXLINE(1361)		 ::snikket::Stanza stanza = message->build()->asStanza();
+HXLINE(1363)		{
+HXLINE(1363)			 ::Dynamic this1 = stanza->attr;
+HXDLIN(1363)			::String value = this->getFullJid()->asString();
+HXDLIN(1363)			::Reflect_obj::setField(this1,HX_("from",6a,a5,c2,43),value);
+            		}
+HXLINE(1364)		 ::snikket::MessageStanza fromStanza = ::snikket::Message_obj::fromStanza(stanza,this->client->jid,null())->parsed;
+HXLINE(1365)		{
+HXLINE(1365)			 ::Dynamic this2 = stanza->attr;
+HXDLIN(1365)			::String value1 = this->client->jid->asString();
+HXDLIN(1365)			::Reflect_obj::setField(this2,HX_("from",6a,a5,c2,43),value1);
+            		}
+HXLINE(1366)		switch((int)(fromStanza->_hx_getIndex())){
+            			case (int)1: {
+HXLINE(1367)				 ::snikket::ChatMessage _g = fromStanza->_hx_getObject(0).StaticCast<  ::snikket::ChatMessage >();
+HXDLIN(1367)				{
+            					HX_BEGIN_LOCAL_FUNC_S2(::hx::LocalFunc,_hx_Closure_0, ::snikket::Channel,_gthis, ::snikket::Stanza,stanza) HXARGC(1)
+            					void _hx_run(::Array< ::Dynamic> stored){
+            						HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1373_sendMessage)
+HXLINE(1374)						_gthis->client->sendStanza(stanza);
+HXLINE(1375)						_gthis->setLastMessage(stored->__get(0).StaticCast<  ::snikket::ChatMessage >());
+HXLINE(1376)						int _hx_tmp;
+HXDLIN(1376)						if ((stored->__get(0).StaticCast<  ::snikket::ChatMessage >()->versions->length > 1)) {
+HXLINE(1376)							_hx_tmp = 1;
+            						}
+            						else {
+HXLINE(1376)							_hx_tmp = 0;
+            						}
+HXDLIN(1376)						_gthis->client->notifyMessageHandlers(stored->__get(0).StaticCast<  ::snikket::ChatMessage >(),_hx_tmp);
+HXLINE(1377)						_gthis->client->trigger(HX_("chats/update",3d,8e,1d,14),::cpp::VirtualArray_obj::__new(1)->init(0,_gthis));
+            					}
+            					HX_END_LOCAL_FUNC1((void))
+
+HXLINE(1368)					if (::hx::IsNotNull( this->isActive )) {
+HXLINE(1369)						this->isActive = true;
+HXLINE(1370)						this->activeThread = message->threadId;
+HXLINE(1371)						stanza->tag(HX_("active",c6,41,46,16), ::Dynamic(::hx::Anon_obj::Create(1)
+            							->setFixed(0,HX_("xmlns",dc,31,74,60),HX_("http://jabber.org/protocol/chatstates",8e,6d,41,6d))))->up();
+            					}
+HXLINE(1373)					 ::snikket::Client _hx_tmp = this->client;
+HXDLIN(1373)					_hx_tmp->storeMessages(::Array_obj< ::Dynamic>::__new(1)->init(0,message->build()), ::Dynamic(new _hx_Closure_0(_gthis,stanza)));
+            				}
+            			}
+            			break;
+            			case (int)3: {
+            				HX_BEGIN_LOCAL_FUNC_S2(::hx::LocalFunc,_hx_Closure_1, ::snikket::Channel,_gthis, ::snikket::Stanza,stanza) HXARGC(1)
+            				void _hx_run( ::snikket::ChatMessage stored){
+            					HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1380_sendMessage)
+HXLINE(1381)					_gthis->client->sendStanza(stanza);
+HXLINE(1382)					if (::hx::IsNotNull( stored )) {
+HXLINE(1382)						_gthis->client->notifyMessageHandlers(stored,2);
+            					}
+            				}
+            				HX_END_LOCAL_FUNC1((void))
+
+HXLINE(1379)				 ::snikket::ReactionUpdate update = fromStanza->_hx_getObject(0).StaticCast<  ::snikket::ReactionUpdate >();
+HXLINE(1380)				::Dynamic _hx_tmp1 = this->persistence;
+HXDLIN(1380)				::snikket::Persistence_obj::storeReaction(_hx_tmp1,this->client->accountId(),update, ::Dynamic(new _hx_Closure_1(_gthis,stanza)));
+            			}
+            			break;
+            			default:{
+HXLINE(1385)				::haxe::Log_obj::trace(HX_("Invalid message",7e,ab,89,95), ::Dynamic(::hx::Anon_obj::Create(5)
+            					->setFixed(0,HX_("className",a3,92,3d,dc),HX_("snikket.Channel",b2,3f,68,db))
+            					->setFixed(1,HX_("customParams",d7,51,18,ed),::cpp::VirtualArray_obj::__new(1)->init(0,fromStanza))
+            					->setFixed(2,HX_("methodName",cc,19,0f,12),HX_("sendMessage",5f,89,1d,24))
+            					->setFixed(3,HX_("fileName",e7,5a,43,62),HX_("snikket/Chat.hx",f4,6b,61,18))
+            					->setFixed(4,HX_("lineNumber",dd,81,22,76),1385)));
+HXLINE(1386)				HX_STACK_DO_THROW(HX_("Trying to send invalid message.",dc,74,a0,91));
+            			}
+            		}
+            	}
+
+
+void Channel_obj::removeReaction( ::snikket::ChatMessage m, ::snikket::Reaction reaction){
+            		HX_BEGIN_LOCAL_FUNC_S2(::hx::LocalFunc,_hx_Closure_1, ::snikket::Channel,_gthis, ::snikket::ReactionUpdate,update4) HXARGC(1)
+            		void _hx_run( ::snikket::ChatMessage stored){
+            			HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1411_removeReaction)
+HXLINE(1412)			 ::snikket::Stanza stanza = update4->asStanza();
+HXLINE(1413)			{
+HXLINE(1413)				::String value = _gthis->chatId;
+HXDLIN(1413)				::Reflect_obj::setField(stanza->attr,HX_("to",7b,65,00,00),value);
+            			}
+HXLINE(1414)			_gthis->client->sendStanza(stanza);
+HXLINE(1415)			if (::hx::IsNotNull( stored )) {
+HXLINE(1415)				_gthis->client->notifyMessageHandlers(stored,2);
+            			}
+            		}
+            		HX_END_LOCAL_FUNC1((void))
+
+            	HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1391_removeReaction)
+HXDLIN(1391)		 ::snikket::Channel _gthis = ::hx::ObjectPtr<OBJ_>(this);
+HXLINE(1392)		if (::Std_obj::isOfType(reaction,::hx::ClassOf< ::snikket::CustomEmojiReaction >())) {
+HXLINE(1393)			if (::hx::IsNull( reaction->envelopeId )) {
+HXLINE(1393)				HX_STACK_DO_THROW(HX_("Cannot remove custom emoji reaction without envelopeId",90,e6,80,fb));
+            			}
+HXLINE(1394)			 ::snikket::ChatMessageBuilder correct = m->reply();
+HXLINE(1395)			correct->localId = ::snikket::ID_obj::_hx_long();
+HXLINE(1396)			correct->setHtml(HX_("",00,00,00,00));
+HXLINE(1397)			correct->text = null();
+HXLINE(1398)			this->correctMessage(reaction->envelopeId,correct);
+HXLINE(1399)			return;
+            		}
+HXLINE(1403)		::Array< ::Dynamic> reactions = ::Array_obj< ::Dynamic>::__new(0);
+HXLINE(1404)		{
+HXLINE(1404)			::Dynamic map = m->reactions;
+HXDLIN(1404)			::Dynamic _g_map = map;
+HXDLIN(1404)			 ::Dynamic _g_keys = ::haxe::IMap_obj::keys(map);
+HXDLIN(1404)			while(( (bool)(_g_keys->__Field(HX_("hasNext",6d,a5,46,18),::hx::paccDynamic)()) )){
+HXLINE(1404)				::String key = ( (::String)(_g_keys->__Field(HX_("next",f3,84,02,49),::hx::paccDynamic)()) );
+HXDLIN(1404)				::Array< ::Dynamic> _g_value = ( (::Array< ::Dynamic>)(::haxe::IMap_obj::get(_g_map,key)) );
+HXDLIN(1404)				::String _g_key = key;
+HXDLIN(1404)				::String areaction = _g_key;
+HXDLIN(1404)				::Array< ::Dynamic> reacts = _g_value;
+HXLINE(1405)				if ((areaction != reaction->key)) {
+            					HX_BEGIN_LOCAL_FUNC_S1(::hx::LocalFunc,_hx_Closure_0, ::snikket::Channel,_gthis) HXARGC(1)
+            					bool _hx_run( ::snikket::Reaction r){
+            						HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1406_removeReaction)
+HXLINE(1406)						::String r1 = r->senderId;
+HXDLIN(1406)						return (r1 == _gthis->getFullJid()->asString());
+            					}
+            					HX_END_LOCAL_FUNC1(return)
+
+HXLINE(1406)					 ::snikket::Reaction react = ( ( ::snikket::Reaction)(::Lambda_obj::find(reacts, ::Dynamic(new _hx_Closure_0(_gthis)))) );
+HXLINE(1407)					bool _hx_tmp;
+HXDLIN(1407)					if (::hx::IsNotNull( react )) {
+HXLINE(1407)						_hx_tmp = !(::Std_obj::isOfType(react,::hx::ClassOf< ::snikket::CustomEmojiReaction >()));
+            					}
+            					else {
+HXLINE(1407)						_hx_tmp = false;
+            					}
+HXDLIN(1407)					if (_hx_tmp) {
+HXLINE(1407)						reactions->push(react);
+            					}
+            				}
+            			}
+            		}
+HXLINE(1410)		::String update = ::snikket::ID_obj::_hx_long();
+HXDLIN(1410)		::String m1 = m->serverId;
+HXDLIN(1410)		::String update1 = m->chatId();
+HXDLIN(1410)		::String update2 = m->chatId();
+HXDLIN(1410)		::String update3 = this->getFullJid()->asString();
+HXDLIN(1410)		 ::snikket::ReactionUpdate update4 =  ::snikket::ReactionUpdate_obj::__alloc( HX_CTX ,update,m1,update1,null(),update2,update3,::snikket::Date_obj::format(::Date_obj::now()),reactions,0);
+HXLINE(1411)		::Dynamic _hx_tmp1 = this->persistence;
+HXDLIN(1411)		::String _hx_tmp2 = this->client->accountId();
+HXDLIN(1411)		::snikket::Persistence_obj::storeReaction(_hx_tmp1,_hx_tmp2,update4, ::Dynamic(new _hx_Closure_1(_gthis,update4)));
+            	}
+
+
+::String Channel_obj::lastMessageId(){
+            	HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1421_lastMessageId)
+HXDLIN(1421)		 ::snikket::ChatMessage tmp = this->lastMessage;
+HXDLIN(1421)		if (::hx::IsNotNull( tmp )) {
+HXDLIN(1421)			return tmp->serverId;
+            		}
+            		else {
+HXDLIN(1421)			return null();
+            		}
+HXDLIN(1421)		return null();
+            	}
+
+
+void Channel_obj::markReadUpTo( ::snikket::ChatMessage message){
+            		HX_BEGIN_LOCAL_FUNC_S2(::hx::LocalFunc,_hx_Closure_0, ::snikket::ChatMessage,message, ::snikket::Channel,_gthis) HXARGC(0)
+            		void _hx_run(){
+            			HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1426_markReadUpTo)
+HXLINE(1427)			::String _gthis1 = _gthis->chatId;
+HXDLIN(1427)			::String stanza = ::snikket::ID_obj::_hx_long();
+HXDLIN(1427)			 ::snikket::Stanza stanza1 =  ::snikket::Stanza_obj::__alloc( HX_CTX ,HX_("message",c7,35,11,9a), ::Dynamic(::hx::Anon_obj::Create(3)
+            				->setFixed(0,HX_("id",db,5b,00,00),stanza)
+            				->setFixed(1,HX_("to",7b,65,00,00),_gthis1)
+            				->setFixed(2,HX_("type",ba,f2,08,4d),HX_("groupchat",97,1d,c8,e5))))->tag(HX_("displayed",21,17,db,c1), ::Dynamic(::hx::Anon_obj::Create(2)
+            				->setFixed(0,HX_("id",db,5b,00,00),message->serverId)
+            				->setFixed(1,HX_("xmlns",dc,31,74,60),HX_("urn:xmpp:chat-markers:0",96,b8,66,e7))))->up();
+HXLINE(1429)			if (::hx::IsNotNull( message->threadId )) {
+HXLINE(1430)				stanza1->textTag(HX_("thread",ca,7a,b9,8e),message->threadId,null());
+            			}
+HXLINE(1432)			_gthis->client->sendStanza(stanza1);
+HXLINE(1434)			_gthis->publishMds();
+HXLINE(1435)			_gthis->client->trigger(HX_("chats/update",3d,8e,1d,14),::cpp::VirtualArray_obj::__new(1)->init(0,_gthis));
+            		}
+            		HX_END_LOCAL_FUNC0((void))
+
+            	HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1425_markReadUpTo)
+HXDLIN(1425)		 ::snikket::Channel _gthis = ::hx::ObjectPtr<OBJ_>(this);
+HXLINE(1426)		this->markReadUpToMessage(message, ::Dynamic(new _hx_Closure_0(message,_gthis)));
+            	}
+
+
+void Channel_obj::bookmark(){
+            		HX_BEGIN_LOCAL_FUNC_S1(::hx::LocalFunc,_hx_Closure_1, ::snikket::Channel,_gthis) HXARGC(1)
+            		void _hx_run( ::snikket::Stanza response){
+            			HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1461_bookmark)
+HXLINE(1461)			if ((( (::String)(::Reflect_obj::field(response->attr,HX_("type",ba,f2,08,4d))) ) == HX_("error",c8,cb,29,73))) {
+HXLINE(1462)				 ::snikket::Stanza tmp = response->getChild(HX_("error",c8,cb,29,73),null());
+HXDLIN(1462)				 ::snikket::Stanza preconditionError;
+HXDLIN(1462)				if (::hx::IsNotNull( tmp )) {
+HXLINE(1462)					preconditionError = tmp->getChild(HX_("precondition-not-met",2d,db,78,db),HX_("http://jabber.org/protocol/pubsub#errors",97,74,3a,a8));
+            				}
+            				else {
+HXLINE(1462)					preconditionError = null();
+            				}
+HXLINE(1463)				if (::hx::IsNotNull( preconditionError )) {
+            					HX_BEGIN_LOCAL_FUNC_S1(::hx::LocalFunc,_hx_Closure_0, ::snikket::Channel,_gthis) HXARGC(1)
+            					void _hx_run( ::snikket::Stanza response){
+            						HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1479_bookmark)
+HXLINE(1479)						if ((( (::String)(::Reflect_obj::field(response->attr,HX_("type",ba,f2,08,4d))) ) == HX_("result",dd,68,84,08))) {
+HXLINE(1480)							_gthis->bookmark();
+            						}
+            					}
+            					HX_END_LOCAL_FUNC1((void))
+
+HXLINE(1465)					 ::snikket::GenericStream _gthis1 = _gthis->stream;
+HXDLIN(1465)					_gthis1->sendIq( ::snikket::Stanza_obj::__alloc( HX_CTX ,HX_("iq",e8,5b,00,00), ::Dynamic(::hx::Anon_obj::Create(1)
+            						->setFixed(0,HX_("type",ba,f2,08,4d),HX_("set",a2,9b,57,00))))->tag(HX_("pubsub",e3,da,f8,66), ::Dynamic(::hx::Anon_obj::Create(1)
+            						->setFixed(0,HX_("xmlns",dc,31,74,60),HX_("http://jabber.org/protocol/pubsub#owner",c7,28,a3,08))))->tag(HX_("configure",e6,f9,5b,c0), ::Dynamic(::hx::Anon_obj::Create(1)
+            						->setFixed(0,HX_("node",02,0a,0a,49),HX_("urn:xmpp:bookmarks:1",58,3c,53,7d))))->tag(HX_("x",78,00,00,00), ::Dynamic(::hx::Anon_obj::Create(2)
+            						->setFixed(0,HX_("type",ba,f2,08,4d),HX_("submit",18,58,06,9a))
+            						->setFixed(1,HX_("xmlns",dc,31,74,60),HX_("jabber:x:data",c2,e1,e9,7c))))->tag(HX_("field",ba,94,93,00), ::Dynamic(::hx::Anon_obj::Create(2)
+            						->setFixed(0,HX_("var",e7,de,59,00),HX_("FORM_TYPE",d5,96,c9,5a))
+            						->setFixed(1,HX_("type",ba,f2,08,4d),HX_("hidden",6a,ff,95,4c))))->textTag(HX_("value",71,7f,b8,31),HX_("http://jabber.org/protocol/pubsub#publish-options",f4,9c,72,50),null())->up()->tag(HX_("field",ba,94,93,00), ::Dynamic(::hx::Anon_obj::Create(1)
+            						->setFixed(0,HX_("var",e7,de,59,00),HX_("pubsub#persist_items",75,44,6b,ad))))->textTag(HX_("value",71,7f,b8,31),HX_("true",4e,a7,03,4d),null())->up()->tag(HX_("field",ba,94,93,00), ::Dynamic(::hx::Anon_obj::Create(1)
+            						->setFixed(0,HX_("var",e7,de,59,00),HX_("pubsub#max_items",05,69,9f,7c))))->textTag(HX_("value",71,7f,b8,31),HX_("max",a4,0a,53,00),null())->up()->tag(HX_("field",ba,94,93,00), ::Dynamic(::hx::Anon_obj::Create(1)
+            						->setFixed(0,HX_("var",e7,de,59,00),HX_("pubsub#send_last_published_item",b6,21,d2,0a))))->textTag(HX_("value",71,7f,b8,31),HX_("never",8c,3e,30,99),null())->up()->tag(HX_("field",ba,94,93,00), ::Dynamic(::hx::Anon_obj::Create(1)
+            						->setFixed(0,HX_("var",e7,de,59,00),HX_("pubsub#access_model",6e,cf,ac,1d))))->textTag(HX_("value",71,7f,b8,31),HX_("whitelist",87,6f,95,29),null())->up()->tag(HX_("field",ba,94,93,00), ::Dynamic(::hx::Anon_obj::Create(1)
+            						->setFixed(0,HX_("var",e7,de,59,00),HX_("pubsub#notify_delete",41,3a,35,54))))->textTag(HX_("value",71,7f,b8,31),HX_("true",4e,a7,03,4d),null())->up()->tag(HX_("field",ba,94,93,00), ::Dynamic(::hx::Anon_obj::Create(1)
+            						->setFixed(0,HX_("var",e7,de,59,00),HX_("pubsub#notify_retract",2b,3b,48,44))))->textTag(HX_("value",71,7f,b8,31),HX_("true",4e,a7,03,4d),null())->up()->up()->up()->up(), ::Dynamic(new _hx_Closure_0(_gthis)));
+            				}
+            			}
+            		}
+            		HX_END_LOCAL_FUNC1((void))
+
+            	HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1440_bookmark)
+HXDLIN(1440)		 ::snikket::Channel _gthis = ::hx::ObjectPtr<OBJ_>(this);
+HXLINE(1441)		 ::snikket::GenericStream _hx_tmp = this->stream;
+HXLINE(1442)		 ::snikket::Stanza _hx_tmp1 =  ::snikket::Stanza_obj::__alloc( HX_CTX ,HX_("iq",e8,5b,00,00), ::Dynamic(::hx::Anon_obj::Create(1)
+            			->setFixed(0,HX_("type",ba,f2,08,4d),HX_("set",a2,9b,57,00))))->tag(HX_("pubsub",e3,da,f8,66), ::Dynamic(::hx::Anon_obj::Create(1)
+            			->setFixed(0,HX_("xmlns",dc,31,74,60),HX_("http://jabber.org/protocol/pubsub",57,94,3c,f2))))->tag(HX_("publish",8f,21,1d,ae), ::Dynamic(::hx::Anon_obj::Create(1)
+            			->setFixed(0,HX_("node",02,0a,0a,49),HX_("urn:xmpp:bookmarks:1",58,3c,53,7d))))->tag(HX_("item",13,c5,bf,45), ::Dynamic(::hx::Anon_obj::Create(1)
+            			->setFixed(0,HX_("id",db,5b,00,00),this->chatId)));
+HXLINE(1446)		::String _hx_tmp2 = this->getDisplayName();
+HXDLIN(1446)		::String _hx_tmp3;
+HXDLIN(1446)		if ((this->uiState == 2)) {
+HXLINE(1446)			_hx_tmp3 = HX_("false",a3,35,4f,fb);
+            		}
+            		else {
+HXLINE(1446)			_hx_tmp3 = HX_("true",4e,a7,03,4d);
+            		}
+HXLINE(1442)		 ::snikket::Stanza _hx_tmp4 = _hx_tmp1->tag(HX_("conference",1c,2b,83,41), ::Dynamic(::hx::Anon_obj::Create(3)
+            			->setFixed(0,HX_("autojoin",d9,f6,b1,3e),_hx_tmp3)
+            			->setFixed(1,HX_("name",4b,72,ff,48),_hx_tmp2)
+            			->setFixed(2,HX_("xmlns",dc,31,74,60),HX_("urn:xmpp:bookmarks:1",58,3c,53,7d))));
+HXLINE(1447)		::String _hx_tmp5 = this->client->displayName();
+HXLINE(1441)		_hx_tmp->sendIq(_hx_tmp4->textTag(HX_("nick",a3,7b,05,49),_hx_tmp5,null())->addChild(this->extensions)->up()->up()->tag(HX_("publish-options",60,0b,5c,74),null())->tag(HX_("x",78,00,00,00), ::Dynamic(::hx::Anon_obj::Create(2)
+            			->setFixed(0,HX_("type",ba,f2,08,4d),HX_("submit",18,58,06,9a))
+            			->setFixed(1,HX_("xmlns",dc,31,74,60),HX_("jabber:x:data",c2,e1,e9,7c))))->tag(HX_("field",ba,94,93,00), ::Dynamic(::hx::Anon_obj::Create(2)
+            			->setFixed(0,HX_("var",e7,de,59,00),HX_("FORM_TYPE",d5,96,c9,5a))
+            			->setFixed(1,HX_("type",ba,f2,08,4d),HX_("hidden",6a,ff,95,4c))))->textTag(HX_("value",71,7f,b8,31),HX_("http://jabber.org/protocol/pubsub#publish-options",f4,9c,72,50),null())->up()->tag(HX_("field",ba,94,93,00), ::Dynamic(::hx::Anon_obj::Create(1)
+            			->setFixed(0,HX_("var",e7,de,59,00),HX_("pubsub#persist_items",75,44,6b,ad))))->textTag(HX_("value",71,7f,b8,31),HX_("true",4e,a7,03,4d),null())->up()->tag(HX_("field",ba,94,93,00), ::Dynamic(::hx::Anon_obj::Create(1)
+            			->setFixed(0,HX_("var",e7,de,59,00),HX_("pubsub#max_items",05,69,9f,7c))))->textTag(HX_("value",71,7f,b8,31),HX_("max",a4,0a,53,00),null())->up()->tag(HX_("field",ba,94,93,00), ::Dynamic(::hx::Anon_obj::Create(1)
+            			->setFixed(0,HX_("var",e7,de,59,00),HX_("pubsub#send_last_published_item",b6,21,d2,0a))))->textTag(HX_("value",71,7f,b8,31),HX_("never",8c,3e,30,99),null())->up()->tag(HX_("field",ba,94,93,00), ::Dynamic(::hx::Anon_obj::Create(1)
+            			->setFixed(0,HX_("var",e7,de,59,00),HX_("pubsub#access_model",6e,cf,ac,1d))))->textTag(HX_("value",71,7f,b8,31),HX_("whitelist",87,6f,95,29),null())->up()->tag(HX_("field",ba,94,93,00), ::Dynamic(::hx::Anon_obj::Create(1)
+            			->setFixed(0,HX_("var",e7,de,59,00),HX_("pubsub#notify_delete",41,3a,35,54))))->textTag(HX_("value",71,7f,b8,31),HX_("true",4e,a7,03,4d),null())->up()->tag(HX_("field",ba,94,93,00), ::Dynamic(::hx::Anon_obj::Create(1)
+            			->setFixed(0,HX_("var",e7,de,59,00),HX_("pubsub#notify_retract",2b,3b,48,44))))->textTag(HX_("value",71,7f,b8,31),HX_("true",4e,a7,03,4d),null())->up()->up()->up()->up()->up(), ::Dynamic(new _hx_Closure_1(_gthis)));
+            	}
+
+
+void Channel_obj::sendChatState(::String state,::String threadId){
+            	HX_GC_STACKFRAME(&_hx_pos_5e4df8d46126c981_1490_sendChatState)
+HXLINE(1492)		::String stanza = ::snikket::ID_obj::_hx_long();
+HXLINE(1494)		::String stanza1 = this->client->jid->asString();
+HXLINE(1491)		 ::snikket::Stanza stanza2 =  ::snikket::Stanza_obj::__alloc( HX_CTX ,HX_("message",c7,35,11,9a), ::Dynamic(::hx::Anon_obj::Create(4)
+            			->setFixed(0,HX_("id",db,5b,00,00),stanza)
+            			->setFixed(1,HX_("to",7b,65,00,00),this->chatId)
+            			->setFixed(2,HX_("from",6a,a5,c2,43),stanza1)
+            			->setFixed(3,HX_("type",ba,f2,08,4d),HX_("groupchat",97,1d,c8,e5))))->tag(state, ::Dynamic(::hx::Anon_obj::Create(1)
+            			->setFixed(0,HX_("xmlns",dc,31,74,60),HX_("http://jabber.org/protocol/chatstates",8e,6d,41,6d))))->up();
+HXLINE(1499)		if (::hx::IsNotNull( threadId )) {
+HXLINE(1500)			stanza2->textTag(HX_("thread",ca,7a,b9,8e),threadId,null());
+            		}
+HXLINE(1502)		this->stream->sendStanza(stanza2);
+            	}
+
+
+void Channel_obj::close(){
+            	HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_1506_close)
+HXLINE(1507)		if (::hx::IsNotNull( this->typingTimer )) {
+HXLINE(1507)			this->typingTimer->stop();
+            		}
+HXLINE(1508)		this->uiState = 2;
+HXLINE(1509)		::Dynamic _hx_tmp = this->persistence;
+HXDLIN(1509)		::snikket::Persistence_obj::storeChats(_hx_tmp,this->client->accountId(),::Array_obj< ::Dynamic>::__new(1)->init(0,::hx::ObjectPtr<OBJ_>(this)));
+HXLINE(1510)		this->selfPing(false);
+HXLINE(1511)		this->bookmark();
+HXLINE(1512)		this->sendChatState(HX_("gone",5f,94,69,44),null());
+HXLINE(1513)		this->client->trigger(HX_("chats/update",3d,8e,1d,14),::cpp::VirtualArray_obj::__new(1)->init(0,::hx::ObjectPtr<OBJ_>(this)));
+            	}
+
+
+
+::hx::ObjectPtr< Channel_obj > Channel_obj::__new( ::snikket::Client client, ::snikket::GenericStream stream,::Dynamic persistence,::String chatId,::hx::Null< int >  __o_uiState,::hx::Null< bool >  __o_isBlocked, ::snikket::Stanza extensions,::String readUpToId,::String readUpToBy, ::snikket::Caps disco) {
+	::hx::ObjectPtr< Channel_obj > __this = new Channel_obj();
+	__this->__construct(client,stream,persistence,chatId,__o_uiState,__o_isBlocked,extensions,readUpToId,readUpToBy,disco);
+	return __this;
+}
+
+::hx::ObjectPtr< Channel_obj > Channel_obj::__alloc(::hx::Ctx *_hx_ctx, ::snikket::Client client, ::snikket::GenericStream stream,::Dynamic persistence,::String chatId,::hx::Null< int >  __o_uiState,::hx::Null< bool >  __o_isBlocked, ::snikket::Stanza extensions,::String readUpToId,::String readUpToBy, ::snikket::Caps disco) {
+	Channel_obj *__this = (Channel_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Channel_obj), true, "snikket.Channel"));
+	*(void **)__this = Channel_obj::_hx_vtable;
+	__this->__construct(client,stream,persistence,chatId,__o_uiState,__o_isBlocked,extensions,readUpToId,readUpToBy,disco);
+	return __this;
+}
+
+Channel_obj::Channel_obj()
+{
+}
+
+void Channel_obj::__Mark(HX_MARK_PARAMS)
+{
+	HX_MARK_BEGIN_CLASS(Channel);
+	HX_MARK_MEMBER_NAME(disco,"disco");
+	HX_MARK_MEMBER_NAME(inSync,"inSync");
+	HX_MARK_MEMBER_NAME(sync,"sync");
+	HX_MARK_MEMBER_NAME(forceLive,"forceLive");
+	HX_MARK_MEMBER_NAME(_nickInUse,"_nickInUse");
+	 ::snikket::Chat_obj::__Mark(HX_MARK_ARG);
+	HX_MARK_END_CLASS();
+}
+
+void Channel_obj::__Visit(HX_VISIT_PARAMS)
+{
+	HX_VISIT_MEMBER_NAME(disco,"disco");
+	HX_VISIT_MEMBER_NAME(inSync,"inSync");
+	HX_VISIT_MEMBER_NAME(sync,"sync");
+	HX_VISIT_MEMBER_NAME(forceLive,"forceLive");
+	HX_VISIT_MEMBER_NAME(_nickInUse,"_nickInUse");
+	 ::snikket::Chat_obj::__Visit(HX_VISIT_ARG);
+}
+
+::hx::Val Channel_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"sync") ) { return ::hx::Val( sync ); }
+		if (HX_FIELD_EQ(inName,"join") ) { return ::hx::Val( join_dyn() ); }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"disco") ) { return ::hx::Val( disco ); }
+		if (HX_FIELD_EQ(inName,"close") ) { return ::hx::Val( close_dyn() ); }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"inSync") ) { return ::hx::Val( inSync ); }
+		if (HX_FIELD_EQ(inName,"doSync") ) { return ::hx::Val( doSync_dyn() ); }
+		break;
+	case 7:
+		if (HX_FIELD_EQ(inName,"preview") ) { return ::hx::Val( preview_dyn() ); }
+		if (HX_FIELD_EQ(inName,"syncing") ) { return ::hx::Val( syncing_dyn() ); }
+		break;
+	case 8:
+		if (HX_FIELD_EQ(inName,"selfPing") ) { return ::hx::Val( selfPing_dyn() ); }
+		if (HX_FIELD_EQ(inName,"bookmark") ) { return ::hx::Val( bookmark_dyn() ); }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"forceLive") ) { return ::hx::Val( forceLive ); }
+		if (HX_FIELD_EQ(inName,"isTrusted") ) { return ::hx::Val( isTrusted_dyn() ); }
+		if (HX_FIELD_EQ(inName,"isPrivate") ) { return ::hx::Val( isPrivate_dyn() ); }
+		if (HX_FIELD_EQ(inName,"nickInUse") ) { return ::hx::Val( nickInUse_dyn() ); }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"_nickInUse") ) { return ::hx::Val( _nickInUse ); }
+		if (HX_FIELD_EQ(inName,"getFullJid") ) { return ::hx::Val( getFullJid_dyn() ); }
+		break;
+	case 11:
+		if (HX_FIELD_EQ(inName,"setPresence") ) { return ::hx::Val( setPresence_dyn() ); }
+		if (HX_FIELD_EQ(inName,"sendMessage") ) { return ::hx::Val( sendMessage_dyn() ); }
+		break;
+	case 12:
+		if (HX_FIELD_EQ(inName,"refreshDisco") ) { return ::hx::Val( refreshDisco_dyn() ); }
+		if (HX_FIELD_EQ(inName,"livePresence") ) { return ::hx::Val( livePresence_dyn() ); }
+		if (HX_FIELD_EQ(inName,"canAudioCall") ) { return ::hx::Val( canAudioCall_dyn() ); }
+		if (HX_FIELD_EQ(inName,"canVideoCall") ) { return ::hx::Val( canVideoCall_dyn() ); }
+		if (HX_FIELD_EQ(inName,"markReadUpTo") ) { return ::hx::Val( markReadUpTo_dyn() ); }
+		break;
+	case 13:
+		if (HX_FIELD_EQ(inName,"lastMessageId") ) { return ::hx::Val( lastMessageId_dyn() ); }
+		if (HX_FIELD_EQ(inName,"sendChatState") ) { return ::hx::Val( sendChatState_dyn() ); }
+		break;
+	case 14:
+		if (HX_FIELD_EQ(inName,"correctMessage") ) { return ::hx::Val( correctMessage_dyn() ); }
+		if (HX_FIELD_EQ(inName,"removeReaction") ) { return ::hx::Val( removeReaction_dyn() ); }
+		break;
+	case 15:
+		if (HX_FIELD_EQ(inName,"selfPingSuccess") ) { return ::hx::Val( selfPingSuccess_dyn() ); }
+		if (HX_FIELD_EQ(inName,"getParticipants") ) { return ::hx::Val( getParticipants_dyn() ); }
+		break;
+	case 16:
+		if (HX_FIELD_EQ(inName,"getMessagesAfter") ) { return ::hx::Val( getMessagesAfter_dyn() ); }
+		break;
+	case 17:
+		if (HX_FIELD_EQ(inName,"getMessagesBefore") ) { return ::hx::Val( getMessagesBefore_dyn() ); }
+		if (HX_FIELD_EQ(inName,"getMessagesAround") ) { return ::hx::Val( getMessagesAround_dyn() ); }
+		break;
+	case 21:
+		if (HX_FIELD_EQ(inName,"getParticipantDetails") ) { return ::hx::Val( getParticipantDetails_dyn() ); }
+		break;
+	case 22:
+		if (HX_FIELD_EQ(inName,"prepareIncomingMessage") ) { return ::hx::Val( prepareIncomingMessage_dyn() ); }
+		if (HX_FIELD_EQ(inName,"prepareOutgoingMessage") ) { return ::hx::Val( prepareOutgoingMessage_dyn() ); }
+	}
+	return super::__Field(inName,inCallProp);
+}
+
+::hx::Val Channel_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
+{
+	switch(inName.length) {
+	case 4:
+		if (HX_FIELD_EQ(inName,"sync") ) { sync=inValue.Cast<  ::snikket::MessageSync >(); return inValue; }
+		break;
+	case 5:
+		if (HX_FIELD_EQ(inName,"disco") ) { disco=inValue.Cast<  ::snikket::Caps >(); return inValue; }
+		break;
+	case 6:
+		if (HX_FIELD_EQ(inName,"inSync") ) { inSync=inValue.Cast< bool >(); return inValue; }
+		break;
+	case 9:
+		if (HX_FIELD_EQ(inName,"forceLive") ) { forceLive=inValue.Cast< bool >(); return inValue; }
+		break;
+	case 10:
+		if (HX_FIELD_EQ(inName,"_nickInUse") ) { _nickInUse=inValue.Cast< ::String >(); return inValue; }
+	}
+	return super::__SetField(inName,inValue,inCallProp);
+}
+
+void Channel_obj::__GetFields(Array< ::String> &outFields)
+{
+	outFields->push(HX_("disco",7a,03,d1,d9));
+	outFields->push(HX_("inSync",e0,98,c5,88));
+	outFields->push(HX_("sync",5b,ba,5f,4c));
+	outFields->push(HX_("forceLive",77,ce,f7,4c));
+	outFields->push(HX_("_nickInUse",80,a6,41,a3));
+	super::__GetFields(outFields);
+};
+
+#ifdef HXCPP_SCRIPTABLE
+static ::hx::StorageInfo Channel_obj_sMemberStorageInfo[] = {
+	{::hx::fsObject /*  ::snikket::Caps */ ,(int)offsetof(Channel_obj,disco),HX_("disco",7a,03,d1,d9)},
+	{::hx::fsBool,(int)offsetof(Channel_obj,inSync),HX_("inSync",e0,98,c5,88)},
+	{::hx::fsObject /*  ::snikket::MessageSync */ ,(int)offsetof(Channel_obj,sync),HX_("sync",5b,ba,5f,4c)},
+	{::hx::fsBool,(int)offsetof(Channel_obj,forceLive),HX_("forceLive",77,ce,f7,4c)},
+	{::hx::fsString,(int)offsetof(Channel_obj,_nickInUse),HX_("_nickInUse",80,a6,41,a3)},
+	{ ::hx::fsUnknown, 0, null()}
+};
+static ::hx::StaticInfo *Channel_obj_sStaticStorageInfo = 0;
+#endif
+
+static ::String Channel_obj_sMemberFields[] = {
+	HX_("disco",7a,03,d1,d9),
+	HX_("inSync",e0,98,c5,88),
+	HX_("sync",5b,ba,5f,4c),
+	HX_("forceLive",77,ce,f7,4c),
+	HX_("_nickInUse",80,a6,41,a3),
+	HX_("selfPing",1e,60,3c,38),
+	HX_("join",ea,33,65,46),
+	HX_("selfPingSuccess",45,4d,98,ab),
+	HX_("setPresence",fd,1b,38,97),
+	HX_("doSync",86,5f,63,1c),
+	HX_("isTrusted",2d,35,a5,1a),
+	HX_("isPrivate",39,aa,6d,8d),
+	HX_("refreshDisco",9f,ff,52,ed),
+	HX_("preview",08,e0,da,3b),
+	HX_("livePresence",47,f9,16,b4),
+	HX_("syncing",67,fd,26,a7),
+	HX_("canAudioCall",64,4a,90,e4),
+	HX_("canVideoCall",89,1c,93,ea),
+	HX_("nickInUse",bf,2a,9f,47),
+	HX_("getFullJid",80,42,92,1f),
+	HX_("getParticipants",16,0b,c7,34),
+	HX_("getParticipantDetails",85,2b,7d,4d),
+	HX_("getMessagesBefore",a1,f1,44,11),
+	HX_("getMessagesAfter",3a,43,91,57),
+	HX_("getMessagesAround",6f,95,16,2d),
+	HX_("prepareIncomingMessage",ba,eb,c6,e3),
+	HX_("prepareOutgoingMessage",f4,b0,f3,49),
+	HX_("correctMessage",7d,36,c3,f4),
+	HX_("sendMessage",5f,89,1d,24),
+	HX_("removeReaction",0d,24,0b,c1),
+	HX_("lastMessageId",4c,90,58,27),
+	HX_("markReadUpTo",59,68,2d,ee),
+	HX_("bookmark",b6,8c,f1,32),
+	HX_("sendChatState",b1,21,95,6e),
+	HX_("close",b8,17,63,48),
+	::String(null()) };
+
+::hx::Class Channel_obj::__mClass;
+
+void Channel_obj::__register()
+{
+	Channel_obj _hx_dummy;
+	Channel_obj::_hx_vtable = *(void **)&_hx_dummy;
+	::hx::Static(__mClass) = new ::hx::Class_obj();
+	__mClass->mName = HX_("snikket.Channel",b2,3f,68,db);
+	__mClass->mSuper = &super::__SGetClass();
+	__mClass->mConstructEmpty = &__CreateEmpty;
+	__mClass->mConstructArgs = &__Create;
+	__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
+	__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
+	__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
+	__mClass->mMembers = ::hx::Class_obj::dupFunctions(Channel_obj_sMemberFields);
+	__mClass->mCanCast = ::hx::TCanCast< Channel_obj >;
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mMemberStorageInfo = Channel_obj_sMemberStorageInfo;
+#endif
+#ifdef HXCPP_SCRIPTABLE
+	__mClass->mStaticStorageInfo = Channel_obj_sStaticStorageInfo;
+#endif
+	::hx::_hx_RegisterClass(__mClass->mName, __mClass);
+}
+
+void Channel_obj::__boot()
+{
+{
+            	HX_STACKFRAME(&_hx_pos_5e4df8d46126c981_975_boot)
+HXDLIN( 975)		__mClass->__meta__ =  ::Dynamic(::hx::Anon_obj::Create(1)
+            			->setFixed(0,HX_("fields",79,8e,8e,80), ::Dynamic(::hx::Anon_obj::Create(19)
+            				->setFixed(0,HX_("setPresence",fd,1b,38,97), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("HaxeCBridge.noemit",dc,2c,99,2f),null())))
+            				->setFixed(1,HX_("syncing",67,fd,26,a7), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("HaxeCBridge.noemit",dc,2c,99,2f),null())))
+            				->setFixed(2,HX_("livePresence",47,f9,16,b4), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("HaxeCBridge.noemit",dc,2c,99,2f),null())))
+            				->setFixed(3,HX_("removeReaction",0d,24,0b,c1), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("HaxeCBridge.noemit",dc,2c,99,2f),null())))
+            				->setFixed(4,HX_("canAudioCall",64,4a,90,e4), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("HaxeCBridge.noemit",dc,2c,99,2f),null())))
+            				->setFixed(5,HX_("canVideoCall",89,1c,93,ea), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("HaxeCBridge.noemit",dc,2c,99,2f),null())))
+            				->setFixed(6,HX_("markReadUpTo",59,68,2d,ee), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("HaxeCBridge.noemit",dc,2c,99,2f),null())))
+            				->setFixed(7,HX_("correctMessage",7d,36,c3,f4), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("HaxeCBridge.noemit",dc,2c,99,2f),null())))
+            				->setFixed(8,HX_("getMessagesBefore",a1,f1,44,11), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("HaxeCBridge.noemit",dc,2c,99,2f),null())))
+            				->setFixed(9,HX_("isTrusted",2d,35,a5,1a), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("HaxeCBridge.noemit",dc,2c,99,2f),null())))
+            				->setFixed(10,HX_("sendMessage",5f,89,1d,24), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("HaxeCBridge.noemit",dc,2c,99,2f),null())))
+            				->setFixed(11,HX_("lastMessageId",4c,90,58,27), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("HaxeCBridge.noemit",dc,2c,99,2f),null())))
+            				->setFixed(12,HX_("getMessagesAround",6f,95,16,2d), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("HaxeCBridge.noemit",dc,2c,99,2f),null())))
+            				->setFixed(13,HX_("bookmark",b6,8c,f1,32), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("HaxeCBridge.noemit",dc,2c,99,2f),null())))
+            				->setFixed(14,HX_("getParticipants",16,0b,c7,34), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("HaxeCBridge.noemit",dc,2c,99,2f),null())))
+            				->setFixed(15,HX_("preview",08,e0,da,3b), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("HaxeCBridge.noemit",dc,2c,99,2f),null())))
+            				->setFixed(16,HX_("close",b8,17,63,48), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("HaxeCBridge.noemit",dc,2c,99,2f),null())))
+            				->setFixed(17,HX_("getParticipantDetails",85,2b,7d,4d), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("HaxeCBridge.noemit",dc,2c,99,2f),null())))
+            				->setFixed(18,HX_("getMessagesAfter",3a,43,91,57), ::Dynamic(::hx::Anon_obj::Create(1)
+            					->setFixed(0,HX_("HaxeCBridge.noemit",dc,2c,99,2f),null()))))));
+            	}
+}
+
+} // end namespace snikket
diff --git a/Sources/c_snikket/src/snikket/Chat.cpp b/Sources/c_snikket/src/snikket/Chat.cpp
new file mode 100644
index 0000000..a916fbb
--- /dev/null
+++ b/Sources/c_snikket/src/snikket/Chat.cpp
@@ -0,0 +1,2205 @@
+// Generated by Haxe 4.3.3
+#include <hxcpp.h>
+
+#ifndef INCLUDED_Reflect
+#include <Reflect.h>
+#endif
+#ifndef INCLUDED_StringTools
+#include <StringTools.h>
+#endif
+#ifndef INCLUDED__HaxeCBridge_Internal
+#include <_HaxeCBridge/Internal.h>
+#endif
+#ifndef INCLUDED_haxe_IMap
+#include <haxe/IMap.h>
+#endif
+#ifndef INCLUDED_haxe_Timer
+#include <haxe/Timer.h>
+#endif
+#ifndef INCLUDED_haxe_ds_IntMap
+#include <haxe/ds/IntMap.h>
+#endif
+#ifndef INCLUDED_haxe_ds_StringMap
+#include <haxe/ds/StringMap.h>
+#endif
+#ifndef INCLUDED_haxe_io_Bytes
+#include <haxe/io/Bytes.h>
+#endif
+#ifndef INCLUDED_haxe_iterators_MapKeyValueIterator
+#include <haxe/iterators/MapKeyValueIterator.h>
+#endif
+#ifndef INCLUDED_snikket_Caps
+#include <snikket/Caps.h>
+#endif
+#ifndef INCLUDED_snikket_Chat
+#include <snikket/Chat.h>
+#endif
+#ifndef INCLUDED_snikket_ChatMessage
+#include <snikket/ChatMessage.h>
+#endif
+#ifndef INCLUDED_snikket_ChatMessageBuilder
+#include <snikket/ChatMessageBuilder.h>
+#endif
+#ifndef INCLUDED_snikket_Client
+#include <snikket/Client.h>
+#endif
+#ifndef INCLUDED_snikket_Color
+#include <snikket/Color.h>
+#endif
+#ifndef INCLUDED_snikket_EventEmitter
+#include <snikket/EventEmitter.h>
+#endif
+#ifndef INCLUDED_snikket_EventResult
+#include <snikket/EventResult.h>
+#endif
+#ifndef INCLUDED_snikket_GenericStream
+#include <snikket/GenericStream.h>
+#endif
+#ifndef INCLUDED_snikket_Hash
+#include <snikket/Hash.h>
+#endif
+#ifndef INCLUDED_snikket_ID
+#include <snikket/ID.h>
+#endif
+#ifndef INCLUDED_snikket_Identity
+#include <snikket/Identity.h>
+#endif
+#ifndef INCLUDED_snikket_JID
+#include <snikket/JID.h>
+#endif
+#ifndef INCLUDED_snikket_MessageStanza
+#include <snikket/MessageStanza.h>
+#endif
+#ifndef INCLUDED_snikket_MessageSync
+#include <snikket/MessageSync.h>
+#endif
+#ifndef INCLUDED_snikket_ModerationAction
+#include <snikket/ModerationAction.h>
+#endif
+#ifndef INCLUDED_snikket_Participant
+#include <snikket/Participant.h>
+#endif
+#ifndef INCLUDED_snikket_Persistence
+#include <snikket/Persistence.h>
+#endif
+#ifndef INCLUDED_snikket_Presence
+#include <snikket/Presence.h>
+#endif
+#ifndef INCLUDED_snikket_Reaction
+#include <snikket/Reaction.h>
+#endif
+#ifndef INCLUDED_snikket_ReactionUpdate
+#include <snikket/ReactionUpdate.h>
+#endif
+#ifndef INCLUDED_snikket_Stanza
+#include <snikket/Stanza.h>
+#endif
+#ifndef INCLUDED_snikket__Stanza_NodeInterface
+#include <snikket/_Stanza/NodeInterface.h>
+#endif
+#ifndef INCLUDED_snikket__Util_Util_Fields_
+#include <snikket/_Util/Util_Fields_.h>
+#endif
+#ifndef INCLUDED_snikket_jingle_DTMFSender
+#include <snikket/jingle/DTMFSender.h>
+#endif
+#ifndef INCLUDED_snikket_jingle_MediaStream
+#include <snikket/jingle/MediaStream.h>
+#endif
+#ifndef INCLUDED_snikket_jingle_MediaStreamTrack
+#include <snikket/jingle/MediaStreamTrack.h>
+#endif
+#ifndef INCLUDED_snikket_jingle_OutgoingProposedSession
+#include <snikket/jingle/OutgoingProposedSession.h>
+#endif
+#ifndef INCLUDED_snikket_jingle_Session
+#include <snikket/jingle/Session.h>
+#endif
+#ifndef INCLUDED_thenshim_Thenable
+#include <thenshim/Thenable.h>
+#endif
+
+HX_DEFINE_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_43_new,"snikket.Chat","new",0x69f01dfb,"snikket.Chat.new","snikket/Chat.hx",43,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_12e7dd114cfbd541_271_chatId__fromC,"snikket.Chat","chatId__fromC",0x863b7961,"snikket.Chat.chatId__fromC","HaxeCBridge.hx",271,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_12e7dd114cfbd541_271_uiState__fromC,"snikket.Chat","uiState__fromC",0x25366141,"snikket.Chat.uiState__fromC","HaxeCBridge.hx",271,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_12e7dd114cfbd541_271_isBlocked__fromC,"snikket.Chat","isBlocked__fromC",0xbc9aae1c,"snikket.Chat.isBlocked__fromC","HaxeCBridge.hx",271,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_12e7dd114cfbd541_221_getMessagesBefore__fromC,"snikket.Chat","getMessagesBefore__fromC",0x76faff7d,"snikket.Chat.getMessagesBefore__fromC","HaxeCBridge.hx",221,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_12e7dd114cfbd541_244_getMessagesBefore__fromC,"snikket.Chat","getMessagesBefore__fromC",0x76faff7d,"snikket.Chat.getMessagesBefore__fromC","HaxeCBridge.hx",244,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_12e7dd114cfbd541_221_getMessagesAfter__fromC,"snikket.Chat","getMessagesAfter__fromC",0xc6ff459a,"snikket.Chat.getMessagesAfter__fromC","HaxeCBridge.hx",221,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_12e7dd114cfbd541_244_getMessagesAfter__fromC,"snikket.Chat","getMessagesAfter__fromC",0xc6ff459a,"snikket.Chat.getMessagesAfter__fromC","HaxeCBridge.hx",244,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_12e7dd114cfbd541_221_getMessagesAround__fromC,"snikket.Chat","getMessagesAround__fromC",0x0c8b916f,"snikket.Chat.getMessagesAround__fromC","HaxeCBridge.hx",221,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_12e7dd114cfbd541_244_getMessagesAround__fromC,"snikket.Chat","getMessagesAround__fromC",0x0c8b916f,"snikket.Chat.getMessagesAround__fromC","HaxeCBridge.hx",244,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_143_fetchFromSync,"snikket.Chat","fetchFromSync",0xa446a09a,"snikket.Chat.fetchFromSync","snikket/Chat.hx",143,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_128_fetchFromSync,"snikket.Chat","fetchFromSync",0xa446a09a,"snikket.Chat.fetchFromSync","snikket/Chat.hx",128,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_135_fetchFromSync,"snikket.Chat","fetchFromSync",0xa446a09a,"snikket.Chat.fetchFromSync","snikket/Chat.hx",135,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_127_fetchFromSync,"snikket.Chat","fetchFromSync",0xa446a09a,"snikket.Chat.fetchFromSync","snikket/Chat.hx",127,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_12e7dd114cfbd541_244_sendMessage__fromC,"snikket.Chat","sendMessage__fromC",0xcfa599bf,"snikket.Chat.sendMessage__fromC","HaxeCBridge.hx",244,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_12e7dd114cfbd541_244_markReadUpTo__fromC,"snikket.Chat","markReadUpTo__fromC",0xb4ac28db,"snikket.Chat.markReadUpTo__fromC","HaxeCBridge.hx",244,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_12e7dd114cfbd541_244_bookmark__fromC,"snikket.Chat","bookmark__fromC",0xb349509e,"snikket.Chat.bookmark__fromC","HaxeCBridge.hx",244,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_12e7dd114cfbd541_242_getParticipants__fromC,"snikket.Chat","getParticipants__fromC",0x549a1368,"snikket.Chat.getParticipants__fromC","HaxeCBridge.hx",242,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_12e7dd114cfbd541_244_getParticipantDetails__fromC,"snikket.Chat","getParticipantDetails__fromC",0x3039b099,"snikket.Chat.getParticipantDetails__fromC","HaxeCBridge.hx",244,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_12e7dd114cfbd541_244_correctMessage__fromC,"snikket.Chat","correctMessage__fromC",0x7adc83f7,"snikket.Chat.correctMessage__fromC","HaxeCBridge.hx",244,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_203_addReaction,"snikket.Chat","addReaction",0xe26cff85,"snikket.Chat.addReaction","snikket/Chat.hx",203,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_206_addReaction,"snikket.Chat","addReaction",0xe26cff85,"snikket.Chat.addReaction","snikket/Chat.hx",206,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_198_addReaction,"snikket.Chat","addReaction",0xe26cff85,"snikket.Chat.addReaction","snikket/Chat.hx",198,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_12e7dd114cfbd541_244_removeReaction__fromC,"snikket.Chat","removeReaction__fromC",0xb57c6867,"snikket.Chat.removeReaction__fromC","HaxeCBridge.hx",244,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_251_typing,"snikket.Chat","typing",0x22ffe3bc,"snikket.Chat.typing","snikket/Chat.hx",251,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_230_typing,"snikket.Chat","typing",0x22ffe3bc,"snikket.Chat.typing","snikket/Chat.hx",230,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_245_typing,"snikket.Chat","typing",0x22ffe3bc,"snikket.Chat.typing","snikket/Chat.hx",245,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_269_setActive,"snikket.Chat","setActive",0x1ec0aae3,"snikket.Chat.setActive","snikket/Chat.hx",269,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_12e7dd114cfbd541_244_close__fromC,"snikket.Chat","close__fromC",0x4574e6c6,"snikket.Chat.close__fromC","HaxeCBridge.hx",244,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_294_togglePinned,"snikket.Chat","togglePinned",0x82375cd1,"snikket.Chat.togglePinned","snikket/Chat.hx",294,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_304_block,"snikket.Chat","block",0xf87b9fa8,"snikket.Chat.block","snikket/Chat.hx",304,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_321_block,"snikket.Chat","block",0xf87b9fa8,"snikket.Chat.block","snikket/Chat.hx",321,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_328_unblock,"snikket.Chat","unblock",0x32f0236f,"snikket.Chat.unblock","snikket/Chat.hx",328,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_338_unblock,"snikket.Chat","unblock",0x32f0236f,"snikket.Chat.unblock","snikket/Chat.hx",338,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_346_setNotifications,"snikket.Chat","setNotifications",0xb3d8bbab,"snikket.Chat.setNotifications","snikket/Chat.hx",346,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_362_notificationsFiltered,"snikket.Chat","notificationsFiltered",0x958be1ba,"snikket.Chat.notificationsFiltered","snikket/Chat.hx",362,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_369_notifyMention,"snikket.Chat","notifyMention",0x4bac447c,"snikket.Chat.notifyMention","snikket/Chat.hx",369,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_376_notifyReply,"snikket.Chat","notifyReply",0xf1fbc63c,"snikket.Chat.notifyReply","snikket/Chat.hx",376,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_12e7dd114cfbd541_244_lastMessageId__fromC,"snikket.Chat","lastMessageId__fromC",0xf7fe75b2,"snikket.Chat.lastMessageId__fromC","HaxeCBridge.hx",244,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_388_lastMessageTimestamp,"snikket.Chat","lastMessageTimestamp",0x5028348a,"snikket.Chat.lastMessageTimestamp","snikket/Chat.hx",388,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_392_updateFromBookmark,"snikket.Chat","updateFromBookmark",0x2780dcae,"snikket.Chat.updateFromBookmark","snikket/Chat.hx",392,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_401_updateFromRoster,"snikket.Chat","updateFromRoster",0x1d9e4f83,"snikket.Chat.updateFromRoster","snikket/Chat.hx",401,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_409_getPhoto,"snikket.Chat","getPhoto",0xd6c858c1,"snikket.Chat.getPhoto","snikket/Chat.hx",409,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_418_getPlaceholder,"snikket.Chat","getPlaceholder",0xa955f8c2,"snikket.Chat.getPlaceholder","snikket/Chat.hx",418,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_425_readUpTo,"snikket.Chat","readUpTo",0x2aa097b1,"snikket.Chat.readUpTo","snikket/Chat.hx",425,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_432_unreadCount,"snikket.Chat","unreadCount",0x5b4cf8bb,"snikket.Chat.unreadCount","snikket/Chat.hx",432,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_437_setUnreadCount,"snikket.Chat","setUnreadCount",0xaf7385e3,"snikket.Chat.setUnreadCount","snikket/Chat.hx",437,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_443_preview,"snikket.Chat","preview",0xbd3d9723,"snikket.Chat.preview","snikket/Chat.hx",443,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_456_setLastMessage,"snikket.Chat","setLastMessage",0x5d3f57d4,"snikket.Chat.setLastMessage","snikket/Chat.hx",456,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_459_setDisplayName,"snikket.Chat","setDisplayName",0x3f747f70,"snikket.Chat.setDisplayName","snikket/Chat.hx",459,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_467_getDisplayName,"snikket.Chat","getDisplayName",0x1f5496fc,"snikket.Chat.getDisplayName","snikket/Chat.hx",467,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_482_setPresence,"snikket.Chat","setPresence",0x5193fc98,"snikket.Chat.setPresence","snikket/Chat.hx",482,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_486_setCaps,"snikket.Chat","setCaps",0x88a113fe,"snikket.Chat.setCaps","snikket/Chat.hx",486,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_498_removePresence,"snikket.Chat","removePresence",0x97f1c0e4,"snikket.Chat.removePresence","snikket/Chat.hx",498,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_506_getCaps,"snikket.Chat","getCaps",0x959f82f2,"snikket.Chat.getCaps","snikket/Chat.hx",506,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_502_getCaps,"snikket.Chat","getCaps",0x959f82f2,"snikket.Chat.getCaps","snikket/Chat.hx",502,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_515_getResourceCaps,"snikket.Chat","getResourceCaps",0x30ef43e0,"snikket.Chat.getResourceCaps","snikket/Chat.hx",515,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_520_setAvatarSha1,"snikket.Chat","setAvatarSha1",0xd1ceb0db,"snikket.Chat.setAvatarSha1","snikket/Chat.hx",520,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_524_setTrusted,"snikket.Chat","setTrusted",0x7948483a,"snikket.Chat.setTrusted","snikket/Chat.hx",524,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_531_isTrusted,"snikket.Chat","isTrusted",0xc3782908,"snikket.Chat.isTrusted","snikket/Chat.hx",531,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_536_livePresence,"snikket.Chat","livePresence",0x0a1fa04c,"snikket.Chat.livePresence","snikket/Chat.hx",536,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_540_syncing,"snikket.Chat","syncing",0x2889b482,"snikket.Chat.syncing","snikket/Chat.hx",540,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_546_canAudioCall,"snikket.Chat","canAudioCall",0x3a98f169,"snikket.Chat.canAudioCall","snikket/Chat.hx",546,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_557_canVideoCall,"snikket.Chat","canVideoCall",0x409bc38e,"snikket.Chat.canVideoCall","snikket/Chat.hx",557,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_571_startCall,"snikket.Chat","startCall",0xa38085fb,"snikket.Chat.startCall","snikket/Chat.hx",571,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_578_addMedia,"snikket.Chat","addMedia",0x3416ab88,"snikket.Chat.addMedia","snikket/Chat.hx",578,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_587_acceptCall,"snikket.Chat","acceptCall",0xc4d6678b,"snikket.Chat.acceptCall","snikket/Chat.hx",587,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_596_hangup,"snikket.Chat","hangup",0x83c5b792,"snikket.Chat.hangup","snikket/Chat.hx",596,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_605_callStatus,"snikket.Chat","callStatus",0x40ee2a35,"snikket.Chat.callStatus","snikket/Chat.hx",605,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_616_dtmf,"snikket.Chat","dtmf",0x419954ee,"snikket.Chat.dtmf","snikket/Chat.hx",616,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_629_videoTracks,"snikket.Chat","videoTracks",0x7880a2fe,"snikket.Chat.videoTracks","snikket/Chat.hx",629,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_12e7dd114cfbd541_242_videoTracks__fromC,"snikket.Chat","videoTracks__fromC",0xb4b1493b,"snikket.Chat.videoTracks__fromC","HaxeCBridge.hx",242,0xa18550d8)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_640_markReadUpToId,"snikket.Chat","markReadUpToId",0x495f62d9,"snikket.Chat.markReadUpToId","snikket/Chat.hx",640,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_633_markReadUpToId,"snikket.Chat","markReadUpToId",0x495f62d9,"snikket.Chat.markReadUpToId","snikket/Chat.hx",633,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_659_markReadUpToMessage,"snikket.Chat","markReadUpToMessage",0xab221609,"snikket.Chat.markReadUpToMessage","snikket/Chat.hx",659,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_650_markReadUpToMessage,"snikket.Chat","markReadUpToMessage",0xab221609,"snikket.Chat.markReadUpToMessage","snikket/Chat.hx",650,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_684_publishMds,"snikket.Chat","publishMds",0x809032b2,"snikket.Chat.publishMds","snikket/Chat.hx",684,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_700_publishMds,"snikket.Chat","publishMds",0x809032b2,"snikket.Chat.publishMds","snikket/Chat.hx",700,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_666_publishMds,"snikket.Chat","publishMds",0x809032b2,"snikket.Chat.publishMds","snikket/Chat.hx",666,0x18616bf4)
+HX_LOCAL_STACK_FRAME(_hx_pos_3993c1e3d3f53fe2_43_boot,"snikket.Chat","boot",0x40431e37,"snikket.Chat.boot","snikket/Chat.hx",43,0x18616bf4)
+namespace snikket{
+
+void Chat_obj::__construct( ::snikket::Client client, ::snikket::GenericStream stream,::Dynamic persistence,::String chatId,::hx::Null< int >  __o_uiState,::hx::Null< bool >  __o_isBlocked, ::snikket::Stanza extensions,::String readUpToId,::String readUpToBy){
+            		int uiState = __o_uiState.Default(1);
+            		bool isBlocked = __o_isBlocked.Default(false);
+            	HX_GC_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_43_new)
+HXLINE(  78)		this->notificationSettings = null();
+HXLINE(  77)		this->activeThread = null();
+HXLINE(  76)		this->isActive = null();
+HXLINE(  75)		this->typingTimer = null();
+HXLINE(  74)		this->typingThread = null();
+HXLINE(  73)		this->isTyping = false;
+HXLINE(  68)		this->_unreadCount = 0;
+HXLINE(  65)		this->isBlocked = false;
+HXLINE(  64)		this->uiState = 1;
+HXLINE(  57)		this->jingleSessions =  ::haxe::ds::StringMap_obj::__alloc( HX_CTX );
+HXLINE(  51)		this->trusted = false;
+HXLINE(  50)		this->presence =  ::haxe::ds::StringMap_obj::__alloc( HX_CTX );
+HXLINE(  48)		this->avatarSha1 = null();
+HXLINE(  82)		this->client = client;
+HXLINE(  83)		this->stream = stream;
+HXLINE(  84)		this->persistence = persistence;
+HXLINE(  85)		this->chatId = chatId;
+HXLINE(  86)		this->uiState = uiState;
+HXLINE(  87)		this->isBlocked = isBlocked;
+HXLINE(  88)		 ::snikket::Stanza tmp = extensions;
+HXDLIN(  88)		 ::snikket::Stanza _hx_tmp;
+HXDLIN(  88)		if (::hx::IsNotNull( tmp )) {
+HXLINE(  88)			_hx_tmp = tmp;
+            		}
+            		else {
+HXLINE(  88)			_hx_tmp =  ::snikket::Stanza_obj::__alloc( HX_CTX ,HX_("extensions",14,7c,70,89), ::Dynamic(::hx::Anon_obj::Create(1)
+            				->setFixed(0,HX_("xmlns",dc,31,74,60),HX_("urn:xmpp:bookmarks:1",58,3c,53,7d))));
+            		}
+HXDLIN(  88)		this->extensions = _hx_tmp;
+HXLINE(  89)		this->readUpToId = readUpToId;
+HXLINE(  90)		this->readUpToBy = readUpToBy;
+HXLINE(  91)		this->displayName = chatId;
+            	}
+
+bool Chat_obj::_hx_isInstanceOf(int inClassId) {
+	return inClassId==(int)0x00000001 || inClassId==(int)0x026b7f35;
+}
+
+::String Chat_obj::chatId__fromC(){
+            	HX_STACKFRAME(&_hx_pos_12e7dd114cfbd541_271_chatId__fromC)
+HXDLIN( 271)		return this->chatId;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Chat_obj,chatId__fromC,return )
+
+int Chat_obj::uiState__fromC(){
+            	HX_STACKFRAME(&_hx_pos_12e7dd114cfbd541_271_uiState__fromC)
+HXDLIN( 271)		return this->uiState;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Chat_obj,uiState__fromC,return )
+
+bool Chat_obj::isBlocked__fromC(){
+            	HX_STACKFRAME(&_hx_pos_12e7dd114cfbd541_271_isBlocked__fromC)
+HXDLIN( 271)		return this->isBlocked;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Chat_obj,isBlocked__fromC,return )
+
+HX_DEFINE_DYNAMIC_FUNC2(Chat_obj,prepareIncomingMessage,return )
+
+HX_DEFINE_DYNAMIC_FUNC3(Chat_obj,getMessagesBefore,(void))
+
+void Chat_obj::getMessagesBefore__fromC(::String beforeId,::String beforeTime,::cpp::Function< void  (void**,size_t,void*) > handler,void* handler__context){
+            		HX_BEGIN_LOCAL_FUNC_S2(::hx::LocalFunc,_hx_Closure_0,::cpp::Function< void  (void** HX_COMMA size_t HX_COMMA void*) >,handler,void*,handler__context) HXARGC(1)
+            		void _hx_run(::Array< ::Dynamic> a0){
+            			HX_GC_STACKFRAME(&_hx_pos_12e7dd114cfbd541_221_getMessagesBefore__fromC)
+HXLINE( 221)			::cpp::Function< void  (void**,size_t,void*) > handler1 = handler;
+HXLINE( 211)			{
+HXLINE( 211)				int _g = 0;
+HXDLIN( 211)				while((_g < a0->length)){
+HXLINE( 211)					 ::snikket::ChatMessage el = a0->__get(_g).StaticCast<  ::snikket::ChatMessage >();
+HXDLIN( 211)					_g = (_g + 1);
+HXDLIN( 211)					{
+HXLINE( 211)						 ::Dynamic haxeObject = el;
+HXDLIN( 211)						void* ptr = haxeObject.mPtr;
+HXDLIN( 211)						::cpp::Int64 ptrInt64 = reinterpret_cast<int64_t>(ptr);
+HXDLIN( 211)						{
+HXLINE( 211)							 ::haxe::ds::IntMap this1 = ::_HaxeCBridge::Internal_obj::gcRetainMap;
+HXDLIN( 211)							int low = ptrInt64 & 0xffffffff;
+HXDLIN( 211)							int high = ptrInt64 >> 32;
+HXDLIN( 211)							 ::haxe::ds::IntMap highMap = ( ( ::haxe::ds::IntMap)(this1->get(low)) );
+HXDLIN( 211)							if (::hx::IsNull( highMap )) {
+HXLINE( 211)								highMap =  ::haxe::ds::IntMap_obj::__alloc( HX_CTX );
+HXDLIN( 211)								this1->set(low,highMap);
+            							}
+HXDLIN( 211)							highMap->set(high,haxeObject);
+            						}
+            					}
+            				}
+            			}
+HXDLIN( 211)			void** ptr1 = (void**)a0->getBase();
+HXDLIN( 211)			::cpp::Int64 ptrInt641 = reinterpret_cast<int64_t>(ptr1);
+HXDLIN( 211)			{
+HXLINE( 211)				 ::haxe::ds::IntMap this2 = ::_HaxeCBridge::Internal_obj::gcRetainMap;
+HXDLIN( 211)				int low1 = ptrInt641 & 0xffffffff;
+HXDLIN( 211)				int high1 = ptrInt641 >> 32;
+HXDLIN( 211)				 ::haxe::ds::IntMap highMap1 = ( ( ::haxe::ds::IntMap)(this2->get(low1)) );
+HXDLIN( 211)				if (::hx::IsNull( highMap1 )) {
+HXLINE( 211)					highMap1 =  ::haxe::ds::IntMap_obj::__alloc( HX_CTX );
+HXDLIN( 211)					this2->set(low1,highMap1);
+            				}
+HXDLIN( 211)				highMap1->set(high1,a0);
+            			}
+HXLINE( 221)			handler1(ptr1,( (size_t)(a0->length) ),handler__context);
+            		}
+            		HX_END_LOCAL_FUNC1((void))
+
+            	HX_STACKFRAME(&_hx_pos_12e7dd114cfbd541_244_getMessagesBefore__fromC)
+HXDLIN( 244)		this->getMessagesBefore(beforeId,beforeTime, ::Dynamic(new _hx_Closure_0(handler,handler__context)));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC3(Chat_obj,getMessagesAfter,(void))
+
+void Chat_obj::getMessagesAfter__fromC(::String afterId,::String afterTime,::cpp::Function< void  (void**,size_t,void*) > handler,void* handler__context){
+            		HX_BEGIN_LOCAL_FUNC_S2(::hx::LocalFunc,_hx_Closure_0,::cpp::Function< void  (void** HX_COMMA size_t HX_COMMA void*) >,handler,void*,handler__context) HXARGC(1)
+            		void _hx_run(::Array< ::Dynamic> a0){
+            			HX_GC_STACKFRAME(&_hx_pos_12e7dd114cfbd541_221_getMessagesAfter__fromC)
+HXLINE( 221)			::cpp::Function< void  (void**,size_t,void*) > handler1 = handler;
+HXLINE( 211)			{
+HXLINE( 211)				int _g = 0;
+HXDLIN( 211)				while((_g < a0->length)){
+HXLINE( 211)					 ::snikket::ChatMessage el = a0->__get(_g).StaticCast<  ::snikket::ChatMessage >();
+HXDLIN( 211)					_g = (_g + 1);
+HXDLIN( 211)					{
+HXLINE( 211)						 ::Dynamic haxeObject = el;
+HXDLIN( 211)						void* ptr = haxeObject.mPtr;
+HXDLIN( 211)						::cpp::Int64 ptrInt64 = reinterpret_cast<int64_t>(ptr);
+HXDLIN( 211)						{
+HXLINE( 211)							 ::haxe::ds::IntMap this1 = ::_HaxeCBridge::Internal_obj::gcRetainMap;
+HXDLIN( 211)							int low = ptrInt64 & 0xffffffff;
+HXDLIN( 211)							int high = ptrInt64 >> 32;
+HXDLIN( 211)							 ::haxe::ds::IntMap highMap = ( ( ::haxe::ds::IntMap)(this1->get(low)) );
+HXDLIN( 211)							if (::hx::IsNull( highMap )) {
+HXLINE( 211)								highMap =  ::haxe::ds::IntMap_obj::__alloc( HX_CTX );
+HXDLIN( 211)								this1->set(low,highMap);
+            							}
+HXDLIN( 211)							highMap->set(high,haxeObject);
+            						}
+            					}
+            				}
+            			}
+HXDLIN( 211)			void** ptr1 = (void**)a0->getBase();
+HXDLIN( 211)			::cpp::Int64 ptrInt641 = reinterpret_cast<int64_t>(ptr1);
+HXDLIN( 211)			{
+HXLINE( 211)				 ::haxe::ds::IntMap this2 = ::_HaxeCBridge::Internal_obj::gcRetainMap;
+HXDLIN( 211)				int low1 = ptrInt641 & 0xffffffff;
+HXDLIN( 211)				int high1 = ptrInt641 >> 32;
+HXDLIN( 211)				 ::haxe::ds::IntMap highMap1 = ( ( ::haxe::ds::IntMap)(this2->get(low1)) );
+HXDLIN( 211)				if (::hx::IsNull( highMap1 )) {
+HXLINE( 211)					highMap1 =  ::haxe::ds::IntMap_obj::__alloc( HX_CTX );
+HXDLIN( 211)					this2->set(low1,highMap1);
+            				}
+HXDLIN( 211)				highMap1->set(high1,a0);
+            			}
+HXLINE( 221)			handler1(ptr1,( (size_t)(a0->length) ),handler__context);
+            		}
+            		HX_END_LOCAL_FUNC1((void))
+
+            	HX_STACKFRAME(&_hx_pos_12e7dd114cfbd541_244_getMessagesAfter__fromC)
+HXDLIN( 244)		this->getMessagesAfter(afterId,afterTime, ::Dynamic(new _hx_Closure_0(handler,handler__context)));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC3(Chat_obj,getMessagesAround,(void))
+
+void Chat_obj::getMessagesAround__fromC(::String aroundId,::String aroundTime,::cpp::Function< void  (void**,size_t,void*) > handler,void* handler__context){
+            		HX_BEGIN_LOCAL_FUNC_S2(::hx::LocalFunc,_hx_Closure_0,::cpp::Function< void  (void** HX_COMMA size_t HX_COMMA void*) >,handler,void*,handler__context) HXARGC(1)
+            		void _hx_run(::Array< ::Dynamic> a0){
+            			HX_GC_STACKFRAME(&_hx_pos_12e7dd114cfbd541_221_getMessagesAround__fromC)
+HXLINE( 221)			::cpp::Function< void  (void**,size_t,void*) > handler1 = handler;
+HXLINE( 211)			{
+HXLINE( 211)				int _g = 0;
+HXDLIN( 211)				while((_g < a0->length)){
+HXLINE( 211)					 ::snikket::ChatMessage el = a0->__get(_g).StaticCast<  ::snikket::ChatMessage >();
+HXDLIN( 211)					_g = (_g + 1);
+HXDLIN( 211)					{
+HXLINE( 211)						 ::Dynamic haxeObject = el;
+HXDLIN( 211)						void* ptr = haxeObject.mPtr;
+HXDLIN( 211)						::cpp::Int64 ptrInt64 = reinterpret_cast<int64_t>(ptr);
+HXDLIN( 211)						{
+HXLINE( 211)							 ::haxe::ds::IntMap this1 = ::_HaxeCBridge::Internal_obj::gcRetainMap;
+HXDLIN( 211)							int low = ptrInt64 & 0xffffffff;
+HXDLIN( 211)							int high = ptrInt64 >> 32;
+HXDLIN( 211)							 ::haxe::ds::IntMap highMap = ( ( ::haxe::ds::IntMap)(this1->get(low)) );
+HXDLIN( 211)							if (::hx::IsNull( highMap )) {
+HXLINE( 211)								highMap =  ::haxe::ds::IntMap_obj::__alloc( HX_CTX );
+HXDLIN( 211)								this1->set(low,highMap);
+            							}
+HXDLIN( 211)							highMap->set(high,haxeObject);
+            						}
+            					}
+            				}
+            			}
+HXDLIN( 211)			void** ptr1 = (void**)a0->getBase();
+HXDLIN( 211)			::cpp::Int64 ptrInt641 = reinterpret_cast<int64_t>(ptr1);
+HXDLIN( 211)			{
+HXLINE( 211)				 ::haxe::ds::IntMap this2 = ::_HaxeCBridge::Internal_obj::gcRetainMap;
+HXDLIN( 211)				int low1 = ptrInt641 & 0xffffffff;
+HXDLIN( 211)				int high1 = ptrInt641 >> 32;
+HXDLIN( 211)				 ::haxe::ds::IntMap highMap1 = ( ( ::haxe::ds::IntMap)(this2->get(low1)) );
+HXDLIN( 211)				if (::hx::IsNull( highMap1 )) {
+HXLINE( 211)					highMap1 =  ::haxe::ds::IntMap_obj::__alloc( HX_CTX );
+HXDLIN( 211)					this2->set(low1,highMap1);
+            				}
+HXDLIN( 211)				highMap1->set(high1,a0);
+            			}
+HXLINE( 221)			handler1(ptr1,( (size_t)(a0->length) ),handler__context);
+            		}
+            		HX_END_LOCAL_FUNC1((void))
+
+            	HX_STACKFRAME(&_hx_pos_12e7dd114cfbd541_244_getMessagesAround__fromC)
+HXDLIN( 244)		this->getMessagesAround(aroundId,aroundTime, ::Dynamic(new _hx_Closure_0(handler,handler__context)));
+            	}
+
+
+void Chat_obj::fetchFromSync( ::snikket::MessageSync sync, ::Dynamic callback){
+            		HX_BEGIN_LOCAL_FUNC_S2(::hx::LocalFunc,_hx_Closure_2, ::snikket::Chat,_gthis, ::Dynamic,callback) HXARGC(1)
+            		void _hx_run( ::Dynamic messageList){
+            			HX_BEGIN_LOCAL_FUNC_S2(::hx::LocalFunc,_hx_Closure_1, ::snikket::Chat,_gthis, ::Dynamic,callback) HXARGC(1)
+            			void _hx_run(::Array< ::Dynamic> chatMessages){
+            				HX_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_143_fetchFromSync)
+HXLINE( 143)				 ::Dynamic callback1 = callback;
+HXDLIN( 143)				::Array< ::Dynamic> _g = ::Array_obj< ::Dynamic>::__new(0);
+HXDLIN( 143)				{
+HXLINE( 143)					int _g1 = 0;
+HXDLIN( 143)					::Array< ::Dynamic> _g2 = chatMessages;
+HXDLIN( 143)					while((_g1 < _g2->length)){
+HXLINE( 143)						 ::snikket::ChatMessage v = _g2->__get(_g1).StaticCast<  ::snikket::ChatMessage >();
+HXDLIN( 143)						_g1 = (_g1 + 1);
+HXDLIN( 143)						bool _hx_tmp;
+HXDLIN( 143)						if (::hx::IsNotNull( v )) {
+HXLINE( 143)							::String _hx_tmp1 = v->chatId();
+HXDLIN( 143)							_hx_tmp = (_hx_tmp1 == _gthis->chatId);
+            						}
+            						else {
+HXLINE( 143)							_hx_tmp = false;
+            						}
+HXDLIN( 143)						if (_hx_tmp) {
+HXLINE( 143)							_g->push(v);
+            						}
+            					}
+            				}
+HXDLIN( 143)				callback1(_g);
+            			}
+            			HX_END_LOCAL_FUNC1((void))
+
+            			HX_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_128_fetchFromSync)
+HXLINE( 129)			::Array< ::Dynamic> chatMessages = ::Array_obj< ::Dynamic>::__new(0);
+HXLINE( 130)			{
+HXLINE( 130)				int _g = 0;
+HXDLIN( 130)				::Array< ::Dynamic> _g1 = ( (::Array< ::Dynamic>)(messageList->__Field(HX_("messages",cc,d8,fd,34),::hx::paccDynamic)) );
+HXDLIN( 130)				while((_g < _g1->length)){
+HXLINE( 130)					 ::snikket::MessageStanza m = _g1->__get(_g).StaticCast<  ::snikket::MessageStanza >();
+HXDLIN( 130)					_g = (_g + 1);
+HXLINE( 131)					switch((int)(m->_hx_getIndex())){
+            						case (int)1: {
+HXLINE( 132)							 ::snikket::ChatMessage message = m->_hx_getObject(0).StaticCast<  ::snikket::ChatMessage >();
+HXLINE( 133)							chatMessages->push(message);
+            						}
+            						break;
+            						case (int)2: {
+HXLINE( 136)							 ::snikket::ModerationAction action = m->_hx_getObject(0).StaticCast<  ::snikket::ModerationAction >();
+HXLINE( 137)							_gthis->client->moderateMessage(action);
+            						}
+            						break;
+            						case (int)3: {
+            							HX_BEGIN_LOCAL_FUNC_S0(::hx::LocalFunc,_hx_Closure_0) HXARGC(1)
+            							void _hx_run( ::snikket::ChatMessage m){
+            								HX_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_135_fetchFromSync)
+            							}
+            							HX_END_LOCAL_FUNC1((void))
+
+HXLINE( 134)							 ::snikket::ReactionUpdate update = m->_hx_getObject(0).StaticCast<  ::snikket::ReactionUpdate >();
+HXLINE( 135)							::Dynamic _gthis1 = _gthis->persistence;
+HXDLIN( 135)							::snikket::Persistence_obj::storeReaction(_gthis1,_gthis->client->accountId(),update, ::Dynamic(new _hx_Closure_0()));
+            						}
+            						break;
+            						default:{
+            						}
+            					}
+            				}
+            			}
+HXLINE( 142)			_gthis->client->storeMessages(chatMessages, ::Dynamic(new _hx_Closure_1(_gthis,callback)));
+            		}
+            		HX_END_LOCAL_FUNC1((void))
+
+            	HX_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_127_fetchFromSync)
+HXDLIN( 127)		 ::snikket::Chat _gthis = ::hx::ObjectPtr<OBJ_>(this);
+HXLINE( 128)		sync->onMessages( ::Dynamic(new _hx_Closure_2(_gthis,callback)));
+HXLINE( 146)		sync->fetchNext();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(Chat_obj,fetchFromSync,(void))
+
+HX_DEFINE_DYNAMIC_FUNC1(Chat_obj,sendMessage,(void))
+
+void Chat_obj::sendMessage__fromC( ::snikket::ChatMessageBuilder message){
+            	HX_STACKFRAME(&_hx_pos_12e7dd114cfbd541_244_sendMessage__fromC)
+HXDLIN( 244)		this->sendMessage(message);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Chat_obj,sendMessage__fromC,(void))
+
+HX_DEFINE_DYNAMIC_FUNC1(Chat_obj,markReadUpTo,(void))
+
+void Chat_obj::markReadUpTo__fromC( ::snikket::ChatMessage message){
+            	HX_STACKFRAME(&_hx_pos_12e7dd114cfbd541_244_markReadUpTo__fromC)
+HXDLIN( 244)		this->markReadUpTo(message);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Chat_obj,markReadUpTo__fromC,(void))
+
+HX_DEFINE_DYNAMIC_FUNC0(Chat_obj,bookmark,(void))
+
+void Chat_obj::bookmark__fromC(){
+            	HX_STACKFRAME(&_hx_pos_12e7dd114cfbd541_244_bookmark__fromC)
+HXDLIN( 244)		this->bookmark();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Chat_obj,bookmark__fromC,(void))
+
+HX_DEFINE_DYNAMIC_FUNC0(Chat_obj,getParticipants,return )
+
+size_t Chat_obj::getParticipants__fromC(const char*** outPtr){
+            	HX_GC_STACKFRAME(&_hx_pos_12e7dd114cfbd541_242_getParticipants__fromC)
+HXDLIN( 242)		::Array< ::String > out = this->getParticipants();
+HXDLIN( 242)		if (::hx::IsNotNull( outPtr )) {
+HXDLIN( 242)			::cpp::Pointer< const char** > _hx_tmp = ::cpp::Pointer_obj::fromRaw(outPtr);
+HXDLIN( 242)			::Array< size_t > arr = ::Array_obj< size_t >::__new(out->length);
+HXDLIN( 242)			{
+HXDLIN( 242)				int _g_current = 0;
+HXDLIN( 242)				::Array< ::String > _g_array = out;
+HXDLIN( 242)				while((_g_current < _g_array->length)){
+HXDLIN( 242)					::String _g_value = _g_array->__get(_g_current);
+HXDLIN( 242)					_g_current = (_g_current + 1);
+HXDLIN( 242)					int _g_key = (_g_current - 1);
+HXDLIN( 242)					int i = _g_key;
+HXDLIN( 242)					::String el = _g_value;
+HXDLIN( 242)					{
+HXDLIN( 242)						const char* cStrPtr = el.utf8_str();
+HXDLIN( 242)						::cpp::Int64 ptrInt64 = reinterpret_cast<int64_t>(cStrPtr);
+HXDLIN( 242)						{
+HXDLIN( 242)							 ::haxe::ds::IntMap this1 = ::_HaxeCBridge::Internal_obj::gcRetainMap;
+HXDLIN( 242)							int low = ptrInt64 & 0xffffffff;
+HXDLIN( 242)							int high = ptrInt64 >> 32;
+HXDLIN( 242)							 ::haxe::ds::IntMap highMap = ( ( ::haxe::ds::IntMap)(this1->get(low)) );
+HXDLIN( 242)							if (::hx::IsNull( highMap )) {
+HXLINE(2083)								highMap =  ::haxe::ds::IntMap_obj::__alloc( HX_CTX );
+HXLINE( 242)								this1->set(low,highMap);
+            							}
+HXDLIN( 242)							highMap->set(high,el);
+            						}
+HXDLIN( 242)						const char* ptr = cStrPtr;
+HXDLIN( 242)						arr[i] = reinterpret_cast<size_t>(ptr);
+            					}
+            				}
+            			}
+HXDLIN( 242)			void** ptr1 = (void**)arr->getBase();
+HXDLIN( 242)			::cpp::Int64 ptrInt641 = reinterpret_cast<int64_t>(ptr1);
+HXDLIN( 242)			{
+HXDLIN( 242)				 ::haxe::ds::IntMap this2 = ::_HaxeCBridge::Internal_obj::gcRetainMap;
+HXDLIN( 242)				int low1 = ptrInt641 & 0xffffffff;
+HXDLIN( 242)				int high1 = ptrInt641 >> 32;
+HXDLIN( 242)				 ::haxe::ds::IntMap highMap1 = ( ( ::haxe::ds::IntMap)(this2->get(low1)) );
+HXDLIN( 242)				if (::hx::IsNull( highMap1 )) {
+HXLINE(2083)					highMap1 =  ::haxe::ds::IntMap_obj::__alloc( HX_CTX );
+HXLINE( 242)					this2->set(low1,highMap1);
+            				}
+HXDLIN( 242)				highMap1->set(high1,arr);
+            			}
+HXDLIN( 242)			_hx_tmp->set_ref(( (const char**)(ptr1) ));
+            		}
+HXDLIN( 242)		return ( (size_t)(out->length) );
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Chat_obj,getParticipantDetails,return )
+
+ ::snikket::Participant Chat_obj::getParticipantDetails__fromC(::String participantId){
+            	HX_STACKFRAME(&_hx_pos_12e7dd114cfbd541_244_getParticipantDetails__fromC)
+HXDLIN( 244)		return this->getParticipantDetails(participantId);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Chat_obj,getParticipantDetails__fromC,return )
+
+HX_DEFINE_DYNAMIC_FUNC2(Chat_obj,correctMessage,(void))
+
+void Chat_obj::correctMessage__fromC(::String localId, ::snikket::ChatMessageBuilder message){
+            	HX_STACKFRAME(&_hx_pos_12e7dd114cfbd541_244_correctMessage__fromC)
+HXDLIN( 244)		this->correctMessage(localId,message);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(Chat_obj,correctMessage__fromC,(void))
+
+void Chat_obj::addReaction( ::snikket::ChatMessage m, ::snikket::Reaction reaction){
+            		HX_BEGIN_LOCAL_FUNC_S1(::hx::LocalFunc,_hx_Closure_0, ::snikket::ChatMessageBuilder,toSend) HXARGC(1)
+            		void _hx_run(::String text){
+            			HX_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_203_addReaction)
+HXLINE( 203)			toSend->text = ::StringTools_obj::replace(text,HX_W(u"\ufe0f",fb86,00b5),HX_("",00,00,00,00));
+            		}
+            		HX_END_LOCAL_FUNC1((void))
+
+            		HX_BEGIN_LOCAL_FUNC_S1(::hx::LocalFunc,_hx_Closure_1, ::snikket::ChatMessageBuilder,toSend) HXARGC(2)
+            		void _hx_run(::String text,::String uri){
+            			HX_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_206_addReaction)
+HXLINE( 207)			 ::snikket::Hash hash = ::snikket::Hash_obj::fromUri(uri);
+HXLINE( 208)			 ::snikket::ChatMessageBuilder toSend1 = toSend;
+HXDLIN( 208)			::String _hx_tmp = ((HX_("<img alt=\"",15,9f,1a,99) + ::snikket::_Util::Util_Fields__obj::xmlEscape(text)) + HX_("\" src=\"",ab,ae,ff,d3));
+HXDLIN( 208)			::String _hx_tmp1;
+HXDLIN( 208)			if (::hx::IsNull( hash )) {
+HXLINE( 208)				_hx_tmp1 = uri;
+            			}
+            			else {
+HXLINE( 208)				_hx_tmp1 = hash->bobUri();
+            			}
+HXDLIN( 208)			toSend1->setHtml(((_hx_tmp + ::snikket::_Util::Util_Fields__obj::xmlEscape(_hx_tmp1)) + HX_("\" />",6d,b2,91,16)));
+            		}
+            		HX_END_LOCAL_FUNC2((void))
+
+            	HX_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_198_addReaction)
+HXLINE( 199)		 ::snikket::ChatMessageBuilder toSend = m->reply();
+HXLINE( 200)		toSend->localId = ::snikket::ID_obj::_hx_long();
+HXLINE( 201)		reaction->render( ::Dynamic(new _hx_Closure_0(toSend)), ::Dynamic(new _hx_Closure_1(toSend)));
+HXLINE( 211)		this->sendMessage(toSend);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(Chat_obj,addReaction,(void))
+
+HX_DEFINE_DYNAMIC_FUNC2(Chat_obj,removeReaction,(void))
+
+void Chat_obj::removeReaction__fromC( ::snikket::ChatMessage m, ::snikket::Reaction reaction){
+            	HX_STACKFRAME(&_hx_pos_12e7dd114cfbd541_244_removeReaction__fromC)
+HXDLIN( 244)		this->removeReaction(m,reaction);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(Chat_obj,removeReaction__fromC,(void))
+
+HX_DEFINE_DYNAMIC_FUNC2(Chat_obj,sendChatState,(void))
+
+void Chat_obj::typing(::String threadId,::String content){
+            		HX_BEGIN_LOCAL_FUNC_S1(::hx::LocalFunc,_hx_Closure_1, ::snikket::Chat,_gthis) HXARGC(0)
+            		void _hx_run(){
+            			HX_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_251_typing)
+HXLINE( 252)			_gthis->sendChatState(HX_("paused",ae,40,84,ef),_gthis->typingThread);
+HXLINE( 253)			_gthis->isTyping = false;
+            		}
+            		HX_END_LOCAL_FUNC0((void))
+
+            	HX_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_230_typing)
+HXDLIN( 230)		 ::snikket::Chat _gthis = ::hx::ObjectPtr<OBJ_>(this);
+HXLINE( 231)		bool _hx_tmp;
+HXDLIN( 231)		if ((threadId != this->typingThread)) {
+HXLINE( 231)			_hx_tmp = this->isTyping;
+            		}
+            		else {
+HXLINE( 231)			_hx_tmp = false;
+            		}
+HXDLIN( 231)		if (_hx_tmp) {
+HXLINE( 233)			this->sendChatState(HX_("paused",ae,40,84,ef),this->typingThread);
+HXLINE( 234)			this->isTyping = false;
+            		}
+HXLINE( 237)		this->typingThread = threadId;
+HXLINE( 238)		if (::hx::IsNotNull( this->typingTimer )) {
+HXLINE( 238)			this->typingTimer->stop();
+            		}
+HXLINE( 240)		if ((content == HX_("",00,00,00,00))) {
+HXLINE( 241)			this->isTyping = false;
+HXLINE( 242)			this->sendChatState(HX_("active",c6,41,46,16),this->typingThread);
+HXLINE( 243)			if (::hx::IsNull( this->isActive )) {
+            				HX_BEGIN_LOCAL_FUNC_S1(::hx::LocalFunc,_hx_Closure_0, ::snikket::Chat,_gthis) HXARGC(0)
+            				void _hx_run(){
+            					HX_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_245_typing)
+HXLINE( 245)					_gthis->sendChatState(HX_("inactive",6b,17,30,6a),_gthis->typingThread);
+            				}
+            				HX_END_LOCAL_FUNC0((void))
+
+HXLINE( 244)				this->typingTimer = ::haxe::Timer_obj::delay( ::Dynamic(new _hx_Closure_0(_gthis)),30000);
+            			}
+HXLINE( 248)			return;
+            		}
+HXLINE( 251)		this->typingTimer = ::haxe::Timer_obj::delay( ::Dynamic(new _hx_Closure_1(_gthis)),10000);
+HXLINE( 256)		if (this->isTyping) {
+HXLINE( 256)			return;
+            		}
+HXLINE( 257)		this->isTyping = true;
+HXLINE( 258)		this->sendChatState(HX_("composing",cf,0a,a5,12),this->typingThread);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(Chat_obj,typing,(void))
+
+void Chat_obj::setActive(bool active,::String threadId){
+            	HX_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_269_setActive)
+HXLINE( 270)		if (::hx::IsNotNull( this->typingTimer )) {
+HXLINE( 270)			this->typingTimer->stop();
+            		}
+HXLINE( 271)		this->isTyping = false;
+HXLINE( 273)		bool _hx_tmp;
+HXDLIN( 273)		bool _hx_tmp1;
+HXDLIN( 273)		if (( (bool)(this->isActive) )) {
+HXLINE( 273)			_hx_tmp1 = active;
+            		}
+            		else {
+HXLINE( 273)			_hx_tmp1 = false;
+            		}
+HXDLIN( 273)		if (_hx_tmp1) {
+HXLINE( 273)			_hx_tmp = (threadId != this->activeThread);
+            		}
+            		else {
+HXLINE( 273)			_hx_tmp = false;
+            		}
+HXDLIN( 273)		if (_hx_tmp) {
+HXLINE( 274)			this->sendChatState(HX_("inactive",6b,17,30,6a),this->activeThread);
+HXLINE( 275)			this->isActive = false;
+            		}
+HXLINE( 277)		if (::hx::IsNotNull( this->isActive )) {
+HXLINE( 278)			bool _hx_tmp2;
+HXDLIN( 278)			if (( (bool)(this->isActive) )) {
+HXLINE( 278)				_hx_tmp2 = active;
+            			}
+            			else {
+HXLINE( 278)				_hx_tmp2 = false;
+            			}
+HXDLIN( 278)			if (_hx_tmp2) {
+HXLINE( 278)				return;
+            			}
+HXLINE( 279)			bool _hx_tmp3;
+HXDLIN( 279)			if (!(( (bool)(this->isActive) ))) {
+HXLINE( 279)				_hx_tmp3 = !(active);
+            			}
+            			else {
+HXLINE( 279)				_hx_tmp3 = false;
+            			}
+HXDLIN( 279)			if (_hx_tmp3) {
+HXLINE( 279)				return;
+            			}
+            		}
+HXLINE( 281)		this->isActive = active;
+HXLINE( 282)		this->activeThread = threadId;
+HXLINE( 283)		::String _hx_tmp4;
+HXDLIN( 283)		if (active) {
+HXLINE( 283)			_hx_tmp4 = HX_("active",c6,41,46,16);
+            		}
+            		else {
+HXLINE( 283)			_hx_tmp4 = HX_("inactive",6b,17,30,6a);
+            		}
+HXDLIN( 283)		this->sendChatState(_hx_tmp4,this->activeThread);
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(Chat_obj,setActive,(void))
+
+HX_DEFINE_DYNAMIC_FUNC0(Chat_obj,close,(void))
+
+void Chat_obj::close__fromC(){
+            	HX_STACKFRAME(&_hx_pos_12e7dd114cfbd541_244_close__fromC)
+HXDLIN( 244)		this->close();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Chat_obj,close__fromC,(void))
+
+void Chat_obj::togglePinned(){
+            	HX_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_294_togglePinned)
+HXLINE( 295)		int _hx_tmp;
+HXDLIN( 295)		if ((this->uiState == 0)) {
+HXLINE( 295)			_hx_tmp = 1;
+            		}
+            		else {
+HXLINE( 295)			_hx_tmp = 0;
+            		}
+HXDLIN( 295)		this->uiState = _hx_tmp;
+HXLINE( 296)		::Dynamic _hx_tmp1 = this->persistence;
+HXDLIN( 296)		::snikket::Persistence_obj::storeChats(_hx_tmp1,this->client->accountId(),::Array_obj< ::Dynamic>::__new(1)->init(0,::hx::ObjectPtr<OBJ_>(this)));
+HXLINE( 297)		this->client->sortChats();
+HXLINE( 298)		this->client->trigger(HX_("chats/update",3d,8e,1d,14),::cpp::VirtualArray_obj::__new(1)->init(0,::hx::ObjectPtr<OBJ_>(this)));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Chat_obj,togglePinned,(void))
+
+void Chat_obj::block( ::snikket::ChatMessage reportSpam,bool onServer){
+            	HX_GC_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_304_block)
+HXLINE( 305)		bool _hx_tmp;
+HXDLIN( 305)		if (::hx::IsNotNull( reportSpam )) {
+HXLINE( 305)			_hx_tmp = !(onServer);
+            		}
+            		else {
+HXLINE( 305)			_hx_tmp = false;
+            		}
+HXDLIN( 305)		if (_hx_tmp) {
+HXLINE( 305)			HX_STACK_DO_THROW(HX_("Can't report SPAM if not sending to server",60,59,79,c5));
+            		}
+HXLINE( 306)		this->isBlocked = true;
+HXLINE( 307)		if ((this->uiState == 2)) {
+HXLINE( 308)			::Dynamic _hx_tmp1 = this->persistence;
+HXDLIN( 308)			::snikket::Persistence_obj::storeChats(_hx_tmp1,this->client->accountId(),::Array_obj< ::Dynamic>::__new(1)->init(0,::hx::ObjectPtr<OBJ_>(this)));
+            		}
+            		else {
+HXLINE( 310)			this->close();
+            		}
+HXLINE( 312)		if (onServer) {
+            			HX_BEGIN_LOCAL_FUNC_S0(::hx::LocalFunc,_hx_Closure_0) HXARGC(1)
+            			void _hx_run( ::snikket::Stanza response){
+            				HX_GC_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_321_block)
+            			}
+            			HX_END_LOCAL_FUNC1((void))
+
+HXLINE( 313)			::String iq = ::snikket::ID_obj::_hx_short();
+HXDLIN( 313)			 ::snikket::Stanza iq1 =  ::snikket::Stanza_obj::__alloc( HX_CTX ,HX_("iq",e8,5b,00,00), ::Dynamic(::hx::Anon_obj::Create(2)
+            				->setFixed(0,HX_("id",db,5b,00,00),iq)
+            				->setFixed(1,HX_("type",ba,f2,08,4d),HX_("set",a2,9b,57,00))))->tag(HX_("block",4d,75,fc,b4), ::Dynamic(::hx::Anon_obj::Create(1)
+            				->setFixed(0,HX_("xmlns",dc,31,74,60),HX_("urn:xmpp:blocking",d1,a1,46,c3))))->tag(HX_("item",13,c5,bf,45), ::Dynamic(::hx::Anon_obj::Create(1)
+            				->setFixed(0,HX_("jid",c5,ca,50,00),this->chatId)));
+HXLINE( 316)			if (::hx::IsNotNull( reportSpam )) {
+HXLINE( 317)				iq1->tag(HX_("report",b4,3c,84,06), ::Dynamic(::hx::Anon_obj::Create(2)
+            					->setFixed(0,HX_("reason",c4,0f,9d,fc),HX_("urn:xmpp:reporting:spam",b1,09,15,35))
+            					->setFixed(1,HX_("xmlns",dc,31,74,60),HX_("urn:xmpp:reporting:1",49,f0,16,fc))))->tag(HX_("stanza-id",73,8a,54,e9), ::Dynamic(::hx::Anon_obj::Create(3)
+            					->setFixed(0,HX_("by",d7,55,00,00),reportSpam->serverIdBy)
+            					->setFixed(1,HX_("id",db,5b,00,00),reportSpam->serverId)
+            					->setFixed(2,HX_("xmlns",dc,31,74,60),HX_("urn:xmpp:sid:0",a8,4b,37,54))));
+            			}
+HXLINE( 321)			this->stream->sendIq(iq1, ::Dynamic(new _hx_Closure_0()));
+            		}
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC2(Chat_obj,block,(void))
+
+void Chat_obj::unblock(bool onServer){
+            	HX_GC_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_328_unblock)
+HXLINE( 329)		this->isBlocked = false;
+HXLINE( 330)		this->uiState = 1;
+HXLINE( 331)		::Dynamic _hx_tmp = this->persistence;
+HXDLIN( 331)		::snikket::Persistence_obj::storeChats(_hx_tmp,this->client->accountId(),::Array_obj< ::Dynamic>::__new(1)->init(0,::hx::ObjectPtr<OBJ_>(this)));
+HXLINE( 332)		this->client->trigger(HX_("chats/update",3d,8e,1d,14),::cpp::VirtualArray_obj::__new(1)->init(0,::hx::ObjectPtr<OBJ_>(this)));
+HXLINE( 333)		if (onServer) {
+            			HX_BEGIN_LOCAL_FUNC_S0(::hx::LocalFunc,_hx_Closure_0) HXARGC(1)
+            			void _hx_run( ::snikket::Stanza response){
+            				HX_GC_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_338_unblock)
+            			}
+            			HX_END_LOCAL_FUNC1((void))
+
+HXLINE( 334)			 ::snikket::GenericStream _hx_tmp1 = this->stream;
+HXLINE( 335)			::String _hx_tmp2 = ::snikket::ID_obj::_hx_short();
+HXLINE( 334)			_hx_tmp1->sendIq( ::snikket::Stanza_obj::__alloc( HX_CTX ,HX_("iq",e8,5b,00,00), ::Dynamic(::hx::Anon_obj::Create(2)
+            				->setFixed(0,HX_("id",db,5b,00,00),_hx_tmp2)
+            				->setFixed(1,HX_("type",ba,f2,08,4d),HX_("set",a2,9b,57,00))))->tag(HX_("unblock",54,6c,8d,b1), ::Dynamic(::hx::Anon_obj::Create(1)
+            				->setFixed(0,HX_("xmlns",dc,31,74,60),HX_("urn:xmpp:blocking",d1,a1,46,c3))))->tag(HX_("item",13,c5,bf,45), ::Dynamic(::hx::Anon_obj::Create(1)
+            				->setFixed(0,HX_("jid",c5,ca,50,00),this->chatId)))->up()->up(), ::Dynamic(new _hx_Closure_0()));
+            		}
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Chat_obj,unblock,(void))
+
+void Chat_obj::setNotifications(bool filtered,bool mention,bool reply){
+            	HX_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_346_setNotifications)
+HXLINE( 347)		if (filtered) {
+HXLINE( 348)			this->notificationSettings =  ::Dynamic(::hx::Anon_obj::Create(2)
+            				->setFixed(0,HX_("mention",ea,9e,bf,b9),mention)
+            				->setFixed(1,HX_("reply",2a,09,c6,e6),reply));
+            		}
+            		else {
+HXLINE( 350)			this->notificationSettings = null();
+            		}
+HXLINE( 352)		::Dynamic _hx_tmp = this->persistence;
+HXDLIN( 352)		::snikket::Persistence_obj::storeChats(_hx_tmp,this->client->accountId(),::Array_obj< ::Dynamic>::__new(1)->init(0,::hx::ObjectPtr<OBJ_>(this)));
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC3(Chat_obj,setNotifications,(void))
+
+bool Chat_obj::notificationsFiltered(){
+            	HX_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_362_notificationsFiltered)
+HXDLIN( 362)		return ::hx::IsNotNull( this->notificationSettings );
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Chat_obj,notificationsFiltered,return )
+
+bool Chat_obj::notifyMention(){
+            	HX_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_369_notifyMention)
+HXDLIN( 369)		if (::hx::IsNotNull( this->notificationSettings )) {
+HXDLIN( 369)			return ( (bool)(this->notificationSettings->__Field(HX_("mention",ea,9e,bf,b9),::hx::paccDynamic)) );
+            		}
+            		else {
+HXDLIN( 369)			return true;
+            		}
+HXDLIN( 369)		return false;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Chat_obj,notifyMention,return )
+
+bool Chat_obj::notifyReply(){
+            	HX_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_376_notifyReply)
+HXDLIN( 376)		if (::hx::IsNotNull( this->notificationSettings )) {
+HXDLIN( 376)			return ( (bool)(this->notificationSettings->__Field(HX_("reply",2a,09,c6,e6),::hx::paccDynamic)) );
+            		}
+            		else {
+HXDLIN( 376)			return true;
+            		}
+HXDLIN( 376)		return false;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Chat_obj,notifyReply,return )
+
+HX_DEFINE_DYNAMIC_FUNC0(Chat_obj,lastMessageId,return )
+
+::String Chat_obj::lastMessageId__fromC(){
+            	HX_STACKFRAME(&_hx_pos_12e7dd114cfbd541_244_lastMessageId__fromC)
+HXDLIN( 244)		return this->lastMessageId();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Chat_obj,lastMessageId__fromC,return )
+
+::String Chat_obj::lastMessageTimestamp(){
+            	HX_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_388_lastMessageTimestamp)
+HXDLIN( 388)		 ::snikket::ChatMessage tmp = this->lastMessage;
+HXDLIN( 388)		if (::hx::IsNotNull( tmp )) {
+HXDLIN( 388)			return tmp->timestamp;
+            		}
+            		else {
+HXDLIN( 388)			return null();
+            		}
+HXDLIN( 388)		return null();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Chat_obj,lastMessageTimestamp,return )
+
+void Chat_obj::updateFromBookmark( ::snikket::Stanza item){
+            	HX_GC_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_392_updateFromBookmark)
+HXLINE( 393)		 ::snikket::Stanza conf = item->getChild(HX_("conference",1c,2b,83,41),HX_("urn:xmpp:bookmarks:1",58,3c,53,7d));
+HXLINE( 394)		::String fn = ( (::String)(::Reflect_obj::field(conf->attr,HX_("name",4b,72,ff,48))) );
+HXLINE( 395)		if (::hx::IsNotNull( fn )) {
+HXLINE( 395)			this->displayName = fn;
+            		}
+HXLINE( 396)		int _hx_tmp;
+HXDLIN( 396)		bool _hx_tmp1;
+HXDLIN( 396)		if ((( (::String)(::Reflect_obj::field(conf->attr,HX_("autojoin",d9,f6,b1,3e))) ) != HX_("1",31,00,00,00))) {
+HXLINE( 396)			_hx_tmp1 = (( (::String)(::Reflect_obj::field(conf->attr,HX_("autojoin",d9,f6,b1,3e))) ) == HX_("true",4e,a7,03,4d));
+            		}
+            		else {
+HXLINE( 396)			_hx_tmp1 = true;
+            		}
+HXDLIN( 396)		if (_hx_tmp1) {
+HXLINE( 396)			if ((this->uiState == 0)) {
+HXLINE( 396)				_hx_tmp = 0;
+            			}
+            			else {
+HXLINE( 396)				_hx_tmp = 1;
+            			}
+            		}
+            		else {
+HXLINE( 396)			_hx_tmp = 2;
+            		}
+HXDLIN( 396)		this->uiState = _hx_tmp;
+HXLINE( 397)		 ::snikket::Stanza tmp = conf->getChild(HX_("extensions",14,7c,70,89),null());
+HXDLIN( 397)		 ::snikket::Stanza _hx_tmp2;
+HXDLIN( 397)		if (::hx::IsNotNull( tmp )) {
+HXLINE( 397)			_hx_tmp2 = tmp;
+            		}
+            		else {
+HXLINE( 397)			_hx_tmp2 =  ::snikket::Stanza_obj::__alloc( HX_CTX ,HX_("extensions",14,7c,70,89), ::Dynamic(::hx::Anon_obj::Create(1)
+            				->setFixed(0,HX_("xmlns",dc,31,74,60),HX_("urn:xmpp:bookmarks:1",58,3c,53,7d))));
+            		}
+HXDLIN( 397)		this->extensions = _hx_tmp2;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Chat_obj,updateFromBookmark,(void))
+
+void Chat_obj::updateFromRoster( ::Dynamic item){
+            	HX_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_401_updateFromRoster)
+HXLINE( 402)		bool _hx_tmp;
+HXDLIN( 402)		if (::hx::IsNotEq( item->__Field(HX_("subscription",1d,ff,00,36),::hx::paccDynamic),HX_("both",81,88,1b,41) )) {
+HXLINE( 402)			_hx_tmp = ::hx::IsEq( item->__Field(HX_("subscription",1d,ff,00,36),::hx::paccDynamic),HX_("from",6a,a5,c2,43) );
+            		}
+            		else {
+HXLINE( 402)			_hx_tmp = true;
+            		}
+HXDLIN( 402)		this->setTrusted(_hx_tmp);
+HXLINE( 403)		bool _hx_tmp1;
+HXDLIN( 403)		if (::hx::IsNotNull( item->__Field(HX_("fn",48,59,00,00),::hx::paccDynamic) )) {
+HXLINE( 403)			_hx_tmp1 = ::hx::IsNotEq( item->__Field(HX_("fn",48,59,00,00),::hx::paccDynamic),HX_("",00,00,00,00) );
+            		}
+            		else {
+HXLINE( 403)			_hx_tmp1 = false;
+            		}
+HXDLIN( 403)		if (_hx_tmp1) {
+HXLINE( 403)			this->displayName = ( (::String)(item->__Field(HX_("fn",48,59,00,00),::hx::paccDynamic)) );
+            		}
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Chat_obj,updateFromRoster,(void))
+
+::String Chat_obj::getPhoto(){
+            	HX_GC_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_409_getPhoto)
+HXLINE( 410)		bool _hx_tmp;
+HXDLIN( 410)		if (::hx::IsNotNull( this->avatarSha1 )) {
+HXLINE( 410)			_hx_tmp = (::haxe::io::Bytes_obj::ofData(this->avatarSha1)->length < 1);
+            		}
+            		else {
+HXLINE( 410)			_hx_tmp = true;
+            		}
+HXDLIN( 410)		if (_hx_tmp) {
+HXLINE( 410)			return null();
+            		}
+HXLINE( 411)		return  ::snikket::Hash_obj::__alloc( HX_CTX ,HX_("sha-1",90,a8,1c,7c),this->avatarSha1)->toUri();
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Chat_obj,getPhoto,return )
+
+::String Chat_obj::getPlaceholder(){
+            	HX_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_418_getPlaceholder)
+HXDLIN( 418)		::String _hx_tmp = this->chatId;
+HXDLIN( 418)		return ::snikket::Color_obj::defaultPhoto(_hx_tmp,this->getDisplayName().charAt(0).toUpperCase());
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Chat_obj,getPlaceholder,return )
+
+::String Chat_obj::readUpTo(){
+            	HX_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_425_readUpTo)
+HXDLIN( 425)		return this->readUpToId;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Chat_obj,readUpTo,return )
+
+int Chat_obj::unreadCount(){
+            	HX_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_432_unreadCount)
+HXDLIN( 432)		return this->_unreadCount;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC0(Chat_obj,unreadCount,return )
+
+void Chat_obj::setUnreadCount(int count){
+            	HX_STACKFRAME(&_hx_pos_3993c1e3d3f53fe2_437_setUnreadCount)
+HXDLIN( 437)		this->_unreadCount = count;
+            	}
+
+
+HX_DEFINE_DYNAMIC_FUNC1(Chat_obj,setUnreadCount,(void))
+
+::String Chat_obj::pr