gd.c

#ifdef __EMSCRIPTEN__
    // The generated interface header is the authoritative one in the engine
    // tree (the plain gdextension_interface.h there is a stale snapshot).
    #include "core/extension/gdextension_interface.gen.h"
    #include <emscripten/bind.h>
    #include <bit>
#else
    #include "gdextension_interface.h"
#endif
#include "gd.h"
#include <stdint.h>
#include <stdlib.h>
#include <stdbool.h>
#include <stddef.h>
#include <string.h>
#include <stdio.h>

// emscripten can only expose std::string to JS, not char *
// we want emscripten to be able to deal with 64bit values without resorting to slow big ints.
#ifdef __EMSCRIPTEN__
    #define UINT64(n) uint32_t n##_1, uint32_t n##_2
    #define UINT64_FROM(v) ((uint64_t)(v##_1) << 32) | ((uint64_t)(v##_2))
    #define UINT64_MAKE(v) (uint32_t)(v >> 32), (uint32_t)(v & 0xFFFFFFFF)
    #define INT64(n) uint32_t n##_1, uint32_t n##_2
    #define INT64_FROM(v) std::__bit_cast<int64_t>(((uint64_t)(v##_1) << 32) | ((uint64_t)(v##_2)))
    #define INT int32_t
    #define STRING std::string
    #define STRING_POINTER(s) (s).c_str()
    #define BUFFER uint32_t
    #define BUFFER_POINTER(s) (char*)(s)
    #define ANY uint32_t
    #define UINT uint32_t
#else
    #define UINT64(n) uint64_t n
    #define UINT64_FROM(v) (v)
    #define UINT64_MAKE(v) (v)
    #define INT64 int64_t
    #define INT64_FROM(v) (v)
    #define INT int64_t
    #define STRING const char*
    #define STRING_POINTER(s) (s)
    #define BUFFER char*
    #define BUFFER_POINTER(s) (s)
    #define ANY void*
    #define UINT uint64_t
#endif

#ifdef _WIN32
#define EXPORT __declspec(dllexport)
#else
#define EXPORT
#endif

#define LOAD_PROC_ADDRESS(m_name, m_type) gdextension_##m_name = (m_type)p_get_proc_address(#m_name);

static GDExtensionClassLibraryPtr gd_library = NULL;
static GDExtensionGodotVersion2 gd_godot_version_cached = {};

typedef struct { uint64_t part[2]; } result_16;
typedef struct { uint64_t part[3]; } result_24;
typedef struct { uint64_t part[4]; } result_32;
typedef struct { uint64_t part[8]; } result_64;

static void engine_exit(void *ignore, GDExtensionInitializationLevel level) {
    gd_on_engine_exit(level);
}
static void callable_call(void *callable_userdata, const GDExtensionConstVariantPtr *p_args, GDExtensionInt p_argument_count, GDExtensionVariantPtr r_return, GDExtensionCallError *r_error) {
    gd_on_callable_call((uintptr_t)callable_userdata, r_return, p_argument_count, (void *)p_args, (CallError*)r_error);
}
static GDExtensionBool callable_validation(void *callable_userdata) {
    return gd_on_callable_validation((uintptr_t)callable_userdata);
}
static void callable_free(void *callable_userdata) {
    gd_on_callable_free((uintptr_t)callable_userdata);
}
static uint32_t callable_hash(void *callable_userdata) {
    return gd_on_callable_hash((uintptr_t)callable_userdata);
}
static GDExtensionBool callable_compare(void *callable_userdata, void *other_userdata) {
    return gd_on_callable_compare((uintptr_t)callable_userdata, (uintptr_t)other_userdata);
}
static GDExtensionBool callable_less_than(void *callable_userdata, void *other_userdata) {
    return gd_on_callable_less_than((uintptr_t)callable_userdata, (uintptr_t)other_userdata);
}
static void callable_stringify(void *callable_userdata, GDExtensionBool *r_is_valid, GDExtensionStringPtr r_out) {
    uint64_t invalid = 0;
    uintptr_t s = gd_on_callable_stringify((uintptr_t)callable_userdata, (CallError*)&invalid);
    *r_is_valid = !(GDExtensionBool)invalid;
    if (invalid) {
        *((uintptr_t*)r_out) = 0;
    } else {
        *((uintptr_t*)r_out) = s;
    }
}
static GDExtensionInt callable_get_argument_count(void *callable_userdata, GDExtensionBool *r_is_valid) {
    uint64_t invalid = 0;
    int64_t count = gd_on_callable_get_argument_count((uintptr_t)callable_userdata, (CallError*)&invalid);
    *r_is_valid = !(GDExtensionBool)invalid;
    if (invalid) return -1;
    return (GDExtensionInt)count;
}
static void extension_instance_dynamic_call(void *method_userdata, GDExtensionClassInstancePtr p_instance, const GDExtensionConstVariantPtr *p_args, GDExtensionInt p_argument_count, GDExtensionVariantPtr r_return, GDExtensionCallError *r_error) {
    gd_on_extension_instance_dynamic_call((uintptr_t)p_instance, (uintptr_t)method_userdata, r_return, p_argument_count, (void *)p_args, (CallError*)r_error);
}
static void extension_instance_checked_call(void *method_userdata, GDExtensionClassInstancePtr p_instance, const GDExtensionConstTypePtr *p_args, GDExtensionTypePtr r_ret) {
    gd_on_extension_instance_checked_call((uintptr_t)p_instance, (uintptr_t)method_userdata, r_ret, (void *)p_args);
}
static void *extension_binding_created(void *p_token, void *p_instance) {
    return (void *)gd_on_extension_binding_created((uintptr_t)p_instance);
}
static void extension_binding_removed(void *p_token, void *p_instance, void *p_binding) {
    gd_on_extension_binding_removed((uintptr_t)p_instance, (uintptr_t)p_binding);
}
static GDExtensionBool extension_binding_reference(void *p_token, void *p_binding, GDExtensionBool p_reference) {
    return gd_on_extension_binding_reference((uintptr_t)p_binding, p_reference);
}
GDExtensionInstanceBindingCallbacks instance_binding_callbacks = {
    .create_callback = extension_binding_created,
    .free_callback = extension_binding_removed,
   // .reference_callback = extension_binding_reference
};

GDExtensionTypeFromVariantConstructorFunc type_from_variant_constructors[GDEXTENSION_VARIANT_TYPE_VARIANT_MAX];
GDExtensionVariantFromTypeConstructorFunc variant_from_type_constructors[GDEXTENSION_VARIANT_TYPE_VARIANT_MAX];
GDExtensionPtrDestructor variant_ptr_destructors[GDEXTENSION_VARIANT_TYPE_VARIANT_MAX];
GDExtensionVariantGetInternalPtrFunc variant_internal_ptr_funcs[GDEXTENSION_VARIANT_TYPE_VARIANT_MAX];
GDExtensionPtrIndexedSetter variant_ptr_indexed_setters[GDEXTENSION_VARIANT_TYPE_VARIANT_MAX];
GDExtensionPtrIndexedGetter variant_ptr_indexed_getters[GDEXTENSION_VARIANT_TYPE_VARIANT_MAX];
GDExtensionPtrKeyedSetter variant_ptr_keyed_setters[GDEXTENSION_VARIANT_TYPE_VARIANT_MAX];
GDExtensionPtrKeyedGetter variant_ptr_keyed_getters[GDEXTENSION_VARIANT_TYPE_VARIANT_MAX];

GDExtensionInterfaceMemAlloc gdextension_mem_alloc = NULL;
GDExtensionInterfaceMemRealloc gdextension_mem_realloc = NULL;
GDExtensionInterfaceMemFree gdextension_mem_free = NULL;
GDExtensionInterfacePrintError gdextension_print_error = NULL;
GDExtensionInterfacePrintErrorWithMessage gdextension_print_error_with_message = NULL;
GDExtensionInterfacePrintWarning gdextension_print_warning = NULL;
GDExtensionInterfacePrintWarningWithMessage gdextension_print_warning_with_message = NULL;
GDExtensionInterfacePrintScriptError gdextension_print_script_error = NULL;
GDExtensionInterfacePrintScriptErrorWithMessage gdextension_print_script_error_with_message = NULL;
GDExtensionInterfaceGetNativeStructSize gdextension_get_native_struct_size = NULL;
GDExtensionInterfaceVariantNewCopy gdextension_variant_new_copy = NULL;
GDExtensionInterfaceVariantNewNil gdextension_variant_new_nil = NULL;
GDExtensionInterfaceVariantDestroy gdextension_variant_destroy = NULL;
GDExtensionInterfaceVariantCall gdextension_variant_call = NULL;
GDExtensionInterfaceVariantCallStatic gdextension_variant_call_static = NULL;
GDExtensionInterfaceVariantEvaluate gdextension_variant_evaluate = NULL;
GDExtensionInterfaceVariantSet gdextension_variant_set = NULL;
GDExtensionInterfaceVariantSetNamed gdextension_variant_set_named = NULL;
GDExtensionInterfaceVariantSetKeyed gdextension_variant_set_keyed = NULL;
GDExtensionInterfaceVariantSetIndexed gdextension_variant_set_indexed = NULL;
GDExtensionInterfaceVariantGet gdextension_variant_get = NULL;
GDExtensionInterfaceVariantGetNamed gdextension_variant_get_named = NULL;
GDExtensionInterfaceVariantGetKeyed gdextension_variant_get_keyed = NULL;
GDExtensionInterfaceVariantGetIndexed gdextension_variant_get_indexed = NULL;
GDExtensionInterfaceVariantIterInit gdextension_variant_iter_init = NULL;
GDExtensionInterfaceVariantIterNext gdextension_variant_iter_next = NULL;
GDExtensionInterfaceVariantIterGet gdextension_variant_iter_get = NULL;
GDExtensionInterfaceVariantHash gdextension_variant_hash = NULL;
GDExtensionInterfaceVariantRecursiveHash gdextension_variant_recursive_hash = NULL;
GDExtensionInterfaceVariantHashCompare gdextension_variant_hash_compare = NULL;
GDExtensionInterfaceVariantBooleanize gdextension_variant_booleanize = NULL;
GDExtensionInterfaceVariantDuplicate gdextension_variant_duplicate = NULL;
GDExtensionInterfaceVariantStringify gdextension_variant_stringify = NULL;
GDExtensionInterfaceVariantGetType gdextension_variant_get_type = NULL;
GDExtensionInterfaceVariantHasMethod gdextension_variant_has_method = NULL;
GDExtensionInterfaceVariantHasMember gdextension_variant_has_member = NULL;
GDExtensionInterfaceVariantHasKey gdextension_variant_has_key = NULL;
GDExtensionInterfaceVariantGetObjectInstanceId gdextension_variant_get_object_instance_id = NULL;
GDExtensionInterfaceVariantGetTypeName gdextension_variant_get_type_name = NULL;
GDExtensionInterfaceVariantCanConvert gdextension_variant_can_convert = NULL;
GDExtensionInterfaceVariantCanConvertStrict gdextension_variant_can_convert_strict = NULL;
GDExtensionInterfaceGetVariantFromTypeConstructor gdextension_get_variant_from_type_constructor = NULL;
GDExtensionInterfaceGetVariantToTypeConstructor gdextension_get_variant_to_type_constructor = NULL;
GDExtensionInterfaceVariantGetPtrInternalGetter gdextension_variant_get_ptr_internal_getter = NULL;
GDExtensionInterfaceVariantGetPtrOperatorEvaluator gdextension_variant_get_ptr_operator_evaluator = NULL;
GDExtensionInterfaceVariantGetPtrBuiltinMethod gdextension_variant_get_ptr_builtin_method = NULL;
GDExtensionInterfaceVariantGetPtrConstructor gdextension_variant_get_ptr_constructor = NULL;
GDExtensionInterfaceVariantGetPtrDestructor gdextension_variant_get_ptr_destructor = NULL;
GDExtensionInterfaceVariantConstruct gdextension_variant_construct = NULL;
GDExtensionInterfaceVariantGetPtrSetter gdextension_variant_get_ptr_setter = NULL;
GDExtensionInterfaceVariantGetPtrGetter gdextension_variant_get_ptr_getter = NULL;
GDExtensionInterfaceVariantGetPtrIndexedSetter gdextension_variant_get_ptr_indexed_setter = NULL;
GDExtensionInterfaceVariantGetPtrIndexedGetter gdextension_variant_get_ptr_indexed_getter = NULL;
GDExtensionInterfaceVariantGetPtrKeyedSetter gdextension_variant_get_ptr_keyed_setter = NULL;
GDExtensionInterfaceVariantGetPtrKeyedGetter gdextension_variant_get_ptr_keyed_getter = NULL;
GDExtensionInterfaceVariantGetPtrKeyedChecker gdextension_variant_get_ptr_keyed_checker = NULL;
GDExtensionInterfaceVariantGetConstantValue gdextension_variant_get_constant_value = NULL;
GDExtensionInterfaceVariantGetPtrUtilityFunction gdextension_variant_get_ptr_utility_function = NULL;
GDExtensionInterfaceStringNewWithLatin1Chars gdextension_string_new_with_latin1_chars = NULL;
GDExtensionInterfaceStringNewWithUtf8Chars gdextension_string_new_with_utf8_chars = NULL;
GDExtensionInterfaceStringNewWithUtf16Chars gdextension_string_new_with_utf16_chars = NULL;
GDExtensionInterfaceStringNewWithUtf32Chars gdextension_string_new_with_utf32_chars = NULL;
GDExtensionInterfaceStringNewWithWideChars gdextension_string_new_with_wide_chars = NULL;
GDExtensionInterfaceStringNewWithLatin1CharsAndLen gdextension_string_new_with_latin1_chars_and_len = NULL;
GDExtensionInterfaceStringNewWithUtf8CharsAndLen gdextension_string_new_with_utf8_chars_and_len = NULL;
GDExtensionInterfaceStringNewWithUtf8CharsAndLen2 gdextension_string_new_with_utf8_chars_and_len2 = NULL;
GDExtensionInterfaceStringNewWithUtf16CharsAndLen gdextension_string_new_with_utf16_chars_and_len = NULL;
GDExtensionInterfaceStringNewWithUtf16CharsAndLen2 gdextension_string_new_with_utf16_chars_and_len2 = NULL;
GDExtensionInterfaceStringNewWithUtf32CharsAndLen gdextension_string_new_with_utf32_chars_and_len = NULL;
GDExtensionInterfaceStringNewWithWideCharsAndLen gdextension_string_new_with_wide_chars_and_len = NULL;
GDExtensionInterfaceStringToLatin1Chars gdextension_string_to_latin1_chars = NULL;
GDExtensionInterfaceStringToUtf8Chars gdextension_string_to_utf8_chars = NULL;
GDExtensionInterfaceStringToUtf16Chars gdextension_string_to_utf16_chars = NULL;
GDExtensionInterfaceStringToUtf32Chars gdextension_string_to_utf32_chars = NULL;
GDExtensionInterfaceStringToWideChars gdextension_string_to_wide_chars = NULL;
GDExtensionInterfaceStringOperatorIndex gdextension_string_operator_index = NULL;
GDExtensionInterfaceStringOperatorIndexConst gdextension_string_operator_index_const = NULL;
GDExtensionInterfaceStringOperatorPlusEqString gdextension_string_operator_plus_eq_string = NULL;
GDExtensionInterfaceStringOperatorPlusEqChar gdextension_string_operator_plus_eq_char = NULL;
GDExtensionInterfaceStringOperatorPlusEqCstr gdextension_string_operator_plus_eq_cstr = NULL;
GDExtensionInterfaceStringOperatorPlusEqWcstr gdextension_string_operator_plus_eq_wcstr = NULL;
GDExtensionInterfaceStringOperatorPlusEqC32str gdextension_string_operator_plus_eq_c32str = NULL;
GDExtensionInterfaceStringResize gdextension_string_resize = NULL;
GDExtensionInterfaceStringNameNewWithLatin1Chars gdextension_string_name_new_with_latin1_chars = NULL;
GDExtensionInterfaceStringNameNewWithUtf8CharsAndLen gdextension_string_name_new_with_utf8_chars_and_len = NULL;
GDExtensionInterfaceXmlParserOpenBuffer gdextension_xml_parser_open_buffer = NULL;
GDExtensionInterfaceFileAccessStoreBuffer gdextension_file_access_store_buffer = NULL;
GDExtensionInterfaceFileAccessGetBuffer gdextension_file_access_get_buffer = NULL;
GDExtensionInterfaceWorkerThreadPoolAddNativeGroupTask gdextension_worker_thread_pool_add_native_group_task = NULL;
GDExtensionInterfaceWorkerThreadPoolAddNativeTask gdextension_worker_thread_pool_add_native_task = NULL;
GDExtensionInterfacePackedByteArrayOperatorIndex gdextension_packed_byte_array_operator_index = NULL;
GDExtensionInterfacePackedByteArrayOperatorIndexConst gdextension_packed_byte_array_operator_index_const = NULL;
GDExtensionInterfacePackedColorArrayOperatorIndex gdextension_packed_color_array_operator_index = NULL;
GDExtensionInterfacePackedColorArrayOperatorIndexConst gdextension_packed_color_array_operator_index_const = NULL;
GDExtensionInterfacePackedFloat32ArrayOperatorIndex gdextension_packed_float32_array_operator_index = NULL;
GDExtensionInterfacePackedFloat32ArrayOperatorIndexConst gdextension_packed_float32_array_operator_index_const = NULL;
GDExtensionInterfacePackedFloat64ArrayOperatorIndex gdextension_packed_float64_array_operator_index = NULL;
GDExtensionInterfacePackedFloat64ArrayOperatorIndexConst gdextension_packed_float64_array_operator_index_const = NULL;
GDExtensionInterfacePackedInt32ArrayOperatorIndex gdextension_packed_int32_array_operator_index = NULL;
GDExtensionInterfacePackedInt32ArrayOperatorIndexConst gdextension_packed_int32_array_operator_index_const = NULL;
GDExtensionInterfacePackedInt64ArrayOperatorIndex gdextension_packed_int64_array_operator_index = NULL;
GDExtensionInterfacePackedInt64ArrayOperatorIndexConst gdextension_packed_int64_array_operator_index_const = NULL;
GDExtensionInterfacePackedStringArrayOperatorIndex gdextension_packed_string_array_operator_index = NULL;
GDExtensionInterfacePackedStringArrayOperatorIndexConst gdextension_packed_string_array_operator_index_const = NULL;
GDExtensionInterfacePackedVector2ArrayOperatorIndex gdextension_packed_vector2_array_operator_index = NULL;
GDExtensionInterfacePackedVector2ArrayOperatorIndexConst gdextension_packed_vector2_array_operator_index_const = NULL;
GDExtensionInterfacePackedVector3ArrayOperatorIndex gdextension_packed_vector3_array_operator_index = NULL;
GDExtensionInterfacePackedVector3ArrayOperatorIndexConst gdextension_packed_vector3_array_operator_index_const = NULL;
GDExtensionInterfacePackedVector4ArrayOperatorIndex gdextension_packed_vector4_array_operator_index = NULL;
GDExtensionInterfacePackedVector4ArrayOperatorIndexConst gdextension_packed_vector4_array_operator_index_const = NULL;
GDExtensionInterfaceArrayOperatorIndex gdextension_array_operator_index = NULL;
GDExtensionInterfaceArrayOperatorIndexConst gdextension_array_operator_index_const = NULL;
GDExtensionInterfaceArraySetTyped gdextension_array_set_typed = NULL;
GDExtensionInterfaceDictionaryOperatorIndex gdextension_dictionary_operator_index = NULL;
GDExtensionInterfaceDictionaryOperatorIndexConst gdextension_dictionary_operator_index_const = NULL;
GDExtensionInterfaceDictionarySetTyped gdextension_dictionary_set_typed = NULL;
GDExtensionInterfaceObjectMethodBindCall gdextension_object_method_bind_call = NULL;
GDExtensionInterfaceObjectMethodBindPtrcall gdextension_object_method_bind_ptrcall = NULL;
GDExtensionInterfaceObjectDestroy gdextension_object_destroy = NULL;
GDExtensionInterfaceGlobalGetSingleton gdextension_global_get_singleton = NULL;
GDExtensionInterfaceObjectGetInstanceBinding gdextension_object_get_instance_binding = NULL;
GDExtensionInterfaceObjectSetInstanceBinding gdextension_object_set_instance_binding = NULL;
GDExtensionInterfaceObjectFreeInstanceBinding gdextension_object_free_instance_binding = NULL;
GDExtensionInterfaceObjectSetInstance gdextension_object_set_instance = NULL;
GDExtensionInterfaceObjectGetClassName gdextension_object_get_class_name = NULL;
GDExtensionInterfaceObjectCastTo gdextension_object_cast_to = NULL;
GDExtensionInterfaceObjectGetInstanceFromId gdextension_object_get_instance_from_id = NULL;
GDExtensionInterfaceObjectGetInstanceId gdextension_object_get_instance_id = NULL;
GDExtensionInterfaceObjectHasScriptMethod gdextension_object_has_script_method = NULL;
GDExtensionInterfaceObjectCallScriptMethod gdextension_object_call_script_method = NULL;
GDExtensionInterfaceCallableCustomCreate2 gdextension_callable_custom_create2 = NULL;
GDExtensionInterfaceCallableCustomGetUserdata gdextension_callable_custom_get_userdata = NULL;
GDExtensionInterfaceRefGetObject gdextension_ref_get_object = NULL;
GDExtensionInterfaceRefSetObject gdextension_ref_set_object = NULL;
GDExtensionInterfaceScriptInstanceCreate3 gdextension_script_instance_create3 = NULL;
GDExtensionInterfacePlaceholderScriptInstanceCreate gdextension_placeholder_script_instance_create = NULL;
GDExtensionInterfacePlaceholderScriptInstanceUpdate gdextension_placeholder_script_instance_update = NULL;
GDExtensionInterfaceObjectGetScriptInstance gdextension_object_get_script_instance = NULL;
GDExtensionInterfaceObjectSetScriptInstance gdextension_object_set_script_instance = NULL;
GDExtensionInterfaceClassdbConstructObject3 gdextension_classdb_construct_object3 = NULL;
GDExtensionInterfaceClassdbGetMethodBind gdextension_classdb_get_method_bind = NULL;
GDExtensionInterfaceClassdbGetClassTag gdextension_classdb_get_class_tag = NULL;
GDExtensionInterfaceClassdbRegisterExtensionClass6 gdextension_classdb_register_extension_class6 = NULL;
GDExtensionInterfaceClassdbRegisterExtensionClassMethod gdextension_classdb_register_extension_class_method = NULL;
GDExtensionInterfaceClassdbRegisterExtensionClassVirtualMethod gdextension_classdb_register_extension_class_virtual_method = NULL;
GDExtensionInterfaceClassdbRegisterExtensionClassIntegerConstant gdextension_classdb_register_extension_class_integer_constant = NULL;
GDExtensionInterfaceClassdbRegisterExtensionClassProperty gdextension_classdb_register_extension_class_property = NULL;
GDExtensionInterfaceClassdbRegisterExtensionClassPropertyIndexed gdextension_classdb_register_extension_class_property_indexed = NULL;
GDExtensionInterfaceClassdbRegisterExtensionClassPropertyGroup gdextension_classdb_register_extension_class_property_group = NULL;
GDExtensionInterfaceClassdbRegisterExtensionClassPropertySubgroup gdextension_classdb_register_extension_class_property_subgroup = NULL;
GDExtensionInterfaceClassdbRegisterExtensionClassSignal gdextension_classdb_register_extension_class_signal = NULL;
GDExtensionInterfaceClassdbUnregisterExtensionClass gdextension_classdb_unregister_extension_class = NULL;
GDExtensionInterfaceGetLibraryPath gdextension_get_library_path = NULL;
GDExtensionInterfaceEditorAddPlugin gdextension_editor_add_plugin = NULL;
GDExtensionInterfaceEditorRemovePlugin gdextension_editor_remove_plugin = NULL;
GDExtensionInterfaceEditorRegisterGetClassesUsedCallback gdextension_editor_register_get_classes_used_callback = NULL;
GDExtensionInterfaceEditorHelpLoadXmlFromUtf8Chars gdextension_editor_help_load_xml_from_utf8_chars = NULL;
GDExtensionInterfaceEditorHelpLoadXmlFromUtf8CharsAndLen gdextension_editor_help_load_xml_from_utf8_chars_and_len = NULL;
GDExtensionInterfaceImagePtrw gdextension_image_ptrw = NULL;
GDExtensionInterfaceImagePtr gdextension_image_ptr = NULL;
GDExtensionInterfaceRegisterMainLoopCallbacks gdextension_register_main_loop_callbacks = NULL;
GDExtensionInterfaceGetGodotVersion2 gdextension_get_godot_version2 = NULL;

