frida-il2cpp-bridge-my/dist/il2cpp/api.js

(my:Support IOS)Frida module to dump, manipulate and hijack any IL2CPP application at runtime with a high level of abstraction.

"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Api = void 0;
const decorator_cache_getter_1 = require("decorator-cache-getter");
const extensions_1 = require("../utils/extensions");
const console_1 = require("../utils/console");
const variables_1 = require("./variables");
const native_api_offset_1 = require("./native_api_offset");
class Api {
    static get _arrayGetElements() {
        return extensions_1.createNF(this.r `array_elements`, "pointer", ["pointer"]);
    }
    static get _arrayGetLength() {
        return extensions_1.createNF(this.r `array_length`, "uint32", ["pointer"]);
    }
    static get _arrayNew() {
        return extensions_1.createNF(this.r `array_new`, "pointer", ["pointer", "uint32"]);
    }
    static get _assemblyGetImage() {
        return extensions_1.createNF(this.r `assembly_get_image`, "pointer", ["pointer"]);
    }
    static get _assemblyGetName() {
        return extensions_1.createNF(this.r `assembly_get_name`, "utf8string", ["pointer"]);
    }
    static get _classFromName() {
        return extensions_1.createNF(this.r `class_from_name`, "pointer", ["pointer", "utf8string", "utf8string"]);
    }
    static get _classFromType() {
        return extensions_1.createNF(this.r `class_from_type`, "pointer", ["pointer"]);
    }
    static get _classGetArrayClass() {
        return extensions_1.createNF(this.r `array_class_get`, "pointer", ["pointer", "uint32"]);
    }
    static get _classGetArrayElementSize() {
        return extensions_1.createNF(this.r `class_array_element_size`, "int", ["pointer"]);
    }
    static get _classGetAssemblyName() {
        return extensions_1.createNF(this.r `class_get_assemblyname`, "utf8string", ["pointer"]);
    }
    static get _classGetDeclaringType() {
        return extensions_1.createNF(this.r `class_get_declaring_type`, "pointer", ["pointer"]);
    }
    static get _classGetElementClass() {
        return extensions_1.createNF(this.r `class_get_element_class`, "pointer", ["pointer"]);
    }
    static get _classGetFieldCount() {
        return extensions_1.createNF(this.r `class_get_field_count`, "uint16", ["pointer"]);
    }
    static get _classGetFields() {
        return extensions_1.createNF(this.r `class_get_fields`, "pointer", ["pointer", "pointer"]);
    }
    static get _classGetGenericClass() {
        return extensions_1.createNF(this.r `class_get_generic_class`, "pointer", ["pointer"]);
    }
    static get _classGetImage() {
        return extensions_1.createNF(this.r `class_get_image`, "pointer", ["pointer"]);
    }
    static get _classGetInstanceSize() {
        return extensions_1.createNF(this.r `class_instance_size`, "uint32", ["pointer"]);
    }
    static get _classGetInterfaceCount() {
        return extensions_1.createNF(this.r `class_get_interface_count`, "uint16", ["pointer"]);
    }
    static get _classGetInterfaces() {
        return extensions_1.createNF(this.r `class_get_interfaces`, "pointer", ["pointer", "pointer"]);
    }
    static get _classGetMethodCount() {
        return extensions_1.createNF(this.r `class_get_method_count`, "uint16", ["pointer"]);
    }
    static get _classGetMethods() {
        return extensions_1.createNF(this.r `class_get_methods`, "pointer", ["pointer", "pointer"]);
    }
    static get _classGetName() {
        return extensions_1.createNF(this.r `class_get_name`, "utf8string", ["pointer"]);
    }
    static get _classGetNamespace() {
        return extensions_1.createNF(this.r `class_get_namespace`, "utf8string", ["pointer"]);
    }
    static get _classGetParent() {
        return extensions_1.createNF(this.r `class_get_parent`, "pointer", ["pointer"]);
    }
    static get _classGetStaticFieldData() {
        return extensions_1.createNF(this.r `class_get_static_field_data`, "pointer", ["pointer"]);
    }
    static get _classGetType() {
        return extensions_1.createNF(this.r `class_get_type`, "pointer", ["pointer"]);
    }
    static get _classHasStaticConstructor() {
        return extensions_1.createNF(this.r `class_has_static_constructor`, "bool", ["pointer"]);
    }
    static get _classInit() {
        return extensions_1.createNF(this.r `runtime_class_init`, "void", ["pointer"]);
    }
    static get _classIsEnum() {
        return extensions_1.createNF(this.r `class_is_enum`, "bool", ["pointer"]);
    }
    static get _classIsInterface() {
        return extensions_1.createNF(this.r `class_is_interface`, "bool", ["pointer"]);
    }
    static get _classIsStaticConstructorFinished() {
        return extensions_1.createNF(this.r `class_is_static_constructor_finished`, "bool", ["pointer"]);
    }
    static get _classIsStruct() {
        return extensions_1.createNF(this.r `class_is_valuetype`, "bool", ["pointer"]);
    }
    static get _domainGet() {
        return extensions_1.createNF(this.r `domain_get`, "pointer", []);
    }
    static get _domainGetAssemblies() {
        function il2cpp_domain_get_assemblies(domain, psize) {
            const assemblies = variables_1.library.base.add(native_api_offset_1.NativeApiOffset.offset_s_assemblies).readPointer();
            const endAssemblies = variables_1.library.base.add(native_api_offset_1.NativeApiOffset.offset_s_assemblies + 0x08).readPointer();
            console.log(`${assemblies}-${endAssemblies}`);
            psize.writeInt(endAssemblies.sub(assemblies).toUInt32() / 8);
            return assemblies;
        }
        return il2cpp_domain_get_assemblies;
    }
    static get _domainGetName() {
        return extensions_1.createNF(this.r `domain_get_name`, "utf8string", ["pointer"]);
    }
    static get _fieldGetClass() {
        return extensions_1.createNF(this.r `field_get_parent`, "pointer", ["pointer"]);
    }
    static get _fieldGetName() {
        return extensions_1.createNF(this.r `field_get_name`, "utf8string", ["pointer"]);
    }
    static get _fieldGetOffset() {
        return extensions_1.createNF(this.r `field_get_offset`, "int32", ["pointer"]);
    }
    static get _fieldGetStaticValue() {
        return extensions_1.createNF(this.r `field_static_get_value`, "void", ["pointer", "pointer"]);
    }
    static get _fieldGetStaticValue2() {
        return extensions_1.createNF(this.r `field_static_get_value`, "void", ["pointer", "pointer"]);
    }
    static get _fieldGetType() {
        return extensions_1.createNF(this.r `field_get_type`, "pointer", ["pointer"]);
    }
    static get _fieldIsInstance() {
        return extensions_1.createNF(this.r `field_is_instance`, "bool", ["pointer"]);
    }
    static get _fieldIsLiteral() {
        return extensions_1.createNF(this.r `field_is_literal`, "bool", ["pointer"]);
    }
    static get _gcCollect() {
        return extensions_1.createNF(this.r `gc_collect`, "void", ["int"]);
    }
    static get _gcCollectALittle() {
        return extensions_1.createNF(this.r `gc_collect_a_little`, "void", []);
    }
    static get _gcDisable() {
        return extensions_1.createNF(this.r `gc_disable`, "void", []);
    }
    static get _gcEnable() {
        return extensions_1.createNF(this.r `gc_enable`, "void", []);
    }
    static get _gcIsDisabled() {
        return extensions_1.createNF(this.r `gc_is_disabled`, "bool", []);
    }
    static get _genericClassGetCachedClass() {
        return extensions_1.createNF(this.r `field_is_literal`, "pointer", ["pointer"]);
    }
    static get _genericClassGetTypesCount() {
        return extensions_1.createNF(this.r `generic_class_get_types_count`, "uint32", ["pointer"]);
    }
    static get _genericClassGetTypes() {
        return extensions_1.createNF(this.r `generic_class_get_types`, "pointer", ["pointer"]);
    }
    static get _imageGetClass() {
        return extensions_1.createNF(this.r `image_get_class`, "pointer", ["pointer", "uint"]);
    }
    static get _imageGetClassCount() {
        return extensions_1.createNF(this.r `image_get_class_count`, "uint32", ["pointer"]);
    }
    static get _imageGetClassStart() {
        return extensions_1.createNF(this.r `image_get_class_start`, "uint32", ["pointer"]);
    }
    static get _imageGetName() {
        return extensions_1.createNF(this.r `image_get_name`, "utf8string", ["pointer"]);
    }
    static get _init() {
        return this.r `init`;
    }
    static get _livenessCalculationBegin() {
        return extensions_1.createNF(this.r `unity_liveness_calculation_begin`, "pointer", [
            "pointer",
            "int",
            "pointer",
            "pointer",
            "pointer",
            "pointer"
        ]);
    }
    static get _livenessCalculationEnd() {
        return extensions_1.createNF(this.r `unity_liveness_calculation_end`, "void", ["pointer"]);
    }
    static get _livenessCalculationFromStatics() {
        return extensions_1.createNF(this.r `unity_liveness_calculation_from_statics`, "void", ["pointer"]);
    }
    static get _memorySnapshotCapture() {
        return extensions_1.createNF(this.r `capture_memory_snapshot`, "pointer", []);
    }
    static get _memorySnapshotFree() {
        return extensions_1.createNF(this.r `free_captured_memory_snapshot`, "void", ["pointer"]);
    }
    static get _memorySnapshotGetTrackedObjectCount() {
        return extensions_1.createNF(this.r `memory_snapshot_get_tracked_object_count`, "uint64", ["pointer"]);
    }
    static get _memorySnapshotGetObjects() {
        return extensions_1.createNF(this.r `memory_snapshot_get_objects`, "pointer", ["pointer"]);
    }
    static get _methodGetClass() {
        return extensions_1.createNF(this.r `method_get_class`, "pointer", ["pointer"]);
    }
    static get _methodGetName() {
        return extensions_1.createNF(this.r `method_get_name`, "utf8string", ["pointer"]);
    }
    static get _methodGetParamCount() {
        return extensions_1.createNF(this.r `method_get_param_count`, "uint8", ["pointer"]);
    }
    static get _methodGetParameters() {
        return extensions_1.createNF(this.r `method_get_parameters`, "pointer", ["pointer", "pointer"]);
    }
    static get _methodGetPointer() {
        return extensions_1.createNF(this.r `method_get_pointer`, "pointer", ["pointer"]);
    }
    static get _methodGetReturnType() {
        return extensions_1.createNF(this.r `method_get_return_type`, "pointer", ["pointer"]);
    }
    static get _methodIsGeneric() {
        return extensions_1.createNF(this.r `method_is_generic`, "bool", ["pointer"]);
    }
    static get _methodIsInflated() {
        return extensions_1.createNF(this.r `method_is_inflated`, "bool", ["pointer"]);
    }
    static get _methodIsInstance() {
        return extensions_1.createNF(this.r `method_is_instance`, "bool", ["pointer"]);
    }
    static get _objectGetClass() {
        return extensions_1.createNF(this.r `object_get_class`, "pointer", ["pointer"]);
    }
    static get _objectGetHeaderSize() {
        return extensions_1.createNF(this.r `object_header_size`, "uint", []);
    }
    static get _objectNew() {
        return extensions_1.createNF(this.r `object_new`, "pointer", ["pointer"]);
    }
    static get _objectUnbox() {
        return extensions_1.createNF(this.r `object_unbox`, "pointer", ["pointer"]);
    }
    static get _parameterGetName() {
        return extensions_1.createNF(this.r `parameter_get_name`, "utf8string", ["pointer"]);
    }
    static get _parameterGetPosition() {
        return extensions_1.createNF(this.r `parameter_get_position`, "int32", ["pointer"]);
    }
    static get _parameterGetType() {
        return extensions_1.createNF(this.r `parameter_get_type`, "pointer", ["pointer"]);
    }
    static get _stringChars() {
        return extensions_1.createNF(this.r `string_chars`, "pointer", ["pointer"]);
    }
    static get _stringLength() {
        return extensions_1.createNF(this.r `string_length`, "int32", ["pointer"]);
    }
    static get _stringNew() {
        return extensions_1.createNF(this.r `string_new`, "pointer", ["utf8string"]);
    }
    static get _stringSetLength() {
        return extensions_1.createNF(this.r `string_set_length`, "void", ["pointer", "int32"]);
    }
    static get _valueBox() {
        return extensions_1.createNF(this.r `value_box`, "pointer", ["pointer", "pointer"]);
    }
    static get _threadAttach() {
        return extensions_1.createNF(this.r `thread_attach`, "void", ["pointer"]);
    }
    static get _typeGetClassOrElementClass() {
        return extensions_1.createNF(this.r `type_get_class_or_element_class`, "pointer", ["pointer"]);
    }
    static get _typeGetDataType() {
        return extensions_1.createNF(this.r `type_get_data_type`, "pointer", ["pointer"]);
    }
    static get _typeGetGenericClass() {
        return extensions_1.createNF(this.r `type_get_generic_class`, "pointer", ["pointer"]);
    }
    static get _typeGetName() {
        return extensions_1.createNF(this.r `type_get_name`, "utf8string", ["pointer"]);
    }
    static get _typeGetTypeEnum() {
        return extensions_1.createNF(this.r `type_get_type`, "int", ["pointer"]);
    }
    static get _typeIsByReference() {
        return extensions_1.createNF(this.r `type_is_byref`, "bool", ["pointer"]);
    }
    static get _typeOffsetOfTypeEnum() {
        return extensions_1.createNF(this.r `type_offset_of_type`, "uint16", []);
    }
    static get sources() {
        return [variables_1.library, createMissingApi()];
    }
    static my_r(exportName) {
    }
    static r(exportName) {
        const name = "il2cpp_" + exportName;
        for (const source of this.sources) {
            const result = source instanceof Module ? source.findExportByName(name) : source[name];
            if (result)
                return result;
        }
        console_1.raise(`Couldn't resolve export "${name}".`);
    }
}
__decorate([
    decorator_cache_getter_1.cache
], Api, "_arrayGetElements", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_arrayGetLength", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_arrayNew", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_assemblyGetImage", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_assemblyGetName", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_classFromName", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_classFromType", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_classGetArrayClass", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_classGetArrayElementSize", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_classGetAssemblyName", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_classGetDeclaringType", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_classGetElementClass", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_classGetFieldCount", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_classGetFields", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_classGetGenericClass", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_classGetImage", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_classGetInstanceSize", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_classGetInterfaceCount", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_classGetInterfaces", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_classGetMethodCount", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_classGetMethods", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_classGetName", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_classGetNamespace", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_classGetParent", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_classGetStaticFieldData", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_classGetType", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_classHasStaticConstructor", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_classInit", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_classIsEnum", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_classIsInterface", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_classIsStaticConstructorFinished", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_classIsStruct", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_domainGet", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_domainGetAssemblies", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_domainGetName", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_fieldGetClass", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_fieldGetName", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_fieldGetOffset", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_fieldGetStaticValue", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_fieldGetStaticValue2", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_fieldGetType", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_fieldIsInstance", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_fieldIsLiteral", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_gcCollect", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_gcCollectALittle", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_gcDisable", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_gcEnable", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_gcIsDisabled", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_genericClassGetCachedClass", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_genericClassGetTypesCount", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_genericClassGetTypes", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_imageGetClass", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_imageGetClassCount", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_imageGetClassStart", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_imageGetName", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_init", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_livenessCalculationBegin", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_livenessCalculationEnd", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_livenessCalculationFromStatics", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_memorySnapshotCapture", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_memorySnapshotFree", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_memorySnapshotGetTrackedObjectCount", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_memorySnapshotGetObjects", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_methodGetClass", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_methodGetName", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_methodGetParamCount", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_methodGetParameters", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_methodGetPointer", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_methodGetReturnType", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_methodIsGeneric", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_methodIsInflated", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_methodIsInstance", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_objectGetClass", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_objectGetHeaderSize", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_objectNew", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_objectUnbox", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_parameterGetName", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_parameterGetPosition", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_parameterGetType", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_stringChars", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_stringLength", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_stringNew", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_stringSetLength", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_valueBox", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_threadAttach", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_typeGetClassOrElementClass", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_typeGetDataType", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_typeGetGenericClass", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_typeGetName", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_typeGetTypeEnum", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_typeIsByReference", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "_typeOffsetOfTypeEnum", null);
__decorate([
    decorator_cache_getter_1.cache
], Api, "sources", null);
exports.Api = Api;
function createMissingApi() {
    const isEqualOrAbove_5_3_2 = +variables_1.unityVersion.isEqualOrAbove("5.3.2");
    const isEqualOrAbove_5_3_3 = +variables_1.unityVersion.isEqualOrAbove("5.3.3");
    const isEqualOrAbove_5_3_6 = +variables_1.unityVersion.isEqualOrAbove("5.3.6");
    const isEqualOrAbove_5_4_4 = +variables_1.unityVersion.isEqualOrAbove("5.4.4");
    const isEqualOrAbove_5_5_0 = +variables_1.unityVersion.isEqualOrAbove("5.5.0");
    const isEqualOrAbove_5_6_0 = +variables_1.unityVersion.isEqualOrAbove("5.6.0");
    const isEqualOrAbove_2017_1_0 = +variables_1.unityVersion.isEqualOrAbove("2017.1.0");
    const isEqualOrAbove_2017_1_3 = +variables_1.unityVersion.isEqualOrAbove("2017.1.3");
    const isEqualOrAbove_2018_1_0 = +variables_1.unityVersion.isEqualOrAbove("2018.1.0");
    const isEqualOrAbove_2018_2_0 = +variables_1.unityVersion.isEqualOrAbove("2018.2.0");
    const isEqualOrAbove_2018_3_0 = +variables_1.unityVersion.isEqualOrAbove("2018.3.0");
    const isEqualOrAbove_2018_3_8 = +variables_1.unityVersion.isEqualOrAbove("2018.3.8");
    const isEqualOrAbove_2019_1_0 = +variables_1.unityVersion.isEqualOrAbove("2019.1.0");
    const isEqualOrAbove_2020_2_0 = +variables_1.unityVersion.isEqualOrAbove("2020.2.0");
    const isBelow_5_3_3 = +!isEqualOrAbove_5_3_3;
    const isBelow_5_3_6 = +!isEqualOrAbove_5_3_6;
    const isBelow_5_5_0 = +!isEqualOrAbove_5_5_0;
    const isBelow_2018_1_0 = +!isEqualOrAbove_2018_1_0;
    const isBelow_2018_3_0 = +!isEqualOrAbove_2018_3_0;
    const isBelow_2019_3_0 = +variables_1.unityVersion.isBelow("2019.3.0");
    const isBelow_2020_2_0 = +!isEqualOrAbove_2020_2_0;
    const isNotEqual_2017_2_0 = +!variables_1.unityVersion.isEqual("2017.2.0");
    const isNotEqual_5_5_0 = +!variables_1.unityVersion.isEqual("5.5.0");
    return new CModule(`
#include <stdint.h>

#define FIELD_ATTRIBUTE_STATIC 0x0010
#define FIELD_ATTRIBUTE_LITERAL 0x0040

#define METHOD_ATTRIBUTE_STATIC 0x0010

typedef struct _Il2CppObject Il2CppObject;
typedef struct _Il2CppString Il2CppString;
typedef struct _Il2CppArray Il2CppArray;
#if ${isEqualOrAbove_5_3_3}
typedef struct _Il2CppArraySize Il2CppArraySize;
#endif
typedef struct _Il2CppDomain Il2CppDomain;
typedef struct _Il2CppAssemblyName Il2CppAssemblyName;
typedef struct _Il2CppAssembly Il2CppAssembly;
typedef struct _Il2CppImage Il2CppImage;
typedef struct _Il2CppClass Il2CppClass;
typedef struct _Il2CppType Il2CppType;
typedef struct _FieldInfo FieldInfo;
typedef struct _MethodInfo MethodInfo;
typedef struct _ParameterInfo ParameterInfo;
typedef enum _Il2CppTypeEnum Il2CppTypeEnum;
typedef struct _VirtualInvokeData VirtualInvokeData;
typedef struct _Il2CppGenericInst Il2CppGenericInst;
typedef struct _Il2CppGenericClass Il2CppGenericClass;
typedef struct _Il2CppGenericContext Il2CppGenericContext;
typedef uint16_t Il2CppChar;
typedef struct _Il2CppManagedMemorySnapshot Il2CppManagedMemorySnapshot;
typedef struct _Il2CppMetadataSnapshot Il2CppMetadataSnapshot;
typedef struct _Il2CppManagedMemorySection Il2CppManagedMemorySection;
typedef struct _Il2CppManagedHeap Il2CppManagedHeap;
typedef struct _Il2CppStacks Il2CppStacks;
typedef struct _Il2CppGCHandles Il2CppGCHandles;
typedef struct _Il2CppRuntimeInformation Il2CppRuntimeInformation;

enum _Il2CppTypeEnum
{
    IL2CPP_TYPE_END = 0x00,
    IL2CPP_TYPE_VOID = 0x01,
    IL2CPP_TYPE_BOOLEAN = 0x02,
    IL2CPP_TYPE_CHAR = 0x03,
    IL2CPP_TYPE_I1 = 0x04,
    IL2CPP_TYPE_U1 = 0x05,
    IL2CPP_TYPE_I2 = 0x06,
    IL2CPP_TYPE_U2 = 0x07,
    IL2CPP_TYPE_I4 = 0x08,
    IL2CPP_TYPE_U4 = 0x09,
    IL2CPP_TYPE_I8 = 0x0a,
    IL2CPP_TYPE_U8 = 0x0b,
    IL2CPP_TYPE_R4 = 0x0c,
    IL2CPP_TYPE_R8 = 0x0d,
    IL2CPP_TYPE_STRING = 0x0e,
    IL2CPP_TYPE_PTR = 0x0f,
    IL2CPP_TYPE_BYREF = 0x10,
    IL2CPP_TYPE_VALUETYPE = 0x11,
    IL2CPP_TYPE_CLASS = 0x12,
    IL2CPP_TYPE_VAR = 0x13,
    IL2CPP_TYPE_ARRAY = 0x14,
    IL2CPP_TYPE_GENERICINST = 0x15,
    IL2CPP_TYPE_TYPEDBYREF = 0x16,
    IL2CPP_TYPE_I = 0x18,
    IL2CPP_TYPE_U = 0x19,
    IL2CPP_TYPE_FNPTR = 0x1b,
    IL2CPP_TYPE_OBJECT = 0x1c,
    IL2CPP_TYPE_SZARRAY = 0x1d,
    IL2CPP_TYPE_MVAR = 0x1e,
    IL2CPP_TYPE_CMOD_REQD = 0x1f,
    IL2CPP_TYPE_CMOD_OPT = 0x20,
    IL2CPP_TYPE_INTERNAL = 0x21,
    IL2CPP_TYPE_MODIFIER = 0x40,
    IL2CPP_TYPE_SENTINEL = 0x41,
    IL2CPP_TYPE_PINNED = 0x45,
    IL2CPP_TYPE_ENUM = 0x55
};

struct _Il2CppObject
{
#if ${isEqualOrAbove_2018_1_0}
    union
    {
        Il2CppClass * klass;
        struct Il2CppVTable * vtable;
    };
#else
    Il2CppClass * klass;
#endif
    struct MonitorData * monitor;
};

#if ${isBelow_2019_3_0}
size_t
il2cpp_object_header_size (void)
{
    return sizeof (Il2CppObject);
}
#endif

struct _Il2CppDomain
{
    struct Il2CppAppDomain * domain;
#if ${isEqualOrAbove_5_5_0}
    struct Il2CppAppDomainSetup * setup;
#else
    Il2CppObject * setup;
#endif
    struct Il2CppAppContext * default_context;
    const char * friendly_name;
    uint32_t domain_id;
#if ${isEqualOrAbove_5_5_0}
    volatile int threadpool_jobs;
#endif
#if ${isEqualOrAbove_2018_1_0}
    void * agent_info;
#endif
};

const char *
il2cpp_domain_get_name (const Il2CppDomain* domain)
{
    return domain->friendly_name;
}

struct _Il2CppAssemblyName
{
#if ${isEqualOrAbove_2018_1_0}
    const char * name;
    const char * culture;
    const char * hash_value;
    const char * public_key;
#else
    int32_t nameIndex;
    int32_t cultureIndex;
    int32_t hashValueIndex;
    int32_t publicKeyIndex;
#endif
    uint32_t hash_alg;
    int32_t hash_len;
    uint32_t flags;
    int32_t major;
    int32_t minor;
    int32_t build;
    int32_t revision;
    uint8_t publicKeyToken[8];
};

struct _Il2CppAssembly
{
#if ${isEqualOrAbove_2018_1_0}
    Il2CppImage * image;
#else
    int32_t imageIndex;
#endif
#if ${isEqualOrAbove_2018_3_0}
    uint32_t token;
#else
    int32_t customAttributeIndex;
#endif
#if ${isEqualOrAbove_5_3_3}
    int32_t referencedAssemblyStart;
    int32_t referencedAssemblyCount;
#endif
    Il2CppAssemblyName aname;
};

#if ${isEqualOrAbove_2018_1_0}
const char *
il2cpp_assembly_get_name (const Il2CppAssembly * assembly)
{
    return assembly->aname.name;
}
#endif

struct _Il2CppImage
{
    const char * name;
#if ${isEqualOrAbove_2017_1_3 && isNotEqual_2017_2_0}
    const char * nameNoExt;
#endif
#if ${isEqualOrAbove_2018_1_0}
    Il2CppAssembly * assembly;
#else
    int32_t assemblyIndex;
#endif
#if ${isBelow_2020_2_0}
    int32_t typeStart;
#endif
    uint32_t typeCount;
#if ${isEqualOrAbove_2017_1_0}
#if ${isBelow_2020_2_0}
    int32_t exportedTypeStart;
#endif
    uint32_t exportedTypeCount;
#endif
#if ${isEqualOrAbove_2018_3_0}
#if ${isBelow_2020_2_0}
    int32_t customAttributeStart;
#endif
    uint32_t customAttributeCount;
#endif
#if ${isEqualOrAbove_2020_2_0}
    const struct Il2CppMetadataImageHandle * metadataHandle;
    struct Il2CppNameToTypeHandleHashTable * nameToClassHashTable;
#else
    int32_t entryPointIndex;
    struct Il2CppNameToTypeDefinitionIndexHashTable * nameToClassHashTable;
#endif
#if ${isEqualOrAbove_2019_1_0}
    const struct Il2CppCodeGenModule * codeGenModule;
#endif
#if ${isEqualOrAbove_5_3_2}
    uint32_t token;
#endif
#if ${isEqualOrAbove_2018_1_0}
    uint8_t dynamic;
#endif
};


uint32_t
il2cpp_image_get_class_start (const Il2CppImage * image)
{
#if ${isBelow_2020_2_0}
    return image->typeStart;
#else
    return 0;
#endif
}


#if ${isBelow_2018_3_0}
uint32_t
il2cpp_image_get_class_count (const Il2CppImage * image)
{
    return image->typeCount;
}
#endif

struct _Il2CppType
{
    union
    {
        void * dummy;
        int32_t klassIndex;
#if ${isEqualOrAbove_2020_2_0}
        const struct Il2CppMetadataTypeHandle * typeHandle;
#endif
        const Il2CppType * type;
        struct Il2CppArrayType * array;
        int32_t genericParameterIndex;
#if ${isEqualOrAbove_2020_2_0}
        const struct Il2CppMetadataGenericParameterHandle * genericParameterHandle;
#endif
        Il2CppGenericClass * generic_class;
    } data;
    unsigned int attrs: 16;
    Il2CppTypeEnum type: 8;
    unsigned int num_mods: 6;
    unsigned int byref: 1;
    unsigned int pinned: 1;
};

uint16_t
il2cpp_type_offset_of_type (void)
{
    return (uint16_t) offsetof (Il2CppType, type);
}

const Il2CppType *
il2cpp_type_get_data_type (const Il2CppType * type)
{
    return type->data.type;
}

Il2CppGenericClass *
il2cpp_type_get_generic_class (const Il2CppType * type)
{
    return type->data.generic_class;
}

#if ${isBelow_2018_1_0}
unsigned int
il2cpp_type_is_byref (const Il2CppType * type)
{
    return type->byref;
}
#endif

struct _VirtualInvokeData
{
    void * methodPtr;
    const MethodInfo * method;
};

struct _Il2CppClass
{
    const Il2CppImage * image;
    void * gc_desc;
    const char * name;
    const char * namespaze;
#if ${isEqualOrAbove_2018_1_0}
    Il2CppType byval_arg;
    Il2CppType this_arg;
#else
    const Il2CppType* byval_arg;
    const Il2CppType* this_arg;
#endif
    Il2CppClass * element_class;
    Il2CppClass * castClass;
    Il2CppClass * declaringType;
    Il2CppClass * parent;
    Il2CppGenericClass * generic_class;
#if ${isEqualOrAbove_2020_2_0}
    const struct Il2CppMetadataTypeHandle * typeMetadataHandle;
#else
    const struct Il2CppTypeDefinition * typeDefinition;
#endif
#if ${isEqualOrAbove_5_6_0}
    const struct Il2CppInteropData * interopData;
#endif
#if ${isEqualOrAbove_2018_1_0}
    Il2CppClass * klass;
#endif
    FieldInfo * fields;
    const struct EventInfo* events;
    const struct PropertyInfo * properties;
    const MethodInfo ** methods;
    Il2CppClass ** nestedTypes;
    Il2CppClass ** implementedInterfaces;
#if ${isEqualOrAbove_5_3_6 && isBelow_5_5_0}
    VirtualInvokeData * vtable;
#endif
#if ${isBelow_5_3_6}
    const MethodInfo ** vtable;
#endif
    struct Il2CppRuntimeInterfaceOffsetPair * interfaceOffsets;
    void * static_fields;
    const struct Il2CppRGCTXData * rgctx_data;
    Il2CppClass ** typeHierarchy;
#if ${isEqualOrAbove_2019_1_0}
    void * unity_user_data;
#endif
#if ${isEqualOrAbove_2018_2_0}
    uint32_t initializationExceptionGCHandle;
#endif
    uint32_t cctor_started;
    uint32_t cctor_finished;
#if ${isEqualOrAbove_2019_1_0}
    __attribute__((aligned(8))) size_t cctor_thread;
#else
    __attribute__((aligned(8))) uint64_t cctor_thread;
#endif
#if ${isEqualOrAbove_2020_2_0}
    const struct Il2CppMetadataGenericContainerHandle * genericContainerHandle;
#else
    int32_t genericContainerIndex;
#endif
#if ${isBelow_2018_3_0}
    int32_t customAttributeIndex;
#endif
    uint32_t instance_size;
    uint32_t actualSize;
    uint32_t element_size;
    int32_t native_size;
    uint32_t static_fields_size;
    uint32_t thread_static_fields_size;
    int32_t thread_static_fields_offset;
    uint32_t flags;
#if ${isEqualOrAbove_5_3_2}
    uint32_t token;
#endif
    uint16_t method_count;
    uint16_t property_count;
    uint16_t field_count;
    uint16_t event_count;
    uint16_t nested_type_count;
    uint16_t vtable_count;
    uint16_t interfaces_count;
    uint16_t interface_offsets_count;
    uint8_t typeHierarchyDepth;
#if ${isEqualOrAbove_5_4_4 && isNotEqual_5_5_0}
    uint8_t genericRecursionDepth;
#endif
    uint8_t rank;
    uint8_t minimumAlignment;
#if ${isEqualOrAbove_2018_3_8}
    uint8_t naturalAligment;
#endif
    uint8_t packingSize;
#if ${isEqualOrAbove_2018_3_0}
    uint8_t initialized_and_no_error: 1;
#endif
    uint8_t valuetype: 1;
    uint8_t initialized: 1;
    uint8_t enumtype: 1;
    uint8_t is_generic: 1;
    uint8_t has_references: 1;
    uint8_t init_pending: 1;
    uint8_t size_inited: 1;
    uint8_t has_finalize: 1;
    uint8_t has_cctor: 1;
    uint8_t is_blittable: 1;
#if ${isEqualOrAbove_5_3_3}
    uint8_t is_import_or_windows_runtime: 1;
#endif
#if ${isEqualOrAbove_5_5_0}
    uint8_t is_vtable_initialized: 1;
#endif
#if ${isEqualOrAbove_2018_2_0}
    uint8_t has_initialization_error: 1;
#endif
#if ${isEqualOrAbove_5_5_0}
    VirtualInvokeData vtable[32];
#endif
};

uint16_t
il2cpp_class_get_interface_count (const Il2CppClass * klass)
{
    return klass->interfaces_count;
}

uint16_t
il2cpp_class_get_method_count (const Il2CppClass * klass)
{
    return klass->method_count;
}

uint16_t
il2cpp_class_get_field_count (const Il2CppClass * klass)
{
    return klass->field_count;
}

uint8_t
il2cpp_class_has_static_constructor (const Il2CppClass * klass)
{
    return klass->has_cctor;
}

uint32_t
il2cpp_class_is_static_constructor_finished (const Il2CppClass * klass)
{
    return klass->cctor_finished;
}

#if ${isBelow_2019_3_0}
void *
il2cpp_class_get_static_field_data (const Il2CppClass * klass)
{
    return klass->static_fields;
}
#endif

Il2CppGenericClass *
il2cpp_class_get_generic_class (const Il2CppClass * klass)
{
    return klass->generic_class;
}

struct _Il2CppGenericInst
{
    uint32_t type_argc;
    const Il2CppType ** type_argv;
};

struct _Il2CppGenericContext
{
    const Il2CppGenericInst * class_inst;
    const Il2CppGenericInst * method_inst;
};

struct _Il2CppGenericClass
{
#if ${isEqualOrAbove_2020_2_0}
    const Il2CppType * type;
#else
    int32_t typeDefinitionIndex;
#endif
    Il2CppGenericContext context;
    Il2CppClass * cached_class;
};

Il2CppClass *
il2cpp_generic_class_get_cached_class (Il2CppGenericClass * class)
{
    return class->cached_class;
}

uint32_t
il2cpp_generic_class_get_types_count (Il2CppGenericClass * class)
{
    return class->context.class_inst->type_argc;
}

const Il2CppType **
il2cpp_generic_class_get_types (Il2CppGenericClass * class)
{
    return class->context.class_inst->type_argv;
}

struct _FieldInfo
{
    const char * name;
    const Il2CppType * type;
    Il2CppClass * parent;
    int32_t offset;
#if ${isBelow_2018_3_0}
    int32_t customAttributeIndex;
#endif
#if ${isEqualOrAbove_5_3_2}
    uint32_t token;
#endif
};

uint8_t
il2cpp_field_is_instance (FieldInfo * field)
{
    return (field->type->attrs & FIELD_ATTRIBUTE_STATIC) == 0;
}

#if ${isBelow_2019_3_0}
uint8_t
il2cpp_field_is_literal (FieldInfo * field)
{
    return field->type->attrs & FIELD_ATTRIBUTE_LITERAL;
}
#endif

struct _ParameterInfo
{
    const char * name;
    int32_t position;
    uint32_t token;
#if ${isBelow_2018_3_0}
    int32_t customAttributeIndex;
#endif
    const Il2CppType * parameter_type;
};

const char *
il2cpp_parameter_get_name(const ParameterInfo * parameter)
{
    return parameter->name;
}

const Il2CppType *
il2cpp_parameter_get_type (const ParameterInfo * parameter)
{
    return parameter->parameter_type;
}

int32_t
il2cpp_parameter_get_position (const ParameterInfo * parameter)
{
    return parameter->position;
}

struct _MethodInfo
{
    void * methodPointer;
    void * invoker_method;
    const char * name;
    Il2CppClass * klass;
    const Il2CppType * return_type;
    const ParameterInfo * parameters;
    union
    {
        const struct Il2CppRGCTXData * rgctx_data;
#if ${isEqualOrAbove_2020_2_0}
        const struct Il2CppMetadataMethodDefinitionHandle * methodMetadataHandle;
#else
        const struct Il2CppMethodDefinition * methodDefinition;
#endif
    };
    union
    {
        const struct Il2CppGenericMethod * genericMethod;
#if ${isEqualOrAbove_2020_2_0}
        const struct Il2CppMetadataGenericContainerHandle * genericContainerHandle;
#else
        const struct Il2CppGenericContainer * genericContainer;
#endif
    };
#if ${isBelow_2018_3_0}
    int32_t customAttributeIndex;
#endif
    uint32_t token;
    uint16_t flags;
    uint16_t iflags;
    uint16_t slot;
    uint8_t parameters_count;
    uint8_t is_generic: 1;
    uint8_t is_inflated: 1;
#if ${isEqualOrAbove_2018_1_0}
    uint8_t wrapper_type: 1;
    uint8_t is_marshaled_from_native: 1;
#endif
};

void *
il2cpp_method_get_pointer(const MethodInfo * method)
{
    return method->methodPointer;
}

const ParameterInfo *
il2cpp_method_get_parameters (const MethodInfo * method,
                              void ** iter)
{
    uint16_t parameters_count = method->parameters_count;

    if (iter != 0 && parameters_count > 0)
    {
        void* temp = *iter;
        if (temp == 0)
        {
            *iter = (void**) method->parameters;
            return method->parameters;
        }
        else
        {
            const ParameterInfo * parameterInfo = (ParameterInfo*) *iter + 1;
            if (parameterInfo < method->parameters + parameters_count)
            {
                *iter = (void*) parameterInfo;
                return parameterInfo;
            }
        }
    }
    return 0;
}


struct _Il2CppString
{
    Il2CppObject object;
    int32_t length;
    Il2CppChar chars[32];
};

void
il2cpp_string_set_length (Il2CppString * string,
                          int32_t length)
{
    string->length = length;
}

struct _Il2CppArray
{
    Il2CppObject obj;
    struct Il2CppArrayBounds * bounds;
    uint32_t max_length;
#if ${isBelow_5_3_3}
    double vector[32];
#endif
};

#if ${isEqualOrAbove_5_3_3}
struct _Il2CppArraySize
{
#if ${isEqualOrAbove_2018_1_0}
    Il2CppObject obj;
    struct Il2CppArrayBounds * bounds;
    uint32_t max_length;
    __attribute__((aligned(8))) void * vector[32];
#else
    Il2CppArray Array;
    __attribute__((aligned(8))) void * vector;
#endif
};
#endif

#if ${isEqualOrAbove_5_3_3}
void *
il2cpp_array_elements (Il2CppArraySize * array) {
#if ${isEqualOrAbove_2018_1_0}
    return array->vector;
#else
    return &array->vector;
#endif
}
#else

void *
il2cpp_array_elements (Il2CppArray * array) {
    return (void*) array->vector;
}
#endif

struct _Il2CppMetadataSnapshot
{
    uint32_t typeCount;
    struct Il2CppMetadataType * types;
};

struct _Il2CppManagedMemorySection
{
    uint64_t sectionStartAddress;
    uint32_t sectionSize;
    uint8_t * sectionBytes;
};

struct _Il2CppManagedHeap
{
    uint32_t sectionCount;
    Il2CppManagedMemorySection * sections;
};

struct _Il2CppStacks
{
    uint32_t stackCount;
    Il2CppManagedMemorySection * stacks;
};

struct _Il2CppGCHandles
{
    uint32_t trackedObjectCount;
    Il2CppObject ** pointersToObjects;
};

struct _Il2CppRuntimeInformation
{
    uint32_t pointerSize;
    uint32_t objectHeaderSize;
    uint32_t arrayHeaderSize;
    uint32_t arrayBoundsOffsetInHeader;
    uint32_t arraySizeOffsetInHeader;
    uint32_t allocationGranularity;
};

struct _Il2CppManagedMemorySnapshot
{
    Il2CppManagedHeap heap;
    Il2CppStacks stacks;
    Il2CppMetadataSnapshot metadata;
    Il2CppGCHandles gcHandles;
    Il2CppRuntimeInformation runtimeInformation;
    void * additionalUserInformation;
};

uint32_t
il2cpp_memory_snapshot_get_tracked_object_count (Il2CppManagedMemorySnapshot * snapshot)
{
    return snapshot->gcHandles.trackedObjectCount;
}

Il2CppObject **
il2cpp_memory_snapshot_get_objects (Il2CppManagedMemorySnapshot * snapshot)
{
    return snapshot->gcHandles.pointersToObjects;
}
`);
}