diff --git a/koala-wrapper/koalaui/interop/src/cpp/SerializerBase.h b/koala-wrapper/koalaui/interop/src/cpp/SerializerBase.h
deleted file mode 100644
index f6cce0fae353bf1452a67ccef9f4606b52e2c74f..0000000000000000000000000000000000000000
--- a/koala-wrapper/koalaui/interop/src/cpp/SerializerBase.h
+++ /dev/null
@@ -1,264 +0,0 @@
-/*
- * Copyright (c) 2025 Huawei Device Co., Ltd.
- * 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.
- */
-
-#ifndef _SERIALIZER_BASE_H
-#define _SERIALIZER_BASE_H
-
-#include <cstdint>
-#include <cstdio>
-#include <cstring>
-#include <string>
-#include <memory>
-#include <cassert>
-#include <cstddef>
-#include <vector>
-
-#include "callback-resource.h"
-#include "interop-types.h"
-#include "koala-types.h"
-
-#ifdef __arm__
-#define KOALA_NO_UNALIGNED_ACCESS 1
-#endif
-
-template <typename T>
-inline InteropRuntimeType runtimeType(const T& value) = delete;
-
-template <>
-inline InteropRuntimeType runtimeType(const InteropCustomObject& value) {
-  return INTEROP_RUNTIME_OBJECT;
-}
-
-template <>
-inline InteropRuntimeType runtimeType(const InteropMaterialized& value) {
-  return INTEROP_RUNTIME_OBJECT;
-}
-
-static const std::size_t buffer_size = 1024 * 1024; // 1 MB
-static std::size_t offset = 0;
-alignas(std::max_align_t) static char buffer[buffer_size];
-
-template <typename T, std::size_t size>
-T* allocArray(const std::array<T, size>& ref) {
-  std::size_t space = sizeof(buffer) - offset;
-  void* ptr = buffer + offset;
-  void* aligned_ptr = std::align(alignof(T), sizeof(T) * size, ptr, space);
-  assert(aligned_ptr != nullptr && "Insufficient space or alignment failed!");
-  offset = (char*)aligned_ptr + sizeof(T) * size - buffer;
-  T* array = reinterpret_cast<T*>(aligned_ptr);
-  for (size_t i = 0; i < size; ++i) {
-    new (&array[i]) T(ref[i]);
-  }
-  return array;
-}
-
-class SerializerBase {
-private:
-    uint8_t* data;
-    uint32_t dataLength;
-    uint32_t position;
-    bool ownData;
-    CallbackResourceHolder* resourceHolder;
-    void resize(uint32_t newLength) {
-        assert(ownData);
-        assert(newLength > dataLength);
-        auto* newData = reinterpret_cast<uint8_t*>(malloc(newLength));
-        memcpy(newData, data, position);
-        free(data);
-        data = newData;
-    }
-public:
-    SerializerBase(CallbackResourceHolder* resourceHolder = nullptr):
-        position(0), ownData(true), resourceHolder(resourceHolder) {
-        this->dataLength = 256;
-        this->data = reinterpret_cast<uint8_t*>(malloc(this->dataLength));
-    }
-
-    SerializerBase(uint8_t* data, uint32_t dataLength, CallbackResourceHolder* resourceHolder = nullptr):
-        data(data), dataLength(dataLength), position(0), ownData(false), resourceHolder(resourceHolder) {
-    }
-
-    virtual ~SerializerBase() {
-        if (ownData) {
-            free(data);
-        }
-    }
-
-    SerializerBase(const SerializerBase&) = delete;
-    SerializerBase& operator=(const SerializerBase&) = delete;
-
-    void* release() {
-        ownData = false;
-        return data;
-    }
-    int length() {
-        return position;
-    }
-
-    inline void check(int more) {
-        if (position + more > dataLength) {
-            if (ownData) {
-                resize(dataLength * 3 / 2 + 2);
-            } else {
-                fprintf(stderr, "Buffer overrun: %d > %d\n", position + more, dataLength);
-                assert(false);
-            }
-        }
-    }
-
-    void writeInt8(InteropInt8 value) {
-        check(1);
-        *((InteropInt8*)(data + position)) = value;
-        position += 1;
-    }
-
-    void writeInt32(InteropInt32 value) {
-        check(4);
-#ifdef KOALA_NO_UNALIGNED_ACCESS
-        memcpy(data + position, &value, 4);
-#else
-        *((InteropInt32*)(data + position)) = value;
-#endif
-        position += 4;
-    }
-
-    void writeInt64(InteropInt64 value) {
-        check(8);
-#ifdef KOALA_NO_UNALIGNED_ACCESS
-        memcpy(data + position, &value, 8);
-#else
-        *((InteropInt64*)(data + position)) = value;
-#endif
-        position += 8;
-    }
-
-    void writeUInt64(InteropUInt64 value) {
-        check(8);
-#ifdef KOALA_NO_UNALIGNED_ACCESS
-        memcpy(data + position, &value, 8);
-#else
-        *((InteropUInt64*)(data + position)) = value;
-#endif
-        position += 8;
-    }
-
-    void writeFloat32(InteropFloat32 value) {
-        check(8);
-#ifdef KOALA_NO_UNALIGNED_ACCESS
-        memcpy(data + position, &value, 4);
-#else
-        *((InteropFloat32*)(data + position)) = value;
-#endif
-        position += 4;
-    }
-
-    void writePointer(InteropNativePointer value) {
-        check(8);
-#ifdef KOALA_NO_UNALIGNED_ACCESS
-        memcpy(data + position, &value, 8);
-#else
-        *((int64_t*)(data + position)) = reinterpret_cast<int64_t>(value);
-#endif
-        position += 8;
-    }
-
-    void writeFunction(InteropFunction value) {
-        // TODO: ignored, remove!
-        writeInt32(0x666);
-    }
-
-    void writeNumber(InteropNumber value) {
-        writeInt8(value.tag);
-        if (value.tag == InteropTag::INTEROP_TAG_INT32) {
-            writeInt32(value.i32);
-        } else if (value.tag == InteropTag::INTEROP_TAG_FLOAT32) {
-            writeFloat32(value.f32);
-        } else {
-            INTEROP_FATAL("Unknown tag number");
-        }
-    }
-
-    void writeString(InteropString value) {
-        writeInt32(value.length + 1);
-        check(value.length + 1);
-        strcpy((char*)(data + position), value.chars);
-        position += value.length + 1;
-    }
-
-    void writeBoolean(InteropBoolean value) {
-        writeInt8(value);
-    }
-
-    void writeLength(InteropLength value) {
-        InteropRuntimeType tag = (InteropRuntimeType) value.type;
-        writeInt8(tag);
-        switch (tag) {
-            case INTEROP_RUNTIME_NUMBER:
-                writeFloat32(value.value);
-                break;
-            case INTEROP_RUNTIME_OBJECT:
-                writeInt32(value.resource);
-                break;
-            case INTEROP_RUNTIME_STRING: {
-                char buf[64];
-                std::string suffix;
-                switch (value.unit) {
-                    case 0: suffix = "px"; break;
-                    case 1: suffix = "vp"; break;
-                    case 2: suffix = "fp"; break;
-                    case 3: suffix = "%"; break;
-                    case 4: suffix = "lpx"; break;
-                }
-                snprintf(buf, 64, "%.8f%s", value.value, suffix.c_str());
-                InteropString str =  { buf, (InteropInt32) strlen(buf) };
-                writeString(str);
-                break;
-            }
-            default:
-                break;
-        }
-    }
-
-    void writeCallbackResource(const InteropCallbackResource resource) {
-        writeInt32(resource.resourceId);
-        writePointer(reinterpret_cast<void*>(resource.hold));
-        writePointer(reinterpret_cast<void*>(resource.release));
-        if (this->resourceHolder != nullptr) {
-            this->resourceHolder->holdCallbackResource(&resource);
-        }
-    }
-
-    void writeCustomObject(std::string type, InteropCustomObject value) {
-        // TODO implement
-    }
-
-    void writeBuffer(InteropBuffer buffer) {
-        writeCallbackResource(buffer.resource);
-        writePointer((void*)buffer.data);
-        writeInt64(buffer.length);
-    }
-
-    KInteropReturnBuffer toReturnBuffer() {
-        if (this->ownData) {
-            KInteropReturnBuffer buffer {this->length(), this->release(), [](KNativePointer data, KInt length) { free(data); }};
-            // TODO fix memory issues
-            return buffer;
-        } else {
-            return {this->length(), this->data, nullptr};
-        }
-    }
-};
-
-#endif // _SERIALIZER_BASE_H
\ No newline at end of file
diff --git a/koala-wrapper/koalaui/interop/src/cpp/common-interop.cc b/koala-wrapper/koalaui/interop/src/cpp/common-interop.cc
index ec6572c6dbb2958320df66ceec657a3dfab29c93..96be3fa07f898104aff881f04e500c4f575653cc 100644
--- a/koala-wrapper/koalaui/interop/src/cpp/common-interop.cc
+++ b/koala-wrapper/koalaui/interop/src/cpp/common-interop.cc
@@ -15,6 +15,8 @@
 #include <string>
 #include <vector>
 #include <map>
+#include <algorithm>
+#include <iterator>
 
 #ifdef KOALA_INTEROP_MODULE
 #undef KOALA_INTEROP_MODULE
@@ -127,7 +129,9 @@ KOALA_INTEROP_1(StringLength, KInt, KNativePointer)
 
 void impl_StringData(KNativePointer ptr, KByte* bytes, KUInt size) {
     string* s = reinterpret_cast<string*>(ptr);
-    if (s) memcpy(bytes, s->c_str(), size);
+    if (s) {
+        std::copy(s->c_str(), s->c_str() + s->size() + 1, bytes);
+    }
 }
 KOALA_INTEROP_V3(StringData, KNativePointer, KByte*, KUInt)
 
@@ -149,7 +153,7 @@ KOALA_INTEROP_1(StringMake, KNativePointer, KStringPtr)
 
 // For slow runtimes w/o fast encoders.
 KInt impl_ManagedStringWrite(const KStringPtr& string, KByte* buffer, KInt offset) {
-    memcpy(buffer + offset, string.c_str(), string.length() + 1);
+    std::copy(string.c_str(), string.c_str() + string.length() + 1, buffer + offset);
     return string.length() + 1;
 }
 KOALA_INTEROP_3(ManagedStringWrite, KInt, KStringPtr, KByte*, KInt)