GDExtensionObjectPtr OS = NULL;
GDExtensionMethodBindPtr OS_get_thread_caller_id = NULL;
GDExtensionMethodBindPtr OS_get_main_thread_id = NULL;
uint64_t main_thread_id = 0;
uint64_t get_thread_caller_id() {
    uint64_t thread_id = 0;
    gdextension_object_method_bind_ptrcall(OS_get_thread_caller_id, OS, NULL, &thread_id);
    return thread_id;
}
static void engine_init(void *ignore, GDExtensionInitializationLevel level) {
    if (level == GDEXTENSION_INITIALIZATION_CORE) {
        uintptr_t string_name_OS;
        gdextension_string_name_new_with_latin1_chars(&string_name_OS, "OS", true);
        OS = gdextension_global_get_singleton(&string_name_OS);
        uintptr_t string_name_get_thread_caller_id;
        gdextension_string_name_new_with_latin1_chars(&string_name_get_thread_caller_id, "get_thread_caller_id", true);
        OS_get_thread_caller_id = gdextension_classdb_get_method_bind(&string_name_OS, &string_name_get_thread_caller_id, 3905245786);
        uintptr_t string_name_get_main_thread_id;
        gdextension_string_name_new_with_latin1_chars(&string_name_get_main_thread_id, "get_main_thread_id", true);
        OS_get_main_thread_id = gdextension_classdb_get_method_bind(&string_name_OS, &string_name_get_main_thread_id, 3905245786);
        gdextension_object_method_bind_ptrcall(OS_get_main_thread_id, OS, NULL, &main_thread_id);
    }
    gd_on_engine_init(level);
}
bool gd_thread_is_main() {
    return get_thread_caller_id() == main_thread_id;
}
EXPORT GDExtensionBool gd_extension_init(GDExtensionInterfaceGetProcAddress p_get_proc_address, GDExtensionClassLibraryPtr p_library, GDExtensionInitialization *r_initialization) {
    LOAD_PROC_ADDRESS(mem_alloc, GDExtensionInterfaceMemAlloc);
	LOAD_PROC_ADDRESS(mem_realloc, GDExtensionInterfaceMemRealloc);
	LOAD_PROC_ADDRESS(mem_free, GDExtensionInterfaceMemFree);
	LOAD_PROC_ADDRESS(print_error_with_message, GDExtensionInterfacePrintErrorWithMessage);
	LOAD_PROC_ADDRESS(print_warning, GDExtensionInterfacePrintWarning);
	LOAD_PROC_ADDRESS(print_warning_with_message, GDExtensionInterfacePrintWarningWithMessage);
	LOAD_PROC_ADDRESS(print_script_error, GDExtensionInterfacePrintScriptError);
	LOAD_PROC_ADDRESS(print_script_error_with_message, GDExtensionInterfacePrintScriptErrorWithMessage);
	LOAD_PROC_ADDRESS(get_native_struct_size, GDExtensionInterfaceGetNativeStructSize);
	LOAD_PROC_ADDRESS(get_godot_version2, GDExtensionInterfaceGetGodotVersion2);
	LOAD_PROC_ADDRESS(variant_new_copy, GDExtensionInterfaceVariantNewCopy);
	LOAD_PROC_ADDRESS(variant_new_nil, GDExtensionInterfaceVariantNewNil);
	LOAD_PROC_ADDRESS(variant_destroy, GDExtensionInterfaceVariantDestroy);
	LOAD_PROC_ADDRESS(variant_call, GDExtensionInterfaceVariantCall);
	LOAD_PROC_ADDRESS(variant_call_static, GDExtensionInterfaceVariantCallStatic);
	LOAD_PROC_ADDRESS(variant_evaluate, GDExtensionInterfaceVariantEvaluate);
	LOAD_PROC_ADDRESS(variant_set, GDExtensionInterfaceVariantSet);
	LOAD_PROC_ADDRESS(variant_set_named, GDExtensionInterfaceVariantSetNamed);
	LOAD_PROC_ADDRESS(variant_set_keyed, GDExtensionInterfaceVariantSetKeyed);
	LOAD_PROC_ADDRESS(variant_set_indexed, GDExtensionInterfaceVariantSetIndexed);
	LOAD_PROC_ADDRESS(variant_get, GDExtensionInterfaceVariantGet);
	LOAD_PROC_ADDRESS(variant_get_named, GDExtensionInterfaceVariantGetNamed);
	LOAD_PROC_ADDRESS(variant_get_keyed, GDExtensionInterfaceVariantGetKeyed);
	LOAD_PROC_ADDRESS(variant_get_indexed, GDExtensionInterfaceVariantGetIndexed);
	LOAD_PROC_ADDRESS(variant_iter_init, GDExtensionInterfaceVariantIterInit);
	LOAD_PROC_ADDRESS(variant_iter_next, GDExtensionInterfaceVariantIterNext);
	LOAD_PROC_ADDRESS(variant_iter_get, GDExtensionInterfaceVariantIterGet);
	LOAD_PROC_ADDRESS(variant_hash, GDExtensionInterfaceVariantHash);
	LOAD_PROC_ADDRESS(variant_recursive_hash, GDExtensionInterfaceVariantRecursiveHash);
	LOAD_PROC_ADDRESS(variant_hash_compare, GDExtensionInterfaceVariantHashCompare);
	LOAD_PROC_ADDRESS(variant_booleanize, GDExtensionInterfaceVariantBooleanize);
	LOAD_PROC_ADDRESS(variant_duplicate, GDExtensionInterfaceVariantDuplicate);
	LOAD_PROC_ADDRESS(variant_stringify, GDExtensionInterfaceVariantStringify);
	LOAD_PROC_ADDRESS(variant_get_type, GDExtensionInterfaceVariantGetType);
	LOAD_PROC_ADDRESS(variant_has_method, GDExtensionInterfaceVariantHasMethod);
	LOAD_PROC_ADDRESS(variant_has_member, GDExtensionInterfaceVariantHasMember);
	LOAD_PROC_ADDRESS(variant_has_key, GDExtensionInterfaceVariantHasKey);
	LOAD_PROC_ADDRESS(variant_get_object_instance_id, GDExtensionInterfaceVariantGetObjectInstanceId);
	LOAD_PROC_ADDRESS(variant_get_type_name, GDExtensionInterfaceVariantGetTypeName);
	LOAD_PROC_ADDRESS(variant_can_convert, GDExtensionInterfaceVariantCanConvert);
	LOAD_PROC_ADDRESS(variant_can_convert_strict, GDExtensionInterfaceVariantCanConvertStrict);
	LOAD_PROC_ADDRESS(get_variant_from_type_constructor, GDExtensionInterfaceGetVariantFromTypeConstructor);
	LOAD_PROC_ADDRESS(get_variant_to_type_constructor, GDExtensionInterfaceGetVariantToTypeConstructor);
	LOAD_PROC_ADDRESS(variant_get_ptr_internal_getter, GDExtensionInterfaceVariantGetPtrInternalGetter);
	LOAD_PROC_ADDRESS(variant_get_ptr_operator_evaluator, GDExtensionInterfaceVariantGetPtrOperatorEvaluator);
	LOAD_PROC_ADDRESS(variant_get_ptr_builtin_method, GDExtensionInterfaceVariantGetPtrBuiltinMethod);
	LOAD_PROC_ADDRESS(variant_get_ptr_constructor, GDExtensionInterfaceVariantGetPtrConstructor);
	LOAD_PROC_ADDRESS(variant_get_ptr_destructor, GDExtensionInterfaceVariantGetPtrDestructor);
	LOAD_PROC_ADDRESS(variant_construct, GDExtensionInterfaceVariantConstruct);
	LOAD_PROC_ADDRESS(variant_get_ptr_setter, GDExtensionInterfaceVariantGetPtrSetter);
	LOAD_PROC_ADDRESS(variant_get_ptr_getter, GDExtensionInterfaceVariantGetPtrGetter);
	LOAD_PROC_ADDRESS(variant_get_ptr_indexed_setter, GDExtensionInterfaceVariantGetPtrIndexedSetter);
	LOAD_PROC_ADDRESS(variant_get_ptr_indexed_getter, GDExtensionInterfaceVariantGetPtrIndexedGetter);
	LOAD_PROC_ADDRESS(variant_get_ptr_keyed_setter, GDExtensionInterfaceVariantGetPtrKeyedSetter);
	LOAD_PROC_ADDRESS(variant_get_ptr_keyed_getter, GDExtensionInterfaceVariantGetPtrKeyedGetter);
	LOAD_PROC_ADDRESS(variant_get_ptr_keyed_checker, GDExtensionInterfaceVariantGetPtrKeyedChecker);
	LOAD_PROC_ADDRESS(variant_get_constant_value, GDExtensionInterfaceVariantGetConstantValue);
	LOAD_PROC_ADDRESS(variant_get_ptr_utility_function, GDExtensionInterfaceVariantGetPtrUtilityFunction);
	LOAD_PROC_ADDRESS(string_new_with_latin1_chars, GDExtensionInterfaceStringNewWithLatin1Chars);
	LOAD_PROC_ADDRESS(string_new_with_utf8_chars, GDExtensionInterfaceStringNewWithUtf8Chars);
	LOAD_PROC_ADDRESS(string_new_with_utf16_chars, GDExtensionInterfaceStringNewWithUtf16Chars);
	LOAD_PROC_ADDRESS(string_new_with_utf32_chars, GDExtensionInterfaceStringNewWithUtf32Chars);
	LOAD_PROC_ADDRESS(string_new_with_wide_chars, GDExtensionInterfaceStringNewWithWideChars);
	LOAD_PROC_ADDRESS(string_new_with_latin1_chars_and_len, GDExtensionInterfaceStringNewWithLatin1CharsAndLen);
	LOAD_PROC_ADDRESS(string_new_with_utf8_chars_and_len, GDExtensionInterfaceStringNewWithUtf8CharsAndLen);
	LOAD_PROC_ADDRESS(string_new_with_utf8_chars_and_len2, GDExtensionInterfaceStringNewWithUtf8CharsAndLen2);
	LOAD_PROC_ADDRESS(string_new_with_utf16_chars_and_len, GDExtensionInterfaceStringNewWithUtf16CharsAndLen);
	LOAD_PROC_ADDRESS(string_new_with_utf16_chars_and_len2, GDExtensionInterfaceStringNewWithUtf16CharsAndLen2);
	LOAD_PROC_ADDRESS(string_new_with_utf32_chars_and_len, GDExtensionInterfaceStringNewWithUtf32CharsAndLen);
	LOAD_PROC_ADDRESS(string_new_with_wide_chars_and_len, GDExtensionInterfaceStringNewWithWideCharsAndLen);
	LOAD_PROC_ADDRESS(string_to_latin1_chars, GDExtensionInterfaceStringToLatin1Chars);
	LOAD_PROC_ADDRESS(string_to_utf8_chars, GDExtensionInterfaceStringToUtf8Chars);
	LOAD_PROC_ADDRESS(string_to_utf16_chars, GDExtensionInterfaceStringToUtf16Chars);
	LOAD_PROC_ADDRESS(string_to_utf32_chars, GDExtensionInterfaceStringToUtf32Chars);
	LOAD_PROC_ADDRESS(string_to_wide_chars, GDExtensionInterfaceStringToWideChars);
	LOAD_PROC_ADDRESS(string_operator_index, GDExtensionInterfaceStringOperatorIndex);
	LOAD_PROC_ADDRESS(string_operator_index_const, GDExtensionInterfaceStringOperatorIndexConst);
	LOAD_PROC_ADDRESS(string_operator_plus_eq_string, GDExtensionInterfaceStringOperatorPlusEqString);
	LOAD_PROC_ADDRESS(string_operator_plus_eq_char, GDExtensionInterfaceStringOperatorPlusEqChar);
	LOAD_PROC_ADDRESS(string_operator_plus_eq_cstr, GDExtensionInterfaceStringOperatorPlusEqCstr);
	LOAD_PROC_ADDRESS(string_operator_plus_eq_wcstr, GDExtensionInterfaceStringOperatorPlusEqWcstr);
	LOAD_PROC_ADDRESS(string_operator_plus_eq_c32str, GDExtensionInterfaceStringOperatorPlusEqC32str);
	LOAD_PROC_ADDRESS(string_resize, GDExtensionInterfaceStringResize);
	LOAD_PROC_ADDRESS(string_name_new_with_latin1_chars, GDExtensionInterfaceStringNameNewWithLatin1Chars);
	LOAD_PROC_ADDRESS(string_name_new_with_utf8_chars_and_len, GDExtensionInterfaceStringNameNewWithUtf8CharsAndLen);
	LOAD_PROC_ADDRESS(xml_parser_open_buffer, GDExtensionInterfaceXmlParserOpenBuffer);
	LOAD_PROC_ADDRESS(file_access_store_buffer, GDExtensionInterfaceFileAccessStoreBuffer);
	LOAD_PROC_ADDRESS(file_access_get_buffer, GDExtensionInterfaceFileAccessGetBuffer);
	LOAD_PROC_ADDRESS(worker_thread_pool_add_native_group_task, GDExtensionInterfaceWorkerThreadPoolAddNativeGroupTask);
	LOAD_PROC_ADDRESS(worker_thread_pool_add_native_task, GDExtensionInterfaceWorkerThreadPoolAddNativeTask);
	LOAD_PROC_ADDRESS(packed_byte_array_operator_index, GDExtensionInterfacePackedByteArrayOperatorIndex);
	LOAD_PROC_ADDRESS(packed_byte_array_operator_index_const, GDExtensionInterfacePackedByteArrayOperatorIndexConst);
	LOAD_PROC_ADDRESS(packed_color_array_operator_index, GDExtensionInterfacePackedColorArrayOperatorIndex);
	LOAD_PROC_ADDRESS(packed_color_array_operator_index_const, GDExtensionInterfacePackedColorArrayOperatorIndexConst);
	LOAD_PROC_ADDRESS(packed_float32_array_operator_index, GDExtensionInterfacePackedFloat32ArrayOperatorIndex);
	LOAD_PROC_ADDRESS(packed_float32_array_operator_index_const, GDExtensionInterfacePackedFloat32ArrayOperatorIndexConst);
	LOAD_PROC_ADDRESS(packed_float64_array_operator_index, GDExtensionInterfacePackedFloat64ArrayOperatorIndex);
	LOAD_PROC_ADDRESS(packed_float64_array_operator_index_const, GDExtensionInterfacePackedFloat64ArrayOperatorIndexConst);
	LOAD_PROC_ADDRESS(packed_int32_array_operator_index, GDExtensionInterfacePackedInt32ArrayOperatorIndex);
	LOAD_PROC_ADDRESS(packed_int32_array_operator_index_const, GDExtensionInterfacePackedInt32ArrayOperatorIndexConst);
	LOAD_PROC_ADDRESS(packed_int64_array_operator_index, GDExtensionInterfacePackedInt64ArrayOperatorIndex);
	LOAD_PROC_ADDRESS(packed_int64_array_operator_index_const, GDExtensionInterfacePackedInt64ArrayOperatorIndexConst);
	LOAD_PROC_ADDRESS(packed_string_array_operator_index, GDExtensionInterfacePackedStringArrayOperatorIndex);
	LOAD_PROC_ADDRESS(packed_string_array_operator_index_const, GDExtensionInterfacePackedStringArrayOperatorIndexConst);
	LOAD_PROC_ADDRESS(packed_vector2_array_operator_index, GDExtensionInterfacePackedVector2ArrayOperatorIndex);
	LOAD_PROC_ADDRESS(packed_vector2_array_operator_index_const, GDExtensionInterfacePackedVector2ArrayOperatorIndexConst);
	LOAD_PROC_ADDRESS(packed_vector3_array_operator_index, GDExtensionInterfacePackedVector3ArrayOperatorIndex);
	LOAD_PROC_ADDRESS(packed_vector3_array_operator_index_const, GDExtensionInterfacePackedVector3ArrayOperatorIndexConst);
	LOAD_PROC_ADDRESS(packed_vector4_array_operator_index, GDExtensionInterfacePackedVector4ArrayOperatorIndex);
	LOAD_PROC_ADDRESS(packed_vector4_array_operator_index_const, GDExtensionInterfacePackedVector4ArrayOperatorIndexConst);
	LOAD_PROC_ADDRESS(array_operator_index, GDExtensionInterfaceArrayOperatorIndex);
	LOAD_PROC_ADDRESS(array_operator_index_const, GDExtensionInterfaceArrayOperatorIndexConst);
	LOAD_PROC_ADDRESS(array_set_typed, GDExtensionInterfaceArraySetTyped);
	LOAD_PROC_ADDRESS(dictionary_operator_index, GDExtensionInterfaceDictionaryOperatorIndex);
	LOAD_PROC_ADDRESS(dictionary_operator_index_const, GDExtensionInterfaceDictionaryOperatorIndexConst);
	LOAD_PROC_ADDRESS(dictionary_set_typed, GDExtensionInterfaceDictionarySetTyped);
	LOAD_PROC_ADDRESS(object_method_bind_call, GDExtensionInterfaceObjectMethodBindCall);
	LOAD_PROC_ADDRESS(object_method_bind_ptrcall, GDExtensionInterfaceObjectMethodBindPtrcall);
	LOAD_PROC_ADDRESS(object_destroy, GDExtensionInterfaceObjectDestroy);
	LOAD_PROC_ADDRESS(global_get_singleton, GDExtensionInterfaceGlobalGetSingleton);
	LOAD_PROC_ADDRESS(object_get_instance_binding, GDExtensionInterfaceObjectGetInstanceBinding);
	LOAD_PROC_ADDRESS(object_set_instance_binding, GDExtensionInterfaceObjectSetInstanceBinding);
	LOAD_PROC_ADDRESS(object_free_instance_binding, GDExtensionInterfaceObjectFreeInstanceBinding);
	LOAD_PROC_ADDRESS(object_set_instance, GDExtensionInterfaceObjectSetInstance);
	LOAD_PROC_ADDRESS(object_get_class_name, GDExtensionInterfaceObjectGetClassName);
	LOAD_PROC_ADDRESS(object_cast_to, GDExtensionInterfaceObjectCastTo);
	LOAD_PROC_ADDRESS(object_get_instance_from_id, GDExtensionInterfaceObjectGetInstanceFromId);
	LOAD_PROC_ADDRESS(object_get_instance_id, GDExtensionInterfaceObjectGetInstanceId);
	LOAD_PROC_ADDRESS(object_has_script_method, GDExtensionInterfaceObjectHasScriptMethod);
	LOAD_PROC_ADDRESS(object_call_script_method, GDExtensionInterfaceObjectCallScriptMethod);
	LOAD_PROC_ADDRESS(callable_custom_create2, GDExtensionInterfaceCallableCustomCreate2);
	LOAD_PROC_ADDRESS(callable_custom_get_userdata, GDExtensionInterfaceCallableCustomGetUserdata);
	LOAD_PROC_ADDRESS(ref_get_object, GDExtensionInterfaceRefGetObject);
	LOAD_PROC_ADDRESS(ref_set_object, GDExtensionInterfaceRefSetObject);
	LOAD_PROC_ADDRESS(script_instance_create3, GDExtensionInterfaceScriptInstanceCreate3);
	LOAD_PROC_ADDRESS(placeholder_script_instance_create, GDExtensionInterfacePlaceholderScriptInstanceCreate);
	LOAD_PROC_ADDRESS(placeholder_script_instance_update, GDExtensionInterfacePlaceholderScriptInstanceUpdate);
	LOAD_PROC_ADDRESS(object_get_script_instance, GDExtensionInterfaceObjectGetScriptInstance);
	LOAD_PROC_ADDRESS(object_set_script_instance, GDExtensionInterfaceObjectSetScriptInstance);
	LOAD_PROC_ADDRESS(classdb_construct_object3, GDExtensionInterfaceClassdbConstructObject3);
	LOAD_PROC_ADDRESS(classdb_get_method_bind, GDExtensionInterfaceClassdbGetMethodBind);
	LOAD_PROC_ADDRESS(classdb_get_class_tag, GDExtensionInterfaceClassdbGetClassTag);
	LOAD_PROC_ADDRESS(classdb_register_extension_class6, GDExtensionInterfaceClassdbRegisterExtensionClass6);
	LOAD_PROC_ADDRESS(classdb_register_extension_class_method, GDExtensionInterfaceClassdbRegisterExtensionClassMethod);
	LOAD_PROC_ADDRESS(classdb_register_extension_class_virtual_method, GDExtensionInterfaceClassdbRegisterExtensionClassVirtualMethod);
	LOAD_PROC_ADDRESS(classdb_register_extension_class_integer_constant, GDExtensionInterfaceClassdbRegisterExtensionClassIntegerConstant);
	LOAD_PROC_ADDRESS(classdb_register_extension_class_property, GDExtensionInterfaceClassdbRegisterExtensionClassProperty);
	LOAD_PROC_ADDRESS(classdb_register_extension_class_property_indexed, GDExtensionInterfaceClassdbRegisterExtensionClassPropertyIndexed);
	LOAD_PROC_ADDRESS(classdb_register_extension_class_property_group, GDExtensionInterfaceClassdbRegisterExtensionClassPropertyGroup);
	LOAD_PROC_ADDRESS(classdb_register_extension_class_property_subgroup, GDExtensionInterfaceClassdbRegisterExtensionClassPropertySubgroup);
	LOAD_PROC_ADDRESS(classdb_register_extension_class_signal, GDExtensionInterfaceClassdbRegisterExtensionClassSignal);
	LOAD_PROC_ADDRESS(classdb_unregister_extension_class, GDExtensionInterfaceClassdbUnregisterExtensionClass);
	LOAD_PROC_ADDRESS(get_library_path, GDExtensionInterfaceGetLibraryPath);
	LOAD_PROC_ADDRESS(editor_add_plugin, GDExtensionInterfaceEditorAddPlugin);
	LOAD_PROC_ADDRESS(editor_remove_plugin, GDExtensionInterfaceEditorRemovePlugin);
	LOAD_PROC_ADDRESS(editor_register_get_classes_used_callback, GDExtensionInterfaceEditorRegisterGetClassesUsedCallback);
	LOAD_PROC_ADDRESS(editor_help_load_xml_from_utf8_chars, GDExtensionInterfaceEditorHelpLoadXmlFromUtf8Chars);
	LOAD_PROC_ADDRESS(editor_help_load_xml_from_utf8_chars_and_len, GDExtensionInterfaceEditorHelpLoadXmlFromUtf8CharsAndLen);
	LOAD_PROC_ADDRESS(image_ptrw, GDExtensionInterfaceImagePtrw);
	LOAD_PROC_ADDRESS(image_ptr, GDExtensionInterfaceImagePtr);
	LOAD_PROC_ADDRESS(register_main_loop_callbacks, GDExtensionInterfaceRegisterMainLoopCallbacks);
    gd_library = p_library;
    r_initialization->userdata = 0;
    r_initialization->minimum_initialization_level = GDEXTENSION_INITIALIZATION_CORE;
    r_initialization->initialize = engine_init;
    r_initialization->deinitialize = engine_exit;
    gdextension_get_godot_version2(&gd_godot_version_cached);
    GDExtensionMainLoopCallbacks callbacks = {
    	.startup_func = gd_on_first_frame,
    	.shutdown_func = gd_on_final_frame,
    	.frame_func = gd_on_every_frame,
    };
    gdextension_register_main_loop_callbacks(p_library, &callbacks);
    for (int i = 1; i < GDEXTENSION_VARIANT_TYPE_VARIANT_MAX; i++) {
    	GDExtensionVariantType v = (GDExtensionVariantType)i;
        variant_from_type_constructors[i] = gdextension_get_variant_from_type_constructor(v);
        type_from_variant_constructors[i] = gdextension_get_variant_to_type_constructor(v);
        variant_ptr_destructors[i] = gdextension_variant_get_ptr_destructor(v);
        variant_internal_ptr_funcs[i] = gdextension_variant_get_ptr_internal_getter(v);
        variant_ptr_indexed_setters[i] = gdextension_variant_get_ptr_indexed_setter(v);
        variant_ptr_indexed_getters[i] = gdextension_variant_get_ptr_indexed_getter(v);
        variant_ptr_keyed_setters[i] = gdextension_variant_get_ptr_keyed_setter(v);
        variant_ptr_keyed_getters[i] = gdextension_variant_get_ptr_keyed_getter(v);
    }
    return true;
}
void prepare_variants(void **frame, uint32_t argc, ANY args) {
    uint8_t *head = (uint8_t*)args;
    for (int i = 0; i < argc; i++) {
        frame[i] = head;
        head += 24;
    }
}
// Helper macro to align a value to the next multiple of 'align'
#define ALIGN_UP(value, align) (((value) + ((align) - 1)) & ~((align) - 1))
// Packed size and alignment of each shape nibble code, mirroring the Go
// side's shapeSizes/shapeAlignMasks (gdextension.SizeArguments).
static const uint8_t gd_shape_sizes[16]  = {0, 1, 2, 4, 8, 8, 12, 16, 16, 24, 24, 36, 48, 64, 0, 0};
static const uint8_t gd_shape_aligns[16] = {1, 1, 2, 4, 8, 4, 4, 8, 4, 8, 4, 4, 4, 4, 1, 1};
uint8_t prepare_callframe(int skip, void **frame, uint64_t shape, ANY args) {
    uint8_t *head = (uint8_t *)args;
    ptrdiff_t offset = 0; // Track current offset in the frame
    int i = 0;
    // Nibbles are contiguous with all higher nibbles zero, so the walk can
    // stop when the remaining bits run out.
    for (uint64_t s = shape >> (skip * 4); s; s >>= 4, i++) {
        Shape code = (Shape)(s & 0xF);
        offset = ALIGN_UP(offset, gd_shape_aligns[code]);
        frame[i] = head + offset;
        offset += gd_shape_sizes[code];
    }
    if (i < 16 - skip) frame[i] = NULL;
    return i;
}
uintptr_t gd_builtin_name(uintptr_t name, INT64(hash)) { return (uintptr_t)gdextension_variant_get_ptr_utility_function((GDExtensionConstStringNamePtr)&name, INT64_FROM(hash));}
void gd_builtin_call(uintptr_t fn, ANY result, UINT64(shape), ANY args) {
    void *points[16]; uint8_t argc = prepare_callframe(1, &points[0], UINT64_FROM(shape), args);
    ((GDExtensionPtrUtilityFunction)fn)((GDExtensionTypePtr)result, (GDExtensionConstTypePtr*)&points[0], argc);
}
void gd_callable_create(uintptr_t id, UINT64(object), ANY result) {
    GDExtensionCallableCustomInfo2 info = {
        .callable_userdata = (void *)id,
        .token = gd_library,
        .object_id = UINT64_FROM(object),
        .call_func = callable_call,
        .is_valid_func = callable_validation,
        .free_func = callable_free,
        .hash_func = callable_hash,
        .equal_func = callable_compare,
        .less_than_func = callable_less_than,
        .to_string_func = callable_stringify,
        .get_argument_count_func = callable_get_argument_count,
    };
    gdextension_callable_custom_create2((uint64_t *)result, &info);
}
uintptr_t gd_library_location() {
    uintptr_t s;
    gdextension_get_library_path(gd_library, &s);
    return s;
}
uintptr_t gd_callable_lookup(UINT64(a), UINT64(b)) {
    uint64_t callable[2] = {UINT64_FROM(a), UINT64_FROM(b)};
    return (uintptr_t)gdextension_callable_custom_get_userdata(&callable, gd_library);
};
void gd_classdb_FileAccess_write(uintptr_t FileAccess, BUFFER buf, INT len) {
    gdextension_file_access_store_buffer((GDExtensionObjectPtr)FileAccess, (const uint8_t *)BUFFER_POINTER(buf), len);
};
INT gd_classdb_FileAccess_read(uintptr_t FileAccess, BUFFER buf, INT len) {
    return gdextension_file_access_get_buffer((GDExtensionObjectPtr)FileAccess, (uint8_t *)BUFFER_POINTER(buf), len);
};
uintptr_t gd_classdb_Image_unsafe(uintptr_t Image) {
    return (uintptr_t)gdextension_image_ptrw((GDExtensionObjectPtr)Image);
};
uint8_t gd_classdb_Image_access(uintptr_t Image, INT offset) {
    return gdextension_image_ptr((GDExtensionObjectPtr)Image)[offset];
};
typedef struct {
    int32_t push;
    int32_t size;
    GDExtensionClassMethodInfo *info;
} method_list;
typedef struct {
    int32_t push;
    int32_t size;
    GDExtensionPropertyInfo *info;
    GDExtensionClassMethodArgumentMetadata *meta;
} property_list;
uintptr_t gd_method_list_make(INT length) {
    method_list *list = (method_list *)gdextension_mem_alloc(sizeof(method_list));
    list->push = 0;
    list->size = length;
    list->info = (GDExtensionClassMethodInfo*)gdextension_mem_alloc(sizeof(GDExtensionClassMethodInfo) * length);
    return (uintptr_t)list;
};
void gd_method_list_push(uintptr_t list_p, uintptr_t name, uintptr_t method, uint32_t method_flags, uintptr_t return_value_info, uintptr_t arguments_info, INT default_argument_count, ANY default_arguments) {
    method_list *list = (method_list *)list_p;
    if (list->push >= list->size) return;
    GDExtensionClassMethodInfo *info = &list->info[list->push++];
    property_list *return_value = (property_list *)return_value_info;
    property_list *arguments = (property_list *)arguments_info;
    uintptr_t *name_allocated = (uintptr_t *)gdextension_mem_alloc(sizeof(uintptr_t));
    *name_allocated = name;
    info->name = (GDExtensionStringNamePtr)name_allocated;
    info->method_userdata = (void *)method;
    info->call_func = extension_instance_dynamic_call;
    info->ptrcall_func = extension_instance_checked_call;
    info->method_flags = method_flags;
    if (return_value && return_value->push > 0) {
        info->has_return_value = true;
        info->return_value_info = return_value->info;
        info->return_value_metadata = *return_value->meta;
    } else {
        info->has_return_value = false;
        info->return_value_info = NULL;
        info->return_value_metadata = (GDExtensionClassMethodArgumentMetadata)0;
    }
    if (arguments && arguments->push > 0) {
        info->argument_count = arguments->push;
        info->arguments_info = arguments->info;
        info->arguments_metadata = arguments->meta;
    } else {
        info->argument_count = 0;
        info->arguments_info = NULL;
        info->arguments_metadata = NULL;
    }
    void **points = (void **)gdextension_mem_alloc(sizeof(void*) * default_argument_count);
    prepare_variants(&points[0], default_argument_count, default_arguments);
    info->default_argument_count = default_argument_count;
    info->default_arguments = points;
};
void gd_method_list_free(uintptr_t list_p) {
    method_list *list = (method_list *)list_p;
    for (int i = 0; i < list->push; i++) {
        gdextension_mem_free(list->info[i].name);
        if (list->info[i].default_arguments) {
            gdextension_mem_free(list->info[i].default_arguments);
        }
    }
    gdextension_mem_free(list->info); gdextension_mem_free(list);
};
uintptr_t gd_property_list_make(INT length) {
    property_list *list = (property_list*)gdextension_mem_alloc(sizeof(property_list));
    list->push = 0;
    list->size = length;
    list->info = (GDExtensionPropertyInfo*)gdextension_mem_alloc(sizeof(GDExtensionPropertyInfo) * length);
    list->meta = (GDExtensionClassMethodArgumentMetadata*)gdextension_mem_alloc(sizeof(GDExtensionClassMethodArgumentMetadata) * length);
    return (uintptr_t)list;
};
void gd_property_list_push(uintptr_t list_p, uint32_t vtype, uintptr_t name, uintptr_t class_name, uint32_t hint, uintptr_t hint_string, uint32_t usage, uint32_t meta) {
    property_list *list = (property_list *)list_p;
    if (list->push >= list->size) return;
    GDExtensionPropertyInfo *info = &list->info[list->push++];
    GDExtensionClassMethodArgumentMetadata *meta_info = &list->meta[list->push - 1];
    uintptr_t *name_allocated = (uintptr_t *)gdextension_mem_alloc(sizeof(uintptr_t));
    *name_allocated = name;
    uintptr_t *class_name_allocated = (uintptr_t *)gdextension_mem_alloc(sizeof(uintptr_t));
    *class_name_allocated = class_name;
    uintptr_t *hint_string_allocated = (uintptr_t *)gdextension_mem_alloc(sizeof(uintptr_t));
    *hint_string_allocated = hint_string;
    info->type = (GDExtensionVariantType)vtype;
    info->name = (GDExtensionStringNamePtr)name_allocated;
    info->class_name = (GDExtensionStringNamePtr)class_name_allocated;
    info->hint = hint;
    info->hint_string = (GDExtensionStringPtr)hint_string_allocated;
    info->usage = usage;
    *meta_info = (GDExtensionClassMethodArgumentMetadata)meta;
};
void gd_property_list_free(uintptr_t list_p) {
    property_list *list = (property_list *)list_p;
    for (int i = 0; i < list->push; i++) {
        gdextension_mem_free(list->info[i].name);
        gdextension_mem_free(list->info[i].class_name);
        gdextension_mem_free(list->info[i].hint_string);
    }
    gdextension_mem_free(list->info);
    gdextension_mem_free(list->meta);
    gdextension_mem_free(list);
};
uint32_t gd_property_info_type(uintptr_t list_p) {
    property_list *list = (property_list *)list_p;
    return list->info[list->push-1].type;
};
uintptr_t gd_property_info_name(uintptr_t list_p) {
    property_list *list = (property_list *)list_p;
    return (uintptr_t)list->info[list->push-1].name;
};
uintptr_t gd_property_info_class_name(uintptr_t list_p) {
    property_list *list = (property_list *)list_p;
    return (uintptr_t)list->info[list->push-1].class_name;
};
uint32_t gd_property_info_hint(uintptr_t list_p) {
    property_list *list = (property_list *)list_p;
    return list->info[list->push-1].hint;
};
uintptr_t gd_property_info_hint_string(uintptr_t list_p) {
    property_list *list = (property_list *)list_p;
    return (uintptr_t)list->info[list->push-1].hint_string;
};
uint32_t gd_property_info_usage(uintptr_t list_p) {
    property_list *list = (property_list *)list_p;
    return list->info[list->push-1].usage;
};
static GDExtensionBool extension_instance_set(GDExtensionClassInstancePtr instance, GDExtensionConstStringNamePtr field, GDExtensionConstVariantPtr value) {
    uint64_t *v = (uint64_t *)value;
    return gd_on_extension_instance_set((uintptr_t)instance, *(uintptr_t*)field, UINT64_MAKE(v[0]), UINT64_MAKE(v[1]), UINT64_MAKE(v[2]));
}
static GDExtensionBool extension_instance_get(GDExtensionClassInstancePtr instance, GDExtensionConstStringNamePtr field, GDExtensionVariantPtr value) {
    return gd_on_extension_instance_get((uintptr_t)instance, *(uintptr_t*)field, value);
}
static GDExtensionBool extension_instance_property_has_default(GDExtensionClassInstancePtr instance, GDExtensionConstStringNamePtr field) {
    return gd_on_extension_instance_property_has_default((uintptr_t)instance, *(uintptr_t*)field);
}
static GDExtensionBool extension_instance_property_get_default(GDExtensionClassInstancePtr instance, GDExtensionConstStringNamePtr field, GDExtensionVariantPtr value) {
    return gd_on_extension_instance_property_get_default((uintptr_t)instance, *(uintptr_t*)field, value);
}
static const GDExtensionPropertyInfo *extension_instance_property_list(GDExtensionClassInstancePtr instance, uint32_t *count) {
    property_list *list = (property_list*)gd_on_extension_instance_property_list((uintptr_t)instance);
    GDExtensionPropertyInfo *info = list ? list->info : NULL;
    *count = list ? list->push : 0;
    if (list && list->meta) {
        gdextension_mem_free(list->meta);
    }
    return info;
}
static void class_free_property_list_func(GDExtensionClassInstancePtr instance, const GDExtensionPropertyInfo *list, uint32_t count) {
   if (list) gdextension_mem_free((void*)list);
}
static GDExtensionBool extension_instance_property_validation(GDExtensionClassInstancePtr instance, GDExtensionPropertyInfo *field) {
    property_list list = {
        .push = 1,
        .size = 1,
        .info = field,
        .meta = NULL
    };
    return gd_on_extension_instance_property_validation((uintptr_t)instance, (uintptr_t)&list);
}
static void extension_instance_stringify(GDExtensionClassInstancePtr instance, GDExtensionBool *ok, GDExtensionStringPtr s) {
    uint32_t result = gd_on_extension_instance_stringify((uintptr_t)instance);
    if (result) {
        *(uint32_t*)s = result;
        *ok = true;
    } else {
        gdextension_string_new_with_latin1_chars(s, ""); // FIXME/TODO remove in 4.5 (where my PR to fix this has been merged https://github.com/godotengine/godot/pull/105546)
        *ok = false;
    }
}
static void extension_instance_reference(GDExtensionClassInstancePtr instance) {
    gd_on_extension_instance_reference((uintptr_t)instance, true);
}
static GDExtensionBool extension_instance_unreference(GDExtensionClassInstancePtr instance) {
    return gd_on_extension_instance_reference((uintptr_t)instance, false);
}
static GDExtensionObjectPtr extension_class_create(void *user_data, GDExtensionBool notify_postinitialize) {
    return (GDExtensionObjectPtr)gd_on_extension_class_create((uintptr_t)user_data, notify_postinitialize);
}
static void *extension_class_caller(void *user_data, GDExtensionConstStringNamePtr name, uint32_t hash) {
    return (void*)gd_on_extension_class_caller((uintptr_t)user_data, *(uintptr_t*)name, hash);
}
static void extension_instance_called(GDExtensionClassInstancePtr p_instance, GDExtensionConstStringNamePtr p_name, void *p_virtual_call_userdata, const GDExtensionConstTypePtr *p_args, GDExtensionTypePtr r_ret) {
    gd_on_extension_instance_called((uintptr_t)p_instance, (uintptr_t)p_virtual_call_userdata, r_ret, (void *)p_args);
}
// gd_stock_virtual_entry exposes the stock entry above so Go can register it
// as the fallback target of a fast-path thunk (compiler.gd's runtime
// fastcbentry tail-jumps to it, arguments untouched, whenever the resident
// fast path's preconditions do not hold).
void *gd_stock_virtual_entry(void) { return (void*)extension_instance_called; }
// gd_ring_drain (defined with the ring machinery next to gd_ring_flush)
// drains the main thread's call ring in C when an engine->Go callback returns,
// so buffered outbound calls execute without a Go->C crossing to pay for the
// flush.
static void gd_ring_drain(void);
// gd_sticky_call_virtual, when set by Go (internal/sticky.EntryAddr), is a
// System V C-ABI thunk that runs the virtual dispatch WITHOUT a cgocallback
// transition (the sticky-P fast path). gd_call_virtual_dispatch routes each
// virtual call to it when armed, else to the stock cgocallback path.
void *gd_sticky_call_virtual = 0;
// gd_frame_active is set by Go (via asmcgocall around the engine Iteration) for
// the duration of a frame during which the P is HELD — the only window in which
// the no-transition fast path is safe (m.p valid, so the dispatch can allocate).
// Outside it, virtual calls take the stock cgocallback path.
int gd_frame_active = 0;
// gd_sticky_generic is the ONE generic fast entry (void(uintptr tag, void*frame))
// for every non-virtual engine->Go callback during a held frame. Set by Go.
void *gd_sticky_generic = 0;
static inline void gd_generic(uintptr_t tag, void *frame) {
    ((void(*)(uintptr_t, void*))gd_sticky_generic)(tag, frame);
}
// Callback tags — must match internal/startup genericDispatch.
enum {
    GD_TAG_NOTIFICATION = 1,
    GD_TAG_CHECKED_CALL = 2,
    GD_TAG_EVERY_FRAME  = 3,
    GD_TAG_FIRST_FRAME  = 4,
    GD_TAG_FINAL_FRAME  = 5,
};
static void gd_call_virtual_dispatch(GDExtensionClassInstancePtr p_instance, GDExtensionConstStringNamePtr p_name, void *p_virtual_call_userdata, const GDExtensionConstTypePtr *p_args, GDExtensionTypePtr r_ret) {
    if (gd_sticky_call_virtual) {
        ((void(*)(GDExtensionClassInstancePtr, GDExtensionConstStringNamePtr, void *, const GDExtensionConstTypePtr *, GDExtensionTypePtr))gd_sticky_call_virtual)(p_instance, p_name, p_virtual_call_userdata, p_args, r_ret);
    } else {
        extension_instance_called(p_instance, p_name, p_virtual_call_userdata, p_args, r_ret);
    }
    gd_ring_drain();
}
static void extension_instance_free(void *p_class_userdata, GDExtensionClassInstancePtr p_instance) {
    gd_on_extension_instance_free((uintptr_t)p_instance);
}
// gd_go_handles_notifications is flipped on by Go (classdb) when a registered
// class implements a Notification handler. Until then the per-frame process
// tick notifications (NOTIFICATION_PHYSICS_PROCESS=16, NOTIFICATION_PROCESS=17,
// NOTIFICATION_INTERNAL_PROCESS=25, NOTIFICATION_INTERNAL_PHYSICS_PROCESS=26)
// are dropped here, engine-side: they arrive once per processing node per frame
// and would otherwise pay a full C->Go crossing just to hit a no-op.
bool gd_go_handles_notifications = false;
static void extension_instance_notification(GDExtensionClassInstancePtr p_instance, int32_t p_what, GDExtensionBool p_reversed) {
    switch (p_what) {
    case 16: case 17: case 25: case 26:
        if (!gd_go_handles_notifications) return;
    }
    gd_on_extension_instance_notification((uintptr_t)p_instance, p_what, p_reversed);
    gd_ring_drain();
}
void gd_classdb_register(uintptr_t class_name, uintptr_t parent, uintptr_t id, bool is_virtual, bool abstract, bool exposed, bool runtime, uintptr_t icon_path) {
    GDExtensionClassCreationInfo6 info = {
        .is_virtual = is_virtual,
        .is_abstract = abstract,
        .is_exposed = exposed,
        .is_runtime = runtime,
        .icon_path = (GDExtensionConstStringNamePtr)&icon_path,
        .set_func = extension_instance_set,
        .get_func = extension_instance_get,
        .get_property_list_func = extension_instance_property_list,
        .free_property_list_func = class_free_property_list_func,
        .property_can_revert_func = extension_instance_property_has_default,
        .property_get_revert_func = extension_instance_property_get_default,
        .validate_property_func = extension_instance_property_validation,
        .notification_func = (GDExtensionClassNotification2)extension_instance_notification,
        .to_string_func = extension_instance_stringify,
        //.reference_func = (GDExtensionClassReference)class_reference, // FIXME JavaScript error: null function or function signature mismatch
        //.unreference_func = (GDExtensionClassUnreference)class_unreference, // FIXME JavaScript error: null function or function signature mismatch
        .create_instance_func = extension_class_create,
        .free_instance_func = extension_instance_free,
        .get_virtual_call_data_func = extension_class_caller,
        .call_virtual_with_data_func = gd_call_virtual_dispatch,
        .class_userdata = (void *)id,
    };
    gdextension_classdb_register_extension_class6(gd_library, (GDExtensionConstStringNamePtr)&class_name, (GDExtensionConstStringNamePtr)&parent, &info);
};
void gd_classdb_register_methods(uintptr_t class_name, uintptr_t methods) {
    method_list *list = (method_list *)methods;
    for (int i = 0; i < list->push; i++) {
        GDExtensionClassMethodInfo *info = &list->info[i];
        gdextension_classdb_register_extension_class_method(gd_library, (GDExtensionConstStringNamePtr)&class_name, info);
    }
};
void gd_classdb_register_constant(uintptr_t class_name, uintptr_t enum_name, uintptr_t name, INT64(value), bool bitfield) {
    gdextension_classdb_register_extension_class_integer_constant(gd_library, (GDExtensionConstStringNamePtr)&class_name, (GDExtensionConstStringNamePtr)&enum_name, (GDExtensionConstStringNamePtr)&name, INT64_FROM(value), bitfield);
};
void gd_classdb_register_property(uintptr_t class_name, uintptr_t info, uintptr_t setter, uintptr_t getter) {
    property_list *list = (property_list *)info;
    gdextension_classdb_register_extension_class_property(gd_library, (GDExtensionConstStringNamePtr)&class_name, list->info, (GDExtensionConstStringNamePtr)&setter, (GDExtensionConstStringNamePtr)&getter);
};
// The Go side passes the index as a single (32-bit safe) integer; INT keeps
// int64_t natively and a single int32 on the web (INT64 would demand a
// hi/lo pair the callers never sent).
void gd_classdb_register_property_indexed(uintptr_t class_name, uintptr_t info, uintptr_t setter, uintptr_t getter, INT index) {
    property_list *list = (property_list *)info;
    gdextension_classdb_register_extension_class_property_indexed(gd_library, (GDExtensionConstStringNamePtr)&class_name, list->info, (GDExtensionConstStringNamePtr)&setter, (GDExtensionConstStringNamePtr)&getter, index);
};
void gd_classdb_register_property_group(uintptr_t class_name, uintptr_t group, uintptr_t prefix) {
    gdextension_classdb_register_extension_class_property_group(gd_library, (GDExtensionConstStringNamePtr)&class_name, (GDExtensionConstStringNamePtr)&group, (GDExtensionConstStringPtr)&prefix);
};
void gd_classdb_register_property_sub_group(uintptr_t class_name, uintptr_t subgroup, uintptr_t prefix) {
    gdextension_classdb_register_extension_class_property_subgroup(gd_library, (GDExtensionConstStringNamePtr)&class_name, (GDExtensionConstStringNamePtr)&subgroup, (GDExtensionConstStringPtr)&prefix);
};
void gd_classdb_register_signal(uintptr_t class_name, uintptr_t name, uintptr_t args) {
    property_list *list = (property_list *)args;
    gdextension_classdb_register_extension_class_signal(gd_library, (GDExtensionConstStringNamePtr)&class_name, (GDExtensionConstStringNamePtr)&name, list->info, list->push);
};
void gd_classdb_register_removal(uintptr_t class_name) {
    gdextension_classdb_unregister_extension_class(gd_library, (GDExtensionConstStringNamePtr)&class_name);
};
void gd_classdb_WorkerThreadPool_add_task(uintptr_t WorkerPool, uintptr_t task_id, bool priority, uintptr_t description) {
    gdextension_worker_thread_pool_add_native_task((GDExtensionObjectPtr)WorkerPool, (GDExtensionWorkerThreadPoolTask)gd_on_worker_thread_pool_task, (void *)task_id, priority, (GDExtensionConstStringNamePtr)&description);
};
void gd_classdb_WorkerThreadPool_add_group_task(uintptr_t WorkerPool, uintptr_t task_id, int32_t elements, int32_t tasks, bool priority, uintptr_t description) {
    gdextension_worker_thread_pool_add_native_group_task((GDExtensionObjectPtr)WorkerPool, (GDExtensionWorkerThreadPoolGroupTask)gd_on_worker_thread_pool_group_task, (void *)task_id, elements, tasks, priority, (GDExtensionConstStringNamePtr)&description);
};
INT gd_classdb_XMLParser_load(uintptr_t XMLParser, BUFFER buf, INT len) {
    return gdextension_xml_parser_open_buffer((GDExtensionObjectPtr)XMLParser, (const uint8_t *)BUFFER_POINTER(buf), len);
};
void gd_packed_dictionary_access(uintptr_t dict, UINT64(k1), UINT64(k2), UINT64(k3), ANY args) {
    uint64_t key[3] = {UINT64_FROM(k1), UINT64_FROM(k2), UINT64_FROM(k3)};
    uint64_t *value = (uint64_t*)gdextension_dictionary_operator_index_const((GDExtensionTypePtr)&dict, &key[0]);
    if (!value) return;
    // Shallow header copy — callers must Variants.Copy before Free (see gd_array_get).
    uint64_t * result = (uint64_t*)args;
    result[0] = value[0];
    result[1] = value[1];
    result[2] = value[2];
};
void gd_packed_dictionary_modify(uintptr_t dict, UINT64(k1), UINT64(k2), UINT64(k3), UINT64(v1), UINT64(v2), UINT64(v3)) {
    uint64_t key[3] = {UINT64_FROM(k1), UINT64_FROM(k2), UINT64_FROM(k3)};
    uint64_t *value = (uint64_t*)gdextension_dictionary_operator_index((GDExtensionTypePtr)&dict, (GDExtensionVariantPtr)&key[0]);
    value[0] = UINT64_FROM(v1);
    value[1] = UINT64_FROM(v2);
    value[2] = UINT64_FROM(v3);
};
void gd_editor_add_documentation(STRING xml, INT len) {
    gdextension_editor_help_load_xml_from_utf8_chars_and_len(STRING_POINTER(xml), len);
};
void gd_editor_add_plugin(uintptr_t class_name) {
    gdextension_editor_add_plugin((GDExtensionConstStringNamePtr)&class_name);
};
void gd_editor_end_plugin(uintptr_t class_name) {
    gdextension_editor_remove_plugin((GDExtensionConstStringNamePtr)&class_name);
};
void gd_iterator_make(UINT64(v1), UINT64(v2), UINT64(v3), ANY result, ANY err) {
    uint64_t self[3] = {UINT64_FROM(v1), UINT64_FROM(v2), UINT64_FROM(v3)};
    GDExtensionBool valid = true;
    valid = valid && gdextension_variant_iter_init(&self, (void*)result, &valid);
    if (valid) return;
    ((GDExtensionCallError*)err)->error = GDEXTENSION_CALL_ERROR_INVALID_ARGUMENT;
};
bool gd_iterator_next(UINT64(v1), UINT64(v2), UINT64(v3), ANY iter, ANY err) {
    uint64_t self[3] = {UINT64_FROM(v1), UINT64_FROM(v2), UINT64_FROM(v3)};
    GDExtensionBool valid = false;
    GDExtensionBool ok = gdextension_variant_iter_next(&self, (GDExtensionVariantPtr)iter, &valid);
    if (ok) {
        return true;
    }
    ((GDExtensionCallError*)err)->error = GDEXTENSION_CALL_ERROR_INVALID_ARGUMENT;
    return false;
};
void gd_iterator_load(UINT64(v1), UINT64(v2), UINT64(v3), UINT64(i1), UINT64(i2), UINT64(i3), ANY result, ANY err) {
    uint64_t self[3] = {UINT64_FROM(v1), UINT64_FROM(v2), UINT64_FROM(v3)};
    uint64_t iter[3] = {UINT64_FROM(i1), UINT64_FROM(i2), UINT64_FROM(i3)};
    void *points[16]; prepare_variants(&points[0], 1, result);
    GDExtensionBool ok = false;
    gdextension_variant_iter_get(&self, &iter, (GDExtensionUninitializedVariantPtr)points[0], &ok);
    if (ok) return;
    ((GDExtensionCallError*)err)->error = GDEXTENSION_CALL_ERROR_INVALID_ARGUMENT;
};
const char *fit_string(const char *str, uint64_t len, char *buf, size_t buf_size) {
    if (len == 0 || str == NULL) {
        return NULL;
    }
    if (len >= buf_size) {
        buf = (char *)gdextension_mem_alloc(len + 1); // +1 for null-terminator
    }
    memcpy(buf, str, len);
    buf[len] = '\0'; // null-terminate the string
    return buf;
}
void gd_log_error(
    STRING text, INT text_len,
    STRING code, INT code_len,
    STRING func, INT func_len,
    STRING file, INT file_len,
    int32_t line, bool notify_editor
) {
    char text_buf[256]; const char *text_ptr = fit_string(STRING_POINTER(text), text_len, &text_buf[0], 256);
    char code_buf[100]; const char *code_ptr = fit_string(STRING_POINTER(code), code_len, &code_buf[0], 100);
    char func_buf[100]; const char *func_ptr = fit_string(STRING_POINTER(func), func_len, &func_buf[0], 100);
    char file_buf[100]; const char *file_ptr = fit_string(STRING_POINTER(file), file_len, &file_buf[0], 100);
    gdextension_print_error_with_message(code_ptr, text_ptr, func_ptr, file_ptr, line, notify_editor);
    if (text_ptr && text_ptr != text_buf) gdextension_mem_free((void *)text_ptr);
    if (code_ptr && code_ptr != code_buf) gdextension_mem_free((void *)code_ptr);
    if (func_ptr && func_ptr != func_buf) gdextension_mem_free((void *)func_ptr);
    if (file_ptr && file_ptr != file_buf) gdextension_mem_free((void *)file_ptr);
};
void gd_log_warning(
    STRING text, INT text_len,
    STRING code, INT code_len,
    STRING func, INT func_len,
    STRING file, INT file_len,
    int32_t line, bool notify_editor
) {
    char text_buf[256]; const char *text_ptr = fit_string(STRING_POINTER(text), text_len, &text_buf[0], 256);
    char code_buf[100]; const char *code_ptr = fit_string(STRING_POINTER(code), code_len, &code_buf[0], 100);
    char func_buf[100]; const char *func_ptr = fit_string(STRING_POINTER(func), func_len, &func_buf[0], 100);
    char file_buf[100]; const char *file_ptr = fit_string(STRING_POINTER(file), file_len, &file_buf[0], 100);
    gdextension_print_warning_with_message(code_ptr, text_ptr, func_ptr, file_ptr, line, notify_editor);
    if (text_ptr && text_ptr != text_buf) gdextension_mem_free((void *)text_ptr);
    if (code_ptr && code_ptr != code_buf) gdextension_mem_free((void *)code_ptr);
    if (func_ptr && func_ptr != func_buf) gdextension_mem_free((void *)func_ptr);
    if (file_ptr && file_ptr != file_buf) gdextension_mem_free((void *)file_ptr);
};
uintptr_t gd_memory_malloc(INT size) {
    return (uintptr_t)gdextension_mem_alloc(size);
};
INT gd_memory_sizeof(uintptr_t name) {
    return gdextension_get_native_struct_size((GDExtensionConstStringNamePtr)&name);
};
uintptr_t gd_memory_resize(uintptr_t addr, INT size) {
    return (uintptr_t)gdextension_mem_realloc((void *)addr, size);
};
void gd_memory_free(uintptr_t addr) {
    gdextension_mem_free((void *)addr);
};
void gd_memory_clear(uintptr_t addr, INT size) {
    if (size <= 0) return;
    memset((void *)addr, 0, size);
};
void gd_memory_edit_byte(uintptr_t addr, uint8_t b) { *(uint8_t *)addr = b; };
void gd_memory_edit_u16(uintptr_t addr, uint16_t b) { *(uint16_t *)addr = b; };
void gd_memory_edit_u32(uintptr_t addr, uint32_t b) { *(uint32_t *)addr = b; };
void gd_memory_edit_u64(uintptr_t addr, UINT64(b)) { *(uint64_t *)addr = UINT64_FROM(b); };
void gd_memory_edit_128(uintptr_t addr, UINT64(a), UINT64(b)) {
    uint64_t *ptr = (uint64_t *)addr;
    ptr[0] = UINT64_FROM(a); ptr[1] = UINT64_FROM(b);
};
void gd_memory_edit_256(uintptr_t addr, UINT64(a), UINT64(b), UINT64(c), UINT64(d)) {
    uint64_t *ptr = (uint64_t *)addr;
    ptr[0] = UINT64_FROM(a); ptr[1] = UINT64_FROM(b); ptr[2] = UINT64_FROM(c); ptr[3] = UINT64_FROM(d);
};
void gd_memory_edit_512(uintptr_t addr, UINT64(a), UINT64(b), UINT64(c), UINT64(d), UINT64(e), UINT64(f), UINT64(g), UINT64(h)) {
    uint64_t *ptr = (uint64_t *)addr;
    ptr[0] = UINT64_FROM(a); ptr[1] = UINT64_FROM(b); ptr[2] = UINT64_FROM(c); ptr[3] = UINT64_FROM(d);
    ptr[4] = UINT64_FROM(e); ptr[5] = UINT64_FROM(f); ptr[6] = UINT64_FROM(g); ptr[7] = UINT64_FROM(h);
};
uint8_t gd_memory_load_byte(uintptr_t addr) {
    return *(uint8_t *)addr;
};
uint16_t gd_memory_load_u16(uintptr_t addr) {
    return *(uint16_t *)addr;
};
uint32_t gd_memory_load_u32(uintptr_t addr) {
    return *(uint32_t *)addr;
};
uintptr_t gd_object_make(uintptr_t name) {
    return (uintptr_t)gdextension_classdb_construct_object3((GDExtensionConstStringNamePtr)&name);
};
void gd_object_call(uintptr_t obj, uintptr_t fn, ANY result, INT argc, ANY args, ANY err) {
    void *points[16]; prepare_variants(&points[0], argc, args);
    gdextension_object_method_bind_call((GDExtensionMethodBindPtr)fn, (GDExtensionObjectPtr)obj, (const GDExtensionConstTypePtr*)&points[0], argc, (GDExtensionTypePtr)result, (GDExtensionCallError*)err);
};
result_24 gd_object_call_24(uintptr_t obj, uintptr_t fn, INT argc, ANY args, ANY err) {
    void *points[16]; prepare_variants(&points[0], argc, args);
    result_24 result = {};
    gdextension_object_method_bind_call((GDExtensionMethodBindPtr)fn, (GDExtensionObjectPtr)obj, (const GDExtensionConstTypePtr*)&points[0], argc, (GDExtensionTypePtr)&result, (GDExtensionCallError*)err);
    return result;
};
void gd_object_unsafe_free(uintptr_t obj) {
    gdextension_object_destroy((GDExtensionObjectPtr)obj);
};
uintptr_t gd_object_name(uintptr_t obj) {
    uintptr_t name = 0;
    gdextension_object_get_class_name((GDExtensionObjectPtr)obj, gd_library, (GDExtensionUninitializedStringNamePtr)&name);
    return name;
};
uintptr_t gd_object_type(uintptr_t name) {
    return (uintptr_t)gdextension_classdb_get_class_tag((GDExtensionConstStringNamePtr)&name);
};
uintptr_t gd_object_cast(uintptr_t obj, uintptr_t tag) {
    return (uintptr_t)gdextension_object_cast_to((GDExtensionObjectPtr)obj, (void *)tag);
};
uintptr_t gd_object_lookup(UINT64(id)) {
    return (uintptr_t)gdextension_object_get_instance_from_id((GDObjectInstanceID)UINT64_FROM(id));
};
uintptr_t gd_object_global(uintptr_t name) {
    return (uintptr_t)gdextension_global_get_singleton((GDExtensionConstStringNamePtr)&name);
};
void gd_object_extension_setup(uintptr_t obj, uintptr_t name, uintptr_t instance) {
    gdextension_object_set_instance((GDExtensionObjectPtr)obj, (GDExtensionConstStringNamePtr)&name, (GDExtensionClassInstancePtr)instance);
    gdextension_object_set_instance_binding((GDExtensionObjectPtr)obj, gd_library, (void *)instance, &instance_binding_callbacks);
};
uintptr_t gd_object_extension_fetch(uintptr_t obj) {
    return (uintptr_t)gdextension_object_get_instance_binding((GDExtensionObjectPtr)obj, gd_library, &instance_binding_callbacks);
};
void gd_object_extension_close(uintptr_t obj) {
    gdextension_object_free_instance_binding((GDExtensionObjectPtr)obj, gd_library);
};
void gd_object_id(uintptr_t obj, ANY id) {
     *((uint64_t*)id) = gdextension_object_get_instance_id((GDExtensionObjectPtr)obj);
};
void gd_object_id_inside_variant(UINT64(v1), UINT64(v2), UINT64(v3), ANY id) {
    uint64_t self[3] = {UINT64_FROM(v1), UINT64_FROM(v2), UINT64_FROM(v3)};
    *(uint64_t*)id = gdextension_variant_get_object_instance_id(&self);
};
uintptr_t gd_object_method_lookup(uintptr_t class_name, uintptr_t method, INT64(hash)) {
    return (uintptr_t)gdextension_classdb_get_method_bind((GDExtensionConstStringNamePtr)&class_name, (GDExtensionConstStringNamePtr)&method, INT64_FROM(hash));
};
void gd_object_unsafe_call(uintptr_t obj, uintptr_t method, ANY result, UINT64(shape), ANY args) {
    void *points[16]; prepare_callframe(1, &points[0], UINT64_FROM(shape), args);
    gdextension_object_method_bind_ptrcall((GDExtensionMethodBindPtr)method, (GDExtensionObjectPtr)obj, (const GDExtensionConstTypePtr*)&points[0], (GDExtensionTypePtr)result);
};
typedef struct {
    uintptr_t object;
    uintptr_t method;
    uint64_t  shape;
    uint8_t   args[256];
    uint8_t   result[64];
    uint16_t  refs[16];
    uintptr_t owner;
    uintptr_t pc;
} ring_entry;
void gd_ring_flush(void *entries, uint32_t tail, uint32_t head, uint32_t *crash_index) {
    ring_entry *ring = (ring_entry *)entries;
    for (uint32_t i = tail; i != head; i++) {
        ring_entry *e = &ring[i & 0xFF];
        *crash_index = i & 0xFF;
        void *points[16];
        prepare_callframe(1, &points[0], e->shape, (ANY)e->args);
        // The result slot must look like a default-constructed value before
        // ptrcall writes to it: Godot's PtrToArg<T>::encode assigns through
        // T::operator=, which unrefs whatever the destination bytes appear
        // to point at. Entries are reused every lap of the ring, so stale
        // result bytes from an earlier call would be unref'd here — freeing
        // a value that a previous caller copied out and still owns (the
        // direct call paths zero their local result buffer the same way).
        // Void methods (result nibble empty) never write the slot, so the
        // zeroing is skipped for them — they are the bulk of buffered calls.
        if (e->shape & 0xF) __builtin_memset(e->result, 0, sizeof e->result);
        gdextension_object_method_bind_ptrcall(
            (GDExtensionMethodBindPtr)e->method,
            (GDExtensionObjectPtr)e->object,
            (const GDExtensionConstTypePtr*)&points[0],
            (GDExtensionTypePtr)e->result
        );
    }
    *crash_index = 0xFFFFFFFF;
}
// C-side draining of the main thread's call ring at engine->Go callback
// boundaries. Go registers the ring once from the main thread (gd_ring_adopt);
// after that, the callback trampolines call gd_ring_drain when a callback
// returns, so entries the callback buffered execute right here in C — no
// Go->C crossing pays for the flush, and Go's own Flush sites find the ring
// already empty. gd_ring_owner is thread-local: virtuals arriving on worker
// threads (resource loader, audio) must not touch the main thread's ring.
typedef struct {
    uint32_t head;
    uint32_t tail;
    ring_entry entries[256];
} gd_ring_buffer;
#ifdef __cplusplus
static_assert(offsetof(gd_ring_buffer, entries) == 8,
    "gd_ring_buffer prefix must match ring.Ring (head, tail uint32)");
#else
_Static_assert(offsetof(gd_ring_buffer, entries) == 8,
    "gd_ring_buffer prefix must match ring.Ring (head, tail uint32)");
#endif
// gd_mpsc_shared mirrors the Go side's ring.mpscShared: the C-visible state of
// the cross-thread (MPSC) command ring. head and seq are written by producer
// goroutines on other threads, so C accesses them with the same atomic
// ordering as Go's atomic.Uint32 (acquire on seq to observe the published
// entry bytes, release on the slot's transition out of published). cursor,
// draining and cdrained are main-thread-only, shared with the Go drain that
// runs on this same thread.
typedef struct {
    uint32_t head;
    uint32_t cursor;
    uint32_t draining;
    uint32_t cdrained;
    uint32_t seq[256];
    uint8_t  kind[256];
    // executed counts kindCall entries either drain has run (loss
    // diagnostics, mirrors ring.mpscShared.executed). Main-thread writes;
    // atomic so Go may read it from any goroutine.
    uint64_t executed;
} gd_mpsc_shared;
#ifdef __cplusplus
static_assert(offsetof(gd_mpsc_shared, seq) == 16 && offsetof(gd_mpsc_shared, kind) == 1040,
    "gd_mpsc_shared must match ring.mpscShared");
#else
_Static_assert(offsetof(gd_mpsc_shared, seq) == 16 && offsetof(gd_mpsc_shared, kind) == 1040,
    "gd_mpsc_shared must match ring.mpscShared");