diff --git a/koala-wrapper/koalaui/interop/src/cpp/jni/convertors-jni.cc b/koala-wrapper/koalaui/interop/src/cpp/jni/convertors-jni.cc
deleted file mode 100644
index 782f2c2e3a853232e2f250c00aa367f2fe10def9..0000000000000000000000000000000000000000
--- a/koala-wrapper/koalaui/interop/src/cpp/jni/convertors-jni.cc
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * Copyright (c) 2025 Huawei Device Co., Ltd.
- * 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.
- */
-
-
-#define KOALA_INTEROP_MODULE
-#include "convertors-jni.h"
-#include "signatures.h"
-#include "interop-logging.h"
-#include "interop-types.h"
-
-static const char* nativeModule = "org/koalaui/arkoala/InteropNativeModule";
-static const char* nativeModulePrefix = "org/koalaui/arkoala/";
-static const char* callCallbackFromNative = "callCallbackFromNative";
-static const char* callCallbackFromNativeSig = "(I[BI)I";
-
-const bool registerByOne = true;
-
-static bool registerNatives(JNIEnv *env, jclass clazz, const std::vector<std::tuple<std::string, std::string, void* >> impls) {
-    size_t numMethods = impls.size();
-    JNINativeMethod *methods = new JNINativeMethod[numMethods];
-    bool result = true;
-    for (size_t i = 0; i < numMethods; i++)
-    {
-        methods[i].name = (char *)std::get<0>(impls[i]).c_str();
-        methods[i].signature = (char *)std::get<1>(impls[i]).c_str();
-        methods[i].fnPtr = std::get<2>(impls[i]);
-        if (registerByOne) {
-            result &= (env->RegisterNatives(clazz, methods + i, 1) >= 0);
-            if (env->ExceptionCheck()) {
-                env->ExceptionDescribe();
-                env->ExceptionClear();
-                result = false;
-            }
-        }
-    }
-    return registerByOne ? true : env->RegisterNatives(clazz, methods, numMethods) >= 0;
-}
-
-constexpr bool splitPerModule = true;
-
-JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) {
-    JNIEnv *env;
-    if (vm->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION_1_8) != JNI_OK) {
-        return JNI_ERR;
-    }
-    auto modules = JniExports::getInstance()->getModules();
-    jclass defaultNativeModule = env->FindClass(nativeModule);
-    for (auto it = modules.begin(); it != modules.end(); ++it) {
-        std::string className = std::string(nativeModulePrefix) + *it;
-        jclass nativeModule =
-            (!splitPerModule) ? defaultNativeModule : env->FindClass(className.c_str());
-        if (nativeModule == nullptr) {
-            LOGE("Cannot find managed class %s", className.c_str());
-            continue;
-        }
-        registerNatives(env, nativeModule, JniExports::getInstance()->getMethods(*it));
-    }
-    if (!setKoalaJniCallbackDispatcher(env, defaultNativeModule, callCallbackFromNative, callCallbackFromNativeSig)) return JNI_ERR;
-    return JNI_VERSION_1_8;
-}
-
-JniExports *JniExports::getInstance()
-{
-    static JniExports *instance = nullptr;
-    if (instance == nullptr)
-    {
-        instance = new JniExports();
-    }
-    return instance;
-}
-
-std::vector<std::string> JniExports::getModules() {
-    std::vector<std::string> result;
-    for (auto it = implementations.begin(); it != implementations.end(); ++it) {
-        result.push_back(it->first);
-    }
-    return result;
-}
-
-const std::vector<std::tuple<std::string, std::string, void*>>& JniExports::getMethods(const std::string& module) {
-    auto it = implementations.find(module);
-    if (it == implementations.end()) {
-        LOGE("Module %s is not registered", module.c_str());
-        INTEROP_FATAL("Fatal error: not registered module %s", module.c_str());
-    }
-    return it->second;
-}
-
-void JniExports::addMethod(const char* module, const char *name, const char *type, void *impl) {
-    auto it = implementations.find(module);
-    if (it == implementations.end()) {
-        it = implementations.insert(std::make_pair(module, std::vector<std::tuple<std::string, std::string, void*>>())).first;
-    }
-    it->second.push_back(std::make_tuple(name, convertType(name, type), impl));
-}
diff --git a/koala-wrapper/koalaui/interop/src/cpp/jni/convertors-jni.h b/koala-wrapper/koalaui/interop/src/cpp/jni/convertors-jni.h
deleted file mode 100644
index 2ebefafe7b242e703e78d5d2a0a108a90b066598..0000000000000000000000000000000000000000
--- a/koala-wrapper/koalaui/interop/src/cpp/jni/convertors-jni.h
+++ /dev/null
@@ -1,1465 +0,0 @@
-/*
- * Copyright (c) 2025 Huawei Device Co., Ltd.
- * 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.
- */
-
-#pragma once
-
-#ifdef KOALA_JNI
-
-#include <jni.h>
-#include <assert.h>
-
-#include <cmath>
-#include <unordered_map>
-#include <vector>
-#include <string>
-#include <tuple>
-
-#include "koala-types.h"
-
-#define KOALA_JNI_CALL(type) extern "C" JNIEXPORT type JNICALL
-
-class JniExports {
-    std::unordered_map<std::string,
-      std::vector<std::tuple<std::string, std::string, void*>>> implementations;
-
-public:
-    static JniExports* getInstance();
-
-    std::vector<std::string> getModules();
-    void addMethod(const char* module, const char* name, const char* type, void* impl);
-    const std::vector<std::tuple<std::string, std::string, void*>>& getMethods(const std::string& module);
-};
-
-#define KOALA_QUOTE0(x) #x
-#define KOALA_QUOTE(x) KOALA_QUOTE0(x)
-
-#ifdef _MSC_VER
-#define MAKE_JNI_EXPORT(module, name, type)                             \
-    static void __init_##name() {                               \
-        JniExports::getInstance()->addMethod(KOALA_QUOTE(module), "_"#name, type, reinterpret_cast<void *>(Java_org_##name)); \
-    }                                                           \
-    namespace {                                                 \
-      struct __Init_##name {                                    \
-        __Init_##name() {  __init_##name(); }                   \
-      } __Init_##name##_v;                                      \
-    }
-#else
-#define MAKE_JNI_EXPORT(module, name, type) \
-    __attribute__((constructor)) \
-    static void __init_jni_##name() { \
-        JniExports::getInstance()->addMethod(KOALA_QUOTE(module), "_"#name, type, reinterpret_cast<void *>(Java_org_##name)); \
-    }
-#endif
-
-template<class T>
-struct InteropTypeConverter {
-    using InteropType = T;
-    static T convertFrom(JNIEnv* env, InteropType value) { return value; }
-    static InteropType convertTo(JNIEnv* env, T value) { return value; }
-    static void release(JNIEnv* env, InteropType value, T converted) {}
-};
-
-template<class T>
-struct SlowInteropTypeConverter {
-    using InteropType = T;
-    static inline T convertFrom(JNIEnv* env, InteropType value) { return value; }
-    static inline InteropType convertTo(JNIEnv* env, T value) { return value; }
-    static void release(JNIEnv* env, InteropType value, T converted) {}
-};
-
-template<>
-struct InteropTypeConverter<KStringPtr> {
-    using InteropType = jstring;
-    static inline KStringPtr convertFrom0(JNIEnv* env, InteropType value) {
-        if (value == nullptr) return KStringPtr();
-        jboolean isCopy;
-        // TODO: use GetStringCritical() instead and utf-8 encode manually.
-		    const char* str_value = env->GetStringUTFChars(value, &isCopy);
-        int len = env->GetStringUTFLength(value);
-        KStringPtr result(str_value, len, false);
-        return result;
-    }
-    static KStringPtr convertFrom(JNIEnv* env, InteropType value) {
-        if (value == nullptr) return KStringPtr();
-        KStringPtr result;
-        // Notice that we use UTF length for buffer size, but counter is expressed in number of Unicode chars.
-        result.resize( env->GetStringUTFLength(value));
-        env->GetStringUTFRegion(value, 0, env->GetStringLength(value), result.data());
-        return result;
-    }
-    static InteropType convertTo(JNIEnv* env, KStringPtr value) = delete;
-    static inline void release(JNIEnv* env, InteropType value, const KStringPtr& converted) {
-    }
-};
-
-template<>
-struct SlowInteropTypeConverter<KVMObjectHandle> {
-    using InteropType = jobject;
-    static inline KVMObjectHandle convertFrom(JNIEnv* env, InteropType value) {
-        return reinterpret_cast<KVMObjectHandle>(value);
-    }
-    static InteropType convertTo(JNIEnv* env, KVMObjectHandle value) {
-      return reinterpret_cast<jobject>(value);
-    }
-    static inline void release(JNIEnv* env, InteropType value, KVMObjectHandle converted) {
-    }
-};
-
-template<>
-struct SlowInteropTypeConverter<KStringPtr> {
-    using InteropType = jstring;
-    static inline KStringPtr convertFrom(JNIEnv* env, InteropType value) {
-        if (value == nullptr) return KStringPtr();
-        jboolean isCopy;
-		    const char* str_value = env->GetStringUTFChars(value, &isCopy);
-        int len = env->GetStringLength(value);
-        KStringPtr result(str_value, len, false);
-        return result;
-    }
-    static InteropType convertTo(JNIEnv* env, KStringPtr value) {
-      return env->NewStringUTF(value.c_str());
-    }
-    static inline void release(JNIEnv* env, InteropType value, const KStringPtr& converted) {
-      env->ReleaseStringUTFChars(value, converted.data());
-    }
-};
-
-template<>
-struct SlowInteropTypeConverter<KInteropBuffer> {
-    using InteropType = jarray;
-    static inline KInteropBuffer convertFrom(JNIEnv* env, InteropType value) {
-        if (value == nullptr) return KInteropBuffer();
-        KInteropBuffer result({env->GetArrayLength(value), reinterpret_cast<KByte*>(env->GetPrimitiveArrayCritical(value, nullptr))});
-        return result;
-    }
-    static InteropType convertTo(JNIEnv* env, KInteropBuffer value) {
-      jarray result = env->NewByteArray(value.length);
-      void* data = env->GetPrimitiveArrayCritical(result, nullptr);
-      memcpy(data, value.data, value.length);
-      env->ReleasePrimitiveArrayCritical(result, data, 0);
-      return result;
-    }
-    static inline void release(JNIEnv* env, InteropType value, const KInteropBuffer& converted) {
-      env->ReleasePrimitiveArrayCritical(value, converted.data, 0);
-    }
-};
-
-template<>
-struct SlowInteropTypeConverter<KInteropReturnBuffer> {
-    using InteropType = jarray;
-    static inline KInteropReturnBuffer convertFrom(JNIEnv* env, InteropType value) = delete;
-    static InteropType convertTo(JNIEnv* env, KInteropReturnBuffer value) {
-      jarray result = env->NewByteArray(value.length);
-      void* data = env->GetPrimitiveArrayCritical(result, nullptr);
-      memcpy(data, value.data, value.length);
-      env->ReleasePrimitiveArrayCritical(result, data, 0);
-      value.dispose(value.data, value.length);
-      return result;
-    }
-    static inline void release(JNIEnv* env, InteropType value, const KInteropReturnBuffer& converted) = delete;
-};
-
-template<>
-struct InteropTypeConverter<KByte*> {
-    using InteropType = jbyteArray;
-    static inline KByte* convertFrom(JNIEnv* env, InteropType value) {
-        return value ? reinterpret_cast<KByte*>(env->GetPrimitiveArrayCritical(value, nullptr)) : nullptr;
-    }
-    static InteropType convertTo(JNIEnv* env, KByte* value) = delete;
-    static inline void release(JNIEnv* env, InteropType value, KByte* converted) {
-        if (converted) env->ReleasePrimitiveArrayCritical(value, converted, 0);
-    }
-};
-
-template<>
-struct SlowInteropTypeConverter<KByte*> {
-    using InteropType = jbyteArray;
-    static inline KByte* convertFrom(JNIEnv* env, InteropType value) {
-        return value ? reinterpret_cast<KByte*>(env->GetByteArrayElements(value, nullptr)) : nullptr;
-    }
-    static InteropType convertTo(JNIEnv* env, KByte* value) = delete;
-    static inline void release(JNIEnv* env, InteropType value, KByte* converted) {
-        if (converted) env->ReleaseByteArrayElements(value, reinterpret_cast<jbyte*>(converted), 0);
-    }
-};
-
-template<>
-struct InteropTypeConverter<KInt*> {
-    using InteropType = jintArray;
-    static KInt* convertFrom(JNIEnv* env, InteropType value) {
-        return value ? reinterpret_cast<KInt*>(env->GetPrimitiveArrayCritical(value, nullptr)) : nullptr;
-    }
-    static InteropType convertTo(JNIEnv* env, KInt* value) = delete;
-    static void release(JNIEnv* env, InteropType value, KInt* converted) {
-         env->ReleasePrimitiveArrayCritical(value, converted, 0);
-    }
-};
-
-template<>
-struct SlowInteropTypeConverter<KInt*> {
-    using InteropType = jintArray;
-    static KInt* convertFrom(JNIEnv* env, InteropType value) {
-        return value ? reinterpret_cast<KInt*>(env->GetIntArrayElements(value, nullptr)) : nullptr;
-    }
-    static InteropType convertTo(JNIEnv* env, KInt* value) = delete;
-    static void release(JNIEnv* env, InteropType value, KInt* converted) {
-         env->ReleaseIntArrayElements(value, reinterpret_cast<jint*>(converted), 0);
-    }
-};
-
-template<>
-struct InteropTypeConverter<KFloat*> {
-    using InteropType = jfloatArray;
-    static KFloat* convertFrom(JNIEnv* env, InteropType value) {
-        return value ? reinterpret_cast<KFloat*>(env->GetPrimitiveArrayCritical(value, nullptr)) : nullptr;
-    }
-    static InteropType convertTo(JNIEnv* env, KFloat* value) = delete;
-    static void release(JNIEnv* env, InteropType value, KFloat* converted) {
-        env->ReleasePrimitiveArrayCritical(value, converted, 0);
-    }
-};
-
-template<>
-struct SlowInteropTypeConverter<KFloat*> {
-    using InteropType = jfloatArray;
-    static KFloat* convertFrom(JNIEnv* env, InteropType value) {
-        return value ? reinterpret_cast<KFloat*>(env->GetFloatArrayElements(value, nullptr)) : nullptr;
-    }
-    static InteropType convertTo(JNIEnv* env, KFloat* value) = delete;
-    static void release(JNIEnv* env, InteropType value, KFloat* converted) {
-        env->ReleaseFloatArrayElements(value, reinterpret_cast<jfloat*>(converted), 0);
-    }
-};
-
-template<>
-struct InteropTypeConverter<KNativePointer> {
-    using InteropType = jlong;
-    static KNativePointer convertFrom(JNIEnv* env, InteropType value) {
-      return reinterpret_cast<KNativePointer>(value);
-    }
-    static InteropType convertTo(JNIEnv* env, KNativePointer value) {
-      return reinterpret_cast<jlong>(value);
-    }
-    static inline void release(JNIEnv* env, InteropType value, KNativePointer converted) {}
-};
-
-template<>
-struct SlowInteropTypeConverter<KNativePointer> {
-    using InteropType = jlong;
-    static KNativePointer convertFrom(JNIEnv* env, InteropType value) {
-      return reinterpret_cast<KNativePointer>(value);
-    }
-    static InteropType convertTo(JNIEnv* env, KNativePointer value) {
-      return reinterpret_cast<jlong>(value);
-    }
-    static void release(JNIEnv* env, InteropType value, KNativePointer converted) {}
-};
-
-template<>
-struct InteropTypeConverter<KInteropNumber> {
-    using InteropType = jdouble;
-    static KInteropNumber convertFrom(JNIEnv* env, InteropType value) {
-        return KInteropNumber::fromDouble(value);
-    }
-    static InteropType convertTo(JNIEnv* env, KInteropNumber value) {
-        return value.asDouble();
-    }
-    static inline void release(JNIEnv* env, InteropType value, KInteropNumber converted) {}
-};
-
-template<>
-struct SlowInteropTypeConverter<KInteropNumber> {
-    using InteropType = jdouble;
-    static KInteropNumber convertFrom(JNIEnv* env, InteropType value) {
-        return KInteropNumber::fromDouble(value);
-    }
-    static InteropType convertTo(JNIEnv* env, KInteropNumber value) {
-        return value.asDouble();
-    }
-    static void release(JNIEnv* env, InteropType value, KInteropNumber converted) {}
-};
-
-template<>
-struct InteropTypeConverter<KLength> {
-    using InteropType = jstring;
-    static KLength convertFrom(JNIEnv* env, InteropType value) {
-        KLength result = { 0 };
-
-        if (value == nullptr) {
-            result.type = -1; // ARK_RUNTIME_UNEXPECTED
-            return result;
-        }
-        jboolean isCopy;
-        const char* str_value = env->GetStringUTFChars(value, &isCopy);
-        int len = env->GetStringLength(value);
-        KStringPtr kStr(str_value, len, false);
-        parseKLength(kStr, &result);
-        env->ReleaseStringUTFChars(value, str_value);
-        result.type = 2; // ARK_RUNTIME_STRING
-        result.resource = 0;
-
-        return result;
-    }
-    static InteropType convertTo(JNIEnv* env, KLength value) = delete;
-    static inline void release(JNIEnv* env, InteropType value, KLength converted) {}
-};
-
-template <typename Type>
-inline Type getArgument(JNIEnv* env, typename InteropTypeConverter<Type>::InteropType arg) {
-  return InteropTypeConverter<Type>::convertFrom(env, arg);
-}
-
-template <typename Type>
-inline void releaseArgument(JNIEnv* env, typename InteropTypeConverter<Type>::InteropType arg, Type& data) {
-  InteropTypeConverter<Type>::release(env, arg, data);
-}
-
-#ifndef KOALA_INTEROP_MODULE
-#error KOALA_INTEROP_MODULE is undefined
-#endif
-
-#define KOALA_INTEROP_0(name, Ret) \
-  KOALA_JNI_CALL(InteropTypeConverter<Ret>::InteropType) Java_org_##name(JNIEnv* env, jclass instance) { \
-      KOALA_MAYBE_LOG(name) \
-      return InteropTypeConverter<Ret>::convertTo(env, impl_##name()); \
-  } \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret)
-
-#define KOALA_INTEROP_1(name, Ret, P0) \
-   KOALA_JNI_CALL(InteropTypeConverter<Ret>::InteropType) \
-   Java_org_##name(JNIEnv* env, jclass instance, \
-    InteropTypeConverter<P0>::InteropType _p0) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      auto rv = InteropTypeConverter<Ret>::convertTo(env, impl_##name(p0)); \
-      releaseArgument(env, _p0, p0); \
-      return rv; \
-  } \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0)
-
-#define KOALA_INTEROP_2(name, Ret, P0, P1) \
-  KOALA_JNI_CALL(InteropTypeConverter<Ret>::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \
-  InteropTypeConverter<P0>::InteropType _p0, \
-  InteropTypeConverter<P1>::InteropType _p1) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      auto rv = InteropTypeConverter<Ret>::convertTo(env, impl_##name(p0, p1)); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      return rv; \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1)
-
-#define KOALA_INTEROP_3(name, Ret, P0, P1, P2) \
-  KOALA_JNI_CALL(InteropTypeConverter<Ret>::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \
-  InteropTypeConverter<P0>::InteropType _p0, \
-  InteropTypeConverter<P1>::InteropType _p1, \
-  InteropTypeConverter<P2>::InteropType _p2) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      auto rv = InteropTypeConverter<Ret>::convertTo(env, impl_##name(p0, p1, p2)); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      return rv; \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2)
-
-#define KOALA_INTEROP_4(name, Ret, P0, P1, P2, P3) \
-  KOALA_JNI_CALL(InteropTypeConverter<Ret>::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \
-  InteropTypeConverter<P0>::InteropType _p0, \
-  InteropTypeConverter<P1>::InteropType _p1, \
-  InteropTypeConverter<P2>::InteropType _p2, \
-  InteropTypeConverter<P3>::InteropType _p3) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      P3 p3 = getArgument<P3>(env, _p3); \
-      auto rv = InteropTypeConverter<Ret>::convertTo(env, impl_##name(p0, p1, p2, p3)); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      releaseArgument(env, _p3, p3); \
-      return rv; \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3)
-
-#define KOALA_INTEROP_5(name, Ret, P0, P1, P2, P3, P4) \
-  KOALA_JNI_CALL(InteropTypeConverter<Ret>::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \
-    InteropTypeConverter<P0>::InteropType _p0, \
-    InteropTypeConverter<P1>::InteropType _p1, \
-    InteropTypeConverter<P2>::InteropType _p2, \
-    InteropTypeConverter<P3>::InteropType _p3, \
-    InteropTypeConverter<P4>::InteropType _p4) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      P3 p3 = getArgument<P3>(env, _p3); \
-      P4 p4 = getArgument<P4>(env, _p4); \
-      auto rv = InteropTypeConverter<Ret>::convertTo(env, impl_##name(p0, p1, p2, p3, p4)); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      releaseArgument(env, _p3, p3); \
-      releaseArgument(env, _p4, p4); \
-      return rv; \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4)
-
-#define KOALA_INTEROP_6(name, Ret, P0, P1, P2, P3, P4, P5) \
-  KOALA_JNI_CALL(InteropTypeConverter<Ret>::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \
-  InteropTypeConverter<P0>::InteropType _p0, \
-  InteropTypeConverter<P1>::InteropType _p1, \
-  InteropTypeConverter<P2>::InteropType _p2, \
-  InteropTypeConverter<P3>::InteropType _p3, \
-  InteropTypeConverter<P4>::InteropType _p4, \
-  InteropTypeConverter<P5>::InteropType _p5) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      P3 p3 = getArgument<P3>(env, _p3); \
-      P4 p4 = getArgument<P4>(env, _p4); \
-      P5 p5 = getArgument<P5>(env, _p5); \
-      auto rv = InteropTypeConverter<Ret>::convertTo(env, impl_##name(p0, p1, p2, p3, p4, p5)); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      releaseArgument(env, _p3, p3); \
-      releaseArgument(env, _p4, p4); \
-      releaseArgument(env, _p5, p5); \
-      return rv; \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5)
-
-#define KOALA_INTEROP_7(name, Ret, P0, P1, P2, P3, P4, P5, P6) \
-  KOALA_JNI_CALL(InteropTypeConverter<Ret>::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \
-    InteropTypeConverter<P0>::InteropType _p0, \
-    InteropTypeConverter<P1>::InteropType _p1, \
-    InteropTypeConverter<P2>::InteropType _p2, \
-    InteropTypeConverter<P3>::InteropType _p3, \
-    InteropTypeConverter<P4>::InteropType _p4, \
-    InteropTypeConverter<P5>::InteropType _p5, \
-    InteropTypeConverter<P6>::InteropType _p6) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      P3 p3 = getArgument<P3>(env, _p3); \
-      P4 p4 = getArgument<P4>(env, _p4); \
-      P5 p5 = getArgument<P5>(env, _p5); \
-      P6 p6 = getArgument<P6>(env, _p6); \
-      auto rv = InteropTypeConverter<Ret>::convertTo(env, impl_##name(p0, p1, p2, p3, p4, p5, p6)); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      releaseArgument(env, _p3, p3); \
-      releaseArgument(env, _p4, p4); \
-      releaseArgument(env, _p5, p5); \
-      releaseArgument(env, _p6, p6); \
-      return rv; \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6)
-
-#define KOALA_INTEROP_8(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) \
-  KOALA_JNI_CALL(InteropTypeConverter<Ret>::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \
-  InteropTypeConverter<P0>::InteropType _p0, \
-  InteropTypeConverter<P1>::InteropType _p1, \
-  InteropTypeConverter<P2>::InteropType _p2, \
-  InteropTypeConverter<P3>::InteropType _p3, \
-  InteropTypeConverter<P4>::InteropType _p4, \
-  InteropTypeConverter<P5>::InteropType _p5, \
-  InteropTypeConverter<P6>::InteropType _p6, \
-  InteropTypeConverter<P7>::InteropType _p7) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      P3 p3 = getArgument<P3>(env, _p3); \
-      P4 p4 = getArgument<P4>(env, _p4); \
-      P5 p5 = getArgument<P5>(env, _p5); \
-      P6 p6 = getArgument<P6>(env, _p6); \
-      P7 p7 = getArgument<P7>(env, _p7); \
-      auto rv = InteropTypeConverter<Ret>::convertTo(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7)); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      releaseArgument(env, _p3, p3); \
-      releaseArgument(env, _p4, p4); \
-      releaseArgument(env, _p5, p5); \
-      releaseArgument(env, _p6, p6); \
-      releaseArgument(env, _p7, p7); \
-      return rv; \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7)
-
-#define KOALA_INTEROP_9(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) \
-  KOALA_JNI_CALL(InteropTypeConverter<Ret>::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \
-  InteropTypeConverter<P0>::InteropType _p0, \
-  InteropTypeConverter<P1>::InteropType _p1, \
-  InteropTypeConverter<P2>::InteropType _p2, \
-  InteropTypeConverter<P3>::InteropType _p3, \
-  InteropTypeConverter<P4>::InteropType _p4, \
-  InteropTypeConverter<P5>::InteropType _p5, \
-  InteropTypeConverter<P6>::InteropType _p6, \
-  InteropTypeConverter<P7>::InteropType _p7, \
-  InteropTypeConverter<P8>::InteropType _p8) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      P3 p3 = getArgument<P3>(env, _p3); \
-      P4 p4 = getArgument<P4>(env, _p4); \
-      P5 p5 = getArgument<P5>(env, _p5); \
-      P6 p6 = getArgument<P6>(env, _p6); \
-      P7 p7 = getArgument<P7>(env, _p7); \
-      P8 p8 = getArgument<P8>(env, _p8); \
-      auto rv = InteropTypeConverter<Ret>::convertTo(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8)); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      releaseArgument(env, _p3, p3); \
-      releaseArgument(env, _p4, p4); \
-      releaseArgument(env, _p5, p5); \
-      releaseArgument(env, _p6, p6); \
-      releaseArgument(env, _p7, p7); \
-      releaseArgument(env, _p8, p8); \
-      return rv; \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8)
-
-#define KOALA_INTEROP_10(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \
-  KOALA_JNI_CALL(InteropTypeConverter<Ret>::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \
-  InteropTypeConverter<P0>::InteropType _p0, \
-  InteropTypeConverter<P1>::InteropType _p1, \
-  InteropTypeConverter<P2>::InteropType _p2, \
-  InteropTypeConverter<P3>::InteropType _p3, \
-  InteropTypeConverter<P4>::InteropType _p4, \
-  InteropTypeConverter<P5>::InteropType _p5, \
-  InteropTypeConverter<P6>::InteropType _p6, \
-  InteropTypeConverter<P7>::InteropType _p7, \
-  InteropTypeConverter<P8>::InteropType _p8, \
-  InteropTypeConverter<P9>::InteropType _p9) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      P3 p3 = getArgument<P3>(env, _p3); \
-      P4 p4 = getArgument<P4>(env, _p4); \
-      P5 p5 = getArgument<P5>(env, _p5); \
-      P6 p6 = getArgument<P6>(env, _p6); \
-      P7 p7 = getArgument<P7>(env, _p7); \
-      P8 p8 = getArgument<P8>(env, _p8); \
-      P9 p9 = getArgument<P9>(env, _p9); \
-      auto rv = InteropTypeConverter<Ret>::convertTo(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      releaseArgument(env, _p3, p3); \
-      releaseArgument(env, _p4, p4); \
-      releaseArgument(env, _p5, p5); \
-      releaseArgument(env, _p6, p6); \
-      releaseArgument(env, _p7, p7); \
-      releaseArgument(env, _p8, p8); \
-      releaseArgument(env, _p9, p9); \
-      return rv; \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9)
-
-#define KOALA_INTEROP_11(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \
-  KOALA_JNI_CALL(InteropTypeConverter<Ret>::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \
-  InteropTypeConverter<P0>::InteropType _p0, \
-  InteropTypeConverter<P1>::InteropType _p1, \
-  InteropTypeConverter<P2>::InteropType _p2, \
-  InteropTypeConverter<P3>::InteropType _p3, \
-  InteropTypeConverter<P4>::InteropType _p4, \
-  InteropTypeConverter<P5>::InteropType _p5, \
-  InteropTypeConverter<P6>::InteropType _p6, \
-  InteropTypeConverter<P7>::InteropType _p7, \
-  InteropTypeConverter<P8>::InteropType _p8, \
-  InteropTypeConverter<P9>::InteropType _p9, \
-  InteropTypeConverter<P10>::InteropType _p10) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      P3 p3 = getArgument<P3>(env, _p3); \
-      P4 p4 = getArgument<P4>(env, _p4); \
-      P5 p5 = getArgument<P5>(env, _p5); \
-      P6 p6 = getArgument<P6>(env, _p6); \
-      P7 p7 = getArgument<P7>(env, _p7); \
-      P8 p8 = getArgument<P8>(env, _p8); \
-      P9 p9 = getArgument<P9>(env, _p9); \
-      P10 p10 = getArgument<P10>(env, _p10); \
-      auto rv = InteropTypeConverter<Ret>::convertTo(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      releaseArgument(env, _p3, p3); \
-      releaseArgument(env, _p4, p4); \
-      releaseArgument(env, _p5, p5); \
-      releaseArgument(env, _p6, p6); \
-      releaseArgument(env, _p7, p7); \
-      releaseArgument(env, _p8, p8); \
-      releaseArgument(env, _p9, p9); \
-      releaseArgument(env, _p10, p10); \
-      return rv; \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10)
-
-#define KOALA_INTEROP_12(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) \
-  KOALA_JNI_CALL(InteropTypeConverter<Ret>::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \
-    InteropTypeConverter<P0>::InteropType _p0, \
-    InteropTypeConverter<P1>::InteropType _p1, \
-    InteropTypeConverter<P2>::InteropType _p2, \
-    InteropTypeConverter<P3>::InteropType _p3, \
-    InteropTypeConverter<P4>::InteropType _p4, \
-    InteropTypeConverter<P5>::InteropType _p5, \
-    InteropTypeConverter<P6>::InteropType _p6, \
-    InteropTypeConverter<P7>::InteropType _p7, \
-    InteropTypeConverter<P8>::InteropType _p8, \
-    InteropTypeConverter<P9>::InteropType _p9, \
-    InteropTypeConverter<P10>::InteropType _p10, \
-    InteropTypeConverter<P11>::InteropType _p11) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      P3 p3 = getArgument<P3>(env, _p3); \
-      P4 p4 = getArgument<P4>(env, _p4); \
-      P5 p5 = getArgument<P5>(env, _p5); \
-      P6 p6 = getArgument<P6>(env, _p6); \
-      P7 p7 = getArgument<P7>(env, _p7); \
-      P8 p8 = getArgument<P8>(env, _p8); \
-      P9 p9 = getArgument<P9>(env, _p9); \
-      P10 p10 = getArgument<P10>(env, _p10); \
-      P11 p11 = getArgument<P11>(env, _p11); \
-      auto rv = InteropTypeConverter<Ret>::convertTo(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      releaseArgument(env, _p3, p3); \
-      releaseArgument(env, _p4, p4); \
-      releaseArgument(env, _p5, p5); \
-      releaseArgument(env, _p6, p6); \
-      releaseArgument(env, _p7, p7); \
-      releaseArgument(env, _p8, p8); \
-      releaseArgument(env, _p9, p9); \
-      releaseArgument(env, _p10, p10); \
-      releaseArgument(env, _p11, p11); \
-      return rv; \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11)
-
-#define KOALA_INTEROP_13(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) \
-  KOALA_JNI_CALL(InteropTypeConverter<Ret>::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \
-    InteropTypeConverter<P0>::InteropType _p0, \
-    InteropTypeConverter<P1>::InteropType _p1, \
-    InteropTypeConverter<P2>::InteropType _p2, \
-    InteropTypeConverter<P3>::InteropType _p3, \
-    InteropTypeConverter<P4>::InteropType _p4, \
-    InteropTypeConverter<P5>::InteropType _p5, \
-    InteropTypeConverter<P6>::InteropType _p6, \
-    InteropTypeConverter<P7>::InteropType _p7, \
-    InteropTypeConverter<P8>::InteropType _p8, \
-    InteropTypeConverter<P9>::InteropType _p9, \
-    InteropTypeConverter<P10>::InteropType _p10, \
-    InteropTypeConverter<P11>::InteropType _p11, \
-    InteropTypeConverter<P12>::InteropType _p12) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      P3 p3 = getArgument<P3>(env, _p3); \
-      P4 p4 = getArgument<P4>(env, _p4); \
-      P5 p5 = getArgument<P5>(env, _p5); \
-      P6 p6 = getArgument<P6>(env, _p6); \
-      P7 p7 = getArgument<P7>(env, _p7); \
-      P8 p8 = getArgument<P8>(env, _p8); \
-      P9 p9 = getArgument<P9>(env, _p9); \
-      P10 p10 = getArgument<P10>(env, _p10); \
-      P11 p11 = getArgument<P11>(env, _p11); \
-      P12 p12 = getArgument<P12>(env, _p12); \
-      auto rv = InteropTypeConverter<Ret>::convertTo(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      releaseArgument(env, _p3, p3); \
-      releaseArgument(env, _p4, p4); \
-      releaseArgument(env, _p5, p5); \
-      releaseArgument(env, _p6, p6); \
-      releaseArgument(env, _p7, p7); \
-      releaseArgument(env, _p8, p8); \
-      releaseArgument(env, _p9, p9); \
-      releaseArgument(env, _p10, p10); \
-      releaseArgument(env, _p11, p11); \
-      releaseArgument(env, _p12, p12); \
-      return rv; \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9"|" #P10 "|" #P11 "|" #P12)
-
-#define KOALA_INTEROP_14(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) \
-  KOALA_JNI_CALL(InteropTypeConverter<Ret>::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \
-    InteropTypeConverter<P0>::InteropType _p0, \
-    InteropTypeConverter<P1>::InteropType _p1, \
-    InteropTypeConverter<P2>::InteropType _p2, \
-    InteropTypeConverter<P3>::InteropType _p3, \
-    InteropTypeConverter<P4>::InteropType _p4, \
-    InteropTypeConverter<P5>::InteropType _p5, \
-    InteropTypeConverter<P6>::InteropType _p6, \
-    InteropTypeConverter<P7>::InteropType _p7, \
-    InteropTypeConverter<P8>::InteropType _p8, \
-    InteropTypeConverter<P9>::InteropType _p9, \
-    InteropTypeConverter<P10>::InteropType _p10, \
-    InteropTypeConverter<P11>::InteropType _p11, \
-    InteropTypeConverter<P12>::InteropType _p12, \
-    InteropTypeConverter<P13>::InteropType _p13) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      P3 p3 = getArgument<P3>(env, _p3); \
-      P4 p4 = getArgument<P4>(env, _p4); \
-      P5 p5 = getArgument<P5>(env, _p5); \
-      P6 p6 = getArgument<P6>(env, _p6); \
-      P7 p7 = getArgument<P7>(env, _p7); \
-      P8 p8 = getArgument<P8>(env, _p8); \
-      P9 p9 = getArgument<P9>(env, _p9); \
-      P10 p10 = getArgument<P10>(env, _p10); \
-      P11 p11 = getArgument<P11>(env, _p11); \
-      P12 p12 = getArgument<P12>(env, _p12); \
-      P13 p13 = getArgument<P13>(env, _p13); \
-      auto rv = InteropTypeConverter<Ret>::convertTo(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      releaseArgument(env, _p3, p3); \
-      releaseArgument(env, _p4, p4); \
-      releaseArgument(env, _p5, p5); \
-      releaseArgument(env, _p6, p6); \
-      releaseArgument(env, _p7, p7); \
-      releaseArgument(env, _p8, p8); \
-      releaseArgument(env, _p9, p9); \
-      releaseArgument(env, _p10, p10); \
-      releaseArgument(env, _p11, p11); \
-      releaseArgument(env, _p12, p12); \
-      releaseArgument(env, _p13, p13); \
-      return rv; \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9"|" #P10 "|" #P11 "|" #P12 "|" #P13)
-
-
-#define KOALA_INTEROP_V0(name) \
-  KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance) { \
-      KOALA_MAYBE_LOG(name) \
-      impl_##name(); \
-  } \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void")
-
-#define KOALA_INTEROP_V1(name, P0) \
-   KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \
-    InteropTypeConverter<P0>::InteropType _p0) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      impl_##name(p0); \
-      releaseArgument(env, _p0, p0); \
-  } \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0)
-
-#define KOALA_INTEROP_V2(name, P0, P1) \
-  KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \
-   InteropTypeConverter<P0>::InteropType _p0, \
-   InteropTypeConverter<P1>::InteropType _p1) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      impl_##name(p0, p1); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1)
-
-#define KOALA_INTEROP_V3(name, P0, P1, P2) \
-  KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \
-   InteropTypeConverter<P0>::InteropType _p0, \
-   InteropTypeConverter<P1>::InteropType _p1, \
-   InteropTypeConverter<P2>::InteropType _p2) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      impl_##name(p0, p1, p2); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2)
-
-#define KOALA_INTEROP_V4(name, P0, P1, P2, P3) \
-  KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \
-  InteropTypeConverter<P0>::InteropType _p0, \
-  InteropTypeConverter<P1>::InteropType _p1, \
-  InteropTypeConverter<P2>::InteropType _p2, \
-  InteropTypeConverter<P3>::InteropType _p3) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      P3 p3 = getArgument<P3>(env, _p3); \
-      impl_##name(p0, p1, p2, p3); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      releaseArgument(env, _p3, p3); \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3)
-
-#define KOALA_INTEROP_V5(name, P0, P1, P2, P3, P4) \
-  KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \
-  InteropTypeConverter<P0>::InteropType _p0, \
-  InteropTypeConverter<P1>::InteropType _p1, \
-  InteropTypeConverter<P2>::InteropType _p2, \
-  InteropTypeConverter<P3>::InteropType _p3, \
-  InteropTypeConverter<P4>::InteropType _p4) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      P3 p3 = getArgument<P3>(env, _p3); \
-      P4 p4 = getArgument<P4>(env, _p4); \
-      impl_##name(p0, p1, p2, p3, p4); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      releaseArgument(env, _p3, p3); \
-      releaseArgument(env, _p4, p4); \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4)
-
-#define KOALA_INTEROP_V6(name, P0, P1, P2, P3, P4, P5) \
-  KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \
-  InteropTypeConverter<P0>::InteropType _p0, \
-  InteropTypeConverter<P1>::InteropType _p1, \
-  InteropTypeConverter<P2>::InteropType _p2, \
-  InteropTypeConverter<P3>::InteropType _p3, \
-  InteropTypeConverter<P4>::InteropType _p4, \
-  InteropTypeConverter<P5>::InteropType _p5) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      P3 p3 = getArgument<P3>(env, _p3); \
-      P4 p4 = getArgument<P4>(env, _p4); \
-      P5 p5 = getArgument<P5>(env, _p5); \
-      impl_##name(p0, p1, p2, p3, p4, p5); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      releaseArgument(env, _p3, p3); \
-      releaseArgument(env, _p4, p4); \
-      releaseArgument(env, _p5, p5); \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5)
-
-#define KOALA_INTEROP_V7(name, P0, P1, P2, P3, P4, P5, P6) \
-  KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \
-  InteropTypeConverter<P0>::InteropType _p0, \
-  InteropTypeConverter<P1>::InteropType _p1, \
-  InteropTypeConverter<P2>::InteropType _p2, \
-  InteropTypeConverter<P3>::InteropType _p3, \
-  InteropTypeConverter<P4>::InteropType _p4, \
-  InteropTypeConverter<P5>::InteropType _p5, \
-  InteropTypeConverter<P6>::InteropType _p6) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      P3 p3 = getArgument<P3>(env, _p3); \
-      P4 p4 = getArgument<P4>(env, _p4); \
-      P5 p5 = getArgument<P5>(env, _p5); \
-      P6 p6 = getArgument<P6>(env, _p6); \
-      impl_##name(p0, p1, p2, p3, p4, p5, p6); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      releaseArgument(env, _p3, p3); \
-      releaseArgument(env, _p4, p4); \
-      releaseArgument(env, _p5, p5); \
-      releaseArgument(env, _p6, p6); \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6)
-
-#define KOALA_INTEROP_V8(name, P0, P1, P2, P3, P4, P5, P6, P7) \
-  KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \
-  InteropTypeConverter<P0>::InteropType _p0, \
-  InteropTypeConverter<P1>::InteropType _p1, \
-  InteropTypeConverter<P2>::InteropType _p2, \
-  InteropTypeConverter<P3>::InteropType _p3, \
-  InteropTypeConverter<P4>::InteropType _p4, \
-  InteropTypeConverter<P5>::InteropType _p5, \
-  InteropTypeConverter<P6>::InteropType _p6, \
-  InteropTypeConverter<P7>::InteropType _p7) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      P3 p3 = getArgument<P3>(env, _p3); \
-      P4 p4 = getArgument<P4>(env, _p4); \
-      P5 p5 = getArgument<P5>(env, _p5); \
-      P6 p6 = getArgument<P6>(env, _p6); \
-      P7 p7 = getArgument<P7>(env, _p7); \
-      impl_##name(p0, p1, p2, p3, p4, p5, p6, p7); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      releaseArgument(env, _p3, p3); \
-      releaseArgument(env, _p4, p4); \
-      releaseArgument(env, _p5, p5); \
-      releaseArgument(env, _p6, p6); \
-      releaseArgument(env, _p7, p7); \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7)
-
-#define KOALA_INTEROP_V9(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) \
-  KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \
-    InteropTypeConverter<P0>::InteropType _p0, \
-    InteropTypeConverter<P1>::InteropType _p1, \
-    InteropTypeConverter<P2>::InteropType _p2, \
-    InteropTypeConverter<P3>::InteropType _p3, \
-    InteropTypeConverter<P4>::InteropType _p4, \
-    InteropTypeConverter<P5>::InteropType _p5, \
-    InteropTypeConverter<P6>::InteropType _p6, \
-    InteropTypeConverter<P7>::InteropType _p7, \
-    InteropTypeConverter<P8>::InteropType _p8) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      P3 p3 = getArgument<P3>(env, _p3); \
-      P4 p4 = getArgument<P4>(env, _p4); \
-      P5 p5 = getArgument<P5>(env, _p5); \
-      P6 p6 = getArgument<P6>(env, _p6); \
-      P7 p7 = getArgument<P7>(env, _p7); \
-      P8 p8 = getArgument<P8>(env, _p8); \
-      impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      releaseArgument(env, _p3, p3); \
-      releaseArgument(env, _p4, p4); \
-      releaseArgument(env, _p5, p5); \
-      releaseArgument(env, _p6, p6); \
-      releaseArgument(env, _p7, p7); \
-      releaseArgument(env, _p8, p8); \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8)
-
-#define KOALA_INTEROP_V10(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \
-  KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \
-  InteropTypeConverter<P0>::InteropType _p0, \
-  InteropTypeConverter<P1>::InteropType _p1, \
-  InteropTypeConverter<P2>::InteropType _p2, \
-  InteropTypeConverter<P3>::InteropType _p3, \
-  InteropTypeConverter<P4>::InteropType _p4, \
-  InteropTypeConverter<P5>::InteropType _p5, \
-  InteropTypeConverter<P6>::InteropType _p6, \
-  InteropTypeConverter<P7>::InteropType _p7, \
-  InteropTypeConverter<P8>::InteropType _p8, \
-  InteropTypeConverter<P9>::InteropType _p9) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      P3 p3 = getArgument<P3>(env, _p3); \
-      P4 p4 = getArgument<P4>(env, _p4); \
-      P5 p5 = getArgument<P5>(env, _p5); \
-      P6 p6 = getArgument<P6>(env, _p6); \
-      P7 p7 = getArgument<P7>(env, _p7); \
-      P8 p8 = getArgument<P8>(env, _p8); \
-      P9 p9 = getArgument<P9>(env, _p9); \
-      impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      releaseArgument(env, _p3, p3); \
-      releaseArgument(env, _p4, p4); \
-      releaseArgument(env, _p5, p5); \
-      releaseArgument(env, _p6, p6); \
-      releaseArgument(env, _p7, p7); \
-      releaseArgument(env, _p8, p8); \
-      releaseArgument(env, _p9, p9); \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9)
-
-#define KOALA_INTEROP_V11(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \
-  KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \
-  InteropTypeConverter<P0>::InteropType _p0, \
-  InteropTypeConverter<P1>::InteropType _p1, \
-  InteropTypeConverter<P2>::InteropType _p2, \
-  InteropTypeConverter<P3>::InteropType _p3, \
-  InteropTypeConverter<P4>::InteropType _p4, \
-  InteropTypeConverter<P5>::InteropType _p5, \
-  InteropTypeConverter<P6>::InteropType _p6, \
-  InteropTypeConverter<P7>::InteropType _p7, \
-  InteropTypeConverter<P8>::InteropType _p8, \
-  InteropTypeConverter<P9>::InteropType _p9, \
-  InteropTypeConverter<P10>::InteropType _p10) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      P3 p3 = getArgument<P3>(env, _p3); \
-      P4 p4 = getArgument<P4>(env, _p4); \
-      P5 p5 = getArgument<P5>(env, _p5); \
-      P6 p6 = getArgument<P6>(env, _p6); \
-      P7 p7 = getArgument<P7>(env, _p7); \
-      P8 p8 = getArgument<P8>(env, _p8); \
-      P9 p9 = getArgument<P9>(env, _p9); \
-      P10 p10 = getArgument<P10>(env, _p10); \
-      impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      releaseArgument(env, _p3, p3); \
-      releaseArgument(env, _p4, p4); \
-      releaseArgument(env, _p5, p5); \
-      releaseArgument(env, _p6, p6); \
-      releaseArgument(env, _p7, p7); \
-      releaseArgument(env, _p8, p8); \
-      releaseArgument(env, _p9, p9); \
-      releaseArgument(env, _p10, p10); \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10)
-
-#define KOALA_INTEROP_V12(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) \
-  KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \
-  InteropTypeConverter<P0>::InteropType _p0, \
-  InteropTypeConverter<P1>::InteropType _p1, \
-  InteropTypeConverter<P2>::InteropType _p2, \
-  InteropTypeConverter<P3>::InteropType _p3, \
-  InteropTypeConverter<P4>::InteropType _p4, \
-  InteropTypeConverter<P5>::InteropType _p5, \
-  InteropTypeConverter<P6>::InteropType _p6, \
-  InteropTypeConverter<P7>::InteropType _p7, \
-  InteropTypeConverter<P8>::InteropType _p8, \
-  InteropTypeConverter<P9>::InteropType _p9, \
-  InteropTypeConverter<P10>::InteropType _p10, \
-  InteropTypeConverter<P11>::InteropType _p11) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      P3 p3 = getArgument<P3>(env, _p3); \
-      P4 p4 = getArgument<P4>(env, _p4); \
-      P5 p5 = getArgument<P5>(env, _p5); \
-      P6 p6 = getArgument<P6>(env, _p6); \
-      P7 p7 = getArgument<P7>(env, _p7); \
-      P8 p8 = getArgument<P8>(env, _p8); \
-      P9 p9 = getArgument<P9>(env, _p9); \
-      P10 p10 = getArgument<P10>(env, _p10); \
-      P11 p11 = getArgument<P11>(env, _p11); \
-      impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      releaseArgument(env, _p3, p3); \
-      releaseArgument(env, _p4, p4); \
-      releaseArgument(env, _p5, p5); \
-      releaseArgument(env, _p6, p6); \
-      releaseArgument(env, _p7, p7); \
-      releaseArgument(env, _p8, p8); \
-      releaseArgument(env, _p9, p9); \
-      releaseArgument(env, _p10, p10); \
-      releaseArgument(env, _p11, p11); \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11)
-
-#define KOALA_INTEROP_V13(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) \
-  KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \
-  InteropTypeConverter<P0>::InteropType _p0, \
-  InteropTypeConverter<P1>::InteropType _p1, \
-  InteropTypeConverter<P2>::InteropType _p2, \
-  InteropTypeConverter<P3>::InteropType _p3, \
-  InteropTypeConverter<P4>::InteropType _p4, \
-  InteropTypeConverter<P5>::InteropType _p5, \
-  InteropTypeConverter<P6>::InteropType _p6, \
-  InteropTypeConverter<P7>::InteropType _p7, \
-  InteropTypeConverter<P8>::InteropType _p8, \
-  InteropTypeConverter<P9>::InteropType _p9, \
-  InteropTypeConverter<P10>::InteropType _p10, \
-  InteropTypeConverter<P11>::InteropType _p11, \
-  InteropTypeConverter<P12>::InteropType _p12) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      P3 p3 = getArgument<P3>(env, _p3); \
-      P4 p4 = getArgument<P4>(env, _p4); \
-      P5 p5 = getArgument<P5>(env, _p5); \
-      P6 p6 = getArgument<P6>(env, _p6); \
-      P7 p7 = getArgument<P7>(env, _p7); \
-      P8 p8 = getArgument<P8>(env, _p8); \
-      P9 p9 = getArgument<P9>(env, _p9); \
-      P10 p10 = getArgument<P10>(env, _p10); \
-      P11 p11 = getArgument<P11>(env, _p11); \
-      P12 p12 = getArgument<P12>(env, _p12); \
-      impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      releaseArgument(env, _p3, p3); \
-      releaseArgument(env, _p4, p4); \
-      releaseArgument(env, _p5, p5); \
-      releaseArgument(env, _p6, p6); \
-      releaseArgument(env, _p7, p7); \
-      releaseArgument(env, _p8, p8); \
-      releaseArgument(env, _p9, p9); \
-      releaseArgument(env, _p10, p10); \
-      releaseArgument(env, _p11, p11); \
-      releaseArgument(env, _p12, p12); \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11 "|" #P12)
-
-#define KOALA_INTEROP_V14(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) \
-  KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \
-  InteropTypeConverter<P0>::InteropType _p0, \
-  InteropTypeConverter<P1>::InteropType _p1, \
-  InteropTypeConverter<P2>::InteropType _p2, \
-  InteropTypeConverter<P3>::InteropType _p3, \
-  InteropTypeConverter<P4>::InteropType _p4, \
-  InteropTypeConverter<P5>::InteropType _p5, \
-  InteropTypeConverter<P6>::InteropType _p6, \
-  InteropTypeConverter<P7>::InteropType _p7, \
-  InteropTypeConverter<P8>::InteropType _p8, \
-  InteropTypeConverter<P9>::InteropType _p9, \
-  InteropTypeConverter<P10>::InteropType _p10, \
-  InteropTypeConverter<P11>::InteropType _p11, \
-  InteropTypeConverter<P12>::InteropType _p12, \
-  InteropTypeConverter<P13>::InteropType _p13) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      P3 p3 = getArgument<P3>(env, _p3); \
-      P4 p4 = getArgument<P4>(env, _p4); \
-      P5 p5 = getArgument<P5>(env, _p5); \
-      P6 p6 = getArgument<P6>(env, _p6); \
-      P7 p7 = getArgument<P7>(env, _p7); \
-      P8 p8 = getArgument<P8>(env, _p8); \
-      P9 p9 = getArgument<P9>(env, _p9); \
-      P10 p10 = getArgument<P10>(env, _p10); \
-      P11 p11 = getArgument<P11>(env, _p11); \
-      P12 p12 = getArgument<P12>(env, _p12); \
-      P13 p13 = getArgument<P13>(env, _p13); \
-      impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      releaseArgument(env, _p3, p3); \
-      releaseArgument(env, _p4, p4); \
-      releaseArgument(env, _p5, p5); \
-      releaseArgument(env, _p6, p6); \
-      releaseArgument(env, _p7, p7); \
-      releaseArgument(env, _p8, p8); \
-      releaseArgument(env, _p9, p9); \
-      releaseArgument(env, _p10, p10); \
-      releaseArgument(env, _p11, p11); \
-      releaseArgument(env, _p12, p12); \
-      releaseArgument(env, _p13, p13); \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11 "|" #P12 "|" #P13)
-
-#define KOALA_INTEROP_V15(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) \
-  KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \
-  InteropTypeConverter<P0>::InteropType _p0, \
-  InteropTypeConverter<P1>::InteropType _p1, \
-  InteropTypeConverter<P2>::InteropType _p2, \
-  InteropTypeConverter<P3>::InteropType _p3, \
-  InteropTypeConverter<P4>::InteropType _p4, \
-  InteropTypeConverter<P5>::InteropType _p5, \
-  InteropTypeConverter<P6>::InteropType _p6, \
-  InteropTypeConverter<P7>::InteropType _p7, \
-  InteropTypeConverter<P8>::InteropType _p8, \
-  InteropTypeConverter<P9>::InteropType _p9, \
-  InteropTypeConverter<P10>::InteropType _p10, \
-  InteropTypeConverter<P11>::InteropType _p11, \
-  InteropTypeConverter<P12>::InteropType _p12, \
-  InteropTypeConverter<P13>::InteropType _p13, \
-  InteropTypeConverter<P14>::InteropType _p14) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      P3 p3 = getArgument<P3>(env, _p3); \
-      P4 p4 = getArgument<P4>(env, _p4); \
-      P5 p5 = getArgument<P5>(env, _p5); \
-      P6 p6 = getArgument<P6>(env, _p6); \
-      P7 p7 = getArgument<P7>(env, _p7); \
-      P8 p8 = getArgument<P8>(env, _p8); \
-      P9 p9 = getArgument<P9>(env, _p9); \
-      P10 p10 = getArgument<P10>(env, _p10); \
-      P11 p11 = getArgument<P11>(env, _p11); \
-      P12 p12 = getArgument<P12>(env, _p12); \
-      P13 p13 = getArgument<P13>(env, _p13); \
-      P14 p14 = getArgument<P14>(env, _p14); \
-      impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      releaseArgument(env, _p3, p3); \
-      releaseArgument(env, _p4, p4); \
-      releaseArgument(env, _p5, p5); \
-      releaseArgument(env, _p6, p6); \
-      releaseArgument(env, _p7, p7); \
-      releaseArgument(env, _p8, p8); \
-      releaseArgument(env, _p9, p9); \
-      releaseArgument(env, _p10, p10); \
-      releaseArgument(env, _p11, p11); \
-      releaseArgument(env, _p12, p12); \
-      releaseArgument(env, _p13, p13); \
-      releaseArgument(env, _p14, p14); \
-}  \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11 "|" #P12 "|" #P13 "|" #P14)
-
-#define KOALA_INTEROP_CTX_0(name, Ret) \
-   KOALA_JNI_CALL(SlowInteropTypeConverter<Ret>::InteropType) \
-   Java_org_##name(JNIEnv* env, jclass instance) { \
-      KOALA_MAYBE_LOG(name) \
-      KVMContext ctx = (KVMContext)env; \
-      auto rv = SlowInteropTypeConverter<Ret>::convertTo(env, impl_##name(ctx)); \
-      return rv; \
-  } \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret)
-
-#define KOALA_INTEROP_CTX_1(name, Ret, P0) \
-   KOALA_JNI_CALL(SlowInteropTypeConverter<Ret>::InteropType) \
-   Java_org_##name(JNIEnv* env, jclass instance, \
-    SlowInteropTypeConverter<P0>::InteropType _p0) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      KVMContext ctx = (KVMContext)env; \
-      auto rv = SlowInteropTypeConverter<Ret>::convertTo(env, impl_##name(ctx, p0)); \
-      releaseArgument(env, _p0, p0); \
-      return rv; \
-  } \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0)
-
-#define KOALA_INTEROP_CTX_2(name, Ret, P0, P1) \
-  KOALA_JNI_CALL(SlowInteropTypeConverter<Ret>::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \
-  SlowInteropTypeConverter<P0>::InteropType _p0, \
-  SlowInteropTypeConverter<P1>::InteropType _p1) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      KVMContext ctx = (KVMContext)env; \
-      auto rv = SlowInteropTypeConverter<Ret>::convertTo(env, impl_##name(ctx, p0, p1)); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      return rv; \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1)
-
-#define KOALA_INTEROP_CTX_3(name, Ret, P0, P1, P2) \
-  KOALA_JNI_CALL(SlowInteropTypeConverter<Ret>::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \
-  SlowInteropTypeConverter<P0>::InteropType _p0, \
-  SlowInteropTypeConverter<P1>::InteropType _p1, \
-  SlowInteropTypeConverter<P2>::InteropType _p2) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      KVMContext ctx = (KVMContext)env; \
-      auto rv = SlowInteropTypeConverter<Ret>::convertTo(env, impl_##name(ctx, p0, p1, p2)); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      return rv; \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2)
-
-#define KOALA_INTEROP_CTX_4(name, Ret, P0, P1, P2, P3) \
-  KOALA_JNI_CALL(SlowInteropTypeConverter<Ret>::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \
-  SlowInteropTypeConverter<P0>::InteropType _p0, \
-  SlowInteropTypeConverter<P1>::InteropType _p1, \
-  SlowInteropTypeConverter<P2>::InteropType _p2, \
-  SlowInteropTypeConverter<P3>::InteropType _p3) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      P3 p3 = getArgument<P3>(env, _p3); \
-      KVMContext ctx = (KVMContext)env; \
-      auto rv = SlowInteropTypeConverter<Ret>::convertTo(env, impl_##name(ctx, p0, p1, p2, p3)); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      releaseArgument(env, _p3, p3); \
-      return rv; \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3)
-
-#define KOALA_INTEROP_CTX_V0(name) \
-   KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance) { \
-      KOALA_MAYBE_LOG(name) \
-      KVMContext ctx = (KVMContext)env; \
-      impl_##name(ctx); \
-  } \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void")
-
-#define KOALA_INTEROP_CTX_V1(name, P0) \
-   KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \
-    SlowInteropTypeConverter<P0>::InteropType _p0) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      KVMContext ctx = (KVMContext)env; \
-      impl_##name(ctx, p0); \
-      releaseArgument(env, _p0, p0); \
-  } \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0)
-
-#define KOALA_INTEROP_CTX_V2(name, P0, P1) \
-  KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \
-   SlowInteropTypeConverter<P0>::InteropType _p0, \
-   SlowInteropTypeConverter<P1>::InteropType _p1) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      KVMContext ctx = (KVMContext)env; \
-      impl_##name(ctx, p0, p1); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1)
-
-#define KOALA_INTEROP_CTX_V3(name, P0, P1, P2) \
-  KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \
-   SlowInteropTypeConverter<P0>::InteropType _p0, \
-   SlowInteropTypeConverter<P1>::InteropType _p1, \
-   SlowInteropTypeConverter<P2>::InteropType _p2) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      KVMContext ctx = (KVMContext)env; \
-      impl_##name(ctx, p0, p1, p2); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2)
-
-#define KOALA_INTEROP_CTX_V4(name, P0, P1, P2, P3) \
-  KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \
-   SlowInteropTypeConverter<P0>::InteropType _p0, \
-   SlowInteropTypeConverter<P1>::InteropType _p1, \
-   SlowInteropTypeConverter<P2>::InteropType _p2, \
-   SlowInteropTypeConverter<P3>::InteropType _p3) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      P3 p3 = getArgument<P3>(env, _p3); \
-      KVMContext ctx = (KVMContext)env; \
-      impl_##name(ctx, p0, p1, p2, p3); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      releaseArgument(env, _p3, p3); \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3)
-
-#define KOALA_INTEROP_CTX_V5(name, P0, P1, P2, P3, P4) \
-  KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \
-   SlowInteropTypeConverter<P0>::InteropType _p0, \
-   SlowInteropTypeConverter<P1>::InteropType _p1, \
-   SlowInteropTypeConverter<P2>::InteropType _p2, \
-   SlowInteropTypeConverter<P3>::InteropType _p3, \
-   SlowInteropTypeConverter<P4>::InteropType _p4) { \
-      KOALA_MAYBE_LOG(name) \
-      P0 p0 = getArgument<P0>(env, _p0); \
-      P1 p1 = getArgument<P1>(env, _p1); \
-      P2 p2 = getArgument<P2>(env, _p2); \
-      P3 p3 = getArgument<P3>(env, _p3); \
-      P4 p4 = getArgument<P4>(env, _p4); \
-      KVMContext ctx = (KVMContext)env; \
-      impl_##name(ctx, p0, p1, p2, p3, p4); \
-      releaseArgument(env, _p0, p0); \
-      releaseArgument(env, _p1, p1); \
-      releaseArgument(env, _p2, p2); \
-      releaseArgument(env, _p3, p3); \
-      releaseArgument(env, _p4, p4); \
-} \
-MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4)
-
-bool setKoalaJniCallbackDispatcher(
-    JNIEnv* env,
-    jclass clazz,
-    const char* dispatcherMethodName,
-    const char* dispactherMethodSig
-);
-void getKoalaJniCallbackDispatcher(jclass* clazz, jmethodID* method);
-
-#define KOALA_INTEROP_CALL_VOID(venv, id, length, args)                            \
-{                                                                                  \
-  jclass clazz = nullptr;                                                          \
-  jmethodID method = nullptr;                                                      \
-  getKoalaJniCallbackDispatcher(&clazz, &method);                                  \
-  JNIEnv* jniEnv = reinterpret_cast<JNIEnv*>(venv);                                \
-  jniEnv->PushLocalFrame(1);                                                       \
-  jbyteArray args_jni = jniEnv->NewByteArray(length);                              \
-  jniEnv->SetByteArrayRegion(args_jni, 0, length, reinterpret_cast<jbyte*>(args)); \
-  jniEnv->CallStaticIntMethod(clazz, method, id, args_jni, length);                \
-  jniEnv->GetByteArrayRegion(args_jni, 0, length, reinterpret_cast<jbyte*>(args)); \
-  jniEnv->PopLocalFrame(nullptr);                                                  \
-}
-
-#define KOALA_INTEROP_CALL_INT(venv, id, length, args)                             \
-{                                                                                  \
-  jclass clazz = nullptr;                                                          \
-  jmethodID method = nullptr;                                                      \
-  getKoalaJniCallbackDispatcher(&clazz, &method);                                  \
-  JNIEnv* jniEnv = reinterpret_cast<JNIEnv*>(venv);                                \
-  jniEnv->PushLocalFrame(1);                                                       \
-  jbyteArray args_jni = jniEnv->NewByteArray(length);                              \
-  jniEnv->SetByteArrayRegion(args_jni, 0, length, reinterpret_cast<jbyte*>(args)); \
-  int32_t rv = jniEnv->CallStaticIntMethod(clazz, method, id, args_jni, length);   \
-  jniEnv->GetByteArrayRegion(args_jni, 0, length, reinterpret_cast<jbyte*>(args)); \
-  jniEnv->PopLocalFrame(nullptr);                                                  \
-  return rv;                                                                       \
-}
-
-#define KOALA_INTEROP_CALL_VOID_INTS32(venv, id, argc, args) KOALA_INTEROP_CALL_VOID(venv, id, (argc) * sizeof(int32_t), args)
-#define KOALA_INTEROP_CALL_INT_INTS32(venv, id, argc, args) KOALA_INTEROP_CALL_INT(venv, id, (argc) * sizeof(int32_t), args)
-
-#define KOALA_INTEROP_THROW(vmContext, object, ...) \
-   do { \
-     JNIEnv* env = reinterpret_cast<JNIEnv*>(vmContext); \
-     env->Throw(object); \
-     return __VA_ARGS__; \
-   } while (0)
-
-#define KOALA_INTEROP_THROW_STRING(vmContext, message, ...) \
-  do { \
-    JNIEnv* env = reinterpret_cast<JNIEnv*>(vmContext); \
-    const static jclass errorClass = env->FindClass("java/lang/RuntimeException"); \
-    env->ThrowNew(errorClass, message); \
-  } while (0)
-
-#endif  // KOALA_JNI_CALL
diff --git a/koala-wrapper/koalaui/interop/src/cpp/jsc/convertors-jsc.cc b/koala-wrapper/koalaui/interop/src/cpp/jsc/convertors-jsc.cc
deleted file mode 100644
index b1edbde65eac06b3d0184cbdd22bb14e8a09b95c..0000000000000000000000000000000000000000
--- a/koala-wrapper/koalaui/interop/src/cpp/jsc/convertors-jsc.cc
+++ /dev/null
@@ -1,285 +0,0 @@
-/*
- * Copyright (c) 2022-2025 Huawei Device Co., Ltd.
- * 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.
- */
-
-#include <MacTypes.h>
-#include <_types/_uint32_t.h>
-#include <_types/_uint8_t.h>
-#include <assert.h>
-#include <cstdint>
-
-#include "convertors-jsc.h"
-
-// See https://github.com/BabylonJS/BabylonNative/blob/master/Dependencies/napi/napi-direct/source/js_native_api_javascriptcore.cc
-// for convertors logic.
-
-
-KInt* getInt32Elements(JSContextRef context, const JSValueRef arguments) {
-    return getTypedElements<KInt>(context, arguments);
-}
-
-uint32_t* getUInt32Elements(JSContextRef context, const JSValueRef arguments) {
-    return getTypedElements<uint32_t>(context, arguments);
-}
-
-float* getFloat32Elements(JSContextRef context, const JSValueRef arguments) {
-    return getTypedElements<float>(context, arguments);
-}
-
-KByte* getByteElements(JSContextRef context, const JSValueRef arguments) {
-    return getTypedElements<KByte>(context, arguments);
-}
-
-KStringArray getKStringArray(JSContextRef context, const JSValueRef arguments) {
-    return getTypedElements<uint8_t>(context, arguments);
-}
-
-KUShort* getUShortElements(JSContextRef context, const JSValueRef arguments) {
-    return getTypedElements<KUShort>(context, arguments);
-}
-
-KShort* getShortElements(JSContextRef context, const JSValueRef arguments) {
-    return getTypedElements<KShort>(context, arguments);
-}
-
-int32_t getInt32(JSContextRef context, JSValueRef value) {
-    JSValueRef exception {};
-    if (JSValueIsNull(context, value)) {
-        return 0;
-    }
-    if (JSValueIsUndefined(context, value)) {
-        assert(false);
-        return 0;
-    }
-    double result = JSValueToNumber(context, value, &exception);
-    return static_cast<int32_t>(result);
-}
-
-uint32_t getUInt32(JSContextRef context, JSValueRef value) {
-    JSValueRef exception {};
-    if (JSValueIsNull(context, value)) {
-        return 0;
-    }
-    if (JSValueIsUndefined(context, value)) {
-        assert(false);
-        return 0;
-    }
-    double result = JSValueToNumber(context, value, &exception);
-    return static_cast<uint32_t>(result);
-}
-
-uint8_t getUInt8(JSContextRef context, JSValueRef value) {
-    JSValueRef exception {};
-    if (JSValueIsNull(context, value)) {
-        return 0;
-    }
-    if (JSValueIsUndefined(context, value)) {
-        assert(false);
-        return 0;
-    }
-    double result = JSValueToNumber(context, value, &exception);
-    return static_cast<uint8_t>(result);
-}
-
-/*
-static JSStringRef bigintToArrayCastFuncName = JSStringCreateWithUTF8CString("__JSC__castFromBigInt");
-static JSStringRef bigintToArrayCastFuncParams[] = { JSStringCreateWithUTF8CString("ptr") };
-static JSStringRef bigintToArrayCastFuncBody = JSStringCreateWithUTF8CString(
-    "return new Uint32Array([ptr & 0xFFFFFFFFn, (ptr >> 32n) & 0xFFFFFFFFn]);"
-);
-
-static JSStringRef arrayToBigintCastFuncName = JSStringCreateWithUTF8CString("__JSC__castToBigInt");
-static JSStringRef arrayToBigintCastFuncParams[] = { JSStringCreateWithUTF8CString("ptr") };
-static JSStringRef arrayToBigintCastFuncBody = JSStringCreateWithUTF8CString(
-    "return BigInt(ptr[1]) << 32n | BigInt(ptr[0])"
-);
-*/
-
-#ifdef KOALA_JSC_USE_CALLBACK_CAST
-
-static JSStringRef bigIntFromPartsFuncName = JSStringCreateWithUTF8CString("__JSC__bigIntFromParts");
-static JSStringRef bigIntFromPartsFuncParams[] = { JSStringCreateWithUTF8CString("hi"), JSStringCreateWithUTF8CString("lo") };
-static JSStringRef bigIntFromPartsFuncBody = JSStringCreateWithUTF8CString(
-    "return BigInt(hi) << 32n | BigInt(lo);"
-);
-
-static JSObjectRef getGlobalCallback(JSContextRef context, JSStringRef name, JSStringRef params[], JSStringRef body) {
-    JSObjectRef globalThis = JSContextGetGlobalObject(context);
-    JSValueRef propname = JSValueMakeString(context, name);
-    JSValueRef castFunc = JSObjectGetPropertyForKey(context, globalThis, propname, nullptr);
-    if (JSValueIsUndefined(context, castFunc)) {
-        JSObjectRef castFuncObj = JSObjectMakeFunction(context, name, 1, params, body, nullptr, 0, nullptr);
-        JSPropertyAttributes attributes = kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum;
-        JSObjectSetPropertyForKey(context, globalThis, propname, castFuncObj, attributes, nullptr);
-        return castFuncObj;
-    }
-    return JSValueToObject(context, castFunc, nullptr);
-}
-
-static JSObjectRef getBigIntFromParts(JSContextRef context) {
-    return getGlobalCallback(context, bigIntFromPartsFuncName, bigIntFromPartsFuncParams, bigIntFromPartsFuncBody);
-}
-
-#endif
-
-static JSValueRef u64ToBigInt(JSContextRef context, uint64_t value) {
-    JSValueRef bigint;
-#ifdef KOALA_JSC_USE_CALLBACK_CAST
-    // TODO benchmark this
-    JSObjectRef bigIntFromParts = getBigIntFromParts(context);
-    JSValueRef parts[2] = {
-        JSValueMakeNumber(context, (double) (value >> 32)),
-        JSValueMakeNumber(context, (double) (value & 0xFFFFFFFF)),
-    };
-    bigint = JSObjectCallAsFunction(context, bigIntFromParts, nullptr, 2, parts, nullptr);
-#else
-    char buffer[128] = {0};
-    std::snprintf(buffer, sizeof(buffer) - 1, "%zun", (size_t) value);
-    JSStringRef script = JSStringCreateWithUTF8CString(buffer);
-    bigint = JSEvaluateScript(context, script, nullptr, nullptr, 0, nullptr);
-    JSStringRelease(script);
-#endif
-    return bigint;
-}
-
-static uint64_t bigIntToU64(JSContextRef ctx, JSValueRef value) {
-    char buf[128];
-    JSStringRef strRef = JSValueToStringCopy(ctx, value, nullptr);
-    size_t len = JSStringGetUTF8CString(strRef, buf, sizeof(buf));
-    JSStringRelease(strRef);
-    assert(len < sizeof(buf));
-    char* suf;
-    uint64_t numValue = std::strtoull(buf, &suf, 10);
-    assert(*suf == '\0');
-    return numValue;
-}
-
-KNativePointer getPointer(JSContextRef context, JSValueRef value) {
-    uint64_t raw = bigIntToU64(context, value);
-    return reinterpret_cast<void*>(static_cast<uintptr_t>(raw));
-}
-
-KNativePointerArray getPointerElements(JSContextRef context, JSValueRef value) {
-    if (JSValueIsNull(context, value) || JSValueIsUndefined(context, value)) {
-        return nullptr;
-    }
-
-    assert(JSValueIsObject(context, value));
-    assert(JSValueGetTypedArrayType(context, value, nullptr) == kJSTypedArrayTypeBigUint64Array);
-
-    JSObjectRef typedArray = JSValueToObject(context, value, nullptr);
-    return reinterpret_cast<KNativePointerArray>(JSObjectGetTypedArrayBytesPtr(context, typedArray, nullptr));
-}
-
-KFloat getFloat(JSContextRef context, JSValueRef value) {
-    JSValueRef exception {};
-    if (JSValueIsNull(context, value)) {
-        return 0;
-    }
-    if (JSValueIsUndefined(context, value)) {
-        assert(false);
-        return 0;
-    }
-    double result = JSValueToNumber(context, value, &exception);
-    return static_cast<KFloat>(result);
-}
-
-KShort getShort(JSContextRef context, JSValueRef value) {
-    JSValueRef exception {};
-    if (JSValueIsNull(context, value)) {
-        return 0;
-    }
-    if (JSValueIsUndefined(context, value)) {
-        assert(false);
-        return 0;
-    }
-    double result = JSValueToNumber(context, value, &exception);
-    return static_cast<KShort>(result);
-}
-
-KUShort getUShort(JSContextRef context, JSValueRef value) {
-    JSValueRef exception {};
-    if (JSValueIsNull(context, value)) {
-        return 0;
-    }
-    if (JSValueIsUndefined(context, value)) {
-        assert(false);
-        return 0;
-    }
-    double result = JSValueToNumber(context, value, &exception);
-    return static_cast<KUShort>(result);
-}
-
-KStringPtr getString(JSContextRef context, JSValueRef value) {
-    if (JSValueIsNull(context, value)) {
-        return KStringPtr();
-    }
-    if (JSValueIsUndefined(context, value)) {
-        return KStringPtr();
-    }
-    KStringPtr result;
-    JSStringRef valueString = JSValueToStringCopy(context, value, NULL);
-    size_t size = JSStringGetMaximumUTF8CStringSize(valueString);
-    result.resize(size);
-    JSStringGetUTF8CString(valueString, result.data(), size);
-    JSStringRelease(valueString);
-    return result;
-}
-
-KBoolean getBoolean(JSContextRef context, JSValueRef value) {
-    bool result = JSValueToBoolean(context, value);
-    return static_cast<KBoolean>(result);
-}
-
-JSValueRef makeInt32(JSContextRef context, int32_t value) {
-    return JSValueMakeNumber(context, value);
-}
-
-JSValueRef makeUInt32(JSContextRef context, uint32_t value) {
-    return JSValueMakeNumber(context, value);
-}
-
-JSValueRef makePointer(JSContextRef context, KNativePointer value) {
-    return u64ToBigInt(context, static_cast<uint64_t>(reinterpret_cast<uintptr_t>(value)));
-}
-
-JSValueRef makeFloat(JSContextRef context, KFloat value) {
-    return JSValueMakeNumber(context, value);
-}
-
-JSValueRef makeBoolean(JSContextRef context, KBoolean value) {
-    return JSValueMakeBoolean(context, value);
-}
-
-JSValueRef makeVoid(JSContextRef context) {
-    return JSValueMakeUndefined(context);
-}
-
-Exports* Exports::getInstance() {
-  static Exports *instance = nullptr;
-  if (instance == nullptr) {
-      instance = new Exports();
-  }
-  return instance;
-}
-
-void InitExports(JSGlobalContextRef globalContext) {
-    JSObjectRef globalObject = JSContextGetGlobalObject(globalContext);
-    for (auto impl: Exports::getInstance()->getImpls()) {
-        JSStringRef functionName = JSStringCreateWithUTF8CString(impl.first.c_str());
-        JSObjectRef functionObject = JSObjectMakeFunctionWithCallback(globalContext, functionName, impl.second);
-        JSObjectSetProperty(globalContext, globalObject, functionName, functionObject, kJSPropertyAttributeNone, nullptr);
-        JSStringRelease(functionName);
-    }
-}
diff --git a/koala-wrapper/koalaui/interop/src/cpp/jsc/convertors-jsc.h b/koala-wrapper/koalaui/interop/src/cpp/jsc/convertors-jsc.h
deleted file mode 100644
index b100dff7d67a8525a98b0ef0394c98bddf6b7654..0000000000000000000000000000000000000000
--- a/koala-wrapper/koalaui/interop/src/cpp/jsc/convertors-jsc.h
+++ /dev/null
@@ -1,722 +0,0 @@
-/*
- * Copyright (c) 2022-2025 Huawei Device Co., Ltd.
- * 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.
- */
-
-#pragma once
-
-#if defined(linux)
-#include <JavaScriptCore/JavaScript.h> // For IDE completion
-#else
-#include <JavaScriptCore/JavaScriptCore.h>
-#endif
-#include <_types/_uint8_t.h>
-#include <vector>
-#include <string>
-#include <iostream>
-
-#include <assert.h>
-
-#include "koala-types.h"
-
-template <typename ElemType>
-inline ElemType* getTypedElements(JSContextRef context, const JSValueRef arguments) {
-  if (JSValueIsNull(context, arguments)) {
-      return nullptr;
-  }
-  if (JSValueIsUndefined(context, arguments)) {
-      assert(false);
-      return nullptr;
-  }
-  JSValueRef exception {};
-  ElemType* data = reinterpret_cast<ElemType*>(JSObjectGetTypedArrayBytesPtr(context,
-        JSValueToObject(context, arguments, &exception), &exception));
-  return data;
-}
-
-template <typename ElemType>
-inline ElemType* getTypedElements(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) {
-  assert(index < argumentCount);
-  return getTypedElements<ElemType>(context, arguments[index]);
-}
-
-uint8_t* getUInt8Elements(JSContextRef context, const JSValueRef arguments);
-int32_t* getInt32Elements(JSContextRef context, const JSValueRef arguments);
-uint32_t* getUInt32Elements(JSContextRef context, const JSValueRef arguments);
-float* getFloat32Elements(JSContextRef context, const JSValueRef arguments);
-KByte* getByteElements(JSContextRef context, const JSValueRef arguments);
-KUShort* getUShortElements(JSContextRef context, const JSValueRef arguments);
-KShort* getShortElements(JSContextRef context, const JSValueRef arguments);
-KNativePointerArray getPointerElements(JSContextRef context, const JSValueRef arguments);
-KStringArray getKStringArray(JSContextRef context, const JSValueRef arguments);
-
-uint8_t getUInt8(JSContextRef context, JSValueRef value);
-int32_t getInt32(JSContextRef context, JSValueRef value);
-uint32_t getUInt32(JSContextRef context, JSValueRef value);
-KNativePointer getPointer(JSContextRef context, JSValueRef value);
-KFloat getFloat(JSContextRef context, JSValueRef value);
-KStringPtr getString(JSContextRef context, JSValueRef value);
-KBoolean getBoolean(JSContextRef context, JSValueRef value);
-KStringPtr getString(JSContextRef context, JSValueRef value);
-
-template <typename Type>
-inline Type getArgument(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) = delete;
-
-template <>
-inline int32_t getArgument<int32_t>(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) {
-  assert(index < argumentCount);
-  return getInt32(context, arguments[index]);
-}
-
-template <>
-inline uint32_t getArgument<uint32_t>(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) {
-  assert(index < argumentCount);
-  return getUInt32(context, arguments[index]);
-}
-
-template <>
-inline uint8_t getArgument<uint8_t>(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) {
-  assert(index < argumentCount);
-  return getUInt8(context, arguments[index]);
-}
-
-template <>
-inline KNativePointer getArgument<KNativePointer>(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) {
-  assert(index < argumentCount);
-  return getPointer(context, arguments[index]);
-}
-
-template <>
-inline KFloat getArgument<KFloat>(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) {
-  assert(index < argumentCount);
-  return getFloat(context, arguments[index]);
-}
-
-template <>
-inline KStringPtr getArgument<KStringPtr>(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) {
-  assert(index < argumentCount);
-  return getString(context, arguments[index]);
-}
-
-template <>
-inline KBoolean getArgument<KBoolean>(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) {
-  assert(index < argumentCount);
-  return getBoolean(context, arguments[index]);
-}
-
-template <>
-inline KInt* getArgument<KInt*>(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) {
-  assert(index < argumentCount);
-  return getInt32Elements(context, arguments[index]);
-}
-
-template <>
-inline float* getArgument<float*>(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) {
-  assert(index < argumentCount);
-  return getFloat32Elements(context, arguments[index]);
-}
-
-template <>
-inline KByte* getArgument<KByte*>(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) {
-  assert(index < argumentCount);
-  return getByteElements(context, arguments[index]);
-}
-
-template <>
-inline KStringArray getArgument<KStringArray>(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) {
-  assert(index < argumentCount);
-  return getKStringArray(context, arguments[index]);
-}
-
-template <>
-inline KUShort* getArgument<KUShort*>(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) {
-  assert(index < argumentCount);
-  return getUShortElements(context, arguments[index]);
-}
-
-template <>
-inline KNativePointerArray getArgument<KNativePointerArray>(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) {
-  assert(index < argumentCount);
-  return getPointerElements(context, arguments[index]);
-}
-
-template <>
-inline KShort* getArgument<KShort*>(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) {
-  assert(index < argumentCount);
-  return getShortElements(context, arguments[index]);
-}
-
-JSValueRef makeInt32(JSContextRef context, int32_t value);
-JSValueRef makeUInt32(JSContextRef context, uint32_t value);
-JSValueRef makePointer(JSContextRef context, KNativePointer value);
-JSValueRef makeFloat(JSContextRef context, KFloat value);
-JSValueRef makeBoolean(JSContextRef context, KBoolean value);
-JSValueRef makeVoid(JSContextRef context);
-
-template <typename Type>
-inline JSValueRef makeResult(JSContextRef context, Type value) = delete;
-
-template <>
-inline JSValueRef makeResult<int32_t>(JSContextRef context, int32_t value) {
-  return makeInt32(context, value);
-}
-
-template <>
-inline JSValueRef makeResult<uint32_t>(JSContextRef context, uint32_t value) {
-  return makeUInt32(context, value);
-}
-
-template <>
-inline JSValueRef makeResult<KNativePointer>(JSContextRef context, KNativePointer value) {
-  return makePointer(context, value);
-}
-
-template <>
-inline JSValueRef makeResult<KFloat>(JSContextRef context, KFloat value) {
-  return makeFloat(context, value);
-}
-
-template <>
-inline JSValueRef makeResult<KBoolean>(JSContextRef context, KBoolean value) {
-  return makeBoolean(context, value);
-}
-
-typedef JSValueRef (*jsc_type_t)(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);
-
-class Exports {
-    std::vector<std::pair<std::string, jsc_type_t>> implementations;
-
-public:
-    static Exports* getInstance();
-
-    void addImpl(const char* name, jsc_type_t impl) {
-        implementations.push_back(std::make_pair(name, impl));
-    }
-
-    const std::vector<std::pair<std::string, jsc_type_t>>& getImpls() {
-        return implementations;
-    }
-};
-
-void InitExports(JSGlobalContextRef globalContext);
-
-#define MAKE_JSC_EXPORT(name) \
-    __attribute__((constructor)) \
-    static void __init_##name() { \
-        Exports::getInstance()->addImpl("_"#name, Jsc_##name); \
-    }
-
-#define MAKE_JSC_EXPORT_V1(name) \
-    __attribute__((constructor)) \
-    static void __init_##name() { \
-        Exports::getInstance()->addImpl(#name, Jsc_##name); \
-    }
-
-#define KOALA_INTEROP_0(name, Ret) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-      KOALA_MAYBE_LOG(name)                       \
-      return makeResult<Ret>(ctx, impl_##name()); \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_1(name, Ret, P0) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-      KOALA_MAYBE_LOG(name)                                            \
-      P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0); \
-      return makeResult<Ret>(ctx, impl_##name(p0));                    \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_2(name, Ret, P0, P1) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                             \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    return makeResult<Ret>(ctx, impl_##name(p0, p1));                  \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_3(name, Ret, P0, P1, P2) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                             \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);  \
-    return makeResult<Ret>(ctx, impl_##name(p0,p1,p2));         \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_4(name, Ret, P0, P1, P2, P3) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                             \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);  \
-    P3 p3 = getArgument<P3>(ctx, argumentCount, arguments, 3);  \
-    return makeResult<Ret>(ctx, impl_##name(p0,p1,p2,p3));             \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_5(name, Ret, P0, P1, P2, P3, P4) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                             \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);  \
-    P3 p3 = getArgument<P3>(ctx, argumentCount, arguments, 3);  \
-    P4 p4 = getArgument<P4>(ctx, argumentCount, arguments, 4);  \
-    return makeResult<Ret>(ctx, impl_##name(p0,p1,p2,p3,p4));          \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_6(name, Ret, P0, P1, P2, P3, P4, P5) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                             \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);  \
-    P3 p3 = getArgument<P3>(ctx, argumentCount, arguments, 3);  \
-    P4 p4 = getArgument<P4>(ctx, argumentCount, arguments, 4);  \
-    P5 p5 = getArgument<P5>(ctx, argumentCount, arguments, 5);  \
-    return makeResult<Ret>(ctx, impl_##name(p0,p1,p2,p3,p4,p5));       \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_7(name, Ret, P0, P1, P2, P3, P4, P5, P6) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                             \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);  \
-    P3 p3 = getArgument<P3>(ctx, argumentCount, arguments, 3);  \
-    P4 p4 = getArgument<P4>(ctx, argumentCount, arguments, 4);  \
-    P5 p5 = getArgument<P5>(ctx, argumentCount, arguments, 5);  \
-    P6 p6 = getArgument<P6>(ctx, argumentCount, arguments, 6);  \
-    return makeResult<Ret>(ctx, impl_##name(p0,p1,p2,p3,p4,p5,p6));    \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_8(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                             \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);  \
-    P3 p3 = getArgument<P3>(ctx, argumentCount, arguments, 3);  \
-    P4 p4 = getArgument<P4>(ctx, argumentCount, arguments, 4);  \
-    P5 p5 = getArgument<P5>(ctx, argumentCount, arguments, 5);  \
-    P6 p6 = getArgument<P6>(ctx, argumentCount, arguments, 6);  \
-    P7 p7 = getArgument<P7>(ctx, argumentCount, arguments, 7);  \
-    return makeResult<Ret>(ctx, impl_##name(p0,p1,p2,p3,p4,p5,p6,p7)); \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_9(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                             \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);  \
-    P3 p3 = getArgument<P3>(ctx, argumentCount, arguments, 3);  \
-    P4 p4 = getArgument<P4>(ctx, argumentCount, arguments, 4);  \
-    P5 p5 = getArgument<P5>(ctx, argumentCount, arguments, 5);  \
-    P6 p6 = getArgument<P6>(ctx, argumentCount, arguments, 6);  \
-    P7 p7 = getArgument<P7>(ctx, argumentCount, arguments, 7);  \
-    P8 p8 = getArgument<P8>(ctx, argumentCount, arguments, 8);  \
-    return makeResult<Ret>(ctx, impl_##name(p0,p1,p2,p3,p4,p5,p6,p7,p8)); \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_10(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                             \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);  \
-    P3 p3 = getArgument<P3>(ctx, argumentCount, arguments, 3);  \
-    P4 p4 = getArgument<P4>(ctx, argumentCount, arguments, 4);  \
-    P5 p5 = getArgument<P5>(ctx, argumentCount, arguments, 5);  \
-    P6 p6 = getArgument<P6>(ctx, argumentCount, arguments, 6);  \
-    P7 p7 = getArgument<P7>(ctx, argumentCount, arguments, 7);  \
-    P8 p8 = getArgument<P8>(ctx, argumentCount, arguments, 8);  \
-    P9 p9 = getArgument<P9>(ctx, argumentCount, arguments, 9);  \
-    return makeResult<Ret>(ctx, impl_##name(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9)); \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_11(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                             \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);  \
-    P3 p3 = getArgument<P3>(ctx, argumentCount, arguments, 3);  \
-    P4 p4 = getArgument<P4>(ctx, argumentCount, arguments, 4);  \
-    P5 p5 = getArgument<P5>(ctx, argumentCount, arguments, 5);  \
-    P6 p6 = getArgument<P6>(ctx, argumentCount, arguments, 6);  \
-    P7 p7 = getArgument<P7>(ctx, argumentCount, arguments, 7);  \
-    P8 p8 = getArgument<P8>(ctx, argumentCount, arguments, 8);  \
-    P9 p9 = getArgument<P9>(ctx, argumentCount, arguments, 9);  \
-    P10 p10 = getArgument<P10>(ctx, argumentCount, arguments, 10);  \
-    return makeResult<Ret>(ctx, impl_##name(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10)); \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_12(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                             \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);  \
-    P3 p3 = getArgument<P3>(ctx, argumentCount, arguments, 3);  \
-    P4 p4 = getArgument<P4>(ctx, argumentCount, arguments, 4);  \
-    P5 p5 = getArgument<P5>(ctx, argumentCount, arguments, 5);  \
-    P6 p6 = getArgument<P6>(ctx, argumentCount, arguments, 6);  \
-    P7 p7 = getArgument<P7>(ctx, argumentCount, arguments, 7);  \
-    P8 p8 = getArgument<P8>(ctx, argumentCount, arguments, 8);  \
-    P9 p9 = getArgument<P9>(ctx, argumentCount, arguments, 9);  \
-    P10 p10 = getArgument<P10>(ctx, argumentCount, arguments, 10);  \
-    P11 p11 = getArgument<P11>(ctx, argumentCount, arguments, 11);  \
-    return makeResult<Ret>(ctx, impl_##name(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11)); \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_13(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                             \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);  \
-    P3 p3 = getArgument<P3>(ctx, argumentCount, arguments, 3);  \
-    P4 p4 = getArgument<P4>(ctx, argumentCount, arguments, 4);  \
-    P5 p5 = getArgument<P5>(ctx, argumentCount, arguments, 5);  \
-    P6 p6 = getArgument<P6>(ctx, argumentCount, arguments, 6);  \
-    P7 p7 = getArgument<P7>(ctx, argumentCount, arguments, 7);  \
-    P8 p8 = getArgument<P8>(ctx, argumentCount, arguments, 8);  \
-    P9 p9 = getArgument<P9>(ctx, argumentCount, arguments, 9);  \
-    P10 p10 = getArgument<P10>(ctx, argumentCount, arguments, 10);  \
-    P11 p11 = getArgument<P11>(ctx, argumentCount, arguments, 11);  \
-    P12 p12 = getArgument<P12>(ctx, argumentCount, arguments, 12);  \
-    return makeResult<Ret>(ctx, impl_##name(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12)); \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_14(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                             \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);  \
-    P3 p3 = getArgument<P3>(ctx, argumentCount, arguments, 3);  \
-    P4 p4 = getArgument<P4>(ctx, argumentCount, arguments, 4);  \
-    P5 p5 = getArgument<P5>(ctx, argumentCount, arguments, 5);  \
-    P6 p6 = getArgument<P6>(ctx, argumentCount, arguments, 6);  \
-    P7 p7 = getArgument<P7>(ctx, argumentCount, arguments, 7);  \
-    P8 p8 = getArgument<P8>(ctx, argumentCount, arguments, 8);  \
-    P9 p9 = getArgument<P9>(ctx, argumentCount, arguments, 9);  \
-    P10 p10 = getArgument<P10>(ctx, argumentCount, arguments, 10);  \
-    P11 p11 = getArgument<P11>(ctx, argumentCount, arguments, 11);  \
-    P12 p12 = getArgument<P12>(ctx, argumentCount, arguments, 12);  \
-    P13 p13 = getArgument<P13>(ctx, argumentCount, arguments, 13);  \
-    return makeResult<Ret>(ctx, impl_##name(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13)); \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_V0(name) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                       \
-    impl_##name();                                                     \
-    return makeVoid(ctx);                                       \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_V1(name, P0) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                       \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    impl_##name(p0);                                                   \
-    return makeVoid(ctx);                                       \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_V2(name, P0, P1) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                             \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    impl_##name(p0,p1);                                                 \
-    return makeVoid(ctx);                                       \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_V3(name, P0, P1, P2) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                       \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);  \
-    impl_##name(p0,p1,p2);                                             \
-    return makeVoid(ctx);                                       \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_V4(name, P0, P1, P2, P3) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                             \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);  \
-    P3 p3 = getArgument<P3>(ctx, argumentCount, arguments, 3);  \
-    impl_##name(p0,p1,p2,p3);                                           \
-    return makeVoid(ctx);                                       \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_V5(name, P0, P1, P2, P3, P4) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                             \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);  \
-    P3 p3 = getArgument<P3>(ctx, argumentCount, arguments, 3);  \
-    P4 p4 = getArgument<P4>(ctx, argumentCount, arguments, 4);  \
-    impl_##name(p0,p1,p2,p3,p4);                                        \
-    return makeVoid(ctx);                                       \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_V6(name, P0, P1, P2, P3, P4, P5) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                             \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);  \
-    P3 p3 = getArgument<P3>(ctx, argumentCount, arguments, 3);  \
-    P4 p4 = getArgument<P4>(ctx, argumentCount, arguments, 4);  \
-    P5 p5 = getArgument<P5>(ctx, argumentCount, arguments, 5);  \
-    impl_##name(p0,p1,p2,p3,p4,p5);                                     \
-    return makeVoid(ctx);                                       \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_V7(name, P0, P1, P2, P3, P4, P5, P6) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                             \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);  \
-    P3 p3 = getArgument<P3>(ctx, argumentCount, arguments, 3);  \
-    P4 p4 = getArgument<P4>(ctx, argumentCount, arguments, 4);  \
-    P5 p5 = getArgument<P5>(ctx, argumentCount, arguments, 5);  \
-    P6 p6 = getArgument<P6>(ctx, argumentCount, arguments, 6);  \
-    impl_##name(p0,p1,p2,p3,p4,p5,p6);                                  \
-    return makeVoid(ctx);                                       \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_V8(name, P0, P1, P2, P3, P4, P5, P6, P7) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                             \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);  \
-    P3 p3 = getArgument<P3>(ctx, argumentCount, arguments, 3);  \
-    P4 p4 = getArgument<P4>(ctx, argumentCount, arguments, 4);  \
-    P5 p5 = getArgument<P5>(ctx, argumentCount, arguments, 5);  \
-    P6 p6 = getArgument<P6>(ctx, argumentCount, arguments, 6);  \
-    P7 p7 = getArgument<P7>(ctx, argumentCount, arguments, 7);  \
-    impl_##name(p0,p1,p2,p3,p4,p5,p6,p7);                               \
-    return makeVoid(ctx);                                       \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_V9(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                             \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);  \
-    P3 p3 = getArgument<P3>(ctx, argumentCount, arguments, 3);  \
-    P4 p4 = getArgument<P4>(ctx, argumentCount, arguments, 4);  \
-    P5 p5 = getArgument<P5>(ctx, argumentCount, arguments, 5);  \
-    P6 p6 = getArgument<P6>(ctx, argumentCount, arguments, 6);  \
-    P7 p7 = getArgument<P7>(ctx, argumentCount, arguments, 7);  \
-    P8 p8 = getArgument<P8>(ctx, argumentCount, arguments, 8);  \
-    impl_##name(p0,p1,p2,p3,p4,p5,p6,p7,p8);                            \
-    return makeVoid(ctx);                                       \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_V10(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                             \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);  \
-    P3 p3 = getArgument<P3>(ctx, argumentCount, arguments, 3);  \
-    P4 p4 = getArgument<P4>(ctx, argumentCount, arguments, 4);  \
-    P5 p5 = getArgument<P5>(ctx, argumentCount, arguments, 5);  \
-    P6 p6 = getArgument<P6>(ctx, argumentCount, arguments, 6);  \
-    P7 p7 = getArgument<P7>(ctx, argumentCount, arguments, 7);  \
-    P8 p8 = getArgument<P8>(ctx, argumentCount, arguments, 8);  \
-    P9 p9 = getArgument<P9>(ctx, argumentCount, arguments, 9);  \
-    impl_##name(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9);                         \
-    return makeVoid(ctx);                                       \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_V11(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                             \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);  \
-    P3 p3 = getArgument<P3>(ctx, argumentCount, arguments, 3);  \
-    P4 p4 = getArgument<P4>(ctx, argumentCount, arguments, 4);  \
-    P5 p5 = getArgument<P5>(ctx, argumentCount, arguments, 5);  \
-    P6 p6 = getArgument<P6>(ctx, argumentCount, arguments, 6);  \
-    P7 p7 = getArgument<P7>(ctx, argumentCount, arguments, 7);  \
-    P8 p8 = getArgument<P8>(ctx, argumentCount, arguments, 8);  \
-    P9 p9 = getArgument<P9>(ctx, argumentCount, arguments, 9);  \
-    P10 p10 = getArgument<P10>(ctx, argumentCount, arguments, 10);  \
-    impl_##name(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10);                         \
-    return makeVoid(ctx);                                       \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_V12(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                             \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);  \
-    P3 p3 = getArgument<P3>(ctx, argumentCount, arguments, 3);  \
-    P4 p4 = getArgument<P4>(ctx, argumentCount, arguments, 4);  \
-    P5 p5 = getArgument<P5>(ctx, argumentCount, arguments, 5);  \
-    P6 p6 = getArgument<P6>(ctx, argumentCount, arguments, 6);  \
-    P7 p7 = getArgument<P7>(ctx, argumentCount, arguments, 7);  \
-    P8 p8 = getArgument<P8>(ctx, argumentCount, arguments, 8);  \
-    P9 p9 = getArgument<P9>(ctx, argumentCount, arguments, 9);  \
-    P10 p10 = getArgument<P10>(ctx, argumentCount, arguments, 10);  \
-    P11 p11 = getArgument<P11>(ctx, argumentCount, arguments, 11);  \
-    impl_##name(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11);                     \
-    return makeVoid(ctx);                                       \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_V13(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                             \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);  \
-    P3 p3 = getArgument<P3>(ctx, argumentCount, arguments, 3);  \
-    P4 p4 = getArgument<P4>(ctx, argumentCount, arguments, 4);  \
-    P5 p5 = getArgument<P5>(ctx, argumentCount, arguments, 5);  \
-    P6 p6 = getArgument<P6>(ctx, argumentCount, arguments, 6);  \
-    P7 p7 = getArgument<P7>(ctx, argumentCount, arguments, 7);  \
-    P8 p8 = getArgument<P8>(ctx, argumentCount, arguments, 8);  \
-    P9 p9 = getArgument<P9>(ctx, argumentCount, arguments, 9);  \
-    P10 p10 = getArgument<P10>(ctx, argumentCount, arguments, 10);  \
-    P11 p11 = getArgument<P11>(ctx, argumentCount, arguments, 11);  \
-    P12 p12 = getArgument<P12>(ctx, argumentCount, arguments, 12);  \
-    impl_##name(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12);                 \
-    return makeVoid(ctx);                                       \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_V14(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    KOALA_MAYBE_LOG(name)                                             \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);  \
-    P3 p3 = getArgument<P3>(ctx, argumentCount, arguments, 3);  \
-    P4 p4 = getArgument<P4>(ctx, argumentCount, arguments, 4);  \
-    P5 p5 = getArgument<P5>(ctx, argumentCount, arguments, 5);  \
-    P6 p6 = getArgument<P6>(ctx, argumentCount, arguments, 6);  \
-    P7 p7 = getArgument<P7>(ctx, argumentCount, arguments, 7);  \
-    P8 p8 = getArgument<P8>(ctx, argumentCount, arguments, 8);  \
-    P9 p9 = getArgument<P9>(ctx, argumentCount, arguments, 9);  \
-    P10 p10 = getArgument<P10>(ctx, argumentCount, arguments, 10);  \
-    P11 p11 = getArgument<P11>(ctx, argumentCount, arguments, 11);  \
-    P12 p12 = getArgument<P12>(ctx, argumentCount, arguments, 12);  \
-    P13 p13 = getArgument<P13>(ctx, argumentCount, arguments, 13);  \
-    impl_##name(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13);             \
-    return makeVoid(ctx);                                       \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-// todo: implement properly
-#define KOALA_INTEROP_CTX_3(name, Ret, P0, P1, P2)                                                                                                                 \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef *exception) \
-  {                                                                                                                                                                \
-    printf("TODO: implement KOALA_INTEROP_CTX_3 for jsc");                                                                                                         \
-    KOALA_MAYBE_LOG(name)                                                                                                                                          \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);                                                                                                     \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);                                                                                                     \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);                                                                                                     \
-    return makeResult<Ret>(ctx, impl_##name(nullptr, p0, p1, p2));                                                                                                          \
-  }                                                                                                                                                                \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_CTX_4(name, Ret, P0, P1, P2, P4)                                                                                                             \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef *exception) \
-  {                                                                                                                                                                \
-    printf("TODO: implement KOALA_INTEROP_CTX_4 for jsc");                                                                                                         \
-    KOALA_MAYBE_LOG(name)                                                                                                                                          \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);                                                                                                     \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);                                                                                                     \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);                                                                                                     \
-    P3 p3 = getArgument<P3>(ctx, argumentCount, arguments, 3);                                                                                                     \
-    return makeResult<Ret>(ctx, impl_##name(nullptr, p0, p1, p2, p3));                                                                                             \
-  }                                                                                                                                                                \
-  MAKE_JSC_EXPORT(name)
-
-// todo: implement properly
-#define KOALA_INTEROP_CTX_V3(name, P0, P1, P2) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    printf("TODO: implement KOALA_INTEROP_CTX_V3 for jsc"); \
-    KOALA_MAYBE_LOG(name)                                             \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);  \
-    impl_##name(nullptr, p0, p1, p2);             \
-    return makeVoid(ctx);                                       \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_CTX_V4(name, P0, P1, P2, P3) \
-  JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \
-    printf("TODO: implement KOALA_INTEROP_CTX_V4 for jsc"); \
-    KOALA_MAYBE_LOG(name)                                             \
-    P0 p0 = getArgument<P0>(ctx, argumentCount, arguments, 0);  \
-    P1 p1 = getArgument<P1>(ctx, argumentCount, arguments, 1);  \
-    P2 p2 = getArgument<P2>(ctx, argumentCount, arguments, 2);  \
-    P3 p3 = getArgument<P3>(ctx, argumentCount, arguments, 3);  \
-    impl_##name(nullptr, p0, p1, p2, p3);             \
-    return makeVoid(ctx);                                       \
-  } \
-  MAKE_JSC_EXPORT(name)
-
-#define KOALA_INTEROP_THROW(vmContext, object, ...) \
-   do { \
-     /* TODO: implement*/ assert(false); \
-     return __VA_ARGS__; \
-   } while (0)
-
-#define KOALA_INTEROP_THROW_STRING(vmContext, message, ...) \
-   do { \
-      assert(false); /* TODO: implement*/ \
-     return __VA_ARGS__; \
-   } while (0)
diff --git a/koala-wrapper/koalaui/interop/src/cpp/ohos/oh_sk_log.cc b/koala-wrapper/koalaui/interop/src/cpp/ohos/oh_sk_log.cc
deleted file mode 100644
index 6aa01fe5e4a441b08f2f7bba07d29ade769d1d16..0000000000000000000000000000000000000000
--- a/koala-wrapper/koalaui/interop/src/cpp/ohos/oh_sk_log.cc
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright (c) 2022-2025 Huawei Device Co., Ltd.
- * 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.
- */
-
-#include <cstdio>
-#include <ctime>
-#include <sys/time.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <cstdarg>
-#include <memory>
-#include "oh_sk_log.h"
-
-static const char* KOALAUI_OHOS_LOG_ROOT = "/data/storage/el2/base/files/logs";
-
-#define APPLY_LOG_FILE_PATTERN(buf, t, ms, pid) \
-    sprintf(buf, "%s/%d_%d_%d_%ld.pid%d.log", \
-    KOALAUI_OHOS_LOG_ROOT, t.tm_year + 1900, t.tm_mon + 1, t.tm_mday, ms.tv_sec, pid)
-
-const char* oh_sk_log_type_str(oh_sk_log_type type) {
-    switch (type) {
-        case Log_Debug: return "D";
-        case Log_Info: return "I";
-        case Log_Warn: return "W";
-        case Log_Error: return "E";
-        case Log_Fatal: return "F";
-    }
-}
-
-void oh_sk_file_log(oh_sk_log_type type, const char* msg, ...) {
-    time_t t = time(nullptr);
-    struct tm lt = *localtime(&t);
-    struct timeval ms{};
-    gettimeofday(&ms, nullptr);
-
-    static char* path = nullptr;
-    if (!path) {
-        path = new char[strlen(KOALAUI_OHOS_LOG_ROOT) + 100];
-        APPLY_LOG_FILE_PATTERN(path, lt, ms, getpid());
-        mkdir(KOALAUI_OHOS_LOG_ROOT, 0777);
-    }
-
-    std::unique_ptr<FILE, decltype(&fclose)> file(fopen(path, "a"), fclose);
-    if (!file) return;
-
-    fprintf(file.get(), "%02d-%02d %02d:%02d:%02d.%03ld %s koala: ",
-            lt.tm_mon + 1, lt.tm_mday, lt.tm_hour, lt.tm_min, lt.tm_sec, ms.tv_usec / 1000,
-            oh_sk_log_type_str(type));
-
-    va_list args;
-    va_start(args, msg);
-    vfprintf(file.get(), msg, args);
-    va_end(args);
-
-    fprintf(file.get(), "\n");
-}
diff --git a/koala-wrapper/koalaui/interop/src/cpp/ohos/oh_sk_log.h b/koala-wrapper/koalaui/interop/src/cpp/ohos/oh_sk_log.h
deleted file mode 100644
index 961e2c0f10796ce18bca6538dca29b0b5e0f373d..0000000000000000000000000000000000000000
--- a/koala-wrapper/koalaui/interop/src/cpp/ohos/oh_sk_log.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright (c) 2022-2025 Huawei Device Co., Ltd.
- * 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.
- */
-
-#pragma once
-
-#include <hilog/log.h>
-
-typedef enum {
-    Log_Debug,
-    Log_Info,
-    Log_Warn,
-    Log_Error,
-    Log_Fatal
-} oh_sk_log_type;
-
-void oh_sk_file_log(oh_sk_log_type type, const char* msg, ...);
-const char* oh_sk_log_type_str(oh_sk_log_type type);
-
-#ifdef OH_SK_LOG_TO_FILE
-
-#define OH_SK_LOG_INFO(msg) oh_sk_file_log(oh_sk_log_type::Log_Info, msg)
-#define OH_SK_LOG_INFO_A(msg, ...) oh_sk_file_log(oh_sk_log_type::Log_Info, msg, ##__VA_ARGS__)
-#define OH_SK_LOG_ERROR(msg) oh_sk_file_log(oh_sk_log_type::Log_Error, msg)
-#define OH_SK_LOG_ERROR_A(msg, ...) oh_sk_file_log(oh_sk_log_type::Log_Error, msg, ##__VA_ARGS__)
-#define OH_SK_LOG_DEBUG(msg) oh_sk_file_log(oh_sk_log_type::Log_Debug, msg)
-#define OH_SK_LOG_DEBUG_A(msg, ...) oh_sk_file_log(oh_sk_log_type::Log_Debug, msg, ##__VA_ARGS__)
-#define OH_SK_LOG_WARN(msg) oh_sk_file_log(oh_sk_log_type::Log_Warn, msg)
-#define OH_SK_LOG_WARN_A(msg, ...) oh_sk_file_log(oh_sk_log_type::Log_Warn, msg, ##__VA_ARGS__)
-#define OH_SK_LOG_FATAL(msg) oh_sk_file_log(oh_sk_log_type::Log_Fatal, msg)
-#define OH_SK_LOG_FATAL_A(msg, ...) oh_sk_file_log(oh_sk_log_type::Log_Fatal, msg, ##__VA_ARGS__)
-
-#else
-
-#define OH_SK_LOG_INFO(msg) OH_LOG_Print(LOG_APP, LOG_INFO, 0xFF00, "Koala", msg)
-#define OH_SK_LOG_INFO_A(msg, ...) OH_LOG_Print(LOG_APP, LOG_INFO, 0xFF00, "Koala", msg, ##__VA_ARGS__)
-#define OH_SK_LOG_ERROR(msg) OH_LOG_Print(LOG_APP, LOG_ERROR, 0xFF00, "Koala", msg)
-#define OH_SK_LOG_ERROR_A(msg, ...) OH_LOG_Print(LOG_APP, LOG_ERROR, 0xFF00, "Koala", msg, ##__VA_ARGS__)
-#define OH_SK_LOG_DEBUG(msg) OH_LOG_Print(LOG_APP, LOG_DEBUG, 0xFF00, "Koala", msg)
-#define OH_SK_LOG_DEBUG_A(msg, ...) OH_LOG_Print(LOG_APP, LOG_DEBUG, 0xFF00, "Koala", msg, ##__VA_ARGS__)
-#define OH_SK_LOG_WARN(msg) OH_LOG_Print(LOG_APP, LOG_WARN, 0xFF00, "Koala", msg)
-#define OH_SK_LOG_WARN_A(msg, ...) OH_LOG_Print(LOG_APP, LOG_WARN, 0xFF00, "Koala", msg, ##__VA_ARGS__)
-#define OH_SK_LOG_FATAL(msg) OH_LOG_Print(LOG_APP, LOG_FATAL, 0xFF00, "Koala", msg)
-#define OH_SK_LOG_FATAL_A(msg, ...) OH_LOG_Print(LOG_APP, LOG_FATAL, 0xFF00, "Koala", msg, ##__VA_ARGS__)
-
-#endif
diff --git a/koala-wrapper/koalaui/interop/src/cpp/profiler.h b/koala-wrapper/koalaui/interop/src/cpp/profiler.h
index a3b9da38ce6e377eaa57fd2fe38e50fef4407ffd..920a3402f9355ea91b4bb457e8ea76ddcbdb3b5d 100644
--- a/koala-wrapper/koalaui/interop/src/cpp/profiler.h
+++ b/koala-wrapper/koalaui/interop/src/cpp/profiler.h
@@ -67,9 +67,7 @@ class InteropProfiler {
         std::for_each(elems.begin(), elems.end(), [total, &result](const std::pair<std::string, InteropProfilerRecord>&a) {
             auto ns = a.second.time;
             auto count = a.second.count;
-            char buffer[1024];
-            snprintf(buffer, sizeof buffer, "for %s[%lld]: %.01f%% (%lld)\n", a.first.c_str(), (long long)count, (double)ns / total * 100.0, (long long)ns);
-            result += buffer;
+            result += std::format("for %s[%lld]: %.01f%% (%lld)\n", a.first.c_str(), (long long)count, (double)ns / total * 100.0, (long long)ns);
         });
         return result;
     }