#endif
static gd_ring_buffer *gd_ring_main = NULL;
static uint32_t *gd_ring_main_crash_index = NULL;
static gd_mpsc_shared *gd_ring_threads = NULL;
static ring_entry *gd_ring_threads_entries = NULL;
static __thread int gd_ring_owner = 0;
void gd_ring_adopt(void *ring, uint32_t *crash_index, void *threads_shared, void *threads_entries) {
    gd_ring_main = (gd_ring_buffer *)ring;
    gd_ring_main_crash_index = crash_index;
    gd_ring_threads = (gd_mpsc_shared *)threads_shared;
    gd_ring_threads_entries = (ring_entry *)threads_entries;
    gd_ring_owner = 1;
}
// Drains the published fire-and-forget prefix of the cross-thread ring: runs
// of kind==0 entries (plain engine calls). Thunks and parked calls (kind!=0)
// stop the scan — they need the Go drain (Go functions, cond signalling) and
// FIFO order must hold. Claim-then-execute: cursor advances before the call so
// a nested drain (from a callback the call triggers) skips the entry.
static void gd_ring_drain_threads(void) {
    gd_mpsc_shared *s = gd_ring_threads;
    if (s == NULL || s->draining) return;
    // Empty fast path: nothing published at the cursor. This runs after
    // EVERY engine->Go callback (gd_ring_drain), so skip the draining-flag
    // stores when there is no work; the acquire load is the same check the
    // loop below would make first.
    if (__atomic_load_n(&s->seq[s->cursor & 0xFF], __ATOMIC_ACQUIRE) != s->cursor + 1) return;
    // Hold the drain flag for the loop, exactly like the Go drain: an entry's
    // engine call can re-enter Go, and neither a nested Go flush nor a nested
    // C drain may execute later entries before this one completes (FIFO).
    s->draining = 1;
    int released = 0;
    for (;;) {
        uint32_t i = s->cursor;
        if (__atomic_load_n(&s->seq[i & 0xFF], __ATOMIC_ACQUIRE) != i + 1) break;
        if (s->kind[i & 0xFF] != 0) break;
        s->cursor = i + 1;
        gd_ring_flush(gd_ring_threads_entries, i, i + 1, gd_ring_main_crash_index);
        __atomic_fetch_add(&s->executed, 1, __ATOMIC_RELAXED);
        // released: free for the producer of index i+Size. C cannot signal the
        // Go-side cond a lapped producer parks on; cdrained defers that wake
        // to the next Go drain.
        __atomic_store_n(&s->seq[i & 0xFF], i + 256, __ATOMIC_RELEASE);
        released = 1;
    }
    if (released) s->cdrained = 1;
    s->draining = 0;
}
static void gd_ring_drain(void) {
    if (!gd_ring_owner) return;
    gd_ring_buffer *r = gd_ring_main;
    if (r != NULL) {
        // Claim-then-execute, the same protocol as the Go side's Flush:
        // advance tail before executing, so re-entrant flushes (nested
        // callbacks buffering and flushing) only see newly-buffered entries.
        while (r->tail != r->head) {
            uint32_t tail = r->tail, head = r->head;
            r->tail = head;
            gd_ring_flush(r->entries, tail, head, gd_ring_main_crash_index);
        }
    }
    gd_ring_drain_threads();
    // A threads entry can buffer main-ring work via a nested callback whose
    // own trampoline drained it already; this final sweep only catches calls
    // buffered by paths without a drain of their own (cheap when empty).
    if (r != NULL && r->tail != r->head) {
        uint32_t tail = r->tail, head = r->head;
        r->tail = head;
        gd_ring_flush(r->entries, tail, head, gd_ring_main_crash_index);
    }
}
uint64_t gd_object_unsafe_call_8(uintptr_t obj, uintptr_t method, UINT64(shape), ANY args) {
    void *points[16]; prepare_callframe(1, &points[0], UINT64_FROM(shape), args);
    uint64_t result = 0;
    gdextension_object_method_bind_ptrcall((GDExtensionMethodBindPtr)method, (GDExtensionObjectPtr)obj, (const GDExtensionConstTypePtr*)&points[0], (GDExtensionTypePtr)&result);
    return result;
};
// gd_iterate_g0 wraps the 8-byte-return unsafe call so it can be invoked via
// runtime.asmcgocall (single pointer arg): asmcgocall runs it on g0 WITHOUT
// entersyscall, so the P is HELD across the whole engine frame it drives, and
// the per-node virtual callbacks nested inside can allocate on the fast path.
struct gd_iter_args { uintptr_t obj; uintptr_t method; uint64_t shape; void *args; uint64_t result; };
void gd_iterate_g0(struct gd_iter_args *a) {
    a->result = gd_object_unsafe_call_8(a->obj, a->method, UINT64_MAKE(a->shape), (ANY)(uintptr_t)a->args);
}
void *gd_iterate_g0_addr(void) { return (void*)&gd_iterate_g0; }
// gd_resident_call: outbound method-bind ptrcall for resident-callback mode,
// invoked via the patched runtime's fastcbCallC (asmcgocall, single pointer
// argument): the calling goroutine stays _Grunning so engine->Go callbacks
// nested inside the ptrcall take the resident fast path. The pack must live in
// NON-MOVING memory (a Go global): nested callbacks can grow and move the
// goroutine stack, and both this code and the engine (which encodes the return
// value only after the method body ran) hold raw pointers into the pack across
// them. Layout must match noescape.residentPack.
struct gd_resident_pack {
    uintptr_t object;
    uintptr_t method;
    uint64_t  shape;
    uint8_t   args[256];
    uint8_t   result[64];
};
void gd_resident_call(void *v) {
    struct gd_resident_pack *p = (struct gd_resident_pack *)v;
    void *points[16]; prepare_callframe(1, &points[0], p->shape, (ANY)p->args);
    // Zero the result slot: PtrToArg<T>::encode assigns through T::operator=,
    // which unrefs whatever the destination bytes appear to point at (see
    // gd_ring_flush). Packs are reused per nesting depth.
    __builtin_memset(p->result, 0, sizeof p->result);
    gdextension_object_method_bind_ptrcall(
        (GDExtensionMethodBindPtr)p->method,
        (GDExtensionObjectPtr)p->object,
        (const GDExtensionConstTypePtr*)&points[0],
        (GDExtensionTypePtr)p->result
    );
}
void *gd_resident_call_addr(void) { return (void*)&gd_resident_call; }
// gd_resident_variant_call is the variant-call (method_bind_call) analogue of
// gd_resident_call, for script/vararg method calls. Same non-moving-memory
// contract; layout must match noescape.residentVariantPack.
struct gd_resident_variant_pack {
    uintptr_t object;
    uintptr_t method;
    int64_t   argc;
    uint8_t   args[240];   // up to 10 Variants, 24 bytes each
    uint8_t   result[24];  // Variant
    uint8_t   err[12];     // GDExtensionCallError
    uint8_t   pad[4];
};
void gd_resident_variant_call(void *v) {
    struct gd_resident_variant_pack *p = (struct gd_resident_variant_pack *)v;
    void *points[16]; prepare_variants(&points[0], (uint32_t)p->argc, (ANY)p->args);
    __builtin_memset(p->result, 0, sizeof p->result);
    gdextension_object_method_bind_call(
        (GDExtensionMethodBindPtr)p->method,
        (GDExtensionObjectPtr)p->object,
        (const GDExtensionConstTypePtr*)&points[0],
        p->argc,
        (GDExtensionTypePtr)p->result,
        (GDExtensionCallError*)p->err
    );
}
void *gd_resident_variant_call_addr(void) { return (void*)&gd_resident_variant_call; }
// gd_resident_script_call is gd_object_script_call staged for resident mode
// (same pack layout as gd_resident_variant_call; method holds the StringName
// value, the engine takes its address).
void gd_resident_script_call(void *v) {
    struct gd_resident_variant_pack *p = (struct gd_resident_variant_pack *)v;
    void *points[16]; points[1] = 0; prepare_variants(&points[0], (uint32_t)p->argc, (ANY)p->args);
    __builtin_memset(p->result, 0, sizeof p->result);
    gdextension_object_call_script_method(
        (GDExtensionObjectPtr)p->object,
        (GDExtensionConstStringNamePtr)&p->method,
        (const GDExtensionConstTypePtr*)&points[0],
        p->argc,
        (GDExtensionTypePtr)p->result,
        (GDExtensionCallError*)p->err
    );
}
void *gd_resident_script_call_addr(void) { return (void*)&gd_resident_script_call; }
// gd_ring_flush_g0 wraps gd_ring_flush behind a single-pointer argument so the
// resident path can flush the ring via fastcb.CallC (asmcgocall): callbacks
// triggered by buffered calls (signal handlers, notifications) then take the
// resident fast path. The pack must be a Go global (see gd_resident_call); the
// ring itself already is one.
struct gd_ring_flush_pack {
    void     *entries;
    uint32_t  tail;
    uint32_t  head;
    uint32_t *crash_index;
};
void gd_ring_flush_g0(void *v) {
    struct gd_ring_flush_pack *p = (struct gd_ring_flush_pack *)v;
    gd_ring_flush(p->entries, p->tail, p->head, p->crash_index);
}
void *gd_ring_flush_g0_addr(void) { return (void*)&gd_ring_flush_g0; }
result_16 gd_object_unsafe_call_16(uintptr_t obj, uintptr_t method, UINT64(shape), ANY args) {
    void *points[16]; prepare_callframe(1, &points[0], UINT64_FROM(shape), args);
    result_16 result = {};
    gdextension_object_method_bind_ptrcall((GDExtensionMethodBindPtr)method, (GDExtensionObjectPtr)obj, (const GDExtensionConstTypePtr*)&points[0], (GDExtensionTypePtr)&result);
    return result;
};
result_32 gd_object_unsafe_call_32(uintptr_t obj, uintptr_t method, UINT64(shape), ANY args) {
    void *points[16]; prepare_callframe(1, &points[0], UINT64_FROM(shape), args);
    result_32 result = {};
    gdextension_object_method_bind_ptrcall((GDExtensionMethodBindPtr)method, (GDExtensionObjectPtr)obj, (const GDExtensionConstTypePtr*)&points[0], (GDExtensionTypePtr)&result);
    return result;
};
result_64 gd_object_unsafe_call_64(uintptr_t obj, uintptr_t method, UINT64(shape), ANY args) {
    void *points[16]; prepare_callframe(1, &points[0], UINT64_FROM(shape), args);
    result_64 result = {};
    gdextension_object_method_bind_ptrcall((GDExtensionMethodBindPtr)method, (GDExtensionObjectPtr)obj, (const GDExtensionConstTypePtr*)&points[0], (GDExtensionTypePtr)&result);
    return result;
};
uintptr_t gd_ptrcall_fn_addr() {
    return (uintptr_t)gdextension_object_method_bind_ptrcall;
}
static GDExtensionBool extension_script_categorization(GDExtensionScriptInstanceDataPtr instance, GDExtensionPropertyInfo *info) {
    property_list list = { .info = info };
    return gd_on_extension_script_categorization((uintptr_t)instance, (uintptr_t)&list);
}
static GDExtensionObjectPtr extension_script_get_owner(GDExtensionScriptInstanceDataPtr instance) {
    return (GDExtensionObjectPtr)gd_on_extension_script_get_owner((uintptr_t)instance);
}
void gd_object_script_property_state_add(uintptr_t fn, uintptr_t arg, uintptr_t name, UINT64(s1), UINT64(s2), UINT64(s3)) {
    uint64_t state[3] = {UINT64_FROM(s1), UINT64_FROM(s2), UINT64_FROM(s3)};
    ((GDExtensionScriptInstancePropertyStateAdd)fn)(&name, &state, (void *)arg);
}
static void extension_script_get_property_state(GDExtensionScriptInstanceDataPtr p_instance, GDExtensionScriptInstancePropertyStateAdd p_add_func, void *p_userdata) {
    gd_on_extension_script_get_property_state((uintptr_t)p_instance, (uintptr_t)p_add_func, (uintptr_t)p_userdata);
}
static GDExtensionBool extension_script_has_method(GDExtensionScriptInstanceDataPtr instance, GDExtensionConstStringNamePtr method) {
    return gd_on_extension_script_has_method((uintptr_t)instance, *(uintptr_t*)method);
}

static GDExtensionInt extension_script_get_method_argument_count(GDExtensionScriptInstanceDataPtr instance, GDExtensionConstStringNamePtr method, GDExtensionBool *valid) {
    *valid = 1;
    return gd_on_extension_script_get_method_argument_count((uintptr_t)instance, *(uintptr_t*)method);
}
static GDExtensionObjectPtr extension_script_get(GDExtensionScriptInstanceDataPtr instance) {
    return (GDExtensionObjectPtr)gd_on_extension_script_get((uintptr_t)instance);
}
static GDExtensionBool extension_script_is_placeholder(GDExtensionScriptInstanceDataPtr instance) {
    return gd_on_extension_script_is_placeholder((uintptr_t)instance);
}
static GDExtensionObjectPtr extension_script_get_language(GDExtensionScriptInstanceDataPtr instance) {
    return (GDExtensionObjectPtr)gd_on_extension_script_get_language((uintptr_t)instance);
}
uintptr_t gd_object_script_make(uintptr_t instance) {
    GDExtensionScriptInstanceInfo3 info = {
        .set_func = extension_instance_set,
        .get_func = extension_instance_get,
        .get_property_list_func = extension_instance_property_list,
        .free_property_list_func = class_free_property_list_func,
        .get_class_category_func = extension_script_categorization,
        .property_can_revert_func = extension_instance_property_has_default,
        .property_get_revert_func = extension_instance_property_get_default,
        .get_owner_func = extension_script_get_owner,
        .get_property_state_func = extension_script_get_property_state,
        .validate_property_func = extension_instance_property_validation,
        .has_method_func = extension_script_has_method,
        .get_method_argument_count_func = extension_script_get_method_argument_count,
        .call_func = (GDExtensionScriptInstanceCall)extension_instance_dynamic_call,
        .notification_func = (GDExtensionClassNotification2)extension_instance_notification,
        .to_string_func = extension_instance_stringify,
        //.refcount_incremented_func = class_reference,
        //.refcount_decremented_func = class_unreference,
        .get_script_func = extension_script_get,
        .is_placeholder_func = extension_script_is_placeholder,
        .get_language_func = extension_script_get_language,
        .free_func = (GDExtensionScriptInstanceFree)gd_on_extension_instance_free,
    };
    return (uintptr_t)gdextension_script_instance_create3(&info, (GDExtensionScriptInstanceDataPtr)&instance);
};
void gd_object_script_call(uintptr_t obj, uintptr_t method, ANY result, INT argc, ANY args, ANY err) {
    void *points[16]; points[1] = 0; prepare_variants(&points[0], argc, args);
    gdextension_object_call_script_method((GDExtensionObjectPtr)obj, (GDExtensionConstStringNamePtr)&method, (const GDExtensionConstTypePtr*)&points[0], argc, (GDExtensionTypePtr)result, (GDExtensionCallError*)err);
};
void gd_object_script_setup(uintptr_t obj, uintptr_t instance) {
    gdextension_object_set_script_instance((GDExtensionScriptInstanceDataPtr)obj, (GDExtensionClassInstancePtr)instance);
};
uintptr_t gd_object_script_fetch(uintptr_t obj, uintptr_t language) {
    return (uintptr_t)gdextension_object_get_script_instance((GDExtensionScriptInstanceDataPtr)obj, (GDExtensionClassInstancePtr)language);
};
bool gd_object_script_defines_method(uintptr_t obj, uintptr_t method) {
    return gdextension_object_has_script_method((GDExtensionScriptInstanceDataPtr)obj, (GDExtensionConstStringNamePtr)&method);
};
uintptr_t gd_object_script_placeholder_create(uintptr_t language, uintptr_t script, uintptr_t owner) {
    return (uintptr_t)gdextension_placeholder_script_instance_create((GDExtensionScriptInstanceDataPtr)language, (GDExtensionObjectPtr)script, (GDExtensionObjectPtr)owner);
};
void gd_object_script_placeholder_update(uintptr_t p_placeholder, uintptr_t p_properties, uintptr_t p_values) {
    gdextension_placeholder_script_instance_update((GDExtensionScriptInstanceDataPtr)p_placeholder, (GDExtensionConstTypePtr)&p_properties, (GDExtensionConstTypePtr)&p_values);
};
uintptr_t gd_packed_byte_array_unsafe(UINT a1, UINT a2) {
    uintptr_t packed_array[2] = {a1, a2};
    // Const index: writable operator_index can COW and invalidate bulk reads.
    return (uintptr_t)gdextension_packed_byte_array_operator_index_const(&packed_array[0], 0);
};
uint8_t gd_packed_byte_array_access(UINT a1, UINT a2, INT i) {
    uintptr_t packed_array[2] = {a1, a2};
    return *(uint8_t *)gdextension_packed_byte_array_operator_index_const(&packed_array[0], i);
};
uintptr_t gd_packed_color_array_unsafe(UINT a1, UINT a2) {
    uintptr_t packed_array[2] = {a1, a2};
    return (uintptr_t)gdextension_packed_color_array_operator_index(&packed_array[0], 0);
};
void gd_packed_color_array_access(UINT a1, UINT a2, INT i, ANY result) {
    uintptr_t packed_array[2] = {a1, a2};
    const float *color = (float *)gdextension_packed_color_array_operator_index_const(&packed_array[0], i);
    memcpy((float*)result, color, sizeof(float)*4);
};
uintptr_t gd_packed_float32_array_unsafe(UINT a1, UINT a2) {
    uintptr_t packed_array[2] = {a1, a2};
    return (uintptr_t)gdextension_packed_float32_array_operator_index(&packed_array[0], 0);
};
float gd_packed_float32_array_access(UINT a1, UINT a2, INT i) {
    uintptr_t packed_array[2] = {a1, a2};
    return *(float *)gdextension_packed_float32_array_operator_index_const(&packed_array[0], i);
};
uintptr_t gd_packed_float64_array_unsafe(UINT a1, UINT a2) {
    uintptr_t packed_array[2] = {a1, a2};
    return (uintptr_t)gdextension_packed_float64_array_operator_index(&packed_array[0], 0);
};
double gd_packed_float64_array_access(UINT a1, UINT a2, INT i) {
    uintptr_t packed_array[2] = {a1, a2};
    return *(double *)gdextension_packed_float64_array_operator_index_const(&packed_array[0], i);
};
uintptr_t gd_packed_int32_array_unsafe(UINT a1, UINT a2) {
    uintptr_t packed_array[2] = {a1, a2};
    return (uintptr_t)gdextension_packed_int32_array_operator_index(&packed_array[0], 0);
};
int32_t gd_packed_int32_array_access(UINT a1, UINT a2, INT i) {
    uintptr_t packed_array[2] = {a1, a2};
    return *(int32_t *)gdextension_packed_int32_array_operator_index_const(&packed_array[0], i);
};
uintptr_t gd_packed_int64_array_unsafe(UINT a1, UINT a2) {
    uintptr_t packed_array[2] = {a1, a2};
    return (uintptr_t)gdextension_packed_int64_array_operator_index(&packed_array[0], 0);
};
void gd_packed_int64_array_access(UINT a1, UINT a2, INT i, ANY value) {
    uintptr_t packed_array[2] = {a1, a2};
    *(int64_t *)value = *(int64_t *)gdextension_packed_int64_array_operator_index_const(&packed_array[0], i);
};
uintptr_t gd_packed_string_array_unsafe(UINT a1, UINT a2) {
    uintptr_t packed_array[2] = {a1, a2};
    return (uintptr_t)gdextension_packed_string_array_operator_index(&packed_array[0], 0);
};
uintptr_t gd_packed_string_array_access(UINT a1, UINT a2, INT i) {
    uintptr_t packed_array[2] = {a1, a2};
    return *(uintptr_t*)gdextension_packed_string_array_operator_index_const(&packed_array[0], i);
};
void gd_array_set(uintptr_t a, INT i, UINT64(v1), UINT64(v2), UINT64(v3)) {
    uint64_t *variant = (uint64_t*)gdextension_array_operator_index(&a, i);
    variant[0] = UINT64_FROM(v1);
    variant[1] = UINT64_FROM(v2);
    variant[2] = UINT64_FROM(v3);
};
void gd_array_get(uintptr_t a, INT i, ANY result) {
    // operator_index_const returns a pointer into the array's storage.
    // Callers (Array.Index) must Variants.Copy before taking ownership.
    // TODO: switch to gdextension_variant_new_copy here and drop the Go-side
    // Copy once all export templates ship that change together.
    uint64_t *packed = (uint64_t*)gdextension_array_operator_index_const(&a, i);
    memcpy((uint64_t*)result, packed, sizeof(uint64_t)*3);
};
uintptr_t gd_packed_vector2_array_unsafe(UINT a1, UINT a2) {
    uintptr_t packed_array[2] = {a1, a2};
    return (uintptr_t)gdextension_packed_vector2_array_operator_index(&packed_array[0], 0);
};
void gd_packed_vector2_array_access(UINT a1, UINT a2, INT i, ANY result) {
    uintptr_t packed_array[2] = {a1, a2};
    const float *vector = (const float *)gdextension_packed_vector2_array_operator_index_const(&packed_array[0], i);
    memcpy((float*)result, vector, sizeof(float)*2);
};
uintptr_t gd_packed_vector3_array_unsafe(UINT a1, UINT a2) {
    uintptr_t packed_array[2] = {a1, a2};
    return (uintptr_t)gdextension_packed_vector3_array_operator_index(&packed_array[0], 0);
};
void gd_packed_vector3_array_access(UINT a1, UINT a2, INT i, ANY result) {
    uintptr_t packed_array[2] = {a1, a2};
    const float *vector = (const float *)gdextension_packed_vector3_array_operator_index_const(&packed_array[0], i);
    memcpy((float*)result, vector, sizeof(float)*3);
};
uintptr_t gd_packed_vector4_array_unsafe(UINT a1, UINT a2) {
    uintptr_t packed_array[2] = {a1, a2};
    return (uintptr_t)gdextension_packed_vector4_array_operator_index(&packed_array[0], 0);
};
void gd_packed_vector4_array_access(UINT a1, UINT a2, INT i, ANY result) {
    uintptr_t packed_array[2] = {a1, a2};
    const float *vector = (const float *)gdextension_packed_vector4_array_operator_index_const(&packed_array[0], i);
    memcpy((float *)result, vector, sizeof(float)*4);
};
uintptr_t gd_ref_get_object(uintptr_t ref) {
    return (uintptr_t)gdextension_ref_get_object((GDExtensionObjectPtr)ref);
};
void gd_ref_set_object(uintptr_t ref, uintptr_t obj) {
    gdextension_ref_set_object((GDExtensionObjectPtr)ref, (GDExtensionObjectPtr)obj);
};
int32_t gd_string_access(uintptr_t s, INT i) {
    return *(int32_t *)gdextension_string_operator_index_const((GDExtensionStringPtr)s, i);
};
uintptr_t gd_string_resize(uintptr_t s, INT size) {
    uintptr_t ptr = s;
    gdextension_string_resize((GDExtensionStringPtr)&ptr, size);
    return ptr;
};
uintptr_t gd_string_unsafe(uintptr_t s) {
    return (uintptr_t)gdextension_string_operator_index((GDExtensionStringPtr)s, 0);
};
uintptr_t gd_string_append(uintptr_t s, uintptr_t other) {
    uintptr_t ptr = s;
    gdextension_string_operator_plus_eq_string((GDExtensionStringPtr)&ptr, (GDExtensionConstStringPtr)&other);
    return ptr;
};
uintptr_t gd_string_append_rune(uintptr_t s, int32_t rune) {
    uintptr_t ptr = s;
    gdextension_string_operator_plus_eq_char((GDExtensionStringPtr)&ptr, rune);
    return ptr;
};
uintptr_t gd_string_decode_latin1(STRING s, INT len) {
    uintptr_t ptr = 0;
    gdextension_string_new_with_latin1_chars_and_len((GDExtensionUninitializedStringPtr)&ptr, STRING_POINTER(s), len);
    return ptr;
};
uintptr_t gd_string_decode_utf8(STRING s, INT len) {
    uintptr_t ptr = 0;
    gdextension_string_new_with_utf8_chars_and_len((GDExtensionUninitializedStringPtr)&ptr, STRING_POINTER(s), len);
    return ptr;
};
uintptr_t gd_string_decode_utf16(STRING s, INT len, bool le) {
    uintptr_t ptr = 0;
    gdextension_string_new_with_utf16_chars_and_len2((GDExtensionUninitializedStringPtr)&ptr, (const char16_t *)STRING_POINTER(s), len, le);
    return ptr;
};
uintptr_t gd_string_decode_utf32(STRING s, INT len) {
    uintptr_t ptr = 0;
    gdextension_string_new_with_utf32_chars_and_len((GDExtensionUninitializedStringPtr)&ptr, (const char32_t *)STRING_POINTER(s), len);
    return ptr;
};
uintptr_t gd_string_decode_wide(STRING s, INT len) {
    uintptr_t ptr = 0;
    gdextension_string_new_with_wide_chars_and_len((GDExtensionUninitializedStringPtr)&ptr, (const wchar_t *)STRING_POINTER(s), len);
    return ptr;
};
INT gd_string_encode_latin1(uintptr_t s, BUFFER addr, INT len) {
    return gdextension_string_to_latin1_chars((GDExtensionStringPtr)&s, BUFFER_POINTER(addr), len);
};
INT gd_string_encode_utf8(uintptr_t s, BUFFER addr, INT len) {
    return gdextension_string_to_utf8_chars((GDExtensionStringPtr)&s, BUFFER_POINTER(addr), len);
};
INT gd_string_encode_utf16(uintptr_t s, BUFFER addr, INT len) {
    return gdextension_string_to_utf16_chars((GDExtensionStringPtr)&s, (char16_t *)BUFFER_POINTER(addr), len/2);
};
INT gd_string_encode_utf32(uintptr_t s, BUFFER addr, INT len) {
    return gdextension_string_to_utf32_chars((GDExtensionStringPtr)&s, (char32_t *)BUFFER_POINTER(addr), len/4);
};
INT gd_string_encode_wide(uintptr_t s, BUFFER addr, INT len) {
    return gdextension_string_to_wide_chars((GDExtensionStringPtr)&s, (wchar_t *)BUFFER_POINTER(addr), len/sizeof(wchar_t));
};
uintptr_t gd_string_intern_latin1(STRING s, INT len) {
    char buf[256]; const char *s_ptr = fit_string(STRING_POINTER(s), len, &buf[0], 256);
    uintptr_t ptr = 0;
    gdextension_string_name_new_with_latin1_chars((GDExtensionUninitializedStringNamePtr)&ptr, s_ptr, false);
    if (s_ptr != &buf[0]) gdextension_mem_free((void *)s_ptr); // Free the buffer if it was allocated
    return ptr;
};
uintptr_t gd_string_intern_utf8(STRING s, INT len) {
    uintptr_t ptr = 0;
    gdextension_string_name_new_with_utf8_chars_and_len((GDExtensionUninitializedStringNamePtr)&ptr, STRING_POINTER(s), len);
    return ptr;
};
uintptr_t gd_variant_type_name(uint32_t vtype) {
    uintptr_t name = 0;
    gdextension_variant_get_type_name((GDExtensionVariantType)vtype, &name);
    return name;
};
void gd_variant_unsafe_make_native(uint32_t vtype, UINT64(v1), UINT64(v2), UINT64(v3), UINT64(shape), ANY args) {
    void *points[16]; prepare_callframe(1, &points[0], UINT64_FROM(shape), args);
    uint64_t self[4] = {UINT64_FROM(v1), UINT64_FROM(v2), UINT64_FROM(v3)};
    type_from_variant_constructors[vtype](points[0], &self[0]);
};
void gd_variant_unsafe_from_native(uint32_t vtype, ANY result, UINT64(shape), ANY args) {
    void *points[16]; prepare_callframe(1, &points[0], UINT64_FROM(shape), args);
    variant_from_type_constructors[vtype]((GDExtensionUninitializedVariantPtr)result, points[0]);
};
void gd_variant_type_call(uint32_t vtype, uintptr_t name, ANY result, INT argc, ANY args, ANY err) {
    void *points[16]; prepare_variants(&points[0], argc, args);
    gdextension_variant_call_static((GDExtensionVariantType)vtype, (GDExtensionConstStringNamePtr)&name, (const GDExtensionConstTypePtr*)&points[0], argc, (GDExtensionTypePtr)result, (GDExtensionCallError*)err);
};
bool gd_variant_type_convertable(uint32_t a, uint32_t b, bool strict) {
    if (strict) {
        return gdextension_variant_can_convert_strict((GDExtensionVariantType)a, (GDExtensionVariantType)b);
    } else {
        return gdextension_variant_can_convert((GDExtensionVariantType)a, (GDExtensionVariantType)b);
    }
};
void gd_variant_type_setup_array(uintptr_t array, uint32_t vtype, uintptr_t class_name, UINT64(s1), UINT64(s2), UINT64(s3)) {
    uint64_t script[3] = {UINT64_FROM(s1), UINT64_FROM(s2), UINT64_FROM(s3)};
    gdextension_array_set_typed(&array, (GDExtensionVariantType)vtype, &class_name, &script[0]);
};
void gd_variant_type_setup_dictionary(uintptr_t dict, uint32_t ktype, uintptr_t kclass_name, UINT64(ks1), UINT64(ks2), UINT64(ks3), uint32_t vtype, uintptr_t vclass_name, UINT64(vs1), UINT64(vs2), UINT64(vs3)) {
    uint64_t k_script[3] = {UINT64_FROM(ks1), UINT64_FROM(ks2), UINT64_FROM(ks3)};
    uint64_t v_script[3] = {UINT64_FROM(vs1), UINT64_FROM(vs2), UINT64_FROM(vs3)};
    gdextension_dictionary_set_typed(&dict, (GDExtensionVariantType)ktype, &kclass_name, &k_script[0], (GDExtensionVariantType)vtype, &vclass_name, &v_script[0]);
};
void gd_variant_type_fetch_constant(uint32_t vtype, uintptr_t name, ANY result) {
    void *points[16]; prepare_variants(&points[0], 1, result);
    gdextension_variant_get_constant_value((GDExtensionVariantType)vtype, (GDExtensionConstStringNamePtr)&name, (GDExtensionTypePtr)points[0]);
};
uintptr_t gd_variant_type_builtin_method(uint32_t vtype, uintptr_t name, INT64(hash)) {
    return (uintptr_t)gdextension_variant_get_ptr_builtin_method((GDExtensionVariantType)vtype, (GDExtensionConstStringNamePtr)&name, INT64_FROM(hash));
};
uintptr_t gd_variant_type_unsafe_constructor(uint32_t vtype, INT n) {
    return (uintptr_t)gdextension_variant_get_ptr_constructor((GDExtensionVariantType)vtype, n);
};
void gd_variant_type_unsafe_free(uint32_t vtype, UINT64(shape), ANY args) {
    void *points[16]; prepare_callframe(1, &points[0], UINT64_FROM(shape), args);
    variant_ptr_destructors[vtype](points[0]);
};
void gd_variant_zero(ANY result) {
    gdextension_variant_new_nil((GDExtensionUninitializedVariantPtr)result);
};
void gd_variant_copy(UINT64(v1), UINT64(v2), UINT64(v3), ANY result) {
    uint64_t self[3] = {UINT64_FROM(v1), UINT64_FROM(v2), UINT64_FROM(v3)};
    gdextension_variant_new_copy((GDExtensionUninitializedVariantPtr)result, &self);
};
void gd_variant_call(UINT64(v1), UINT64(v2), UINT64(v3), uintptr_t name, ANY result, INT argc, ANY args, ANY err) {
    uint64_t self[3] = {UINT64_FROM(v1), UINT64_FROM(v2), UINT64_FROM(v3)};
    void *points[16]; prepare_variants(&points[0], argc, args);
    gdextension_variant_call(&self, (GDExtensionConstStringNamePtr)&name, (const GDExtensionConstTypePtr*)&points[0], argc, (GDExtensionTypePtr)result, (GDExtensionCallError*)err);
};
bool gd_variant_eval(uint32_t op, UINT64(a1), UINT64(a2), UINT64(a3), UINT64(b1), UINT64(b2), UINT64(b3), ANY result) {
    uint64_t a[3] = {UINT64_FROM(a1), UINT64_FROM(a2), UINT64_FROM(a3)};
    uint64_t b[3] = {UINT64_FROM(b1), UINT64_FROM(b2), UINT64_FROM(b3)};
    GDExtensionBool valid = false;
    gdextension_variant_evaluate((GDExtensionVariantOperator)op, &a[0], &b[0], (GDExtensionUninitializedVariantPtr)result, &valid);
    return valid;
};
void gd_variant_hash(UINT64(v1), UINT64(v2), UINT64(v3), ANY hash) {
    uint64_t self[3] = {UINT64_FROM(v1), UINT64_FROM(v2), UINT64_FROM(v3)};
    *(int64_t*)hash = gdextension_variant_hash(&self);
};
bool gd_variant_bool(UINT64(v1), UINT64(v2), UINT64(v3)) {
    uint64_t self[3] = {UINT64_FROM(v1), UINT64_FROM(v2), UINT64_FROM(v3)};
    return gdextension_variant_booleanize(&self);
};
uintptr_t gd_variant_text(UINT64(v1), UINT64(v2), UINT64(v3)) {
    uint64_t self[3] = {UINT64_FROM(v1), UINT64_FROM(v2), UINT64_FROM(v3)};
    uintptr_t text = 0;
    gdextension_variant_stringify(&self, &text);
    return text;
};
uint32_t gd_variant_type(UINT64(v1), UINT64(v2), UINT64(v3)) {
    uint64_t self[3] = {UINT64_FROM(v1), UINT64_FROM(v2), UINT64_FROM(v3)};
    return gdextension_variant_get_type(&self);
};
void gd_variant_deep_copy(UINT64(v1), UINT64(v2), UINT64(v3), ANY result) {
    uint64_t self[3] = {UINT64_FROM(v1), UINT64_FROM(v2), UINT64_FROM(v3)};
    gdextension_variant_duplicate(&self, (GDExtensionVariantPtr)result, true);
};
void gd_variant_deep_hash(UINT64(v1), UINT64(v2), UINT64(v3), INT recursion, ANY hash) {
    uint64_t self[3] = {UINT64_FROM(v1), UINT64_FROM(v2), UINT64_FROM(v3)};
    *(int64_t*)hash = gdextension_variant_recursive_hash(&self, recursion);
};
bool gd_variant_get_index(UINT64(v1), UINT64(v2), UINT64(v3), UINT64(i1), UINT64(i2), UINT64(i3), ANY result) {
    uint64_t self[3] = {UINT64_FROM(v1), UINT64_FROM(v2), UINT64_FROM(v3)};
    uint64_t index[3] = {UINT64_FROM(i1), UINT64_FROM(i2), UINT64_FROM(i3)};
    GDExtensionBool valid = false;
    gdextension_variant_get_keyed(&self, &index[0], (GDExtensionUninitializedVariantPtr)result, &valid);
    return valid;
};
bool gd_variant_get_array(UINT64(v1), UINT64(v2), UINT64(v3), INT i, ANY result, ANY err) {
    uint64_t self[3] = {UINT64_FROM(v1), UINT64_FROM(v2), UINT64_FROM(v3)};
    GDExtensionBool valid = false;
    GDExtensionBool oob = false;
    gdextension_variant_get_indexed(&self, i, (GDExtensionUninitializedVariantPtr)result, &valid, &oob);
    if (oob) ((GDExtensionCallError*)err)->error = GDEXTENSION_CALL_ERROR_INVALID_ARGUMENT;
    return valid;
};
bool gd_variant_get_field(UINT64(v1), UINT64(v2), UINT64(v3), uintptr_t name, ANY result) {
    uint64_t self[3] = {UINT64_FROM(v1), UINT64_FROM(v2), UINT64_FROM(v3)};
    GDExtensionBool valid = false;
    gdextension_variant_get_named(&self, (GDExtensionConstStringNamePtr)&name, (GDExtensionUninitializedVariantPtr)result, &valid);
    return valid;
};
bool gd_variant_type_has_property(uint32_t vtype, uintptr_t name) {
    return gdextension_variant_has_member((GDExtensionVariantType)vtype, (GDExtensionConstStringNamePtr)&name);
};
bool gd_variant_has_index(UINT64(v1), UINT64(v2), UINT64(v3), UINT64(i1), UINT64(i2), UINT64(i3)) {
    uint64_t self[3] = {UINT64_FROM(v1), UINT64_FROM(v2), UINT64_FROM(v3)};
    uint64_t index[3] = {UINT64_FROM(i1), UINT64_FROM(i2), UINT64_FROM(i3)};
    GDExtensionBool valid = false;
    gdextension_variant_has_key(&self, &index[0], &valid);
    return valid;
};
bool gd_variant_has_method(UINT64(v1), UINT64(v2), UINT64(v3), uintptr_t name) {
    uint64_t self[3] = {UINT64_FROM(v1), UINT64_FROM(v2), UINT64_FROM(v3)};
    return gdextension_variant_has_method(&self, (GDExtensionConstStringNamePtr)&name);
};
bool gd_variant_set_index(UINT64(v1), UINT64(v2), UINT64(v3), UINT64(i1), UINT64(i2), UINT64(i3), UINT64(v1_set), UINT64(v2_set), UINT64(v3_set)) {
    uint64_t self[3] = {UINT64_FROM(v1), UINT64_FROM(v2), UINT64_FROM(v3)};
    uint64_t index[3] = {UINT64_FROM(i1), UINT64_FROM(i2), UINT64_FROM(i3)};
    uint64_t value[3] = {UINT64_FROM(v1_set), UINT64_FROM(v2_set), UINT64_FROM(v3_set)};
    GDExtensionBool valid = false;
    gdextension_variant_set_keyed(&self, &index[0], &value[0], &valid);
    return valid;
};
bool gd_variant_set_array(UINT64(v1), UINT64(v2), UINT64(v3), INT i, UINT64(v1_set), UINT64(v2_set), UINT64(v3_set), ANY err) {
    uint64_t self[3] = {UINT64_FROM(v1), UINT64_FROM(v2), UINT64_FROM(v3)};
    uint64_t value[3] = {UINT64_FROM(v1_set), UINT64_FROM(v2_set), UINT64_FROM(v3_set)};
    GDExtensionBool valid = false;
    GDExtensionBool oob = false;
    gdextension_variant_set_indexed(&self, i, &value[0], &valid, &oob);
    if (oob) ((GDExtensionCallError*)err)->error = GDEXTENSION_CALL_ERROR_INVALID_ARGUMENT;
    return valid;
};
bool gd_variant_set_field(UINT64(v1), UINT64(v2), UINT64(v3), uintptr_t name, UINT64(v1_set), UINT64(v2_set), UINT64(v3_set)) {
    uint64_t self[3] = {UINT64_FROM(v1), UINT64_FROM(v2), UINT64_FROM(v3)};
    uint64_t value[3] = {UINT64_FROM(v1_set), UINT64_FROM(v2_set), UINT64_FROM(v3_set)};
    GDExtensionBool valid = false;
    gdextension_variant_set_named(&self, (GDExtensionConstStringNamePtr)&name, &value[0], &valid);
    return valid;
};
void gd_variant_unsafe_eval(uintptr_t fn, ANY result, UINT64(shape), ANY args) {
    void *points[16]; prepare_callframe(1, &points[0], UINT64_FROM(shape), args);
    ((GDExtensionPtrOperatorEvaluator)fn)(points[0], points[1], (GDExtensionTypePtr)result);
};
void gd_variant_unsafe_call(uintptr_t fn, ANY result, UINT64(shape), ANY args) {
    void *points[16]; uint8_t argc = prepare_callframe(1, &points[0], UINT64_FROM(shape), args);
    ((GDExtensionPtrBuiltInMethod)fn)((GDExtensionTypePtr*)points[0], (const GDExtensionConstTypePtr*)&points[1], (GDExtensionTypePtr)result, argc);
};
void gd_variant_unsafe_free(UINT64(v1), UINT64(v2), UINT64(v3)) {
    uint64_t self[3] = {UINT64_FROM(v1), UINT64_FROM(v2), UINT64_FROM(v3)};
    gdextension_variant_destroy(&self);
};
uintptr_t gd_variant_unsafe_internal_pointer(uint32_t vtype, UINT64(v1), UINT64(v2), UINT64(v3)) {
    uint64_t self[3] = {UINT64_FROM(v1), UINT64_FROM(v2), UINT64_FROM(v3)};
    return (uintptr_t)variant_internal_ptr_funcs[vtype](&self);
};
void gd_variant_unsafe_get_field(uintptr_t getter, ANY result, UINT64(shape), ANY args) {
    void *points[16]; prepare_callframe(1, &points[0], UINT64_FROM(shape), args);
    ((GDExtensionPtrGetter)getter)(points[0], &result);
};
void gd_variant_unsafe_get_array(uint32_t vtype, INT i, ANY result, UINT64(shape), ANY args) {
    void *points[16]; prepare_callframe(1, &points[0], UINT64_FROM(shape), args);
    variant_ptr_indexed_getters[vtype]((GDExtensionConstTypePtr)result, i, points[0]);
};
void gd_variant_unsafe_get_index(uint32_t vtype, ANY result, UINT64(shape), ANY args) {
    void *points[16]; prepare_callframe(1, &points[0], UINT64_FROM(shape), args);
    variant_ptr_keyed_getters[vtype](points[0], points[1], (GDExtensionTypePtr)result);
};
void gd_variant_unsafe_set_field(uintptr_t setter, UINT64(shape), ANY args) {
    void *points[16]; prepare_callframe(1, &points[0], UINT64_FROM(shape), args);
    ((GDExtensionPtrSetter)setter)(points[1], points[2]);
};
void gd_variant_unsafe_set_array(uint32_t vtype, INT i, UINT64(shape), ANY args) {
    void *points[16]; prepare_callframe(1, &points[0], UINT64_FROM(shape), args);
    variant_ptr_indexed_setters[vtype](points[0], i, points[1]);
};
void gd_variant_unsafe_set_index(uint32_t vtype, UINT64(shape), ANY args) {
    void *points[16]; prepare_callframe(1, &points[0], UINT64_FROM(shape), args);
    variant_ptr_keyed_setters[vtype](points[0], points[1], points[2]);
};
uintptr_t gd_variant_type_setter(uint32_t vtype, uintptr_t name) {
    return (uintptr_t)gdextension_variant_get_ptr_setter((GDExtensionVariantType)vtype, (GDExtensionConstStringNamePtr)&name);
}
uintptr_t gd_variant_type_getter(uint32_t vtype, uintptr_t name) {
    return (uintptr_t)gdextension_variant_get_ptr_getter((GDExtensionVariantType)vtype, (GDExtensionConstStringNamePtr)&name);
}
void gd_variant_type_unsafe_make(uintptr_t fn, ANY result, UINT64(shape), ANY args) {
    void *points[16]; prepare_callframe(1, &points[0], UINT64_FROM(shape), args);
    ((GDExtensionPtrConstructor)fn)((GDExtensionUninitializedTypePtr)result, (const GDExtensionConstTypePtr *)&points[0]);
}
void gd_variant_type_make(uint32_t vtype, ANY result, INT argc, ANY args, ANY err) {
    void *points[16]; prepare_variants(&points[0], argc, args);
    gdextension_variant_construct((GDExtensionVariantType)vtype, (GDExtensionUninitializedVariantPtr)result, (const GDExtensionConstVariantPtr *)&points[0], argc, (GDExtensionCallError*)err);
}
void gd_variant_type_unsafe_call(ANY self, uintptr_t fn, ANY result, UINT64(shape), ANY args) {
    void *points[16]; uint8_t argc = prepare_callframe(2, &points[0], UINT64_FROM(shape), args);
    ((GDExtensionPtrBuiltInMethod)fn)((GDExtensionTypePtr*)self, (const GDExtensionConstTypePtr*)&points[0], (GDExtensionTypePtr)result, argc);
}
uintptr_t gd_variant_type_evaluator(uint32_t op, uint32_t a, uint32_t b) {
    return (uintptr_t)gdextension_variant_get_ptr_operator_evaluator((GDExtensionVariantOperator)op, (GDExtensionVariantType)a, (GDExtensionVariantType)b);
}

uint32_t gd_version_major() {return gd_godot_version_cached.major;};
uint32_t gd_version_minor() {return gd_godot_version_cached.minor;};
uint32_t gd_version_patch() {return gd_godot_version_cached.patch;};
uint32_t gd_version_hex() {return gd_godot_version_cached.hex;};
uintptr_t gd_version_status() {
    uintptr_t s;
    gdextension_string_new_with_latin1_chars(&s, gd_godot_version_cached.status);
    return s;
};
uintptr_t gd_version_build() {
    uintptr_t s;
    gdextension_string_new_with_latin1_chars(&s, gd_godot_version_cached.build);
    return s;
};
uintptr_t gd_version_hash() {
    uintptr_t s;
    gdextension_string_new_with_latin1_chars(&s, gd_godot_version_cached.hash);
    return s;
};
void gd_version_timestamp(ANY time) {
    *(uint64_t*)time = gd_godot_version_cached.timestamp;
};
uintptr_t gd_version_string() {
    uintptr_t s;
    gdextension_string_new_with_latin1_chars(&s, gd_godot_version_cached.string);
    return s;
};

#ifdef __EMSCRIPTEN__

// Raw WASM exports for direct WASM-to-WASM calls (bypassing embind JS trampolines).
// These use native types (real uint64_t instead of split uint32 pairs).
#include <emscripten/emscripten.h>
extern "C" {
    EMSCRIPTEN_KEEPALIVE uint32_t wasm_gd_memory_malloc(uint32_t size) { return (uint32_t)gdextension_mem_alloc(size); }
    EMSCRIPTEN_KEEPALIVE uint32_t wasm_gd_memory_resize(uint32_t addr, uint32_t size) { return (uint32_t)gdextension_mem_realloc((void *)(uintptr_t)addr, size); }
    EMSCRIPTEN_KEEPALIVE void wasm_gd_memory_clear(uint32_t addr, uint32_t size) { if (size <= 0) return; memset((void *)(uintptr_t)addr, 0, size); }
    EMSCRIPTEN_KEEPALIVE void wasm_gd_memory_free(uint32_t addr) { gdextension_mem_free((void *)(uintptr_t)addr); }
    EMSCRIPTEN_KEEPALIVE uint32_t wasm_gd_memory_load_byte(uint32_t addr) { return *(uint8_t *)(uintptr_t)addr; }
    EMSCRIPTEN_KEEPALIVE uint32_t wasm_gd_memory_load_u16(uint32_t addr) { return *(uint16_t *)(uintptr_t)addr; }
    EMSCRIPTEN_KEEPALIVE uint32_t wasm_gd_memory_load_u32(uint32_t addr) { return *(uint32_t *)(uintptr_t)addr; }
    EMSCRIPTEN_KEEPALIVE void wasm_gd_memory_edit_byte(uint32_t addr, uint32_t b) { *(uint8_t *)(uintptr_t)addr = (uint8_t)b; }
    EMSCRIPTEN_KEEPALIVE void wasm_gd_memory_edit_u16(uint32_t addr, uint32_t b) { *(uint16_t *)(uintptr_t)addr = (uint16_t)b; }
    EMSCRIPTEN_KEEPALIVE void wasm_gd_memory_edit_u32(uint32_t addr, uint32_t b) { *(uint32_t *)(uintptr_t)addr = b; }
    EMSCRIPTEN_KEEPALIVE void wasm_gd_memory_edit_u64(uint32_t addr, uint32_t b_hi, uint32_t b_lo) {
        *(uint64_t *)(uintptr_t)addr = ((uint64_t)b_hi << 32) | (uint64_t)b_lo;
    }
    EMSCRIPTEN_KEEPALIVE void wasm_gd_memory_edit_128(uint32_t addr, uint32_t a_hi, uint32_t a_lo, uint32_t b_hi, uint32_t b_lo) {
        uint64_t *ptr = (uint64_t *)(uintptr_t)addr;
        ptr[0] = ((uint64_t)a_hi << 32) | (uint64_t)a_lo;
        ptr[1] = ((uint64_t)b_hi << 32) | (uint64_t)b_lo;
    }
    EMSCRIPTEN_KEEPALIVE void wasm_gd_memory_edit_256(uint32_t addr,
        uint32_t a_hi, uint32_t a_lo, uint32_t b_hi, uint32_t b_lo,
        uint32_t c_hi, uint32_t c_lo, uint32_t d_hi, uint32_t d_lo) {
        uint64_t *ptr = (uint64_t *)(uintptr_t)addr;
        ptr[0] = ((uint64_t)a_hi << 32) | (uint64_t)a_lo;
        ptr[1] = ((uint64_t)b_hi << 32) | (uint64_t)b_lo;
        ptr[2] = ((uint64_t)c_hi << 32) | (uint64_t)c_lo;
        ptr[3] = ((uint64_t)d_hi << 32) | (uint64_t)d_lo;
    }
    EMSCRIPTEN_KEEPALIVE void wasm_gd_memory_edit_512(uint32_t addr,
        uint32_t a_hi, uint32_t a_lo, uint32_t b_hi, uint32_t b_lo,
        uint32_t c_hi, uint32_t c_lo, uint32_t d_hi, uint32_t d_lo,
        uint32_t e_hi, uint32_t e_lo, uint32_t f_hi, uint32_t f_lo,
        uint32_t g_hi, uint32_t g_lo, uint32_t h_hi, uint32_t h_lo) {
        uint64_t *ptr = (uint64_t *)(uintptr_t)addr;
        ptr[0] = ((uint64_t)a_hi << 32) | (uint64_t)a_lo;
        ptr[1] = ((uint64_t)b_hi << 32) | (uint64_t)b_lo;
        ptr[2] = ((uint64_t)c_hi << 32) | (uint64_t)c_lo;
        ptr[3] = ((uint64_t)d_hi << 32) | (uint64_t)d_lo;
        ptr[4] = ((uint64_t)e_hi << 32) | (uint64_t)e_lo;
        ptr[5] = ((uint64_t)f_hi << 32) | (uint64_t)f_lo;
        ptr[6] = ((uint64_t)g_hi << 32) | (uint64_t)g_lo;
        ptr[7] = ((uint64_t)h_hi << 32) | (uint64_t)h_lo;
    }
    EMSCRIPTEN_KEEPALIVE void wasm_gd_object_unsafe_call(uint32_t obj, uint32_t method, uint32_t result, uint32_t shape_hi, uint32_t shape_lo, uint32_t args) {
        uint64_t shape = ((uint64_t)shape_hi << 32) | (uint64_t)shape_lo;
        void *points[16]; prepare_callframe(1, &points[0], shape, args);
        gdextension_object_method_bind_ptrcall((GDExtensionMethodBindPtr)(uintptr_t)method, (GDExtensionObjectPtr)(uintptr_t)obj, (const GDExtensionConstTypePtr*)&points[0], (GDExtensionTypePtr)(uintptr_t)result);
    }
    // WASM uses 8-byte uintptr: Object(0,8) Method(8,8) Shape(16,8) Args(24,256)
    EMSCRIPTEN_KEEPALIVE void wasm_gd_ring_flush(uint32_t ring_base, uint32_t entry_stride, uint32_t tail, uint32_t head) {
        for (uint32_t i = tail; i != head; i++) {
            uint8_t *entry = (uint8_t *)(uintptr_t)(ring_base + (i & 0xFF) * entry_stride);
            uint32_t object = *(uint32_t *)(entry + 0);
            uint32_t method = *(uint32_t *)(entry + 8);
            uint64_t shape = *(uint64_t *)(entry + 16);
            uint32_t args = (uint32_t)(uintptr_t)(entry + 24);
            void *points[16];
            prepare_callframe(1, &points[0], shape, args);
            gdextension_object_method_bind_ptrcall(
                (GDExtensionMethodBindPtr)(uintptr_t)method,
                (GDExtensionObjectPtr)(uintptr_t)object,
                (const GDExtensionConstTypePtr*)&points[0],
                NULL);
        }
    }
}

// Generated raw exports for the rest of the gd_* surface, so the Go module's
// //go:wasmimport bindings resolve directly instead of via syscall/js+embind.
#include "gd_web_exports.h"

using namespace emscripten;
EMSCRIPTEN_BINDINGS(my_module) {
	function("gd_builtin_name", &gd_builtin_name, allow_raw_pointers());
	function("gd_builtin_call", &gd_builtin_call, allow_raw_pointers());
	function("gd_callable_create", &gd_callable_create, allow_raw_pointers());
	function("gd_callable_lookup", &gd_callable_lookup, allow_raw_pointers());
	function("gd_classdb_FileAccess_write", &gd_classdb_FileAccess_write, allow_raw_pointers());
	function("gd_classdb_FileAccess_read", &gd_classdb_FileAccess_read, allow_raw_pointers());
	function("gd_classdb_Image_unsafe", &gd_classdb_Image_unsafe, allow_raw_pointers());
	function("gd_classdb_Image_access", &gd_classdb_Image_access, allow_raw_pointers());
	function("gd_method_list_make", &gd_method_list_make, allow_raw_pointers());
	function("gd_method_list_push", &gd_method_list_push, allow_raw_pointers());
	function("gd_method_list_free", &gd_method_list_free, allow_raw_pointers());
	function("gd_property_list_make", &gd_property_list_make, allow_raw_pointers());
	function("gd_property_list_push", &gd_property_list_push, allow_raw_pointers());
	function("gd_property_list_free", &gd_property_list_free, allow_raw_pointers());
	function("gd_property_info_type", &gd_property_info_type, allow_raw_pointers());
	function("gd_property_info_name", &gd_property_info_name, allow_raw_pointers());
	function("gd_property_info_class_name", &gd_property_info_class_name, allow_raw_pointers());
	function("gd_property_info_hint", &gd_property_info_hint, allow_raw_pointers());
	function("gd_property_info_hint_string", &gd_property_info_hint_string, allow_raw_pointers());
	function("gd_property_info_usage", &gd_property_info_usage, allow_raw_pointers());
	function("gd_classdb_register", &gd_classdb_register, allow_raw_pointers());
	function("gd_classdb_register_methods", &gd_classdb_register_methods, allow_raw_pointers());
	function("gd_classdb_register_constant", &gd_classdb_register_constant, allow_raw_pointers());
	function("gd_classdb_register_property", &gd_classdb_register_property, allow_raw_pointers());
	function("gd_classdb_register_property_indexed", &gd_classdb_register_property_indexed, allow_raw_pointers());
	function("gd_classdb_register_property_group", &gd_classdb_register_property_group, allow_raw_pointers());
	function("gd_classdb_register_property_sub_group", &gd_classdb_register_property_sub_group, allow_raw_pointers());
	function("gd_classdb_register_signal", &gd_classdb_register_signal, allow_raw_pointers());
	function("gd_classdb_register_removal", &gd_classdb_register_removal, allow_raw_pointers());
	function("gd_classdb_WorkerThreadPool_add_task", &gd_classdb_WorkerThreadPool_add_task, allow_raw_pointers());
	function("gd_classdb_WorkerThreadPool_add_group_task", &gd_classdb_WorkerThreadPool_add_group_task, allow_raw_pointers());
	function("gd_classdb_XMLParser_load", &gd_classdb_XMLParser_load, allow_raw_pointers());
	function("gd_packed_dictionary_access", &gd_packed_dictionary_access, allow_raw_pointers());
	function("gd_packed_dictionary_modify", &gd_packed_dictionary_modify, allow_raw_pointers());
	function("gd_editor_add_documentation", &gd_editor_add_documentation, allow_raw_pointers());
	function("gd_editor_add_plugin", &gd_editor_add_plugin, allow_raw_pointers());
	function("gd_editor_end_plugin", &gd_editor_end_plugin, allow_raw_pointers());
	function("gd_iterator_make", &gd_iterator_make, allow_raw_pointers());
	function("gd_iterator_next", &gd_iterator_next, allow_raw_pointers());
	function("gd_iterator_load", &gd_iterator_load, allow_raw_pointers());
	function("gd_log_error", &gd_log_error, allow_raw_pointers());
	function("gd_log_warning", &gd_log_warning, allow_raw_pointers());
	function("gd_memory_malloc", &gd_memory_malloc, allow_raw_pointers());
	function("gd_memory_sizeof", &gd_memory_sizeof, allow_raw_pointers());
	function("gd_memory_clear", &gd_memory_clear, allow_raw_pointers());
	function("gd_memory_resize", &gd_memory_resize, allow_raw_pointers());
	function("gd_memory_free", &gd_memory_free, allow_raw_pointers());
	function("gd_memory_edit_byte", &gd_memory_edit_byte, allow_raw_pointers());
	function("gd_memory_edit_u16", &gd_memory_edit_u16, allow_raw_pointers());
	function("gd_memory_edit_u32", &gd_memory_edit_u32, allow_raw_pointers());
	function("gd_memory_edit_u64", &gd_memory_edit_u64, allow_raw_pointers());
	function("gd_memory_edit_128", &gd_memory_edit_128, allow_raw_pointers());
	function("gd_memory_edit_256", &gd_memory_edit_256, allow_raw_pointers());
	function("gd_memory_edit_512", &gd_memory_edit_512, allow_raw_pointers());
	function("gd_memory_load_byte", &gd_memory_load_byte, allow_raw_pointers());
	function("gd_memory_load_u16", &gd_memory_load_u16, allow_raw_pointers());
	function("gd_memory_load_u32", &gd_memory_load_u32, allow_raw_pointers());
	function("gd_object_make", &gd_object_make, allow_raw_pointers());
	function("gd_object_call", &gd_object_call, allow_raw_pointers());
	function("gd_object_name", &gd_object_name, allow_raw_pointers());
	function("gd_object_type", &gd_object_type, allow_raw_pointers());
	function("gd_object_cast", &gd_object_cast, allow_raw_pointers());
	function("gd_object_lookup", &gd_object_lookup, allow_raw_pointers());
	function("gd_object_global", &gd_object_global, allow_raw_pointers());
	function("gd_object_extension_setup", &gd_object_extension_setup, allow_raw_pointers());
	function("gd_object_extension_fetch", &gd_object_extension_fetch, allow_raw_pointers());
	function("gd_object_extension_close", &gd_object_extension_close, allow_raw_pointers());
	function("gd_object_id", &gd_object_id, allow_raw_pointers());
	function("gd_object_id_inside_variant", &gd_object_id_inside_variant, allow_raw_pointers());
	function("gd_object_method_lookup", &gd_object_method_lookup, allow_raw_pointers());
	function("gd_object_script_make", &gd_object_script_make, allow_raw_pointers());
	function("gd_object_script_call", &gd_object_script_call, allow_raw_pointers());
	function("gd_object_script_setup", &gd_object_script_setup, allow_raw_pointers());
	function("gd_object_script_fetch", &gd_object_script_fetch, allow_raw_pointers());
	function("gd_object_script_defines_method", &gd_object_script_defines_method, allow_raw_pointers());
	function("gd_object_script_property_state_add", &gd_object_script_property_state_add, allow_raw_pointers());
	function("gd_object_script_placeholder_create", &gd_object_script_placeholder_create, allow_raw_pointers());
	function("gd_object_script_placeholder_update", &gd_object_script_placeholder_update, allow_raw_pointers());
	function("gd_object_unsafe_call", &gd_object_unsafe_call, allow_raw_pointers());
	function("gd_object_unsafe_free", &gd_object_unsafe_free, allow_raw_pointers());
	function("gd_packed_byte_array_unsafe", &gd_packed_byte_array_unsafe, allow_raw_pointers());
	function("gd_packed_byte_array_access", &gd_packed_byte_array_access, allow_raw_pointers());
	function("gd_packed_color_array_unsafe", &gd_packed_color_array_unsafe, allow_raw_pointers());
	function("gd_packed_color_array_access", &gd_packed_color_array_access, allow_raw_pointers());
	function("gd_packed_float32_array_unsafe", &gd_packed_float32_array_unsafe, allow_raw_pointers());
	function("gd_packed_float32_array_access", &gd_packed_float32_array_access, allow_raw_pointers());
	function("gd_packed_float64_array_unsafe", &gd_packed_float64_array_unsafe, allow_raw_pointers());
	function("gd_packed_float64_array_access", &gd_packed_float64_array_access, allow_raw_pointers());
	function("gd_packed_int32_array_unsafe", &gd_packed_int32_array_unsafe, allow_raw_pointers());
	function("gd_packed_int32_array_access", &gd_packed_int32_array_access, allow_raw_pointers());
	function("gd_packed_int64_array_unsafe", &gd_packed_int64_array_unsafe, allow_raw_pointers());
	function("gd_packed_int64_array_access", &gd_packed_int64_array_access, allow_raw_pointers());
	function("gd_packed_string_array_unsafe", &gd_packed_string_array_unsafe, allow_raw_pointers());
	function("gd_packed_string_array_access", &gd_packed_string_array_access, allow_raw_pointers());
	function("gd_array_set", &gd_array_set, allow_raw_pointers());
	function("gd_array_get", &gd_array_get, allow_raw_pointers());
	function("gd_packed_vector2_array_unsafe", &gd_packed_vector2_array_unsafe, allow_raw_pointers());
	function("gd_packed_vector2_array_access", &gd_packed_vector2_array_access, allow_raw_pointers());
	function("gd_packed_vector3_array_unsafe", &gd_packed_vector3_array_unsafe, allow_raw_pointers());
	function("gd_packed_vector3_array_access", &gd_packed_vector3_array_access, allow_raw_pointers());
	function("gd_packed_vector4_array_unsafe", &gd_packed_vector4_array_unsafe, allow_raw_pointers());
	function("gd_packed_vector4_array_access", &gd_packed_vector4_array_access, allow_raw_pointers());
	function("gd_ref_get_object", &gd_ref_get_object, allow_raw_pointers());
	function("gd_ref_set_object", &gd_ref_set_object, allow_raw_pointers());
	function("gd_string_access", &gd_string_access, allow_raw_pointers());
	function("gd_string_resize", &gd_string_resize, allow_raw_pointers());
	function("gd_string_unsafe", &gd_string_unsafe, allow_raw_pointers());
	function("gd_string_append", &gd_string_append, allow_raw_pointers());
	function("gd_string_append_rune", &gd_string_append_rune, allow_raw_pointers());
	function("gd_string_decode_latin1", &gd_string_decode_latin1, allow_raw_pointers());
	function("gd_string_decode_utf8", &gd_string_decode_utf8, allow_raw_pointers());
	function("gd_string_decode_utf16", &gd_string_decode_utf16, allow_raw_pointers());
	function("gd_string_decode_utf32", &gd_string_decode_utf32, allow_raw_pointers());
	function("gd_string_decode_wide", &gd_string_decode_wide, allow_raw_pointers());
	function("gd_string_encode_latin1", &gd_string_encode_latin1, allow_raw_pointers());
	function("gd_string_encode_utf8", &gd_string_encode_utf8, allow_raw_pointers());
	function("gd_string_encode_utf16", &gd_string_encode_utf16, allow_raw_pointers());
	function("gd_string_encode_utf32", &gd_string_encode_utf32, allow_raw_pointers());
	function("gd_string_encode_wide", &gd_string_encode_wide, allow_raw_pointers());
	function("gd_string_intern_latin1", &gd_string_intern_latin1, allow_raw_pointers());
	function("gd_string_intern_utf8", &gd_string_intern_utf8, allow_raw_pointers());
	function("gd_variant_type_name", &gd_variant_type_name, allow_raw_pointers());
	function("gd_variant_type_make", &gd_variant_type_make, allow_raw_pointers());
	function("gd_variant_type_call", &gd_variant_type_call, allow_raw_pointers());
	function("gd_variant_type_convertable", &gd_variant_type_convertable, allow_raw_pointers());
	function("gd_variant_type_setup_array", &gd_variant_type_setup_array, allow_raw_pointers());
	function("gd_variant_type_setup_dictionary", &gd_variant_type_setup_dictionary, allow_raw_pointers());
	function("gd_variant_type_fetch_constant", &gd_variant_type_fetch_constant, allow_raw_pointers());
	function("gd_variant_type_builtin_method", &gd_variant_type_builtin_method, allow_raw_pointers());
	function("gd_variant_type_unsafe_constructor", &gd_variant_type_unsafe_constructor, allow_raw_pointers());
	function("gd_variant_type_evaluator", &gd_variant_type_evaluator, allow_raw_pointers());
	function("gd_variant_type_setter", &gd_variant_type_setter, allow_raw_pointers());
	function("gd_variant_type_getter", &gd_variant_type_getter, allow_raw_pointers());
	function("gd_variant_type_has_property", &gd_variant_type_has_property, allow_raw_pointers());
	function("gd_variant_type_unsafe_call", &gd_variant_type_unsafe_call, allow_raw_pointers());
	function("gd_variant_type_unsafe_make", &gd_variant_type_unsafe_make, allow_raw_pointers());
	function("gd_variant_type_unsafe_free", &gd_variant_type_unsafe_free, allow_raw_pointers());
	function("gd_variant_zero", &gd_variant_zero, allow_raw_pointers());
	function("gd_variant_copy", &gd_variant_copy, allow_raw_pointers());
	function("gd_variant_call", &gd_variant_call, allow_raw_pointers());
	function("gd_variant_eval", &gd_variant_eval, allow_raw_pointers());
	function("gd_variant_hash", &gd_variant_hash, allow_raw_pointers());
	function("gd_variant_bool", &gd_variant_bool, allow_raw_pointers());
	function("gd_variant_text", &gd_variant_text, allow_raw_pointers());
	function("gd_variant_type", &gd_variant_type, allow_raw_pointers());
	function("gd_variant_deep_copy", &gd_variant_deep_copy, allow_raw_pointers());
	function("gd_variant_deep_hash", &gd_variant_deep_hash, allow_raw_pointers());
	function("gd_variant_get_index", &gd_variant_get_index, allow_raw_pointers());
	function("gd_variant_get_array", &gd_variant_get_array, allow_raw_pointers());
	function("gd_variant_get_field", &gd_variant_get_field, allow_raw_pointers());
	function("gd_variant_has_index", &gd_variant_has_index, allow_raw_pointers());
	function("gd_variant_has_method", &gd_variant_has_method, allow_raw_pointers());
	function("gd_variant_set_index", &gd_variant_set_index, allow_raw_pointers());
	function("gd_variant_set_array", &gd_variant_set_array, allow_raw_pointers());
	function("gd_variant_set_field", &gd_variant_set_field, allow_raw_pointers());
	function("gd_variant_unsafe_call", &gd_variant_unsafe_call, allow_raw_pointers());
	function("gd_variant_unsafe_eval", &gd_variant_unsafe_eval, allow_raw_pointers());
	function("gd_variant_unsafe_free", &gd_variant_unsafe_free, allow_raw_pointers());
	function("gd_variant_unsafe_make_native", &gd_variant_unsafe_make_native, allow_raw_pointers());
	function("gd_variant_unsafe_from_native", &gd_variant_unsafe_from_native, allow_raw_pointers());
	function("gd_variant_unsafe_internal_pointer", &gd_variant_unsafe_internal_pointer, allow_raw_pointers());
	function("gd_variant_unsafe_get_field", &gd_variant_unsafe_get_field, allow_raw_pointers());
	function("gd_variant_unsafe_get_array", &gd_variant_unsafe_get_array, allow_raw_pointers());
	function("gd_variant_unsafe_get_index", &gd_variant_unsafe_get_index, allow_raw_pointers());
	function("gd_variant_unsafe_set_field", &gd_variant_unsafe_set_field, allow_raw_pointers());
	function("gd_variant_unsafe_set_array", &gd_variant_unsafe_set_array, allow_raw_pointers());
	function("gd_variant_unsafe_set_index", &gd_variant_unsafe_set_index, allow_raw_pointers());
	function("gd_version_major", &gd_version_major, allow_raw_pointers());
	function("gd_version_minor", &gd_version_minor, allow_raw_pointers());
	function("gd_version_patch", &gd_version_patch, allow_raw_pointers());
	function("gd_version_hex", &gd_version_hex, allow_raw_pointers());
	function("gd_version_status", &gd_version_status, allow_raw_pointers());
	function("gd_version_build", &gd_version_build, allow_raw_pointers());
	function("gd_version_hash", &gd_version_hash, allow_raw_pointers());
	function("gd_version_timestamp", &gd_version_timestamp, allow_raw_pointers());
	function("gd_version_string", &gd_version_string, allow_raw_pointers());
	function("gd_thread_is_main", &gd_thread_is_main, allow_raw_pointers());
}
#endif // __EMSCRIPTEN__