// Copyright (c) 2012-2023 Wojciech Figat. All rights reserved.

#include "Engine/Scripting/Types.h"

#if USE_MONO

#include "Engine/Core/Log.h"
#include "Engine/Core/Types/DateTime.h"
#include "Engine/Core/Types/TimeSpan.h"
#include "Engine/Platform/File.h"
#include "Engine/Platform/FileSystem.h"
#include "Engine/Engine/Globals.h"
#include "Engine/Engine/CommandLine.h"
#include "Engine/Scripting/ManagedCLR/MCore.h"
#include "Engine/Scripting/ManagedCLR/MAssembly.h"
#include "Engine/Scripting/ManagedCLR/MClass.h"
#include "Engine/Scripting/ManagedCLR/MDomain.h"
#include "Engine/Scripting/ManagedCLR/MEvent.h"
#include "Engine/Scripting/ManagedCLR/MField.h"
#include "Engine/Scripting/ManagedCLR/MMethod.h"
#include "Engine/Scripting/ManagedCLR/MProperty.h"
#include "Engine/Scripting/ManagedCLR/MException.h"
#include "Engine/Scripting/ManagedCLR/MUtils.h"
#include "Engine/Scripting/Scripting.h"
#include "Engine/Scripting/BinaryModule.h"
#include "Engine/Profiler/ProfilerCPU.h"
#include "Engine/Threading/Threading.h"
#include "Engine/Debug/Exceptions/CLRInnerException.h"
#include <mono/jit/jit.h>
#include <mono/utils/mono-counters.h>
#include <mono/utils/mono-logger.h>
#include <mono/metadata/appdomain.h>
#include <mono/metadata/object.h>
#include <mono/metadata/assembly.h>
#include <mono/metadata/attrdefs.h>
#include <mono/metadata/threads.h>
#include <mono/metadata/mono-debug.h>
#include <mono/metadata/mono-config.h>
#include <mono/metadata/mono-gc.h>
#include <mono/metadata/profiler.h>
#include <mono/metadata/tokentype.h>
#include <mono/metadata/exception.h>
#if !USE_MONO_DYNAMIC_LIB
#include <mono/utils/mono-dl-fallback.h>
#endif

#ifdef USE_MONO_AOT_MODULE
void* MonoAotModuleHandle = nullptr;
#endif

#define GET_CUSTOM_ATTR() (MonoCustomAttrInfo*)(_attrInfo ? _attrInfo : _attrInfo = mono_custom_attrs_from_class(_monoClass))

extern MDomain* MRootDomain;
extern MDomain* MActiveDomain;
extern Array<MDomain*, FixedAllocation<4>> MDomains;

// Inlined mono private types to access MonoType internals

typedef struct _MonoGenericClass MonoGenericClass;
typedef struct _MonoGenericContext MonoGenericContext;

struct _MonoGenericInst
{
    unsigned int id;
    unsigned int type_argc : 22;
    unsigned int is_open : 1;
    MonoType* type_argv[MONO_ZERO_LEN_ARRAY];
};

struct _MonoGenericContext
{
    MonoGenericInst* class_inst;
    MonoGenericInst* method_inst;
};

struct _MonoGenericClass
{
    MonoClass* container_class;
    MonoGenericContext context;
    unsigned int is_dynamic : 1;
    unsigned int is_tb_open : 1;
    unsigned int need_sync : 1;
    MonoClass* cached_class;
    class MonoImageSet* owner;
};

struct _MonoType
{
    union
    {
        MonoClass* klass;
        MonoType* type;
        MonoArrayType* array;
        MonoMethodSignature* method;
        MonoGenericParam* generic_param;
        MonoGenericClass* generic_class;
    } data;

    unsigned int attrs : 16;
    MonoTypeEnum type : 8;
    unsigned int has_cmods : 1;
    unsigned int byref : 1;
    unsigned int pinned : 1;
};

namespace
{
    static StringAnsi PlusStr("+");
    static StringAnsi DotStr(".");

    void GetClassFullname(MonoClass* monoClass, StringAnsi& fullname)
    {
        // Name
        fullname = mono_class_get_name(monoClass);

        // Outer class for nested types
        MonoClass* nestingClass = mono_class_get_nesting_type(monoClass);
        MonoClass* lastClass = monoClass;
        while (nestingClass)
        {
            lastClass = nestingClass;
            fullname = mono_class_get_name(nestingClass) + PlusStr + fullname;
            nestingClass = mono_class_get_nesting_type(nestingClass);
        }

        // Namespace
        const char* lastClassNamespace = mono_class_get_namespace(lastClass);
        if (lastClassNamespace && *lastClassNamespace)
            fullname = lastClassNamespace + DotStr + fullname;

        // Generic instance arguments
        MonoType* mType = mono_class_get_type(monoClass);
        if (mType && mType->type == MONO_TYPE_GENERICINST)
        {
            fullname += '[';
            StringAnsi tmp;
            for (unsigned int i = 0; i < mType->data.generic_class->context.class_inst->type_argc; i++)
            {
                if (i != 0)
                    fullname += ',';
                MType* argType = mType->data.generic_class->context.class_inst->type_argv[i];
                GetClassFullname(mono_class_from_mono_type(argType), tmp);
                fullname += tmp;
            }
            fullname += ']';
        }
    }

    MClass* FindClass(MonoClass* monoClass, bool addIfMissing = true)
    {
        if (monoClass == nullptr)
            return nullptr;
        PROFILE_CPU();
        auto& modules = BinaryModule::GetModules();
        for (auto module : modules)
        {
            auto managedModule = dynamic_cast<ManagedBinaryModule*>(module);
            if (managedModule && managedModule->Assembly->IsLoaded())
            {
                MClass* result = managedModule->Assembly->GetClass(monoClass);
                if (result != nullptr)
                    return result;
            }
        }
        if (addIfMissing)
        {
            MISSING_CODE("TODO: register new MClass"); // TODO: this might happen when for example querying class to array of game script type and it should add new MClass to handle this
        }
        return nullptr;
    }
}

MDomain* MCore::CreateDomain(const StringAnsi& domainName)
{
#if USE_MONO_AOT
    LOG(Fatal, "Scripts can run only in single domain mode with AOT mode enabled.");
    return nullptr;
#endif

    for (int32 i = 0; i < MDomains.Count(); i++)
    {
        if (MDomains[i]->GetName() == domainName)
            return MDomains[i];
    }

    auto domain = New<MDomain>(domainName);
    const auto monoDomain = mono_domain_create_appdomain((char*)domainName.Get(), nullptr);
#if MONO_DEBUG_ENABLE
    mono_debug_domain_create(monoDomain);
#endif
    ASSERT(monoDomain);
    domain->_monoDomain = monoDomain;
    MDomains.Add(domain);
    return domain;
}

void MCore::UnloadDomain(const StringAnsi& domainName)
{
    int32 i = 0;
    for (; i < MDomains.Count(); i++)
    {
        if (MDomains[i]->GetName() == domainName)
            break;
    }
    if (i == MDomains.Count())
        return;

    auto domain = MDomains[i];
#if MONO_DEBUG_ENABLE
    //mono_debug_domain_unload(domain->GetNative());
#endif
    //mono_domain_finalize(domain->GetNative(), 2000);
    MObject* exception = nullptr;
    mono_domain_try_unload(domain->GetNative(), &exception);
    if (exception)
    {
        MException ex(exception);
        ex.Log(LogType::Fatal, TEXT("Scripting::Release"));
    }
    Delete(domain);
    MDomains.RemoveAtKeepOrder(i);
}

#if 0

void* MonoMalloc(size_t size)
{
	return malloc(size);
}

void* MonoRealloc(void* mem, size_t count)
{
	return realloc(mem, count);
}

void MonoFree(void* mem)
{
	return free(mem);
}

void* MonoCalloc(size_t count, size_t size)
{
	return calloc(count, size);
}

#endif

#if USE_MONO_PROFILER

#include "Engine/Core/Types/StringBuilder.h"

struct FlaxMonoProfiler
{
};

FlaxMonoProfiler Profiler;

struct StackWalkDataResult
{
    StringBuilder Buffer;
};

mono_bool OnStackWalk(MonoMethod* method, int32_t native_offset, int32_t il_offset, mono_bool managed, void* data)
{
    auto result = (StackWalkDataResult*)data;

    if (method)
    {
        auto mName = mono_method_get_name(method);
        auto mKlassNameSpace = mono_class_get_namespace(mono_method_get_class(method));
        auto mKlassName = mono_class_get_name(mono_method_get_class(method));
        result->Buffer.Append(mKlassNameSpace);
        result->Buffer.Append(TEXT("."));
        result->Buffer.Append(mKlassName);
        result->Buffer.Append(TEXT("::"));
        result->Buffer.Append(mName);
        result->Buffer.Append(TEXT("\n"));
    }
    else if (!managed)
    {
        result->Buffer.Append(TEXT("<unmanaged>\n"));
    }

    return 0;
}

void OnGCAllocation(MonoProfiler* profiler, MonoObject* obj)
{
    // Get allocation info
    auto klass = mono_object_get_class(obj);
    //auto name_space = mono_class_get_namespace(klass);
    //auto name = mono_class_get_name(klass);
    auto size = mono_class_instance_size(klass);

    //LOG(Info, "GC new: {0}.{1} ({2} bytes)", name_space, name, size);

#if 0
    if (ProfilerCPU::IsProfilingCurrentThread())
    {
        static int details = 0;
        if (details)
        {
            StackWalkDataResult stackTrace;
            stackTrace.Buffer.SetCapacity(1024);
            mono_stack_walk(&OnStackWalk, &stackTrace);

            const auto msg = String::Format(TEXT("GC new: {0}.{1} ({2} bytes). Stack Trace:\n{3}"), String(name_space), String(name), size, stackTrace.Buffer.ToStringView());
            Platform::Log(*msg);
            //LOG_STR(Info, msg);
        }
    }
#endif

#if COMPILE_WITH_PROFILER
    // Register allocation during the current CPU event
    auto thread = ProfilerCPU::GetCurrentThread();
    if (thread != nullptr && thread->Buffer.GetCount() != 0)
    {
        auto& activeEvent = thread->Buffer.Last().Event();
        if (activeEvent.End < ZeroTolerance)
        {
            activeEvent.ManagedMemoryAllocation += size;
        }
    }
#endif
}

void OnGCEvent(MonoProfiler* profiler, MonoProfilerGCEvent event, uint32_t generation, mono_bool is_serial)
{
#if COMPILE_WITH_PROFILER
    // GC
    static int32 ActiveEventIndex;
    if (event == MONO_GC_EVENT_PRE_STOP_WORLD_LOCKED)
    {
        ActiveEventIndex = ProfilerCPU::BeginEvent(TEXT("Garbage Collection"));
    }
    else if (event == MONO_GC_EVENT_POST_START_WORLD_UNLOCKED)
    {
        ProfilerCPU::EndEvent(ActiveEventIndex);
    }
#endif
}

#endif

void OnLogCallback(const char* logDomain, const char* logLevel, const char* message, mono_bool fatal, void* userData)
{
    String currentDomain(logDomain);
    String msg(message);
    msg.Replace('\n', ' ');

    static const char* monoErrorLevels[] =
    {
        nullptr,
        "error",
        "critical",
        "warning",
        "message",
        "info",
        "debug"
    };

    uint32 errorLevel = 0;
    if (logLevel != nullptr)
    {
        for (uint32 i = 1; i < 7; i++)
        {
            if (strcmp(monoErrorLevels[i], logLevel) == 0)
            {
                errorLevel = i;
                break;
            }
        }
    }

    if (currentDomain.IsEmpty())
    {
        auto domain = MCore::GetActiveDomain();
        if (domain != nullptr)
        {
            currentDomain = domain->GetName().Get();
        }
        else
        {
            currentDomain = "null";
        }
    }

#if 0
	// Print C# stack trace (crash may be caused by the managed code)
	if (mono_domain_get() && Assemblies::FlaxEngine.Assembly->IsLoaded())
	{
		const auto managedStackTrace = DebugLog::GetStackTrace();
		if (managedStackTrace.HasChars())
		{
			LOG(Warning, "Managed stack trace:");
			LOG_STR(Warning, managedStackTrace);
		}
	}
#endif

    if (errorLevel == 0)
    {
        Log::CLRInnerException(String::Format(TEXT("Message: {0} | Domain: {1}"), msg, currentDomain)).SetLevel(LogType::Error);
    }
    else if (errorLevel <= 2)
    {
        Log::CLRInnerException(String::Format(TEXT("Message: {0} | Domain: {1}"), msg, currentDomain)).SetLevel(LogType::Error);
    }
    else if (errorLevel <= 3)
    {
        LOG(Warning, "Message: {0} | Domain: {1}", msg, currentDomain);
    }
    else
    {
        LOG(Info, "Message: {0} | Domain: {1}", msg, currentDomain);
    }
}

void OnPrintCallback(const char* string, mono_bool isStdout)
{
    LOG_STR(Warning, String(string));
}

void OnPrintErrorCallback(const char* string, mono_bool isStdout)
{
    // HACK: ignore this message
    if (string && Platform::MemoryCompare(string, "debugger-agent: Unable to listen on ", 36) == 0)
        return;

    LOG_STR(Error, String(string));
}

#if PLATFORM_LINUX && !USE_MONO_DYNAMIC_LIB

#include <dlfcn.h>

#define MONO_THIS_LIB_HANDLE ((void*)(intptr)-1)

static void* ThisLibHandle = nullptr;

static void* OnMonoLinuxDlOpen(const char* name, int flags, char** err, void* user_data)
{
    void* result = nullptr;
	if (name && StringUtils::Compare(name + StringUtils::Length(name) - 17, "libmono-native.so") == 0)
    {
        result = MONO_THIS_LIB_HANDLE;
    }
    return result;
}

static void* OnMonoLinuxDlSym(void* handle, const char* name, char** err, void* user_data)
{
	void* result = nullptr;
    if (handle == MONO_THIS_LIB_HANDLE && ThisLibHandle != nullptr)
    {
        result = dlsym(ThisLibHandle, name);
    }
	return result;
}

#endif

bool MCore::LoadEngine()
{
    PROFILE_CPU();
    ASSERT(Globals::MonoPath.IsANSI());

    // Debugging Mono GC
    //Platform::SetEnvironmentVariable(TEXT("MONO_GC_DEBUG"), TEXT("6:gc-log.txt,check-remset-consistency,nursery-canaries"));

#if 0
    // Override memory allocation callback
    // TODO: use ENABLE_OVERRIDABLE_ALLOCATORS when building Mono to support memory callbacks or use counters for memory profiling
    MonoAllocatorVTable alloc;
    alloc.version = MONO_ALLOCATOR_VTABLE_VERSION;
    alloc.malloc = MonoMalloc;
    alloc.realloc = MonoRealloc;
    alloc.free = MonoFree;
    alloc.calloc = MonoCalloc;
    mono_set_allocator_vtable(&alloc);
#endif

#if USE_MONO_AOT
    mono_jit_set_aot_mode(USE_MONO_AOT_MODE);
#endif

#ifdef USE_MONO_AOT_MODULE
    // Load AOT module
    const DateTime aotModuleLoadStartTime = DateTime::Now();
    LOG(Info, "Loading Mono AOT module...");
    void* libAotModule = Platform::LoadLibrary(TEXT(USE_MONO_AOT_MODULE));
    if (libAotModule == nullptr)
    {
        LOG(Error, "Failed to laod Mono AOT module (" TEXT(USE_MONO_AOT_MODULE) ")");
        return true;
    }
    MonoAotModuleHandle = libAotModule;
    void* getModulesPtr = Platform::GetProcAddress(libAotModule, "GetMonoModules");
    if (getModulesPtr == nullptr)
    {
        LOG(Error, "Failed to get Mono AOT modules getter.");
        return true;
    }
    typedef int (*GetMonoModulesFunc)(void** buffer, int bufferSize);
    const auto getModules = (GetMonoModulesFunc)getModulesPtr;
    const int32 moduelsCount = getModules(nullptr, 0);
    void** modules = (void**)Allocator::Allocate(moduelsCount * sizeof(void*));
    getModules(modules, moduelsCount);
    for (int32 i = 0; i < moduelsCount; i++)
    {
        mono_aot_register_module((void**)modules[i]);
    }
    Allocator::Free(modules);
    LOG(Info, "Mono AOT module loaded in {0}ms", (int32)(DateTime::Now() - aotModuleLoadStartTime).GetTotalMilliseconds());
#endif

    // Set mono assemblies path
    StringAnsi pathLib = (Globals::MonoPath / TEXT("/lib")).ToStringAnsi();
    StringAnsi pathEtc = (Globals::MonoPath / TEXT("/etc")).ToStringAnsi();
    mono_set_dirs(pathLib.Get(), pathEtc.Get());

    // Setup debugger
    {
        int32 debuggerLogLevel = 0;
        if (CommandLine::Options.MonoLog.IsTrue())
        {
            LOG(Info, "Using detailed Mono logging");
            mono_trace_set_level_string("debug");
            debuggerLogLevel = 10;
        }
        else
        {
            mono_trace_set_level_string("warning");
        }

#if MONO_DEBUG_ENABLE && !PLATFORM_SWITCH
        StringAnsi debuggerIp = "127.0.0.1";
        uint16 debuggerPort = 41000 + Platform::GetCurrentProcessId() % 1000;
        if (CommandLine::Options.DebuggerAddress.HasValue())
        {
            const auto& address = CommandLine::Options.DebuggerAddress.GetValue();
            const int32 splitIndex = address.Find(':');
            if (splitIndex == INVALID_INDEX)
            {
                debuggerIp = address.ToStringAnsi();
            }
            else
            {
                debuggerIp = address.Left(splitIndex).ToStringAnsi();
                StringUtils::Parse(address.Right(address.Length() - splitIndex - 1).Get(), &debuggerPort);
            }
        }

        char buffer[150];
        sprintf(buffer, "--debugger-agent=transport=dt_socket,address=%s:%d,embedding=1,server=y,suspend=%s,loglevel=%d", debuggerIp.Get(), debuggerPort, CommandLine::Options.WaitForDebugger ? "y,timeout=5000" : "n", debuggerLogLevel);

        const char* options[] = {
            "--soft-breakpoints",
            //"--optimize=float32",
            buffer
        };
        mono_jit_parse_options(ARRAY_COUNT(options), (char**)options);

        mono_debug_init(MONO_DEBUG_FORMAT_MONO, 0);
        LOG(Info, "Mono debugger server at {0}:{1}", ::String(debuggerIp), debuggerPort);
#endif

        // Connects to mono engine callback system
        mono_trace_set_log_handler(OnLogCallback, nullptr);
        mono_trace_set_print_handler(OnPrintCallback);
        mono_trace_set_printerr_handler(OnPrintErrorCallback);
    }

#if USE_MONO_PROFILER
    // Setup profiler options
    bool useExternalProfiler = false;
    {
        ::String monoEnvOptions;
        if (!Platform::GetEnvironmentVariable(TEXT("MONO_ENV_OPTIONS"), monoEnvOptions))
        {
            const StringView prefix(TEXT("--profile="));
            if (monoEnvOptions.StartsWith(prefix))
            {
                monoEnvOptions = monoEnvOptions.Substring(prefix.Length());
                LOG(Info, "Loading Mono profiler with options \'{0}\'", monoEnvOptions);
                StringAnsi monoEnvOptionsAnsi(monoEnvOptions);
                mono_profiler_load(monoEnvOptionsAnsi.Get());
                useExternalProfiler = true;
            }
        }
    }
#endif

#if PLATFORM_ANDROID
    // Disable any AOT code on Android
    mono_jit_set_aot_mode(MONO_AOT_MODE_NONE);

    // Hint to use default system assemblies location
    const StringAnsi assembliesPath = (Globals::MonoPath / TEXT("/lib/mono/2.1")).ToStringAnsi();
    mono_set_assemblies_path(*assembliesPath);
#elif PLATFORM_LINUX
    // Adjust GC threads suspending mode on Linux
    Platform::SetEnvironmentVariable(TEXT("MONO_THREADS_SUSPEND"), TEXT("preemptive"));

#if !USE_MONO_DYNAMIC_LIB
    // Hook for missing library (when using static linking)
    ThisLibHandle = dlopen(nullptr, RTLD_LAZY);
	mono_dl_fallback_register(OnMonoLinuxDlOpen, OnMonoLinuxDlSym, nullptr, nullptr);
#endif
#elif PLATFORM_MAC
    // Adjust GC threads suspending mode on Mac
    Platform::SetEnvironmentVariable(TEXT("MONO_THREADS_SUSPEND"), TEXT("preemptive"));
#endif
    const char* configPath = nullptr;
#if PLATFORM_SWITCH
    StringAnsi configPathBuf = (Globals::MonoPath / TEXT("/etc/mono/config")).ToStringAnsi();
    configPath = *configPathBuf;
    const StringAnsi assembliesPath = (Globals::MonoPath / TEXT("/lib/mono/4.5")).ToStringAnsi();
    mono_set_assemblies_path(*assembliesPath);
#endif
    mono_config_parse(configPath);

#if USE_MONO_PROFILER
    // Init profiler
    if (!useExternalProfiler)
    {
        const MonoProfilerHandle profilerHandle = mono_profiler_create((MonoProfiler*)&Profiler);
        mono_profiler_set_gc_allocation_callback(profilerHandle, &OnGCAllocation);
        mono_profiler_set_gc_event_callback(profilerHandle, &OnGCEvent);
        mono_profiler_enable_allocations();
    }
#endif

    // Init managed runtime
#if PLATFORM_ANDROID
    const char* monoVersion = "mobile";
#else
    const char* monoVersion = "v4.0.30319";
#endif
    auto monoRootDomain = mono_jit_init_version("Flax", monoVersion);
    ASSERT(monoRootDomain);
    MRootDomain = New<MDomain>("Root");
    MRootDomain->_monoDomain = monoRootDomain;
    MDomains.Add(MRootDomain);

    auto exePath = Platform::GetExecutableFilePath();
    auto configDir = StringUtils::GetDirectoryName(exePath).ToStringAnsi();
    auto configFilename = StringUtils::GetFileName(exePath).ToStringAnsi() + ".config";
#if PLATFORM_UWP
	// Change the app root to Mono sub directory to prevent loading .Net Core assemblies from the AppX root folder
	configDir += "\\Mono";
#elif PLATFORM_SWITCH
    // Make config file path absolute
    configFilename = exePath.ToStringAnsi() + ".config";
#endif
    mono_domain_set_config(monoRootDomain, configDir.Get(), configFilename.Get());
    mono_thread_set_main(mono_thread_current());

    // Info
    char* buildInfo = mono_get_runtime_build_info();
    LOG(Info, "Mono runtime version: {0}", ::String(buildInfo));
    mono_free(buildInfo);

    return false;
}

#if PLATFORM_WINDOWS && USE_EDITOR
long MonoHackSehExceptionHandler(class EXCEPTION_POINTERS* ep)
{
    LOG(Error, "Mono crashed on exit");
    return 1;
}
#endif

void MCore::UnloadEngine()
{
    // Only root domain should be alive at this point
    for (auto domain : MDomains)
    {
        if (domain != MRootDomain)
            Delete(domain);
    }
    MDomains.Clear();

    if (MRootDomain)
    {
#if PLATFORM_WINDOWS && USE_EDITOR
        // TODO: reduce issues with hot-reloading C# DLLs because sometimes it crashes on exit
        __try
#endif
        {
            mono_jit_cleanup(MRootDomain->GetNative());
        }
#if PLATFORM_WINDOWS && USE_EDITOR
        __except (MonoHackSehExceptionHandler(nullptr))
        {
        }
#endif
        Delete(MRootDomain);
        MRootDomain = nullptr;
    }

#ifdef USE_MONO_AOT_MODULE
    Platform::FreeLibrary(MonoAotModuleHandle);
#endif

#if PLATFORM_LINUX && !USE_MONO_DYNAMIC_LIB
    if (ThisLibHandle)
    {
        dlclose(ThisLibHandle);
        ThisLibHandle = nullptr;
    }
#endif
}

#if USE_EDITOR

void MCore::ReloadScriptingAssemblyLoadContext()
{
}

#endif

MObject* MCore::Object::Box(void* value, const MClass* klass)
{
    return mono_value_box(mono_domain_get(), klass->GetNative(), value);
}

void* MCore::Object::Unbox(MObject* obj)
{
    return (byte*)obj + sizeof(MonoObject);
    //return mono_object_unbox(obj);
}

MObject* MCore::Object::New(const MClass* klass)
{
    return mono_object_new(mono_domain_get(), klass->GetNative());
}

void MCore::Object::Init(MObject* obj)
{
    mono_runtime_object_init(obj);
}

MClass* MCore::Object::GetClass(MObject* obj)
{
    MonoClass* mclass = mono_object_get_class(obj);
    return FindClass(mclass);
}

MString* MCore::Object::ToString(MObject* obj)
{
    return mono_object_to_string(obj, nullptr);
}

int32 MCore::Object::GetHashCode(MObject* obj)
{
    return mono_object_hash(obj);
}

MString* MCore::String::GetEmpty(MDomain* domain)
{
    MonoDomain* mdomain = domain ? domain->GetNative() : mono_domain_get();
    return mono_string_empty(mdomain);
}

MString* MCore::String::New(const char* str, int32 length, MDomain* domain)
{
    MonoDomain* mdomain = domain ? domain->GetNative() : mono_domain_get();
    return mono_string_new_len(mdomain, str, length);
}

MString* MCore::String::New(const Char* str, int32 length, MDomain* domain)
{
    MonoDomain* mdomain = domain ? domain->GetNative() : mono_domain_get();
    return mono_string_new_utf16(mdomain, str, length);
}

StringView MCore::String::GetChars(MString* obj)
{
    return StringView(mono_string_chars(obj), (int32)mono_string_length(obj));
}

MArray* MCore::Array::New(const MClass* elementKlass, int32 length)
{
    // TODO: use shared empty arrays cache
    return mono_array_new(mono_domain_get(), elementKlass->GetNative(), length);
}

MClass* MCore::Array::GetClass(MClass* elementKlass)
{
    MonoClass* monoClass = mono_array_class_get(elementKlass->GetNative(), 1);
    return FindClass(monoClass);
}

int32 MCore::Array::GetLength(const MArray* obj)
{
    return (int32)mono_array_length((MonoArray*)obj);
}

void* MCore::Array::GetAddress(const MArray* obj)
{
    return mono_array_addr_with_size((MonoArray*)obj, 0, 0);
}

MArray* MCore::Array::Unbox(MObject* obj)
{
    return (MArray*)obj;
}

MGCHandle MCore::GCHandle::New(MObject* obj, bool pinned)
{
    return mono_gchandle_new(obj, pinned);
}

MGCHandle MCore::GCHandle::NewWeak(MObject* obj, bool trackResurrection)
{
    return mono_gchandle_new_weakref(obj, trackResurrection);
}

MObject* MCore::GCHandle::GetTarget(const MGCHandle& handle)
{
    return mono_gchandle_get_target(handle);
}

void MCore::GCHandle::Free(const MGCHandle& handle)
{
    mono_gchandle_free(handle);
}

void MCore::GC::Collect()
{
    PROFILE_CPU();
    mono_gc_collect(mono_gc_max_generation());
}

void MCore::GC::Collect(int32 generation)
{
    PROFILE_CPU();
    mono_gc_collect(generation);
}

void MCore::GC::Collect(int32 generation, MGCCollectionMode collectionMode, bool blocking, bool compacting)
{
    PROFILE_CPU();
    mono_gc_collect(generation);
}

int32 MCore::GC::MaxGeneration()
{
    PROFILE_CPU();
    return mono_gc_max_generation();
}

void MCore::GC::WaitForPendingFinalizers()
{
    PROFILE_CPU();
    if (mono_gc_pending_finalizers())
    {
        mono_gc_finalize_notify();
        do
        {
            Platform::Sleep(1);
        } while (mono_gc_pending_finalizers());
    }
}

void MCore::GC::WriteRef(void* ptr, MObject* ref)
{
    mono_gc_wbarrier_generic_store(ptr, ref);
}

void MCore::GC::WriteValue(void* dst, void* src, int32 count, const MClass* klass)
{
    mono_gc_wbarrier_value_copy(dst, src, count, klass->GetNative());
}

void MCore::GC::WriteArrayRef(MArray* dst, MObject* ref, int32 index)
{
    void* ptr = mono_array_addr_with_size(dst, 0, 0);
    mono_gc_wbarrier_set_arrayref(dst, (byte*)ptr + index * sizeof(void*), ref);
}

void MCore::GC::WriteArrayRef(MArray* dst, Span<MObject*> refs)
{
    void* ptr = mono_array_addr_with_size(dst, 0, 0);
    for (int32 index = 0; index < refs.Length(); index++)
        mono_gc_wbarrier_set_arrayref(dst, (byte*)ptr + index * sizeof(void*), refs[index]);
}

void MCore::Thread::Attach()
{
    if (!IsInMainThread() && !mono_domain_get())
    {
        const auto domain = GetActiveDomain();
        ASSERT(domain);
        mono_thread_attach(domain->GetNative());
    }
}

void MCore::Thread::Exit()
{
    if (!IsInMainThread() && mono_domain_get())
    {
        LOG(Info, "Thread 0x{0:x} exits the managed runtime", Platform::GetCurrentThreadID());
        // TODO: use mono_thread_detach but modify mono to call mono_thread_info_detach there so the thread goes into STATE_DETACHED
        mono_thread_exit();
    }
}

bool MCore::Thread::IsAttached()
{
    return mono_domain_get() && mono_thread_current();
}

void MCore::Exception::Throw(MObject* exception)
{
    mono_raise_exception((MonoException*)exception);
}

MObject* MCore::Exception::GetNullReference()
{
    return (MonoObject*)mono_get_exception_null_reference();
}

MObject* MCore::Exception::Get(const char* msg)
{
    return (MonoObject*)mono_exception_from_name_msg(mono_get_corlib(), "System", "Exception", msg);
}

MObject* MCore::Exception::GetArgument(const char* arg, const char* msg)
{
    return (MonoObject*)mono_get_exception_argument(arg, msg);
}

MObject* MCore::Exception::GetArgumentNull(const char* arg)
{
    return (MonoObject*)mono_get_exception_argument_null(arg);
}

MObject* MCore::Exception::GetArgumentOutOfRange(const char* arg)
{
    return (MonoObject*)mono_get_exception_argument_out_of_range(arg);
}

MObject* MCore::Exception::GetNotSupported(const char* msg)
{
    return (MonoObject*)mono_get_exception_not_supported(msg);
}

::String MCore::Type::ToString(MType* type)
{
    return ::String(mono_type_get_name(type));
}

MClass* MCore::Type::GetClass(MType* type)
{
    MonoClass* mclass = mono_class_from_mono_type(type);
    return FindClass(mclass);
}

MType* MCore::Type::GetElementType(MType* type)
{
    CRASH; // impl this (get type class and call GetElementClass)
    return nullptr;
}

int32 MCore::Type::GetSize(MType* type)
{
    int32 valueAlignment;
    return mono_type_stack_size(type, &valueAlignment);
}

MTypes MCore::Type::GetType(MType* type)
{
    return (MTypes)type->type;
}

bool MCore::Type::IsPointer(MType* type)
{
    return mono_type_is_pointer(type) != 0;
}

bool MCore::Type::IsReference(MType* type)
{
    return mono_type_is_reference(type) != 0;
}

MTypeObject* MCore::Type::GetObject(MType* type)
{
    return mono_type_get_object(mono_domain_get(), type);
}

MType* MCore::Type::Get(MTypeObject* type)
{
    return mono_reflection_type_get_type(type);
}

MClass* MAssembly::GetClass(MonoClass* monoClass) const
{
    if (monoClass == nullptr || !IsLoaded() || mono_class_get_image(monoClass) != _monoImage)
        return nullptr;

    // Find class by native pointer
    const auto& classes = GetClasses();
    const auto typeToken = mono_class_get_type_token(monoClass);
    for (auto i = classes.Begin(); i.IsNotEnd(); ++i)
    {
        MonoClass* e = i->Value->GetNative();
        if (e == monoClass || mono_class_get_type_token(e) == typeToken)
        {
            return i->Value;
        }
    }

#if 0
    {
        LOG(Warning, "Failed to find class {0}.{1} in assembly {2}. Classes:", String(mono_class_get_namespace(monoClass)), String(mono_class_get_name(monoClass)), ToString());
        for (auto i = classes.Begin(); i.IsNotEnd(); ++i)
        {
            LOG(Warning, " - {0}", String(i->Key));
        }
    }
#endif
    return nullptr;
}

MonoReflectionAssembly* MAssembly::GetNative() const
{
    if (!_monoAssembly)
        return nullptr;
    return mono_assembly_get_object(mono_domain_get(), _monoAssembly);
}

const MAssembly::ClassesDictionary& MAssembly::GetClasses() const
{
    if (_hasCachedClasses || !IsLoaded())
        return _classes;
    PROFILE_CPU();
    const auto startTime = DateTime::NowUTC();

#if TRACY_ENABLE
    const StringAnsiView monoImageName(mono_image_get_name(_monoImage));
    ZoneText(*monoImageName, monoImageName.Length());
#endif
    ScopeLock lock(_locker);
    if (_hasCachedClasses)
        return _classes;
    ASSERT(_classes.IsEmpty());
    const int32 numRows = mono_image_get_table_rows(_monoImage, MONO_TABLE_TYPEDEF);
    _classes.EnsureCapacity(numRows * 4);
    for (int32 i = 1; i < numRows; i++) // Skip <Module> class
    {
        MonoClass* klass = mono_class_get(_monoImage, (i + 1) | MONO_TOKEN_TYPE_DEF);

        // Build the typename
        StringAnsi fullname;
        GetClassFullname(klass, fullname);

        // Create class object
        auto mclass = New<MClass>(this, klass, fullname);
        _classes.Add(fullname, mclass);
    }

    const auto endTime = DateTime::NowUTC();
    LOG(Info, "Caching classes for assembly {0} took {1}ms", String(_name), (int32)(endTime - startTime).GetTotalMilliseconds());

#if 0
    for (auto i = _classes.Begin(); i.IsNotEnd(); ++i)
        LOG(Info, "Class: {0}", String(i->Value->GetFullName()));
#endif

    _hasCachedClasses = true;
    return _classes;
}

bool MAssembly::Load(MonoImage* monoImage)
{
    if (IsLoaded())
        return false;
    PROFILE_CPU();
#if TRACY_ENABLE
    const StringAnsiView monoImageName(mono_image_get_name(monoImage));
    ZoneText(*monoImageName, monoImageName.Length());
#endif

    // Ensure to be unloaded
    Unload();

    // Start
    const auto startTime = DateTime::NowUTC();
    OnLoading();

    // Load
    _monoAssembly = mono_image_get_assembly(monoImage);
    if (_monoAssembly == nullptr)
    {
        OnLoadFailed();
        return true;
    }
    _monoImage = monoImage;
    _hasCachedClasses = false;

    // End
    OnLoaded(startTime);
    return false;
}

bool MAssembly::LoadCorlib()
{
    return Load(mono_get_corlib());
}

bool MAssembly::LoadImage(const String& assemblyPath, const StringView& nativePath)
{
    // Load assembly file data
    Array<byte> data;
    File::ReadAllBytes(assemblyPath, data);

    // Init Mono image
    MonoImageOpenStatus status;
    const auto name = assemblyPath.ToStringAnsi();
    const auto assemblyImage = mono_image_open_from_data_with_name(reinterpret_cast<char*>(data.Get()), data.Count(), true, &status, false, name.Get());
    if (status != MONO_IMAGE_OK || assemblyImage == nullptr)
    {
        Log::CLRInnerException(TEXT("Mono assembly image is invalid at ") + assemblyPath);
        return true;
    }

    // Setup assembly
    const auto assembly = mono_assembly_load_from_full(assemblyImage, name.Substring(0, name.Length() - 3).Get(), &status, false);
    mono_image_close(assemblyImage);
    if (status != MONO_IMAGE_OK || assembly == nullptr)
    {
        Log::CLRInnerException(TEXT("Mono assembly image is corrupted at ") + assemblyPath);
        return true;
    }

#if MONO_DEBUG_ENABLE
    // Try to load debug symbols (use portable PDB format)
    const auto pdbPath = String(StringUtils::GetPathWithoutExtension(assemblyPath)) + TEXT(".pdb");
    if (FileSystem::FileExists(pdbPath))
    {
        // Load .pdb file
        File::ReadAllBytes(pdbPath, _debugData);

        // Attach debugging symbols to image
        if (_debugData.HasItems())
        {
            mono_debug_open_image_from_memory(assemblyImage, _debugData.Get(), _debugData.Count());
        }
    }

    // TODO: load pdbs for custom third-party libs referenced by game assemblies for debugging
#if 0
    // Hack to load debug information for Newtonsoft.Json (enable it to debug C# code of json lib)
    if (assemblyPath.EndsWith(TEXT("FlaxEngine.CSharp.dll")))
    {
        static Array<byte> NewtonsoftJsonDebugData;
        File::ReadAllBytes(String(StringUtils::GetDirectoryName(assemblyPath)) / TEXT("Newtonsoft.Json.pdb"), NewtonsoftJsonDebugData);
        if (NewtonsoftJsonDebugData.HasItems())
        {
            StringAnsi tmp(String(StringUtils::GetDirectoryName(assemblyPath)) / TEXT("Newtonsoft.Json.dll"));
            MonoAssembly* a = mono_assembly_open(tmp.Get(), &status);
            if (a)
            {
                mono_debug_open_image_from_memory(mono_assembly_get_image(a), NewtonsoftJsonDebugData.Get(), NewtonsoftJsonDebugData.Count());
            }
        }
    }
#endif
#endif

    _monoAssembly = assembly;
    _monoImage = assemblyImage;
    _hasCachedClasses = false;
    _assemblyPath = assemblyPath;
    return false;
}

bool MAssembly::UnloadImage(bool isReloading)
{
    if (_monoImage)
    {
        if (isReloading)
        {
            LOG(Info, "Unloading managed assembly \'{0}\' (is reloading)", String(_name));

            mono_assembly_close(_monoAssembly);
        }
        else
        {
            // NOTE: do not try to close all the opened images
            //       that will cause the domain unload to crash because
            //       the images have already been closed (double free)
        }

        _monoAssembly = nullptr;
        _monoImage = nullptr;
    }
    return false;
}

bool MAssembly::ResolveMissingFile(String& assemblyPath) const
{
    return true;
}

MClass::MClass(const MAssembly* parentAssembly, MonoClass* monoClass, const StringAnsi& fullname)
    : _assembly(parentAssembly)
    , _fullname(fullname)
    , _hasCachedProperties(false)
    , _hasCachedFields(false)
    , _hasCachedMethods(false)
    , _hasCachedAttributes(false)
    , _hasCachedEvents(false)
    , _hasCachedInterfaces(false)
{
    _monoClass = monoClass;
    ASSERT(monoClass);

    const uint32_t flags = mono_class_get_flags(monoClass);

    switch (flags & MONO_TYPE_ATTR_VISIBILITY_MASK)
    {
    case MONO_TYPE_ATTR_NOT_PUBLIC:
    case MONO_TYPE_ATTR_NESTED_PRIVATE:
        _visibility = MVisibility::Private;
        break;
    case MONO_TYPE_ATTR_PUBLIC:
    case MONO_TYPE_ATTR_NESTED_PUBLIC:
        _visibility = MVisibility::Public;
        break;
    case MONO_TYPE_ATTR_NESTED_FAMILY:
    case MONO_TYPE_ATTR_NESTED_ASSEMBLY:
        _visibility = MVisibility::Internal;
        break;
    case MONO_TYPE_ATTR_NESTED_FAM_OR_ASSEM:
        _visibility = MVisibility::ProtectedInternal;
        break;
    case MONO_TYPE_ATTR_NESTED_FAM_AND_ASSEM:
        _visibility = MVisibility::PrivateProtected;
        break;
    default:
        CRASH;
    }

    const uint32_t staticClassFlags = MONO_TYPE_ATTR_ABSTRACT | MONO_TYPE_ATTR_SEALED;
    _isStatic = (flags & staticClassFlags) == staticClassFlags;
    _isSealed = !_isStatic && (flags & MONO_TYPE_ATTR_SEALED) == MONO_TYPE_ATTR_SEALED;
    _isAbstract = !_isStatic && (flags & MONO_TYPE_ATTR_ABSTRACT) == MONO_TYPE_ATTR_ABSTRACT;
    _isInterface = (flags & MONO_TYPE_ATTR_CLASS_SEMANTIC_MASK) == MONO_TYPE_ATTR_INTERFACE;
    _isValueType = mono_class_is_valuetype(monoClass);
    _isEnum = mono_class_is_enum(monoClass);
}

MClass::~MClass()
{
    if (_attrInfo)
        mono_custom_attrs_free((MonoCustomAttrInfo*)_attrInfo);
    _fields.ClearDelete();
    _properties.ClearDelete();
    _methods.ClearDelete();
    _attributes.ClearDelete();
    _events.ClearDelete();
}

StringAnsiView MClass::GetName() const
{
    return StringAnsiView(mono_class_get_name(_monoClass));
}

StringAnsiView MClass::GetNamespace() const
{
    return StringAnsiView(mono_class_get_namespace(_monoClass));
}

MType* MClass::GetType() const
{
    return mono_class_get_type(_monoClass);
}

MClass* MClass::GetBaseClass() const
{
    MonoClass* monoBase = mono_class_get_parent(_monoClass);
    if (monoBase == nullptr)
        return nullptr;
    return FindClass(monoBase);
}

bool MClass::IsSubClassOf(const MClass* klass, bool checkInterfaces) const
{
    return klass && mono_class_is_subclass_of(_monoClass, klass->GetNative(), checkInterfaces) != 0;
}

bool MClass::HasInterface(const MClass* klass) const
{
    return klass && mono_class_is_assignable_from(klass->GetNative(), _monoClass) != 0;
}

bool MClass::IsInstanceOfType(MObject* object) const
{
    if (object == nullptr)
        return false;
    MonoClass* monoClass = mono_object_get_class(object);
    return mono_class_is_subclass_of(monoClass, _monoClass, false) != 0;
}

uint32 MClass::GetInstanceSize() const
{
    uint32 align = 0;
    if (IsValueType())
        return mono_class_value_size(_monoClass, &align);
    return mono_class_instance_size(_monoClass);
}

MClass* MClass::GetElementClass() const
{
    MonoClass* monoClass = mono_class_get_element_class(_monoClass);
    return FindClass(monoClass);
}

MMethod* MClass::GetMethod(const char* name, int32 numParams) const
{
    // Lookup for cached method
    for (int32 i = 0; i < _methods.Count(); i++)
    {
        if (_methods[i]->GetName() == name && _methods[i]->GetParametersCount() == numParams)
            return _methods[i];
    }

    // Find Mono method
    MonoMethod* monoMethod = mono_class_get_method_from_name(_monoClass, name, numParams);
    if (monoMethod == nullptr)
        return nullptr;

    // Create method
    auto method = New<MMethod>(monoMethod, name, (MClass*)this);
    _methods.Add(method);
    return method;
}

const Array<MMethod*>& MClass::GetMethods() const
{
    if (_hasCachedMethods)
        return _methods;

    void* iter = nullptr;
    MonoMethod* curClassMethod;
    while ((curClassMethod = mono_class_get_methods(_monoClass, &iter)))
    {
        // Check if has not been added
        bool isMissing = true;
        for (int32 i = 0; i < _methods.Count(); i++)
        {
            if (_methods[i]->GetNative() == curClassMethod)
            {
                isMissing = false;
                break;
            }
        }

        if (isMissing)
        {
            // Create method
            auto method = New<MMethod>(curClassMethod, (MClass*)this);
            _methods.Add(method);
        }
    }

    _hasCachedMethods = true;
    return _methods;
}

MField* MClass::GetField(const char* name) const
{
    // Lookup for cached field
    for (int32 i = 0; i < _fields.Count(); i++)
    {
        if (_fields[i]->GetName() == name)
            return _fields[i];
    }

    // Find mono field
    MonoClassField* field = mono_class_get_field_from_name(_monoClass, name);
    if (field == nullptr)
        return nullptr;

    // Create field
    auto mfield = New<MField>(field, name, (MClass*)this);
    _fields.Add(mfield);
    return mfield;
}

const Array<MField*>& MClass::GetFields() const
{
    if (_hasCachedFields)
        return _fields;

    void* iter = nullptr;
    MonoClassField* curClassField;
    while ((curClassField = mono_class_get_fields(_monoClass, &iter)))
    {
        const char* fieldName = mono_field_get_name(curClassField);
        GetField(fieldName);
    }

    _hasCachedFields = true;
    return _fields;
}

const Array<MEvent*>& MClass::GetEvents() const
{
    if (_hasCachedEvents)
        return _events;

    void* iter = nullptr;
    MonoEvent* curEvent;
    while ((curEvent = mono_class_get_events(_monoClass, &iter)))
    {
        const char* name = mono_event_get_name(curEvent);
        bool missing = true;
        for (int32 i = 0; i < _events.Count(); i++)
        {
            if (_events[i]->GetName() == name)
            {
                missing = false;
                break;
            }
        }
        if (missing)
        {
            auto result = New<MEvent>(curEvent, name, (MClass*)this);
            _events.Add(result);
        }
    }

    _hasCachedEvents = true;
    return _events;
}

MProperty* MClass::GetProperty(const char* name) const
{
    // Lookup for cached property
    for (int32 i = 0; i < _properties.Count(); i++)
    {
        if (_properties[i]->GetName() == name)
            return _properties[i];
    }

    // Find mono property
    MonoProperty* monoProperty = mono_class_get_property_from_name(_monoClass, name);
    if (monoProperty == nullptr)
        return nullptr;

    // Create method
    auto mproperty = New<MProperty>(monoProperty, name, (MClass*)this);
    _properties.Add(mproperty);

    return mproperty;
}

class PhysicsColliderActorInternal
{
public:
    void CollisionEnter_ManagedWrapper(const int32& arg0)
    {
        MMethod* mmethod = nullptr;
        CHECK(mmethod);
        PROFILE_CPU_NAMED("FlaxEngine.PhysicsColliderActor::OnCollisionEnter");
        MonoObject* exception = nullptr;
        void* params[1];
        MonoObject* instance;
        mono_runtime_invoke(mmethod->GetNative(), instance, params, &exception);
        mmethod->Invoke(instance, params, &exception);
    }
};

const Array<MProperty*>& MClass::GetProperties() const
{
    if (_hasCachedProperties)
        return _properties;

    void* iter = nullptr;
    MonoProperty* curClassProperty;
    while ((curClassProperty = mono_class_get_properties(_monoClass, &iter)))
    {
        const char* propertyName = mono_property_get_name(curClassProperty);
        GetProperty(propertyName);
    }

    _hasCachedProperties = true;
    return _properties;
}

const Array<MClass*>& MClass::GetInterfaces() const
{
    if (_hasCachedInterfaces)
        return _interfaces;
    
    void* iter = nullptr;
    MonoClass* curInterface;
    while ((curInterface = mono_class_get_interfaces(_monoClass, &iter)))
    {
        _interfaces.Add(FindClass(curInterface));
    }

    _hasCachedInterfaces = true;
    return _interfaces;
}

bool MClass::HasAttribute(const MClass* monoClass) const
{
    MonoCustomAttrInfo* attrInfo = GET_CUSTOM_ATTR();
    return attrInfo != nullptr && mono_custom_attrs_has_attr(attrInfo, monoClass->GetNative()) != 0;
}

bool MClass::HasAttribute() const
{
    MonoCustomAttrInfo* attrInfo = GET_CUSTOM_ATTR();
    return attrInfo && attrInfo->num_attrs > 0;
}

MObject* MClass::GetAttribute(const MClass* monoClass) const
{
    MonoCustomAttrInfo* attrInfo = GET_CUSTOM_ATTR();
    return attrInfo ? mono_custom_attrs_get_attr(attrInfo, monoClass->GetNative()) : nullptr;
}

const Array<MObject*>& MClass::GetAttributes() const
{
    if (_hasCachedAttributes)
        return _attributes;
    _hasCachedAttributes = true;

    MonoCustomAttrInfo* attrInfo = GET_CUSTOM_ATTR();
    if (attrInfo == nullptr)
        return _attributes;

    MonoArray* monoAttributesArray = mono_custom_attrs_construct(attrInfo);
    const uint32 length = (uint32)mono_array_length(monoAttributesArray);
    _attributes.Resize(length);
    for (uint32 i = 0; i < length; i++)
        _attributes[i] = mono_array_get(monoAttributesArray, MonoObject*, i);
    mono_custom_attrs_free(attrInfo);
    return _attributes;
}

bool MDomain::SetCurrentDomain(bool force)
{
    if (mono_domain_set(_monoDomain, force) == 0)
        return false;
    MActiveDomain = this;
    return true;
}

void MDomain::Dispatch() const
{
    if (!IsInMainThread())
    {
        mono_thread_attach(_monoDomain);
    }
}

MEvent::MEvent(MonoEvent* monoEvent, const char* name, MClass* parentClass)
    : _monoEvent(monoEvent)
    , _addMethod(nullptr)
    , _removeMethod(nullptr)
    , _parentClass(parentClass)
    , _name(name)
    , _hasCachedAttributes(false)
    , _hasAddMonoMethod(true)
    , _hasRemoveMonoMethod(true)
{
#if BUILD_DEBUG
    // Validate input name
    ASSERT(StringUtils::Compare(name, mono_event_get_name(monoEvent)) == 0);
#endif
}

MMethod* MEvent::GetAddMethod() const
{
    if (!_hasAddMonoMethod)
        return nullptr;
    if (_addMethod == nullptr)
    {
        MonoMethod* addMonoMethod = mono_event_get_add_method(_monoEvent);
        if (addMonoMethod != nullptr)
        {
            _hasAddMonoMethod = true;
            return _addMethod = New<MMethod>(addMonoMethod, (MClass*)_parentClass);
        }
    }
    return _addMethod;
}

MMethod* MEvent::GetRemoveMethod() const
{
    if (!_hasRemoveMonoMethod)
        return nullptr;
    if (_removeMethod == nullptr)
    {
        MonoMethod* removeMonoMethod = mono_event_get_remove_method(_monoEvent);
        if (removeMonoMethod)
        {
            _hasRemoveMonoMethod = true;
            return _removeMethod = New<MMethod>(removeMonoMethod, (MClass*)_parentClass);
        }
    }
    return _removeMethod;
}

bool MEvent::HasAttribute(MClass* monoClass) const
{
    MonoClass* parentClass = mono_event_get_parent(_monoEvent);
    MonoCustomAttrInfo* attrInfo = mono_custom_attrs_from_event(parentClass, _monoEvent);
    if (attrInfo == nullptr)
        return false;

    const bool hasAttr = mono_custom_attrs_has_attr(attrInfo, monoClass->GetNative()) != 0;
    mono_custom_attrs_free(attrInfo);
    return hasAttr;
}

bool MEvent::HasAttribute() const
{
    MonoClass* parentClass = mono_event_get_parent(_monoEvent);
    MonoCustomAttrInfo* attrInfo = mono_custom_attrs_from_event(parentClass, _monoEvent);
    if (attrInfo == nullptr)
        return false;

    if (attrInfo->num_attrs > 0)
    {
        mono_custom_attrs_free(attrInfo);
        return true;
    }
    mono_custom_attrs_free(attrInfo);
    return false;
}

MObject* MEvent::GetAttribute(MClass* monoClass) const
{
    MonoClass* parentClass = mono_event_get_parent(_monoEvent);
    MonoCustomAttrInfo* attrInfo = mono_custom_attrs_from_event(parentClass, _monoEvent);
    if (attrInfo == nullptr)
        return nullptr;

    MonoObject* foundAttr = mono_custom_attrs_get_attr(attrInfo, monoClass->GetNative());
    mono_custom_attrs_free(attrInfo);
    return foundAttr;
}

const Array<MObject*>& MEvent::GetAttributes() const
{
    if (_hasCachedAttributes)
        return _attributes;
    _hasCachedAttributes = true;

    MonoClass* parentClass = mono_event_get_parent(_monoEvent);
    MonoCustomAttrInfo* attrInfo = mono_custom_attrs_from_event(parentClass, _monoEvent);
    if (attrInfo == nullptr)
        return _attributes;

    MonoArray* monoAttributesArray = mono_custom_attrs_construct(attrInfo);
    const uint32 length = (uint32)mono_array_length(monoAttributesArray);
    _attributes.Resize(length);
    for (uint32 i = 0; i < length; i++)
        _attributes[i] = mono_array_get(monoAttributesArray, MonoObject*, i);
    mono_custom_attrs_free(attrInfo);
    return _attributes;
}

MException::MException(MObject* exception)
    : InnerException(nullptr)
{
    ASSERT(exception);

    MonoClass* exceptionClass = mono_object_get_class(exception);
    MonoProperty* exceptionMsgProp = mono_class_get_property_from_name(exceptionClass, "Message");
    MonoMethod* exceptionMsgGetter = mono_property_get_get_method(exceptionMsgProp);
    MonoString* exceptionMsg = (MonoString*)mono_runtime_invoke(exceptionMsgGetter, exception, nullptr, nullptr);
    Message = MUtils::ToString(exceptionMsg);

    MonoProperty* exceptionStackProp = mono_class_get_property_from_name(exceptionClass, "StackTrace");
    MonoMethod* exceptionStackGetter = mono_property_get_get_method(exceptionStackProp);
    MonoString* exceptionStackTrace = (MonoString*)mono_runtime_invoke(exceptionStackGetter, exception, nullptr, nullptr);
    StackTrace = MUtils::ToString(exceptionStackTrace);

    MonoProperty* innerExceptionProp = mono_class_get_property_from_name(exceptionClass, "InnerException");
    MonoMethod* innerExceptionGetter = mono_property_get_get_method(innerExceptionProp);
    MonoObject* innerException = (MonoObject*)mono_runtime_invoke(innerExceptionGetter, exception, nullptr, nullptr);
    if (innerException)
        InnerException = New<MException>(innerException);
}

MException::~MException()
{
    if (InnerException)
        Delete(InnerException);
}

MField::MField(MonoClassField* monoField, const char* name, MClass* parentClass)
    : _monoField(monoField)
    , _monoType(mono_field_get_type(monoField))
    , _parentClass(parentClass)
    , _name(name)
    , _hasCachedAttributes(false)
{
#if BUILD_DEBUG
    // Validate input name
    ASSERT(StringUtils::Compare(name, mono_field_get_name(monoField)) == 0);
#endif

    const uint32_t flags = mono_field_get_flags(monoField);
    switch (flags & MONO_FIELD_ATTR_FIELD_ACCESS_MASK)
    {
    case MONO_FIELD_ATTR_PRIVATE:
        _visibility = MVisibility::Private;
        break;
    case MONO_FIELD_ATTR_FAM_AND_ASSEM:
        _visibility = MVisibility::PrivateProtected;
        break;
    case MONO_FIELD_ATTR_ASSEMBLY:
        _visibility = MVisibility::Internal;
        break;
    case MONO_FIELD_ATTR_FAMILY:
        _visibility = MVisibility::Protected;
        break;
    case MONO_FIELD_ATTR_FAM_OR_ASSEM:
        _visibility = MVisibility::ProtectedInternal;
        break;
    case MONO_FIELD_ATTR_PUBLIC:
        _visibility = MVisibility::Public;
        break;
    default:
        CRASH;
    }
    _isStatic = (flags & MONO_FIELD_ATTR_STATIC) != 0;
}

MType* MField::GetType() const
{
    return _monoType;
}

int32 MField::GetOffset() const
{
    return (int32)(mono_field_get_offset(_monoField) - sizeof(MonoObject));
}

void MField::GetValue(MObject* instance, void* result) const
{
    mono_field_get_value(instance, _monoField, result);
}

MObject* MField::GetValueBoxed(MObject* instance) const
{
    return mono_field_get_value_object(mono_domain_get(), _monoField, instance);
}

void MField::SetValue(MObject* instance, void* value) const
{
    mono_field_set_value(instance, _monoField, value);
}

bool MField::HasAttribute(MClass* monoClass) const
{
    MonoClass* parentClass = mono_field_get_parent(_monoField);
    MonoCustomAttrInfo* attrInfo = mono_custom_attrs_from_field(parentClass, _monoField);
    if (attrInfo == nullptr)
        return false;

    const bool hasAttr = mono_custom_attrs_has_attr(attrInfo, monoClass->GetNative()) != 0;
    mono_custom_attrs_free(attrInfo);
    return hasAttr;
}

bool MField::HasAttribute() const
{
    MonoClass* parentClass = mono_field_get_parent(_monoField);
    MonoCustomAttrInfo* attrInfo = mono_custom_attrs_from_field(parentClass, _monoField);
    if (attrInfo == nullptr)
        return false;

    if (attrInfo->num_attrs > 0)
    {
        mono_custom_attrs_free(attrInfo);
        return true;
    }
    mono_custom_attrs_free(attrInfo);
    return false;
}

MObject* MField::GetAttribute(MClass* monoClass) const
{
    MonoClass* parentClass = mono_field_get_parent(_monoField);
    MonoCustomAttrInfo* attrInfo = mono_custom_attrs_from_field(parentClass, _monoField);
    if (attrInfo == nullptr)
        return nullptr;

    MonoObject* foundAttr = mono_custom_attrs_get_attr(attrInfo, monoClass->GetNative());
    mono_custom_attrs_free(attrInfo);
    return foundAttr;
}

const Array<MObject*>& MField::GetAttributes() const
{
    if (_hasCachedAttributes)
        return _attributes;
    _hasCachedAttributes = true;

    MonoClass* parentClass = mono_field_get_parent(_monoField);
    MonoCustomAttrInfo* attrInfo = mono_custom_attrs_from_field(parentClass, _monoField);
    if (attrInfo == nullptr)
        return _attributes;

    MonoArray* monoAttributesArray = mono_custom_attrs_construct(attrInfo);
    const uint32 length = (uint32)mono_array_length(monoAttributesArray);
    _attributes.Resize(length);
    for (uint32 i = 0; i < length; i++)
        _attributes[i] = mono_array_get(monoAttributesArray, MonoObject*, i);
    mono_custom_attrs_free(attrInfo);
    return _attributes;
}

MMethod::MMethod(MonoMethod* monoMethod, MClass* parentClass)
    : MMethod(monoMethod, mono_method_get_name(monoMethod), parentClass)
{
}

MMethod::MMethod(MonoMethod* monoMethod, const char* name, MClass* parentClass)
    : _monoMethod(monoMethod)
    , _parentClass(parentClass)
    , _name(name)
    , _hasCachedAttributes(false)
{
#if BUILD_DEBUG
    // Validate input name
    ASSERT(StringUtils::Compare(name, mono_method_get_name(monoMethod)) == 0);
#endif

    const uint32_t flags = mono_method_get_flags(monoMethod, nullptr);
    _isStatic = (flags & MONO_METHOD_ATTR_STATIC) != 0;
    switch (flags & MONO_METHOD_ATTR_ACCESS_MASK)
    {
    case MONO_METHOD_ATTR_PRIVATE:
        _visibility = MVisibility::Private;
        break;
    case MONO_METHOD_ATTR_FAM_AND_ASSEM:
        _visibility = MVisibility::PrivateProtected;
        break;
    case MONO_METHOD_ATTR_ASSEM:
        _visibility = MVisibility::Internal;
        break;
    case MONO_METHOD_ATTR_FAMILY:
        _visibility = MVisibility::Protected;
        break;
    case MONO_METHOD_ATTR_FAM_OR_ASSEM:
        _visibility = MVisibility::ProtectedInternal;
        break;
    case MONO_METHOD_ATTR_PUBLIC:
        _visibility = MVisibility::Public;
        break;
    default:
        CRASH;
    }

#if COMPILE_WITH_PROFILER
    const StringAnsi& className = parentClass->GetFullName();
    ProfilerName.Resize(className.Length() + 2 + _name.Length());
    Platform::MemoryCopy(ProfilerName.Get(), className.Get(), className.Length());
    ProfilerName.Get()[className.Length()] = ':';
    ProfilerName.Get()[className.Length() + 1] = ':';
    Platform::MemoryCopy(ProfilerName.Get() + className.Length() + 2, _name.Get(), _name.Length());
    ProfilerData.name = ProfilerName.Get();
    ProfilerData.function = _name.Get();
    ProfilerData.file = nullptr;
    ProfilerData.line = 0;
    ProfilerData.color = 0;
#endif
}

MObject* MMethod::Invoke(void* instance, void** params, MObject** exception) const
{
    PROFILE_CPU_SRC_LOC(ProfilerData);
    return mono_runtime_invoke(_monoMethod, instance, params, exception);
}

MObject* MMethod::InvokeVirtual(MObject* instance, void** params, MObject** exception) const
{
    PROFILE_CPU_SRC_LOC(ProfilerData);
    MonoMethod* virtualMethod = mono_object_get_virtual_method(instance, _monoMethod);
    return mono_runtime_invoke(virtualMethod, instance, params, exception);
}

#if !USE_MONO_AOT

void* MMethod::GetThunk()
{
    if (!_cachedThunk)
        _cachedThunk = mono_method_get_unmanaged_thunk(_monoMethod);
    return _cachedThunk;
}

#endif

MMethod* MMethod::InflateGeneric() const
{
    MonoMethod* inflatedMethod = mono_class_inflate_generic_method(_monoMethod, nullptr);
    // TODO: don't leak created method
    return New<MMethod>(inflatedMethod, _parentClass);
}

MType* MMethod::GetReturnType() const
{
    MonoMethodSignature* sig = mono_method_signature(_monoMethod);
    return mono_signature_get_return_type(sig);
}

int32 MMethod::GetParametersCount() const
{
    MonoMethodSignature* sig = mono_method_signature(_monoMethod);
    return (int32)mono_signature_get_param_count(sig);
}

MType* MMethod::GetParameterType(int32 paramIdx) const
{
    MonoMethodSignature* sig = mono_method_signature(_monoMethod);
    ASSERT_LOW_LAYER(paramIdx >= 0 && paramIdx < (int32)mono_signature_get_param_count(sig));
    void* it = nullptr;
    mono_signature_get_params(sig, &it);
    return ((MonoType**)it)[paramIdx];
}

bool MMethod::GetParameterIsOut(int32 paramIdx) const
{
    MonoMethodSignature* sig = mono_method_signature(_monoMethod);
    ASSERT_LOW_LAYER(paramIdx >= 0 && paramIdx < (int32)mono_signature_get_param_count(sig));
    return mono_signature_param_is_out(sig, paramIdx) != 0;
}

bool MMethod::HasAttribute(MClass* monoClass) const
{
    MonoCustomAttrInfo* attrInfo = mono_custom_attrs_from_method(_monoMethod);
    if (attrInfo == nullptr)
        return false;

    const bool hasAttr = mono_custom_attrs_has_attr(attrInfo, monoClass->GetNative()) != 0;
    mono_custom_attrs_free(attrInfo);
    return hasAttr;
}

bool MMethod::HasAttribute() const
{
    MonoCustomAttrInfo* attrInfo = mono_custom_attrs_from_method(_monoMethod);
    if (attrInfo == nullptr)
        return false;

    if (attrInfo->num_attrs > 0)
    {
        mono_custom_attrs_free(attrInfo);
        return true;
    }
    mono_custom_attrs_free(attrInfo);
    return false;
}

MObject* MMethod::GetAttribute(MClass* monoClass) const
{
    MonoCustomAttrInfo* attrInfo = mono_custom_attrs_from_method(_monoMethod);
    if (attrInfo == nullptr)
        return nullptr;

    MonoObject* foundAttr = mono_custom_attrs_get_attr(attrInfo, monoClass->GetNative());
    mono_custom_attrs_free(attrInfo);
    return foundAttr;
}

const Array<MObject*>& MMethod::GetAttributes() const
{
    if (_hasCachedAttributes)
        return _attributes;
    _hasCachedAttributes = true;

    MonoCustomAttrInfo* attrInfo = mono_custom_attrs_from_method(_monoMethod);
    if (attrInfo == nullptr)
        return _attributes;

    MonoArray* monoAttributesArray = mono_custom_attrs_construct(attrInfo);
    const uint32 length = (uint32)mono_array_length(monoAttributesArray);
    _attributes.Resize(length);
    for (uint32 i = 0; i < length; i++)
        _attributes[i] = mono_array_get(monoAttributesArray, MonoObject*, i);
    mono_custom_attrs_free(attrInfo);
    return _attributes;
}

MProperty::MProperty(MonoProperty* monoProperty, const char* name, MClass* parentClass)
    : _monoProperty(monoProperty)
    , _getMethod(nullptr)
    , _setMethod(nullptr)
    , _parentClass(parentClass)
    , _name(name)
    , _hasCachedAttributes(false)
    , _hasSetMethod(true)
    , _hasGetMethod(true)
{
#if BUILD_DEBUG
    // Validate input name
    ASSERT(StringUtils::Compare(name, mono_property_get_name(monoProperty)) == 0);
#endif

    GetGetMethod();
    GetSetMethod();
}

MProperty::~MProperty()
{
    if (_getMethod)
        Delete(_getMethod);
    if (_setMethod)
        Delete(_setMethod);
}

MMethod* MProperty::GetGetMethod() const
{
    if (!_hasGetMethod)
        return nullptr;
    if (_getMethod == nullptr)
    {
        MonoMethod* method = mono_property_get_get_method(_monoProperty);
        if (method != nullptr)
        {
            _hasGetMethod = true;
            return _getMethod = New<MMethod>(method, (MClass*)_parentClass);
        }
    }
    return _getMethod;
}

MMethod* MProperty::GetSetMethod() const
{
    if (!_hasSetMethod)
        return nullptr;
    if (_setMethod == nullptr)
    {
        MonoMethod* method = mono_property_get_set_method(_monoProperty);
        if (method != nullptr)
        {
            _hasSetMethod = true;
            return _setMethod = New<MMethod>(method, (MClass*)_parentClass);
        }
    }
    return _setMethod;
}

MObject* MProperty::GetValue(MObject* instance, MObject** exception) const
{
    return mono_property_get_value(_monoProperty, instance, nullptr, exception);
}

void MProperty::SetValue(MObject* instance, void* value, MObject** exception) const
{
    void* params[1];
    params[0] = value;
    mono_property_set_value(_monoProperty, instance, params, exception);
}

bool MProperty::HasAttribute(MClass* monoClass) const
{
    MonoClass* parentClass = mono_property_get_parent(_monoProperty);
    MonoCustomAttrInfo* attrInfo = mono_custom_attrs_from_property(parentClass, _monoProperty);
    if (attrInfo == nullptr)
        return false;

    const bool hasAttr = mono_custom_attrs_has_attr(attrInfo, monoClass->GetNative()) != 0;
    mono_custom_attrs_free(attrInfo);
    return hasAttr;
}

bool MProperty::HasAttribute() const
{
    MonoClass* parentClass = mono_property_get_parent(_monoProperty);
    MonoCustomAttrInfo* attrInfo = mono_custom_attrs_from_property(parentClass, _monoProperty);
    if (attrInfo == nullptr)
        return false;

    if (attrInfo->num_attrs > 0)
    {
        mono_custom_attrs_free(attrInfo);
        return true;
    }
    mono_custom_attrs_free(attrInfo);
    return false;
}

MObject* MProperty::GetAttribute(MClass* monoClass) const
{
    MonoClass* parentClass = mono_property_get_parent(_monoProperty);
    MonoCustomAttrInfo* attrInfo = mono_custom_attrs_from_property(parentClass, _monoProperty);
    if (attrInfo == nullptr)
        return nullptr;

    MonoObject* foundAttr = mono_custom_attrs_get_attr(attrInfo, monoClass->GetNative());
    mono_custom_attrs_free(attrInfo);
    return foundAttr;
}

const Array<MObject*>& MProperty::GetAttributes() const
{
    if (_hasCachedAttributes)
        return _attributes;
    _hasCachedAttributes = true;

    MonoClass* parentClass = mono_property_get_parent(_monoProperty);
    MonoCustomAttrInfo* attrInfo = mono_custom_attrs_from_property(parentClass, _monoProperty);
    if (attrInfo == nullptr)
        return _attributes;

    MonoArray* monoAttributesArray = mono_custom_attrs_construct(attrInfo);
    const uint32 length = (uint32)mono_array_length(monoAttributesArray);
    _attributes.Resize(length);
    for (uint32 i = 0; i < length; i++)
        _attributes[i] = mono_array_get(monoAttributesArray, MonoObject*, i);
    mono_custom_attrs_free(attrInfo);
    return _attributes;
}

#endif

#if USE_MONO && PLATFORM_WIN32 && !USE_MONO_DYNAMIC_LIB

// Export Mono functions
#pragma comment(linker, "/export:mono_add_internal_call")
#pragma comment(linker, "/export:mono_array_addr_with_size")
#pragma comment(linker, "/export:mono_array_calc_byte_len")
#pragma comment(linker, "/export:mono_array_class_get")
#pragma comment(linker, "/export:mono_array_clone")
#pragma comment(linker, "/export:mono_array_clone_checked")
#pragma comment(linker, "/export:mono_array_clone_in_domain")
#pragma comment(linker, "/export:mono_array_element_size")
#pragma comment(linker, "/export:mono_array_full_copy")
#pragma comment(linker, "/export:mono_array_handle_length")
#pragma comment(linker, "/export:mono_array_handle_memcpy_refs")
#pragma comment(linker, "/export:mono_array_handle_pin_with_size")
#pragma comment(linker, "/export:mono_array_length")
#pragma comment(linker, "/export:mono_array_new")
#pragma comment(linker, "/export:mono_array_new_1")
#pragma comment(linker, "/export:mono_array_new_2")
#pragma comment(linker, "/export:mono_array_new_3")
#pragma comment(linker, "/export:mono_array_new_4")
#pragma comment(linker, "/export:mono_array_new_checked")
#pragma comment(linker, "/export:mono_array_new_full")
#pragma comment(linker, "/export:mono_array_new_full_checked")
#pragma comment(linker, "/export:mono_array_new_full_handle")
#pragma comment(linker, "/export:mono_array_new_handle")
#pragma comment(linker, "/export:mono_array_new_specific")
#pragma comment(linker, "/export:mono_array_new_specific_checked")
#pragma comment(linker, "/export:mono_array_new_specific_handle")
#pragma comment(linker, "/export:mono_array_new_va")
#pragma comment(linker, "/export:mono_array_to_byte_byvalarray")
#pragma comment(linker, "/export:mono_array_to_lparray")
#pragma comment(linker, "/export:mono_array_to_savearray")
#pragma comment(linker, "/export:mono_assembly_addref")
#pragma comment(linker, "/export:mono_assembly_binding_applies_to_image")
#pragma comment(linker, "/export:mono_assembly_candidate_predicate_sn_same_name")
#pragma comment(linker, "/export:mono_assembly_cleanup_domain_bindings")
#pragma comment(linker, "/export:mono_assembly_close")
#pragma comment(linker, "/export:mono_assembly_close_except_image_pools")
#pragma comment(linker, "/export:mono_assembly_close_finish")
#pragma comment(linker, "/export:mono_assembly_fill_assembly_name")
#pragma comment(linker, "/export:mono_assembly_fill_assembly_name_full")
#pragma comment(linker, "/export:mono_assembly_foreach")
#pragma comment(linker, "/export:mono_assembly_get_assemblyref")
#pragma comment(linker, "/export:mono_assembly_get_assemblyref_checked")
#pragma comment(linker, "/export:mono_assembly_get_image")
#pragma comment(linker, "/export:mono_assembly_get_image_internal")
#pragma comment(linker, "/export:mono_assembly_get_main")
#pragma comment(linker, "/export:mono_assembly_get_name")
#pragma comment(linker, "/export:mono_assembly_get_name_internal")
#pragma comment(linker, "/export:mono_assembly_get_object")
#pragma comment(linker, "/export:mono_assembly_get_object_handle")
#pragma comment(linker, "/export:mono_assembly_getrootdir")
#pragma comment(linker, "/export:mono_assembly_has_reference_assembly_attribute")
#pragma comment(linker, "/export:mono_assembly_has_skip_verification")
#pragma comment(linker, "/export:mono_assembly_init_weak_fields")
#pragma comment(linker, "/export:mono_assembly_invoke_load_hook")
#pragma comment(linker, "/export:mono_assembly_invoke_search_hook")
#pragma comment(linker, "/export:mono_assembly_invoke_unload_hook")
#pragma comment(linker, "/export:mono_assembly_is_problematic_version")
#pragma comment(linker, "/export:mono_assembly_is_weak_field")
#pragma comment(linker, "/export:mono_assembly_load")
#pragma comment(linker, "/export:mono_assembly_load_corlib")
#pragma comment(linker, "/export:mono_assembly_load_friends")
#pragma comment(linker, "/export:mono_assembly_load_from")
#pragma comment(linker, "/export:mono_assembly_load_from_assemblies_path")
#pragma comment(linker, "/export:mono_assembly_load_from_full")
#pragma comment(linker, "/export:mono_assembly_load_from_predicate")
#pragma comment(linker, "/export:mono_assembly_load_full")
#pragma comment(linker, "/export:mono_assembly_load_full_nosearch")
#pragma comment(linker, "/export:mono_assembly_load_module")
#pragma comment(linker, "/export:mono_assembly_load_module_checked")
#pragma comment(linker, "/export:mono_assembly_load_reference")
#pragma comment(linker, "/export:mono_assembly_load_references")
#pragma comment(linker, "/export:mono_assembly_load_with_partial_name")
#pragma comment(linker, "/export:mono_assembly_load_with_partial_name_internal")
#pragma comment(linker, "/export:mono_assembly_loaded")
#pragma comment(linker, "/export:mono_assembly_loaded_full")
#pragma comment(linker, "/export:mono_assembly_metadata_foreach_custom_attr")
#pragma comment(linker, "/export:mono_assembly_name_free")
#pragma comment(linker, "/export:mono_assembly_name_free_internal")
#pragma comment(linker, "/export:mono_assembly_name_get_culture")
#pragma comment(linker, "/export:mono_assembly_name_get_name")
#pragma comment(linker, "/export:mono_assembly_name_get_pubkeytoken")
#pragma comment(linker, "/export:mono_assembly_name_get_version")
#pragma comment(linker, "/export:mono_assembly_name_new")
#pragma comment(linker, "/export:mono_assembly_name_parse")
#pragma comment(linker, "/export:mono_assembly_name_parse_full")
#pragma comment(linker, "/export:mono_assembly_names_equal")
#pragma comment(linker, "/export:mono_assembly_names_equal_flags")
#pragma comment(linker, "/export:mono_assembly_open")
#pragma comment(linker, "/export:mono_assembly_open_a_lot")
#pragma comment(linker, "/export:mono_assembly_open_from_bundle")
#pragma comment(linker, "/export:mono_assembly_open_full")
#pragma comment(linker, "/export:mono_assembly_open_predicate")
#pragma comment(linker, "/export:mono_assembly_release_gc_roots")
#pragma comment(linker, "/export:mono_assembly_set_main")
#pragma comment(linker, "/export:mono_assembly_setrootdir")
#pragma comment(linker, "/export:mono_class_alloc")
#pragma comment(linker, "/export:mono_class_alloc0")
#pragma comment(linker, "/export:mono_class_array_element_size")
#pragma comment(linker, "/export:mono_class_bind_generic_parameters")
#pragma comment(linker, "/export:mono_class_can_access_class")
#pragma comment(linker, "/export:mono_class_check_context_used")
#pragma comment(linker, "/export:mono_class_check_vtable_constraints")
#pragma comment(linker, "/export:mono_class_compute_bitmap")
#pragma comment(linker, "/export:mono_class_compute_gc_descriptor")
#pragma comment(linker, "/export:mono_class_contextbound_bit_offset")
#pragma comment(linker, "/export:mono_class_create_array")
#pragma comment(linker, "/export:mono_class_create_array_fill_type")
#pragma comment(linker, "/export:mono_class_create_bounded_array")
#pragma comment(linker, "/export:mono_class_create_fnptr")
#pragma comment(linker, "/export:mono_class_create_from_typedef")
#pragma comment(linker, "/export:mono_class_create_generic_inst")
#pragma comment(linker, "/export:mono_class_create_generic_parameter")
#pragma comment(linker, "/export:mono_class_create_ptr")
#pragma comment(linker, "/export:mono_class_data_size")
#pragma comment(linker, "/export:mono_class_describe_statics")
#pragma comment(linker, "/export:mono_class_enum_basetype")
#pragma comment(linker, "/export:mono_class_enum_basetype_internal")
#pragma comment(linker, "/export:mono_class_field_get_special_static_type")
#pragma comment(linker, "/export:mono_class_field_is_special_static")
#pragma comment(linker, "/export:mono_class_fill_runtime_generic_context")
#pragma comment(linker, "/export:mono_class_find_enum_basetype")
#pragma comment(linker, "/export:mono_class_free_ref_info")
#pragma comment(linker, "/export:mono_class_from_generic_parameter")
#pragma comment(linker, "/export:mono_class_from_mono_type")
#pragma comment(linker, "/export:mono_class_from_mono_type_handle")
#pragma comment(linker, "/export:mono_class_from_name")
#pragma comment(linker, "/export:mono_class_from_name_case")
#pragma comment(linker, "/export:mono_class_from_name_case_checked")
#pragma comment(linker, "/export:mono_class_from_name_checked")
#pragma comment(linker, "/export:mono_class_from_typeref")
#pragma comment(linker, "/export:mono_class_from_typeref_checked")
#pragma comment(linker, "/export:mono_class_full_name")
#pragma comment(linker, "/export:mono_class_generic_sharing_enabled")
#pragma comment(linker, "/export:mono_class_get")
#pragma comment(linker, "/export:mono_class_get_and_inflate_typespec_checked")
#pragma comment(linker, "/export:mono_class_get_appdomain_unloaded_exception_class")
#pragma comment(linker, "/export:mono_class_get_byref_type")
#pragma comment(linker, "/export:mono_class_get_cached_class_info")
#pragma comment(linker, "/export:mono_class_get_cctor")
#pragma comment(linker, "/export:mono_class_get_checked")
#pragma comment(linker, "/export:mono_class_get_com_object_class")
#pragma comment(linker, "/export:mono_class_get_context")
#pragma comment(linker, "/export:mono_class_get_declsec_flags")
#pragma comment(linker, "/export:mono_class_get_default_finalize_method")
#pragma comment(linker, "/export:mono_class_get_dim_conflicts")
#pragma comment(linker, "/export:mono_class_get_element_class")
#pragma comment(linker, "/export:mono_class_get_event_info")
#pragma comment(linker, "/export:mono_class_get_event_token")
#pragma comment(linker, "/export:mono_class_get_events")
#pragma comment(linker, "/export:mono_class_get_exception_data")
#pragma comment(linker, "/export:mono_class_get_exception_for_failure")
#pragma comment(linker, "/export:mono_class_get_field")
#pragma comment(linker, "/export:mono_class_get_field_count")
#pragma comment(linker, "/export:mono_class_get_field_def_values")
#pragma comment(linker, "/export:mono_class_get_field_default_value")
#pragma comment(linker, "/export:mono_class_get_field_from_name")
#pragma comment(linker, "/export:mono_class_get_field_from_name_full")
#pragma comment(linker, "/export:mono_class_get_field_token")
#pragma comment(linker, "/export:mono_class_get_fields")
#pragma comment(linker, "/export:mono_class_get_fields_internal")
#pragma comment(linker, "/export:mono_class_get_fields_lazy")
#pragma comment(linker, "/export:mono_class_get_finalizer")
#pragma comment(linker, "/export:mono_class_get_first_field_idx")
#pragma comment(linker, "/export:mono_class_get_first_method_idx")
#pragma comment(linker, "/export:mono_class_get_flags")
#pragma comment(linker, "/export:mono_class_get_full")
#pragma comment(linker, "/export:mono_class_get_generic_class")
#pragma comment(linker, "/export:mono_class_get_generic_container")
#pragma comment(linker, "/export:mono_class_get_generic_type_definition")
#pragma comment(linker, "/export:mono_class_get_idispatch_class")
#pragma comment(linker, "/export:mono_class_get_image")
#pragma comment(linker, "/export:mono_class_get_implemented_interfaces")
#pragma comment(linker, "/export:mono_class_get_inflated_method")
#pragma comment(linker, "/export:mono_class_get_interfaces")
#pragma comment(linker, "/export:mono_class_get_interop_proxy_class")
#pragma comment(linker, "/export:mono_class_get_iunknown_class")
#pragma comment(linker, "/export:mono_class_get_marshal_info")
#pragma comment(linker, "/export:mono_class_get_method_by_index")
#pragma comment(linker, "/export:mono_class_get_method_count")
#pragma comment(linker, "/export:mono_class_get_method_from_name")
#pragma comment(linker, "/export:mono_class_get_method_from_name_checked")
#pragma comment(linker, "/export:mono_class_get_method_from_name_flags")
#pragma comment(linker, "/export:mono_class_get_method_generic")
#pragma comment(linker, "/export:mono_class_get_methods")
#pragma comment(linker, "/export:mono_class_get_methods_by_name")
#pragma comment(linker, "/export:mono_class_get_name")
#pragma comment(linker, "/export:mono_class_get_namespace")
#pragma comment(linker, "/export:mono_class_get_nested_classes_property")
#pragma comment(linker, "/export:mono_class_get_nested_types")
#pragma comment(linker, "/export:mono_class_get_nesting_type")
#pragma comment(linker, "/export:mono_class_get_nullable_param")
#pragma comment(linker, "/export:mono_class_get_object_finalize_slot")
#pragma comment(linker, "/export:mono_class_get_overrides_full")
#pragma comment(linker, "/export:mono_class_get_parent")
#pragma comment(linker, "/export:mono_class_get_properties")
#pragma comment(linker, "/export:mono_class_get_property_default_value")
#pragma comment(linker, "/export:mono_class_get_property_from_name")
#pragma comment(linker, "/export:mono_class_get_property_info")
#pragma comment(linker, "/export:mono_class_get_property_token")
#pragma comment(linker, "/export:mono_class_get_rank")
#pragma comment(linker, "/export:mono_class_get_ref_info")
#pragma comment(linker, "/export:mono_class_get_ref_info_handle")
#pragma comment(linker, "/export:mono_class_get_ref_info_raw")
#pragma comment(linker, "/export:mono_class_get_type")
#pragma comment(linker, "/export:mono_class_get_type_token")
#pragma comment(linker, "/export:mono_class_get_valuetype_class")
#pragma comment(linker, "/export:mono_class_get_variant_class")
#pragma comment(linker, "/export:mono_class_get_virtual_method")
#pragma comment(linker, "/export:mono_class_get_vtable_entry")
#pragma comment(linker, "/export:mono_class_get_vtable_size")
#pragma comment(linker, "/export:mono_class_get_weak_bitmap")
#pragma comment(linker, "/export:mono_class_gtd_get_canonical_inst")
#pragma comment(linker, "/export:mono_class_has_dim_conflicts")
#pragma comment(linker, "/export:mono_class_has_failure")
#pragma comment(linker, "/export:mono_class_has_finalizer")
#pragma comment(linker, "/export:mono_class_has_ref_info")
#pragma comment(linker, "/export:mono_class_has_special_static_fields")
#pragma comment(linker, "/export:mono_class_has_variant_generic_params")
#pragma comment(linker, "/export:mono_class_implements_interface")
#pragma comment(linker, "/export:mono_class_inflate_generic_class_checked")
#pragma comment(linker, "/export:mono_class_inflate_generic_method")
#pragma comment(linker, "/export:mono_class_inflate_generic_method_checked")
#pragma comment(linker, "/export:mono_class_inflate_generic_method_full_checked")
#pragma comment(linker, "/export:mono_class_inflate_generic_type")
#pragma comment(linker, "/export:mono_class_inflate_generic_type_checked")
#pragma comment(linker, "/export:mono_class_inflate_generic_type_with_mempool")
#pragma comment(linker, "/export:mono_class_init")
#pragma comment(linker, "/export:mono_class_init_checked")
#pragma comment(linker, "/export:mono_class_init_sizes")
#pragma comment(linker, "/export:mono_class_instance_size")
#pragma comment(linker, "/export:mono_class_interface_offset")
#pragma comment(linker, "/export:mono_class_interface_offset_with_variance")
#pragma comment(linker, "/export:mono_class_is_assignable_from")
#pragma comment(linker, "/export:mono_class_is_assignable_from_checked")
#pragma comment(linker, "/export:mono_class_is_assignable_from_internal")
#pragma comment(linker, "/export:mono_class_is_assignable_from_slow")
#pragma comment(linker, "/export:mono_class_is_delegate")
#pragma comment(linker, "/export:mono_class_is_enum")
#pragma comment(linker, "/export:mono_class_is_from_assembly")
#pragma comment(linker, "/export:mono_class_is_magic_float")
#pragma comment(linker, "/export:mono_class_is_magic_int")
#pragma comment(linker, "/export:mono_class_is_nullable")
#pragma comment(linker, "/export:mono_class_is_open_constructed_type")
#pragma comment(linker, "/export:mono_class_is_reflection_method_or_constructor")
#pragma comment(linker, "/export:mono_class_is_subclass_of")
#pragma comment(linker, "/export:mono_class_is_valid_enum")
#pragma comment(linker, "/export:mono_class_is_valuetype")
#pragma comment(linker, "/export:mono_class_is_variant_compatible")
#pragma comment(linker, "/export:mono_class_layout_fields")
#pragma comment(linker, "/export:mono_class_load_from_name")
#pragma comment(linker, "/export:mono_class_min_align")
#pragma comment(linker, "/export:mono_class_name_from_token")
#pragma comment(linker, "/export:mono_class_native_size")
#pragma comment(linker, "/export:mono_class_needs_cctor_run")
#pragma comment(linker, "/export:mono_class_num_events")
#pragma comment(linker, "/export:mono_class_num_fields")
#pragma comment(linker, "/export:mono_class_num_methods")
#pragma comment(linker, "/export:mono_class_num_properties")
#pragma comment(linker, "/export:mono_class_publish_gc_descriptor")
#pragma comment(linker, "/export:mono_class_rgctx_get_array_size")
#pragma comment(linker, "/export:mono_class_set_declsec_flags")
#pragma comment(linker, "/export:mono_class_set_dim_conflicts")
#pragma comment(linker, "/export:mono_class_set_event_info")
#pragma comment(linker, "/export:mono_class_set_exception_data")
#pragma comment(linker, "/export:mono_class_set_failure")
#pragma comment(linker, "/export:mono_class_set_field_count")
#pragma comment(linker, "/export:mono_class_set_field_def_values")
#pragma comment(linker, "/export:mono_class_set_first_field_idx")
#pragma comment(linker, "/export:mono_class_set_first_method_idx")
#pragma comment(linker, "/export:mono_class_set_flags")
#pragma comment(linker, "/export:mono_class_set_generic_container")
#pragma comment(linker, "/export:mono_class_set_is_com_object")
#pragma comment(linker, "/export:mono_class_set_marshal_info")
#pragma comment(linker, "/export:mono_class_set_method_count")
#pragma comment(linker, "/export:mono_class_set_nested_classes_property")
#pragma comment(linker, "/export:mono_class_set_nonblittable")
#pragma comment(linker, "/export:mono_class_set_property_info")
#pragma comment(linker, "/export:mono_class_set_ref_info")
#pragma comment(linker, "/export:mono_class_set_ref_info_handle")
#pragma comment(linker, "/export:mono_class_set_type_load_failure")
#pragma comment(linker, "/export:mono_class_set_type_load_failure_causedby_class")
#pragma comment(linker, "/export:mono_class_set_weak_bitmap")
#pragma comment(linker, "/export:mono_class_setup_basic_field_info")
#pragma comment(linker, "/export:mono_class_setup_events")
#pragma comment(linker, "/export:mono_class_setup_fields")
#pragma comment(linker, "/export:mono_class_setup_has_finalizer")
#pragma comment(linker, "/export:mono_class_setup_interface_id")
#pragma comment(linker, "/export:mono_class_setup_interface_offsets")
#pragma comment(linker, "/export:mono_class_setup_interfaces")
#pragma comment(linker, "/export:mono_class_setup_methods")
#pragma comment(linker, "/export:mono_class_setup_mono_type")
#pragma comment(linker, "/export:mono_class_setup_nested_types")
#pragma comment(linker, "/export:mono_class_setup_parent")
#pragma comment(linker, "/export:mono_class_setup_properties")
#pragma comment(linker, "/export:mono_class_setup_runtime_info")
#pragma comment(linker, "/export:mono_class_setup_supertypes")
#pragma comment(linker, "/export:mono_class_setup_vtable")
#pragma comment(linker, "/export:mono_class_setup_vtable_general")
#pragma comment(linker, "/export:mono_class_static_field_address")
#pragma comment(linker, "/export:mono_class_try_get_com_object_class")
#pragma comment(linker, "/export:mono_class_try_get_generic_class")
#pragma comment(linker, "/export:mono_class_try_get_generic_container")
#pragma comment(linker, "/export:mono_class_try_get_safehandle_class")
#pragma comment(linker, "/export:mono_class_try_get_vtable")
#pragma comment(linker, "/export:mono_class_try_load_from_name")
#pragma comment(linker, "/export:mono_class_value_size")
#pragma comment(linker, "/export:mono_class_vtable")
#pragma comment(linker, "/export:mono_class_vtable_checked")
#pragma comment(linker, "/export:mono_custom_attrs_construct")
#pragma comment(linker, "/export:mono_custom_attrs_free")
#pragma comment(linker, "/export:mono_custom_attrs_from_assembly")
#pragma comment(linker, "/export:mono_custom_attrs_from_assembly_checked")
#pragma comment(linker, "/export:mono_custom_attrs_from_builders")
#pragma comment(linker, "/export:mono_custom_attrs_from_class")
#pragma comment(linker, "/export:mono_custom_attrs_from_class_checked")
#pragma comment(linker, "/export:mono_custom_attrs_from_event")
#pragma comment(linker, "/export:mono_custom_attrs_from_event_checked")
#pragma comment(linker, "/export:mono_custom_attrs_from_field")
#pragma comment(linker, "/export:mono_custom_attrs_from_field_checked")
#pragma comment(linker, "/export:mono_custom_attrs_from_index")
#pragma comment(linker, "/export:mono_custom_attrs_from_index_checked")
#pragma comment(linker, "/export:mono_custom_attrs_from_method")
#pragma comment(linker, "/export:mono_custom_attrs_from_method_checked")
#pragma comment(linker, "/export:mono_custom_attrs_from_param")
#pragma comment(linker, "/export:mono_custom_attrs_from_param_checked")
#pragma comment(linker, "/export:mono_custom_attrs_from_property")
#pragma comment(linker, "/export:mono_custom_attrs_from_property_checked")
#pragma comment(linker, "/export:mono_custom_attrs_get_attr")
#pragma comment(linker, "/export:mono_custom_attrs_get_attr_checked")
#pragma comment(linker, "/export:mono_custom_attrs_has_attr")
#pragma comment(linker, "/export:mono_debug_add_aot_method")
#pragma comment(linker, "/export:mono_debug_add_delegate_trampoline")
#pragma comment(linker, "/export:mono_debug_add_method")
#pragma comment(linker, "/export:mono_debug_cleanup")
#pragma comment(linker, "/export:mono_debug_close_image")
#pragma comment(linker, "/export:mono_debug_close_method")
#pragma comment(linker, "/export:mono_debug_close_mono_symbol_file")
#pragma comment(linker, "/export:mono_debug_count")
#pragma comment(linker, "/export:mono_debug_domain_create")
#pragma comment(linker, "/export:mono_debug_domain_unload")
#pragma comment(linker, "/export:mono_debug_enabled")
#pragma comment(linker, "/export:mono_debug_find_method")
#pragma comment(linker, "/export:mono_debug_free_locals")
#pragma comment(linker, "/export:mono_debug_free_method")
#pragma comment(linker, "/export:mono_debug_free_method_async_debug_info")
#pragma comment(linker, "/export:mono_debug_free_method_jit_info")
#pragma comment(linker, "/export:mono_debug_free_source_location")
#pragma comment(linker, "/export:mono_debug_get_handle")
#pragma comment(linker, "/export:mono_debug_get_seq_points")
#pragma comment(linker, "/export:mono_debug_il_offset_from_address")
#pragma comment(linker, "/export:mono_debug_image_has_debug_info")
#pragma comment(linker, "/export:mono_debug_init")
#pragma comment(linker, "/export:mono_debug_init_method")
#pragma comment(linker, "/export:mono_debug_lookup_locals")
#pragma comment(linker, "/export:mono_debug_lookup_method")
#pragma comment(linker, "/export:mono_debug_lookup_method_addresses")
#pragma comment(linker, "/export:mono_debug_lookup_method_async_debug_info")
#pragma comment(linker, "/export:mono_debug_lookup_source_location")
#pragma comment(linker, "/export:mono_debug_lookup_source_location_by_il")
#pragma comment(linker, "/export:mono_debug_method_lookup_location")
#pragma comment(linker, "/export:mono_debug_open_block")
#pragma comment(linker, "/export:mono_debug_open_method")
#pragma comment(linker, "/export:mono_debug_open_mono_symbols")
#pragma comment(linker, "/export:mono_debug_personality")
#pragma comment(linker, "/export:mono_debug_print_stack_frame")
#pragma comment(linker, "/export:mono_debug_print_vars")
#pragma comment(linker, "/export:mono_debug_record_line_number")
#pragma comment(linker, "/export:mono_debug_remove_method")
#pragma comment(linker, "/export:mono_debug_serialize_debug_info")
#pragma comment(linker, "/export:mono_debug_symfile_free_location")
#pragma comment(linker, "/export:mono_debug_symfile_get_seq_points")
#pragma comment(linker, "/export:mono_debug_symfile_is_loaded")
#pragma comment(linker, "/export:mono_debug_symfile_lookup_locals")
#pragma comment(linker, "/export:mono_debug_symfile_lookup_location")
#pragma comment(linker, "/export:mono_debug_symfile_lookup_method")
#pragma comment(linker, "/export:mono_domain_alloc")
#pragma comment(linker, "/export:mono_domain_alloc0")
#pragma comment(linker, "/export:mono_domain_alloc0_lock_free")
#pragma comment(linker, "/export:mono_domain_assembly_open")
#pragma comment(linker, "/export:mono_domain_assembly_open_internal")
#pragma comment(linker, "/export:mono_domain_assembly_postload_search")
#pragma comment(linker, "/export:mono_domain_code_commit")
#pragma comment(linker, "/export:mono_domain_code_foreach")
#pragma comment(linker, "/export:mono_domain_code_reserve")
#pragma comment(linker, "/export:mono_domain_code_reserve_align")
#pragma comment(linker, "/export:mono_domain_create")
#pragma comment(linker, "/export:mono_domain_create_appdomain")
#pragma comment(linker, "/export:mono_domain_finalize")
#pragma comment(linker, "/export:mono_domain_foreach")
#pragma comment(linker, "/export:mono_domain_free")
#pragma comment(linker, "/export:mono_domain_from_appdomain")
#pragma comment(linker, "/export:mono_domain_get")
#pragma comment(linker, "/export:mono_domain_get_assemblies")
#pragma comment(linker, "/export:mono_domain_get_by_id")
#pragma comment(linker, "/export:mono_domain_get_friendly_name")
#pragma comment(linker, "/export:mono_domain_get_id")
#pragma comment(linker, "/export:mono_domain_has_type_resolve")
#pragma comment(linker, "/export:mono_domain_is_unloading")
#pragma comment(linker, "/export:mono_domain_lock")
#pragma comment(linker, "/export:mono_domain_owns_vtable_slot")
#pragma comment(linker, "/export:mono_domain_parse_assembly_bindings")
#pragma comment(linker, "/export:mono_domain_set")
#pragma comment(linker, "/export:mono_domain_set_config")
#pragma comment(linker, "/export:mono_domain_set_config_checked")
#pragma comment(linker, "/export:mono_domain_set_internal")
#pragma comment(linker, "/export:mono_domain_set_internal_with_options")
#pragma comment(linker, "/export:mono_domain_set_options_from_config")
#pragma comment(linker, "/export:mono_domain_try_type_resolve")
#pragma comment(linker, "/export:mono_domain_try_type_resolve_name")
#pragma comment(linker, "/export:mono_domain_try_type_resolve_typebuilder")
#pragma comment(linker, "/export:mono_domain_try_unload")
#pragma comment(linker, "/export:mono_domain_unload")
#pragma comment(linker, "/export:mono_domain_unlock")
#pragma comment(linker, "/export:mono_domain_unset")
#pragma comment(linker, "/export:mono_exception_from_name")
#pragma comment(linker, "/export:mono_exception_from_name_domain")
#pragma comment(linker, "/export:mono_exception_from_name_msg")
#pragma comment(linker, "/export:mono_exception_from_name_two_strings")
#pragma comment(linker, "/export:mono_exception_from_name_two_strings_checked")
#pragma comment(linker, "/export:mono_exception_from_token")
#pragma comment(linker, "/export:mono_exception_from_token_two_strings")
#pragma comment(linker, "/export:mono_exception_from_token_two_strings_checked")
#pragma comment(linker, "/export:mono_exception_get_managed_backtrace")
#pragma comment(linker, "/export:mono_exception_handle_get_native_backtrace")
#pragma comment(linker, "/export:mono_exception_new_argument")
#pragma comment(linker, "/export:mono_exception_new_argument_null")
#pragma comment(linker, "/export:mono_exception_new_by_name_msg")
#pragma comment(linker, "/export:mono_exception_new_invalid_operation")
#pragma comment(linker, "/export:mono_exception_new_serialization")
#pragma comment(linker, "/export:mono_exception_new_thread_abort")
#pragma comment(linker, "/export:mono_exception_new_thread_interrupted")
#pragma comment(linker, "/export:mono_exception_walk_trace")
#pragma comment(linker, "/export:mono_field_from_token")
#pragma comment(linker, "/export:mono_field_from_token_checked")
#pragma comment(linker, "/export:mono_field_full_name")
#pragma comment(linker, "/export:mono_field_get_data")
#pragma comment(linker, "/export:mono_field_get_flags")
#pragma comment(linker, "/export:mono_field_get_name")
#pragma comment(linker, "/export:mono_field_get_object")
#pragma comment(linker, "/export:mono_field_get_object_checked")
#pragma comment(linker, "/export:mono_field_get_object_handle")
#pragma comment(linker, "/export:mono_field_get_offset")
#pragma comment(linker, "/export:mono_field_get_parent")
#pragma comment(linker, "/export:mono_field_get_type")
#pragma comment(linker, "/export:mono_field_get_type_checked")
#pragma comment(linker, "/export:mono_field_get_value")
#pragma comment(linker, "/export:mono_field_get_value_internal")
#pragma comment(linker, "/export:mono_field_get_value_object")
#pragma comment(linker, "/export:mono_field_get_value_object_checked")
#pragma comment(linker, "/export:mono_field_resolve_type")
#pragma comment(linker, "/export:mono_field_set_value")
#pragma comment(linker, "/export:mono_field_static_get_value")
#pragma comment(linker, "/export:mono_field_static_get_value_checked")
#pragma comment(linker, "/export:mono_field_static_get_value_for_thread")
#pragma comment(linker, "/export:mono_field_static_set_value")
#pragma comment(linker, "/export:mono_free")
#pragma comment(linker, "/export:mono_free_address_info")
#pragma comment(linker, "/export:mono_free_altstack")
#pragma comment(linker, "/export:mono_free_bstr")
#pragma comment(linker, "/export:mono_free_loop_info")
#pragma comment(linker, "/export:mono_free_lparray")
#pragma comment(linker, "/export:mono_free_method")
#pragma comment(linker, "/export:mono_free_verify_list")
#pragma comment(linker, "/export:mono_gc_add_memory_pressure")
#pragma comment(linker, "/export:mono_gc_alloc_array")
#pragma comment(linker, "/export:mono_gc_alloc_fixed")
#pragma comment(linker, "/export:mono_gc_alloc_fixed_no_descriptor")
#pragma comment(linker, "/export:mono_gc_alloc_handle_array")
#pragma comment(linker, "/export:mono_gc_alloc_handle_mature")
#pragma comment(linker, "/export:mono_gc_alloc_handle_obj")
#pragma comment(linker, "/export:mono_gc_alloc_handle_pinned_obj")
#pragma comment(linker, "/export:mono_gc_alloc_handle_string")
#pragma comment(linker, "/export:mono_gc_alloc_handle_vector")
#pragma comment(linker, "/export:mono_gc_alloc_mature")
#pragma comment(linker, "/export:mono_gc_alloc_obj")
#pragma comment(linker, "/export:mono_gc_alloc_pinned_obj")
#pragma comment(linker, "/export:mono_gc_alloc_string")
#pragma comment(linker, "/export:mono_gc_alloc_vector")
#pragma comment(linker, "/export:mono_gc_base_cleanup")
#pragma comment(linker, "/export:mono_gc_base_init")
#pragma comment(linker, "/export:mono_gc_bzero_aligned")
#pragma comment(linker, "/export:mono_gc_bzero_atomic")
#pragma comment(linker, "/export:mono_gc_card_table_nursery_check")
#pragma comment(linker, "/export:mono_gc_cleanup")
#pragma comment(linker, "/export:mono_gc_clear_assembly")
#pragma comment(linker, "/export:mono_gc_clear_domain")
#pragma comment(linker, "/export:mono_gc_collect")
#pragma comment(linker, "/export:mono_gc_collection_count")
#pragma comment(linker, "/export:mono_gc_conservatively_scan_area")
#pragma comment(linker, "/export:mono_gc_debug_set")
#pragma comment(linker, "/export:mono_gc_deregister_root")
#pragma comment(linker, "/export:mono_gc_dllmain")
#pragma comment(linker, "/export:mono_gc_ephemeron_array_add")
#pragma comment(linker, "/export:mono_gc_finalize_assembly")
#pragma comment(linker, "/export:mono_gc_finalize_domain")
#pragma comment(linker, "/export:mono_gc_finalize_notify")
#pragma comment(linker, "/export:mono_gc_free_fixed")
#pragma comment(linker, "/export:mono_gc_get_aligned_size_for_allocator")
#pragma comment(linker, "/export:mono_gc_get_bitmap_for_descr")
#pragma comment(linker, "/export:mono_gc_get_card_table")
#pragma comment(linker, "/export:mono_gc_get_description")
#pragma comment(linker, "/export:mono_gc_get_gc_callbacks")
#pragma comment(linker, "/export:mono_gc_get_gc_name")
#pragma comment(linker, "/export:mono_gc_get_generation")
#pragma comment(linker, "/export:mono_gc_get_heap_size")
#pragma comment(linker, "/export:mono_gc_get_logfile")
#pragma comment(linker, "/export:mono_gc_get_los_limit")
#pragma comment(linker, "/export:mono_gc_get_managed_allocator")
#pragma comment(linker, "/export:mono_gc_get_managed_allocator_by_type")
#pragma comment(linker, "/export:mono_gc_get_managed_allocator_types")
#pragma comment(linker, "/export:mono_gc_get_managed_array_allocator")
#pragma comment(linker, "/export:mono_gc_get_nursery")
#pragma comment(linker, "/export:mono_gc_get_range_copy_func")
#pragma comment(linker, "/export:mono_gc_get_restart_signal")
#pragma comment(linker, "/export:mono_gc_get_specific_write_barrier")
#pragma comment(linker, "/export:mono_gc_get_suspend_signal")
#pragma comment(linker, "/export:mono_gc_get_target_card_table")
#pragma comment(linker, "/export:mono_gc_get_used_size")
#pragma comment(linker, "/export:mono_gc_get_vtable")
#pragma comment(linker, "/export:mono_gc_get_vtable_bits")
#pragma comment(linker, "/export:mono_gc_get_write_barrier")
#pragma comment(linker, "/export:mono_gc_init")
#pragma comment(linker, "/export:mono_gc_invoke_finalizers")
#pragma comment(linker, "/export:mono_gc_invoke_with_gc_lock")
#pragma comment(linker, "/export:mono_gc_is_critical_method")
#pragma comment(linker, "/export:mono_gc_is_disabled")
#pragma comment(linker, "/export:mono_gc_is_finalizer_internal_thread")
#pragma comment(linker, "/export:mono_gc_is_finalizer_thread")
#pragma comment(linker, "/export:mono_gc_is_gc_thread")
#pragma comment(linker, "/export:mono_gc_is_moving")
#pragma comment(linker, "/export:mono_gc_is_null")
#pragma comment(linker, "/export:mono_gc_make_descr_for_array")
#pragma comment(linker, "/export:mono_gc_make_descr_for_object")
#pragma comment(linker, "/export:mono_gc_make_descr_for_string")
#pragma comment(linker, "/export:mono_gc_make_descr_from_bitmap")
#pragma comment(linker, "/export:mono_gc_make_root_descr_all_refs")
#pragma comment(linker, "/export:mono_gc_make_root_descr_user")
#pragma comment(linker, "/export:mono_gc_make_vector_descr")
#pragma comment(linker, "/export:mono_gc_max_generation")
#pragma comment(linker, "/export:mono_gc_memmove_aligned")
#pragma comment(linker, "/export:mono_gc_memmove_atomic")
#pragma comment(linker, "/export:mono_gc_params_set")
#pragma comment(linker, "/export:mono_gc_parse_environment_string_extract_number")
#pragma comment(linker, "/export:mono_gc_pending_finalizers")
#pragma comment(linker, "/export:mono_gc_precise_stack_mark_enabled")
#pragma comment(linker, "/export:mono_gc_reference_queue_add")
#pragma comment(linker, "/export:mono_gc_reference_queue_foreach_remove")
#pragma comment(linker, "/export:mono_gc_reference_queue_foreach_remove2")
#pragma comment(linker, "/export:mono_gc_reference_queue_free")
#pragma comment(linker, "/export:mono_gc_reference_queue_new")
#pragma comment(linker, "/export:mono_gc_register_altstack")
#pragma comment(linker, "/export:mono_gc_register_bridge_callbacks")
#pragma comment(linker, "/export:mono_gc_register_finalizer_callbacks")
#pragma comment(linker, "/export:mono_gc_register_for_finalization")
#pragma comment(linker, "/export:mono_gc_register_obj_with_weak_fields")
#pragma comment(linker, "/export:mono_gc_register_object_with_weak_fields")
#pragma comment(linker, "/export:mono_gc_register_root")
#pragma comment(linker, "/export:mono_gc_register_root_wbarrier")
#pragma comment(linker, "/export:mono_gc_run_finalize")
#pragma comment(linker, "/export:mono_gc_scan_for_specific_ref")
#pragma comment(linker, "/export:mono_gc_scan_object")
#pragma comment(linker, "/export:mono_gc_set_desktop_mode")
#pragma comment(linker, "/export:mono_gc_set_gc_callbacks")
#pragma comment(linker, "/export:mono_gc_set_stack_end")
#pragma comment(linker, "/export:mono_gc_set_string_length")
#pragma comment(linker, "/export:mono_gc_skip_thread_changed")
#pragma comment(linker, "/export:mono_gc_skip_thread_changing")
#pragma comment(linker, "/export:mono_gc_stats")
#pragma comment(linker, "/export:mono_gc_suspend_finalizers")
#pragma comment(linker, "/export:mono_gc_thread_attach")
#pragma comment(linker, "/export:mono_gc_thread_detach_with_lock")
#pragma comment(linker, "/export:mono_gc_thread_in_critical_region")
#pragma comment(linker, "/export:mono_gc_toggleref_add")
#pragma comment(linker, "/export:mono_gc_toggleref_register_callback")
#pragma comment(linker, "/export:mono_gc_user_markers_supported")
#pragma comment(linker, "/export:mono_gc_wait_for_bridge_processing")
#pragma comment(linker, "/export:mono_gc_walk_heap")
#pragma comment(linker, "/export:mono_gc_wbarrier_arrayref_copy")
#pragma comment(linker, "/export:mono_gc_wbarrier_generic_nostore")
#pragma comment(linker, "/export:mono_gc_wbarrier_generic_store")
#pragma comment(linker, "/export:mono_gc_wbarrier_generic_store_atomic")
#pragma comment(linker, "/export:mono_gc_wbarrier_object_copy")
#pragma comment(linker, "/export:mono_gc_wbarrier_object_copy_handle")
#pragma comment(linker, "/export:mono_gc_wbarrier_range_copy")
#pragma comment(linker, "/export:mono_gc_wbarrier_set_arrayref")
#pragma comment(linker, "/export:mono_gc_wbarrier_set_field")
#pragma comment(linker, "/export:mono_gc_wbarrier_value_copy")
#pragma comment(linker, "/export:mono_gchandle_free")
#pragma comment(linker, "/export:mono_gchandle_free_domain")
#pragma comment(linker, "/export:mono_gchandle_from_handle")
#pragma comment(linker, "/export:mono_gchandle_get_target")
#pragma comment(linker, "/export:mono_gchandle_get_target_handle")
#pragma comment(linker, "/export:mono_gchandle_is_in_domain")
#pragma comment(linker, "/export:mono_gchandle_new")
#pragma comment(linker, "/export:mono_gchandle_new_weakref")
#pragma comment(linker, "/export:mono_gchandle_set_target")
#pragma comment(linker, "/export:mono_gchandle_set_target_handle")
#pragma comment(linker, "/export:mono_get_addr_from_ftnptr")
#pragma comment(linker, "/export:mono_get_address_info")
#pragma comment(linker, "/export:mono_get_anonymous_container_for_image")
#pragma comment(linker, "/export:mono_get_aot_cache_config")
#pragma comment(linker, "/export:mono_get_array_class")
#pragma comment(linker, "/export:mono_get_assembly_object")
#pragma comment(linker, "/export:mono_get_boolean_class")
#pragma comment(linker, "/export:mono_get_byte_class")
#pragma comment(linker, "/export:mono_get_cached_unwind_info")
#pragma comment(linker, "/export:mono_get_call_filter")
#pragma comment(linker, "/export:mono_get_char_class")
#pragma comment(linker, "/export:mono_get_config_dir")
#pragma comment(linker, "/export:mono_get_constant_value_from_blob")
#pragma comment(linker, "/export:mono_get_context_capture_method")
#pragma comment(linker, "/export:mono_get_corlib")
#pragma comment(linker, "/export:mono_get_dbnull_object")
#pragma comment(linker, "/export:mono_get_delegate_begin_invoke")
#pragma comment(linker, "/export:mono_get_delegate_begin_invoke_checked")
#pragma comment(linker, "/export:mono_get_delegate_end_invoke")
#pragma comment(linker, "/export:mono_get_delegate_end_invoke_checked")
#pragma comment(linker, "/export:mono_get_delegate_invoke")
#pragma comment(linker, "/export:mono_get_delegate_invoke_checked")
#pragma comment(linker, "/export:mono_get_delegate_virtual_invoke_impl")
#pragma comment(linker, "/export:mono_get_delegate_virtual_invoke_impl_name")
#pragma comment(linker, "/export:mono_get_double_class")
#pragma comment(linker, "/export:mono_get_eh_callbacks")
#pragma comment(linker, "/export:mono_get_enum_class")
#pragma comment(linker, "/export:mono_get_exception_appdomain_unloaded")
#pragma comment(linker, "/export:mono_get_exception_argument")
#pragma comment(linker, "/export:mono_get_exception_argument_null")
#pragma comment(linker, "/export:mono_get_exception_argument_out_of_range")
#pragma comment(linker, "/export:mono_get_exception_arithmetic")
#pragma comment(linker, "/export:mono_get_exception_array_type_mismatch")
#pragma comment(linker, "/export:mono_get_exception_bad_image_format")
#pragma comment(linker, "/export:mono_get_exception_bad_image_format2")
#pragma comment(linker, "/export:mono_get_exception_cannot_unload_appdomain")
#pragma comment(linker, "/export:mono_get_exception_class")
#pragma comment(linker, "/export:mono_get_exception_divide_by_zero")
#pragma comment(linker, "/export:mono_get_exception_execution_engine")
#pragma comment(linker, "/export:mono_get_exception_field_access")
#pragma comment(linker, "/export:mono_get_exception_field_access_msg")
#pragma comment(linker, "/export:mono_get_exception_file_not_found")
#pragma comment(linker, "/export:mono_get_exception_file_not_found2")
#pragma comment(linker, "/export:mono_get_exception_index_out_of_range")
#pragma comment(linker, "/export:mono_get_exception_invalid_cast")
#pragma comment(linker, "/export:mono_get_exception_invalid_operation")
#pragma comment(linker, "/export:mono_get_exception_io")
#pragma comment(linker, "/export:mono_get_exception_method_access")
#pragma comment(linker, "/export:mono_get_exception_method_access_msg")
#pragma comment(linker, "/export:mono_get_exception_missing_field")
#pragma comment(linker, "/export:mono_get_exception_missing_method")
#pragma comment(linker, "/export:mono_get_exception_not_implemented")
#pragma comment(linker, "/export:mono_get_exception_not_supported")
#pragma comment(linker, "/export:mono_get_exception_null_reference")
#pragma comment(linker, "/export:mono_get_exception_out_of_memory")
#pragma comment(linker, "/export:mono_get_exception_out_of_memory_handle")
#pragma comment(linker, "/export:mono_get_exception_overflow")
#pragma comment(linker, "/export:mono_get_exception_reflection_type_load")
#pragma comment(linker, "/export:mono_get_exception_reflection_type_load_checked")
#pragma comment(linker, "/export:mono_get_exception_runtime_wrapped")
#pragma comment(linker, "/export:mono_get_exception_runtime_wrapped_handle")
#pragma comment(linker, "/export:mono_get_exception_security")
#pragma comment(linker, "/export:mono_get_exception_serialization")
#pragma comment(linker, "/export:mono_get_exception_stack_overflow")
#pragma comment(linker, "/export:mono_get_exception_synchronization_lock")
#pragma comment(linker, "/export:mono_get_exception_thread_abort")
#pragma comment(linker, "/export:mono_get_exception_thread_interrupted")
#pragma comment(linker, "/export:mono_get_exception_thread_state")
#pragma comment(linker, "/export:mono_get_exception_type_initialization")
#pragma comment(linker, "/export:mono_get_exception_type_initialization_handle")
#pragma comment(linker, "/export:mono_get_exception_type_load")
#pragma comment(linker, "/export:mono_get_generic_trampoline_name")
#pragma comment(linker, "/export:mono_get_generic_trampoline_simple_name")
#pragma comment(linker, "/export:mono_get_hazardous_pointer")
#pragma comment(linker, "/export:mono_get_image_for_generic_param")
#pragma comment(linker, "/export:mono_get_inflated_method")
#pragma comment(linker, "/export:mono_get_int16_class")
#pragma comment(linker, "/export:mono_get_int32_class")
#pragma comment(linker, "/export:mono_get_int64_class")
#pragma comment(linker, "/export:mono_get_intptr_class")
#pragma comment(linker, "/export:mono_get_jit_icall_info")
#pragma comment(linker, "/export:mono_get_lmf")
#pragma comment(linker, "/export:mono_get_local_interfaces")
#pragma comment(linker, "/export:mono_get_machine_config")
#pragma comment(linker, "/export:mono_get_method")
#pragma comment(linker, "/export:mono_get_method_checked")
#pragma comment(linker, "/export:mono_get_method_constrained")
#pragma comment(linker, "/export:mono_get_method_constrained_checked")
#pragma comment(linker, "/export:mono_get_method_constrained_with_method")
#pragma comment(linker, "/export:mono_get_method_from_ip")
#pragma comment(linker, "/export:mono_get_method_full")
#pragma comment(linker, "/export:mono_get_method_object")
#pragma comment(linker, "/export:mono_get_module_file_name")
#pragma comment(linker, "/export:mono_get_native_calli_wrapper")
#pragma comment(linker, "/export:mono_get_object_class")
#pragma comment(linker, "/export:mono_get_object_from_blob")
#pragma comment(linker, "/export:mono_get_optimizations_for_method")
#pragma comment(linker, "/export:mono_get_restore_context")
#pragma comment(linker, "/export:mono_get_rethrow_exception")
#pragma comment(linker, "/export:mono_get_rgctx_fetch_trampoline_name")
#pragma comment(linker, "/export:mono_get_root_domain")
#pragma comment(linker, "/export:mono_get_runtime_build_info")
#pragma comment(linker, "/export:mono_get_runtime_callbacks")
#pragma comment(linker, "/export:mono_get_runtime_info")
#pragma comment(linker, "/export:mono_get_sbyte_class")
#pragma comment(linker, "/export:mono_get_seq_points")
#pragma comment(linker, "/export:mono_get_shared_generic_inst")
#pragma comment(linker, "/export:mono_get_single_class")
#pragma comment(linker, "/export:mono_get_special_static_data")
#pragma comment(linker, "/export:mono_get_special_static_data_for_thread")
#pragma comment(linker, "/export:mono_get_string_class")
#pragma comment(linker, "/export:mono_get_thread_class")
#pragma comment(linker, "/export:mono_get_throw_corlib_exception")
#pragma comment(linker, "/export:mono_get_throw_exception")
#pragma comment(linker, "/export:mono_get_throw_exception_addr")
#pragma comment(linker, "/export:mono_get_trampoline_code")
#pragma comment(linker, "/export:mono_get_trampoline_func")
#pragma comment(linker, "/export:mono_get_uint16_class")
#pragma comment(linker, "/export:mono_get_uint32_class")
#pragma comment(linker, "/export:mono_get_uint64_class")
#pragma comment(linker, "/export:mono_get_uintptr_class")
#pragma comment(linker, "/export:mono_get_void_class")
#pragma comment(linker, "/export:mono_image_add_to_name_cache")
#pragma comment(linker, "/export:mono_image_addref")
#pragma comment(linker, "/export:mono_image_alloc")
#pragma comment(linker, "/export:mono_image_alloc0")
#pragma comment(linker, "/export:mono_image_append_class_to_reflection_info_set")
#pragma comment(linker, "/export:mono_image_build_metadata")
#pragma comment(linker, "/export:mono_image_check_for_module_cctor")
#pragma comment(linker, "/export:mono_image_close")
#pragma comment(linker, "/export:mono_image_close_except_pools")
#pragma comment(linker, "/export:mono_image_close_finish")
#pragma comment(linker, "/export:mono_image_create_pefile")
#pragma comment(linker, "/export:mono_image_create_token")
#pragma comment(linker, "/export:mono_image_ensure_section")
#pragma comment(linker, "/export:mono_image_ensure_section_idx")
#pragma comment(linker, "/export:mono_image_fixup_vtable")
#pragma comment(linker, "/export:mono_image_g_malloc0")
#pragma comment(linker, "/export:mono_image_get_assembly")
#pragma comment(linker, "/export:mono_image_get_entry_point")
#pragma comment(linker, "/export:mono_image_get_filename")
#pragma comment(linker, "/export:mono_image_get_guid")
#pragma comment(linker, "/export:mono_image_get_methodref_token")
#pragma comment(linker, "/export:mono_image_get_name")
#pragma comment(linker, "/export:mono_image_get_public_key")
#pragma comment(linker, "/export:mono_image_get_resource")
#pragma comment(linker, "/export:mono_image_get_strong_name")
#pragma comment(linker, "/export:mono_image_get_table_info")
#pragma comment(linker, "/export:mono_image_get_table_rows")
#pragma comment(linker, "/export:mono_image_has_authenticode_entry")
#pragma comment(linker, "/export:mono_image_init")
#pragma comment(linker, "/export:mono_image_init_name_cache")
#pragma comment(linker, "/export:mono_image_insert_string")
#pragma comment(linker, "/export:mono_image_is_dynamic")
#pragma comment(linker, "/export:mono_image_load_cli_data")
#pragma comment(linker, "/export:mono_image_load_cli_header")
#pragma comment(linker, "/export:mono_image_load_file_for_image")
#pragma comment(linker, "/export:mono_image_load_file_for_image_checked")
#pragma comment(linker, "/export:mono_image_load_metadata")
#pragma comment(linker, "/export:mono_image_load_module")
#pragma comment(linker, "/export:mono_image_load_module_checked")
#pragma comment(linker, "/export:mono_image_load_names")
#pragma comment(linker, "/export:mono_image_load_pe_data")
#pragma comment(linker, "/export:mono_image_loaded")
#pragma comment(linker, "/export:mono_image_loaded_by_guid")
#pragma comment(linker, "/export:mono_image_loaded_by_guid_full")
#pragma comment(linker, "/export:mono_image_loaded_full")
#pragma comment(linker, "/export:mono_image_loaded_internal")
#pragma comment(linker, "/export:mono_image_lock")
#pragma comment(linker, "/export:mono_image_lookup_resource")
#pragma comment(linker, "/export:mono_image_open")
#pragma comment(linker, "/export:mono_image_open_a_lot")
#pragma comment(linker, "/export:mono_image_open_from_data")
#pragma comment(linker, "/export:mono_image_open_from_data_full")
#pragma comment(linker, "/export:mono_image_open_from_data_internal")
#pragma comment(linker, "/export:mono_image_open_from_data_with_name")
#pragma comment(linker, "/export:mono_image_open_from_module_handle")
#pragma comment(linker, "/export:mono_image_open_full")
#pragma comment(linker, "/export:mono_image_open_metadata_only")
#pragma comment(linker, "/export:mono_image_open_raw")
#pragma comment(linker, "/export:mono_image_property_insert")
#pragma comment(linker, "/export:mono_image_property_lookup")
#pragma comment(linker, "/export:mono_image_property_remove")
#pragma comment(linker, "/export:mono_image_rva_map")
#pragma comment(linker, "/export:mono_image_set_alloc")
#pragma comment(linker, "/export:mono_image_set_alloc0")
#pragma comment(linker, "/export:mono_image_set_description")
#pragma comment(linker, "/export:mono_image_set_lock")
#pragma comment(linker, "/export:mono_image_set_strdup")
#pragma comment(linker, "/export:mono_image_set_unlock")
#pragma comment(linker, "/export:mono_image_strdup")
#pragma comment(linker, "/export:mono_image_strdup_printf")
#pragma comment(linker, "/export:mono_image_strdup_vprintf")
#pragma comment(linker, "/export:mono_image_strerror")
#pragma comment(linker, "/export:mono_image_strong_name_position")
#pragma comment(linker, "/export:mono_image_unlock")
#pragma comment(linker, "/export:mono_metadata_blob_heap")
#pragma comment(linker, "/export:mono_metadata_blob_heap_checked")
#pragma comment(linker, "/export:mono_metadata_clean_for_image")
#pragma comment(linker, "/export:mono_metadata_cleanup")
#pragma comment(linker, "/export:mono_metadata_compute_size")
#pragma comment(linker, "/export:mono_metadata_compute_table_bases")
#pragma comment(linker, "/export:mono_metadata_create_anon_gparam")
#pragma comment(linker, "/export:mono_metadata_cross_helpers_run")
#pragma comment(linker, "/export:mono_metadata_custom_attrs_from_index")
#pragma comment(linker, "/export:mono_metadata_declsec_from_index")
#pragma comment(linker, "/export:mono_metadata_decode_blob_size")
#pragma comment(linker, "/export:mono_metadata_decode_row")
#pragma comment(linker, "/export:mono_metadata_decode_row_checked")
#pragma comment(linker, "/export:mono_metadata_decode_row_col")
#pragma comment(linker, "/export:mono_metadata_decode_signed_value")
#pragma comment(linker, "/export:mono_metadata_decode_table_row")
#pragma comment(linker, "/export:mono_metadata_decode_table_row_col")
#pragma comment(linker, "/export:mono_metadata_decode_value")
#pragma comment(linker, "/export:mono_metadata_encode_value")
#pragma comment(linker, "/export:mono_metadata_events_from_typedef")
#pragma comment(linker, "/export:mono_metadata_field_info")
#pragma comment(linker, "/export:mono_metadata_field_info_with_mempool")
#pragma comment(linker, "/export:mono_metadata_free_array")
#pragma comment(linker, "/export:mono_metadata_free_inflated_signature")
#pragma comment(linker, "/export:mono_metadata_free_marshal_spec")
#pragma comment(linker, "/export:mono_metadata_free_method_signature")
#pragma comment(linker, "/export:mono_metadata_free_mh")
#pragma comment(linker, "/export:mono_metadata_free_type")
#pragma comment(linker, "/export:mono_metadata_generic_class_is_valuetype")
#pragma comment(linker, "/export:mono_metadata_generic_context_equal")
#pragma comment(linker, "/export:mono_metadata_generic_context_hash")
#pragma comment(linker, "/export:mono_metadata_generic_inst_equal")
#pragma comment(linker, "/export:mono_metadata_generic_inst_hash")
#pragma comment(linker, "/export:mono_metadata_generic_param_equal")
#pragma comment(linker, "/export:mono_metadata_generic_param_hash")
#pragma comment(linker, "/export:mono_metadata_get_canonical_generic_inst")
#pragma comment(linker, "/export:mono_metadata_get_constant_index")
#pragma comment(linker, "/export:mono_metadata_get_corresponding_event_from_generic_type_definition")
#pragma comment(linker, "/export:mono_metadata_get_corresponding_field_from_generic_type_definition")
#pragma comment(linker, "/export:mono_metadata_get_corresponding_property_from_generic_type_definition")
#pragma comment(linker, "/export:mono_metadata_get_generic_inst")
#pragma comment(linker, "/export:mono_metadata_get_generic_param_row")
#pragma comment(linker, "/export:mono_metadata_get_image_set_for_class")
#pragma comment(linker, "/export:mono_metadata_get_image_set_for_method")
#pragma comment(linker, "/export:mono_metadata_get_inflated_signature")
#pragma comment(linker, "/export:mono_metadata_get_marshal_info")
#pragma comment(linker, "/export:mono_metadata_get_param_attrs")
#pragma comment(linker, "/export:mono_metadata_get_shared_type")
#pragma comment(linker, "/export:mono_metadata_guid_heap")
#pragma comment(linker, "/export:mono_metadata_has_generic_params")
#pragma comment(linker, "/export:mono_metadata_implmap_from_method")
#pragma comment(linker, "/export:mono_metadata_inflate_generic_inst")
#pragma comment(linker, "/export:mono_metadata_init")
#pragma comment(linker, "/export:mono_metadata_interfaces_from_typedef")
#pragma comment(linker, "/export:mono_metadata_interfaces_from_typedef_full")
#pragma comment(linker, "/export:mono_metadata_load_generic_param_constraints_checked")
#pragma comment(linker, "/export:mono_metadata_load_generic_params")
#pragma comment(linker, "/export:mono_metadata_localscope_from_methoddef")
#pragma comment(linker, "/export:mono_metadata_locate")
#pragma comment(linker, "/export:mono_metadata_locate_token")
#pragma comment(linker, "/export:mono_metadata_lookup_generic_class")
#pragma comment(linker, "/export:mono_metadata_method_has_param_attrs")
#pragma comment(linker, "/export:mono_metadata_methods_from_event")
#pragma comment(linker, "/export:mono_metadata_methods_from_property")
#pragma comment(linker, "/export:mono_metadata_nested_in_typedef")
#pragma comment(linker, "/export:mono_metadata_nesting_typedef")
#pragma comment(linker, "/export:mono_metadata_packing_from_typedef")
#pragma comment(linker, "/export:mono_metadata_parse_array")
#pragma comment(linker, "/export:mono_metadata_parse_custom_mod")
#pragma comment(linker, "/export:mono_metadata_parse_field_type")
#pragma comment(linker, "/export:mono_metadata_parse_generic_inst")
#pragma comment(linker, "/export:mono_metadata_parse_marshal_spec")
#pragma comment(linker, "/export:mono_metadata_parse_marshal_spec_full")
#pragma comment(linker, "/export:mono_metadata_parse_method_signature")
#pragma comment(linker, "/export:mono_metadata_parse_method_signature_full")
#pragma comment(linker, "/export:mono_metadata_parse_mh")
#pragma comment(linker, "/export:mono_metadata_parse_mh_full")
#pragma comment(linker, "/export:mono_metadata_parse_param")
#pragma comment(linker, "/export:mono_metadata_parse_signature")
#pragma comment(linker, "/export:mono_metadata_parse_signature_checked")
#pragma comment(linker, "/export:mono_metadata_parse_type")
#pragma comment(linker, "/export:mono_metadata_parse_type_checked")
#pragma comment(linker, "/export:mono_metadata_parse_typedef_or_ref")
#pragma comment(linker, "/export:mono_metadata_properties_from_typedef")
#pragma comment(linker, "/export:mono_metadata_read_constant_value")
#pragma comment(linker, "/export:mono_metadata_signature_alloc")
#pragma comment(linker, "/export:mono_metadata_signature_deep_dup")
#pragma comment(linker, "/export:mono_metadata_signature_dup")
#pragma comment(linker, "/export:mono_metadata_signature_dup_add_this")
#pragma comment(linker, "/export:mono_metadata_signature_dup_full")
#pragma comment(linker, "/export:mono_metadata_signature_dup_mempool")
#pragma comment(linker, "/export:mono_metadata_signature_equal")
#pragma comment(linker, "/export:mono_metadata_signature_size")
#pragma comment(linker, "/export:mono_metadata_str_hash")
#pragma comment(linker, "/export:mono_metadata_string_heap")
#pragma comment(linker, "/export:mono_metadata_string_heap_checked")
#pragma comment(linker, "/export:mono_metadata_token_from_dor")
#pragma comment(linker, "/export:mono_metadata_translate_token_index")
#pragma comment(linker, "/export:mono_metadata_type_dup")
#pragma comment(linker, "/export:mono_metadata_type_dup_with_cmods")
#pragma comment(linker, "/export:mono_metadata_type_equal")
#pragma comment(linker, "/export:mono_metadata_type_equal_full")
#pragma comment(linker, "/export:mono_metadata_type_hash")
#pragma comment(linker, "/export:mono_metadata_typedef_from_field")
#pragma comment(linker, "/export:mono_metadata_typedef_from_method")
#pragma comment(linker, "/export:mono_metadata_user_string")
#pragma comment(linker, "/export:mono_method_add_generic_virtual_invocation")
#pragma comment(linker, "/export:mono_method_alloc_generic_virtual_trampoline")
#pragma comment(linker, "/export:mono_method_body_get_object")
#pragma comment(linker, "/export:mono_method_body_get_object_handle")
#pragma comment(linker, "/export:mono_method_builder_ilgen_init")
#pragma comment(linker, "/export:mono_method_call_message_new")
#pragma comment(linker, "/export:mono_method_can_access_field")
#pragma comment(linker, "/export:mono_method_can_access_field_full")
#pragma comment(linker, "/export:mono_method_can_access_method")
#pragma comment(linker, "/export:mono_method_can_access_method_full")
#pragma comment(linker, "/export:mono_method_check_context_used")
#pragma comment(linker, "/export:mono_method_clear_object")
#pragma comment(linker, "/export:mono_method_construct_object_context")
#pragma comment(linker, "/export:mono_method_desc_free")
#pragma comment(linker, "/export:mono_method_desc_from_method")
#pragma comment(linker, "/export:mono_method_desc_full_match")
#pragma comment(linker, "/export:mono_method_desc_is_full")
#pragma comment(linker, "/export:mono_method_desc_match")
#pragma comment(linker, "/export:mono_method_desc_new")
#pragma comment(linker, "/export:mono_method_desc_search_in_class")
#pragma comment(linker, "/export:mono_method_desc_search_in_image")
#pragma comment(linker, "/export:mono_method_fill_runtime_generic_context")
#pragma comment(linker, "/export:mono_method_from_method_def_or_ref")
#pragma comment(linker, "/export:mono_method_full_name")
#pragma comment(linker, "/export:mono_method_get_base_method")
#pragma comment(linker, "/export:mono_method_get_class")
#pragma comment(linker, "/export:mono_method_get_context")
#pragma comment(linker, "/export:mono_method_get_context_general")
#pragma comment(linker, "/export:mono_method_get_declaring_generic_method")
#pragma comment(linker, "/export:mono_method_get_flags")
#pragma comment(linker, "/export:mono_method_get_full_name")
#pragma comment(linker, "/export:mono_method_get_generic_container")
#pragma comment(linker, "/export:mono_method_get_header")
#pragma comment(linker, "/export:mono_method_get_header_checked")
#pragma comment(linker, "/export:mono_method_get_header_internal")
#pragma comment(linker, "/export:mono_method_get_header_summary")
#pragma comment(linker, "/export:mono_method_get_imt_slot")
#pragma comment(linker, "/export:mono_method_get_index")
#pragma comment(linker, "/export:mono_method_get_last_managed")
#pragma comment(linker, "/export:mono_method_get_marshal_info")
#pragma comment(linker, "/export:mono_method_get_name")
#pragma comment(linker, "/export:mono_method_get_name_full")
#pragma comment(linker, "/export:mono_method_get_object")
#pragma comment(linker, "/export:mono_method_get_object_checked")
#pragma comment(linker, "/export:mono_method_get_object_handle")
#pragma comment(linker, "/export:mono_method_get_param_names")
#pragma comment(linker, "/export:mono_method_get_param_token")
#pragma comment(linker, "/export:mono_method_get_reflection_name")
#pragma comment(linker, "/export:mono_method_get_signature")
#pragma comment(linker, "/export:mono_method_get_signature_checked")
#pragma comment(linker, "/export:mono_method_get_signature_full")
#pragma comment(linker, "/export:mono_method_get_token")
#pragma comment(linker, "/export:mono_method_get_unmanaged_thunk")
#pragma comment(linker, "/export:mono_method_get_vtable_index")
#pragma comment(linker, "/export:mono_method_get_vtable_slot")
#pragma comment(linker, "/export:mono_method_get_wrapper_cache")
#pragma comment(linker, "/export:mono_method_get_wrapper_data")
#pragma comment(linker, "/export:mono_method_has_marshal_info")
#pragma comment(linker, "/export:mono_method_has_no_body")
#pragma comment(linker, "/export:mono_method_header_get_clauses")
#pragma comment(linker, "/export:mono_method_header_get_code")
#pragma comment(linker, "/export:mono_method_header_get_locals")
#pragma comment(linker, "/export:mono_method_header_get_num_clauses")
#pragma comment(linker, "/export:mono_method_is_from_assembly")
#pragma comment(linker, "/export:mono_method_is_generic_impl")
#pragma comment(linker, "/export:mono_method_is_generic_sharable")
#pragma comment(linker, "/export:mono_method_is_generic_sharable_full")
#pragma comment(linker, "/export:mono_method_lookup_or_register_info")
#pragma comment(linker, "/export:mono_method_needs_static_rgctx_invoke")
#pragma comment(linker, "/export:mono_method_print_code")
#pragma comment(linker, "/export:mono_method_return_message_restore")
#pragma comment(linker, "/export:mono_method_same_domain")
#pragma comment(linker, "/export:mono_method_search_in_array_class")
#pragma comment(linker, "/export:mono_method_set_generic_container")
#pragma comment(linker, "/export:mono_method_signature")
#pragma comment(linker, "/export:mono_method_signature_checked")
#pragma comment(linker, "/export:mono_method_verify")
#pragma comment(linker, "/export:mono_method_verify_with_current_settings")
#pragma comment(linker, "/export:mono_object_castclass_mbyref")
#pragma comment(linker, "/export:mono_object_castclass_unbox")
#pragma comment(linker, "/export:mono_object_castclass_with_cache")
#pragma comment(linker, "/export:mono_object_clone")
#pragma comment(linker, "/export:mono_object_clone_checked")
#pragma comment(linker, "/export:mono_object_clone_handle")
#pragma comment(linker, "/export:mono_object_describe")
#pragma comment(linker, "/export:mono_object_describe_fields")
#pragma comment(linker, "/export:mono_object_get_class")
#pragma comment(linker, "/export:mono_object_get_data")
#pragma comment(linker, "/export:mono_object_get_domain")
#pragma comment(linker, "/export:mono_object_get_size")
#pragma comment(linker, "/export:mono_object_get_virtual_method")
#pragma comment(linker, "/export:mono_object_get_vtable")
#pragma comment(linker, "/export:mono_object_handle_get_virtual_method")
#pragma comment(linker, "/export:mono_object_handle_isinst")
#pragma comment(linker, "/export:mono_object_handle_isinst_mbyref")
#pragma comment(linker, "/export:mono_object_handle_pin_unbox")
#pragma comment(linker, "/export:mono_object_hash")
#pragma comment(linker, "/export:mono_object_is_alive")
#pragma comment(linker, "/export:mono_object_is_from_assembly")
#pragma comment(linker, "/export:mono_object_isinst")
#pragma comment(linker, "/export:mono_object_isinst_checked")
#pragma comment(linker, "/export:mono_object_isinst_icall")
#pragma comment(linker, "/export:mono_object_isinst_mbyref")
#pragma comment(linker, "/export:mono_object_isinst_with_cache")
#pragma comment(linker, "/export:mono_object_new")
#pragma comment(linker, "/export:mono_object_new_alloc_by_vtable")
#pragma comment(linker, "/export:mono_object_new_alloc_specific")
#pragma comment(linker, "/export:mono_object_new_alloc_specific_checked")
#pragma comment(linker, "/export:mono_object_new_checked")
#pragma comment(linker, "/export:mono_object_new_fast")
#pragma comment(linker, "/export:mono_object_new_from_token")
#pragma comment(linker, "/export:mono_object_new_handle")
#pragma comment(linker, "/export:mono_object_new_handle_mature")
#pragma comment(linker, "/export:mono_object_new_mature")
#pragma comment(linker, "/export:mono_object_new_pinned")
#pragma comment(linker, "/export:mono_object_new_pinned_handle")
#pragma comment(linker, "/export:mono_object_new_specific")
#pragma comment(linker, "/export:mono_object_new_specific_checked")
#pragma comment(linker, "/export:mono_object_register_finalizer")
#pragma comment(linker, "/export:mono_object_register_finalizer_handle")
#pragma comment(linker, "/export:mono_object_to_string")
#pragma comment(linker, "/export:mono_object_try_to_string")
#pragma comment(linker, "/export:mono_object_unbox")
#pragma comment(linker, "/export:mono_object_xdomain_representation")
#pragma comment(linker, "/export:mono_profiler_call_context_free_buffer")
#pragma comment(linker, "/export:mono_profiler_call_context_get_argument")
#pragma comment(linker, "/export:mono_profiler_call_context_get_local")
#pragma comment(linker, "/export:mono_profiler_call_context_get_result")
#pragma comment(linker, "/export:mono_profiler_call_context_get_this")
#pragma comment(linker, "/export:mono_profiler_cleanup")
#pragma comment(linker, "/export:mono_profiler_coverage_alloc")
#pragma comment(linker, "/export:mono_profiler_coverage_instrumentation_enabled")
#pragma comment(linker, "/export:mono_profiler_create")
#pragma comment(linker, "/export:mono_profiler_enable_allocations")
#pragma comment(linker, "/export:mono_profiler_enable_call_context_introspection")
#pragma comment(linker, "/export:mono_profiler_enable_clauses")
#pragma comment(linker, "/export:mono_profiler_enable_coverage")
#pragma comment(linker, "/export:mono_profiler_enable_sampling")
#pragma comment(linker, "/export:mono_profiler_get_call_instrumentation_flags")
#pragma comment(linker, "/export:mono_profiler_get_coverage_data")
#pragma comment(linker, "/export:mono_profiler_get_sample_mode")
#pragma comment(linker, "/export:mono_profiler_install")
#pragma comment(linker, "/export:mono_profiler_install_allocation")
#pragma comment(linker, "/export:mono_profiler_install_enter_leave")
#pragma comment(linker, "/export:mono_profiler_install_exception")
#pragma comment(linker, "/export:mono_profiler_install_gc")
#pragma comment(linker, "/export:mono_profiler_install_jit_end")
#pragma comment(linker, "/export:mono_profiler_install_thread")
#pragma comment(linker, "/export:mono_profiler_load")
#pragma comment(linker, "/export:mono_profiler_raise_assembly_loaded")
#pragma comment(linker, "/export:mono_profiler_raise_assembly_loading")
#pragma comment(linker, "/export:mono_profiler_raise_assembly_unloaded")
#pragma comment(linker, "/export:mono_profiler_raise_assembly_unloading")
#pragma comment(linker, "/export:mono_profiler_raise_class_failed")
#pragma comment(linker, "/export:mono_profiler_raise_class_loaded")
#pragma comment(linker, "/export:mono_profiler_raise_class_loading")
#pragma comment(linker, "/export:mono_profiler_raise_context_loaded")
#pragma comment(linker, "/export:mono_profiler_raise_context_unloaded")
#pragma comment(linker, "/export:mono_profiler_raise_domain_loaded")
#pragma comment(linker, "/export:mono_profiler_raise_domain_loading")
#pragma comment(linker, "/export:mono_profiler_raise_domain_name")
#pragma comment(linker, "/export:mono_profiler_raise_domain_unloaded")
#pragma comment(linker, "/export:mono_profiler_raise_domain_unloading")
#pragma comment(linker, "/export:mono_profiler_raise_exception_clause")
#pragma comment(linker, "/export:mono_profiler_raise_exception_throw")
#pragma comment(linker, "/export:mono_profiler_raise_gc_allocation")
#pragma comment(linker, "/export:mono_profiler_raise_gc_event")
#pragma comment(linker, "/export:mono_profiler_raise_gc_finalized")
#pragma comment(linker, "/export:mono_profiler_raise_gc_finalized_object")
#pragma comment(linker, "/export:mono_profiler_raise_gc_finalizing")
#pragma comment(linker, "/export:mono_profiler_raise_gc_finalizing_object")
#pragma comment(linker, "/export:mono_profiler_raise_gc_handle_created")
#pragma comment(linker, "/export:mono_profiler_raise_gc_handle_deleted")
#pragma comment(linker, "/export:mono_profiler_raise_gc_moves")
#pragma comment(linker, "/export:mono_profiler_raise_gc_resize")
#pragma comment(linker, "/export:mono_profiler_raise_gc_root_register")
#pragma comment(linker, "/export:mono_profiler_raise_gc_root_unregister")
#pragma comment(linker, "/export:mono_profiler_raise_gc_roots")
#pragma comment(linker, "/export:mono_profiler_raise_image_failed")
#pragma comment(linker, "/export:mono_profiler_raise_image_loaded")
#pragma comment(linker, "/export:mono_profiler_raise_image_loading")
#pragma comment(linker, "/export:mono_profiler_raise_image_unloaded")
#pragma comment(linker, "/export:mono_profiler_raise_image_unloading")
#pragma comment(linker, "/export:mono_profiler_raise_jit_begin")
#pragma comment(linker, "/export:mono_profiler_raise_jit_chunk_created")
#pragma comment(linker, "/export:mono_profiler_raise_jit_chunk_destroyed")
#pragma comment(linker, "/export:mono_profiler_raise_jit_code_buffer")
#pragma comment(linker, "/export:mono_profiler_raise_jit_done")
#pragma comment(linker, "/export:mono_profiler_raise_jit_failed")
#pragma comment(linker, "/export:mono_profiler_raise_method_begin_invoke")
#pragma comment(linker, "/export:mono_profiler_raise_method_end_invoke")
#pragma comment(linker, "/export:mono_profiler_raise_method_enter")
#pragma comment(linker, "/export:mono_profiler_raise_method_exception_leave")
#pragma comment(linker, "/export:mono_profiler_raise_method_free")
#pragma comment(linker, "/export:mono_profiler_raise_method_leave")
#pragma comment(linker, "/export:mono_profiler_raise_method_tail_call")
#pragma comment(linker, "/export:mono_profiler_raise_monitor_acquired")
#pragma comment(linker, "/export:mono_profiler_raise_monitor_contention")
#pragma comment(linker, "/export:mono_profiler_raise_monitor_failed")
#pragma comment(linker, "/export:mono_profiler_raise_runtime_initialized")
#pragma comment(linker, "/export:mono_profiler_raise_runtime_shutdown_begin")
#pragma comment(linker, "/export:mono_profiler_raise_runtime_shutdown_end")
#pragma comment(linker, "/export:mono_profiler_raise_sample_hit")
#pragma comment(linker, "/export:mono_profiler_raise_thread_exited")
#pragma comment(linker, "/export:mono_profiler_raise_thread_name")
#pragma comment(linker, "/export:mono_profiler_raise_thread_started")
#pragma comment(linker, "/export:mono_profiler_raise_thread_stopped")
#pragma comment(linker, "/export:mono_profiler_raise_thread_stopping")
#pragma comment(linker, "/export:mono_profiler_raise_vtable_failed")
#pragma comment(linker, "/export:mono_profiler_raise_vtable_loaded")
#pragma comment(linker, "/export:mono_profiler_raise_vtable_loading")
#pragma comment(linker, "/export:mono_profiler_sampling_enabled")
#pragma comment(linker, "/export:mono_profiler_sampling_thread_post")
#pragma comment(linker, "/export:mono_profiler_sampling_thread_wait")
#pragma comment(linker, "/export:mono_profiler_set_assembly_loaded_callback")
#pragma comment(linker, "/export:mono_profiler_set_assembly_loading_callback")
#pragma comment(linker, "/export:mono_profiler_set_assembly_unloaded_callback")
#pragma comment(linker, "/export:mono_profiler_set_assembly_unloading_callback")
#pragma comment(linker, "/export:mono_profiler_set_call_instrumentation_filter_callback")
#pragma comment(linker, "/export:mono_profiler_set_class_failed_callback")
#pragma comment(linker, "/export:mono_profiler_set_class_loaded_callback")
#pragma comment(linker, "/export:mono_profiler_set_class_loading_callback")
#pragma comment(linker, "/export:mono_profiler_set_cleanup_callback")
#pragma comment(linker, "/export:mono_profiler_set_context_loaded_callback")
#pragma comment(linker, "/export:mono_profiler_set_context_unloaded_callback")
#pragma comment(linker, "/export:mono_profiler_set_coverage_filter_callback")
#pragma comment(linker, "/export:mono_profiler_set_domain_loaded_callback")
#pragma comment(linker, "/export:mono_profiler_set_domain_loading_callback")
#pragma comment(linker, "/export:mono_profiler_set_domain_name_callback")
#pragma comment(linker, "/export:mono_profiler_set_domain_unloaded_callback")
#pragma comment(linker, "/export:mono_profiler_set_domain_unloading_callback")
#pragma comment(linker, "/export:mono_profiler_set_events")
#pragma comment(linker, "/export:mono_profiler_set_exception_clause_callback")
#pragma comment(linker, "/export:mono_profiler_set_exception_throw_callback")
#pragma comment(linker, "/export:mono_profiler_set_gc_allocation_callback")
#pragma comment(linker, "/export:mono_profiler_set_gc_event_callback")
#pragma comment(linker, "/export:mono_profiler_set_gc_finalized_callback")
#pragma comment(linker, "/export:mono_profiler_set_gc_finalized_object_callback")
#pragma comment(linker, "/export:mono_profiler_set_gc_finalizing_callback")
#pragma comment(linker, "/export:mono_profiler_set_gc_finalizing_object_callback")
#pragma comment(linker, "/export:mono_profiler_set_gc_handle_created_callback")
#pragma comment(linker, "/export:mono_profiler_set_gc_handle_deleted_callback")
#pragma comment(linker, "/export:mono_profiler_set_gc_moves_callback")
#pragma comment(linker, "/export:mono_profiler_set_gc_resize_callback")
#pragma comment(linker, "/export:mono_profiler_set_gc_root_register_callback")
#pragma comment(linker, "/export:mono_profiler_set_gc_root_unregister_callback")
#pragma comment(linker, "/export:mono_profiler_set_gc_roots_callback")
#pragma comment(linker, "/export:mono_profiler_set_image_failed_callback")
#pragma comment(linker, "/export:mono_profiler_set_image_loaded_callback")
#pragma comment(linker, "/export:mono_profiler_set_image_loading_callback")
#pragma comment(linker, "/export:mono_profiler_set_image_unloaded_callback")
#pragma comment(linker, "/export:mono_profiler_set_image_unloading_callback")
#pragma comment(linker, "/export:mono_profiler_set_jit_begin_callback")
#pragma comment(linker, "/export:mono_profiler_set_jit_chunk_created_callback")
#pragma comment(linker, "/export:mono_profiler_set_jit_chunk_destroyed_callback")
#pragma comment(linker, "/export:mono_profiler_set_jit_code_buffer_callback")
#pragma comment(linker, "/export:mono_profiler_set_jit_done_callback")
#pragma comment(linker, "/export:mono_profiler_set_jit_failed_callback")
#pragma comment(linker, "/export:mono_profiler_set_method_begin_invoke_callback")
#pragma comment(linker, "/export:mono_profiler_set_method_end_invoke_callback")
#pragma comment(linker, "/export:mono_profiler_set_method_enter_callback")
#pragma comment(linker, "/export:mono_profiler_set_method_exception_leave_callback")
#pragma comment(linker, "/export:mono_profiler_set_method_free_callback")
#pragma comment(linker, "/export:mono_profiler_set_method_leave_callback")
#pragma comment(linker, "/export:mono_profiler_set_method_tail_call_callback")
#pragma comment(linker, "/export:mono_profiler_set_monitor_acquired_callback")
#pragma comment(linker, "/export:mono_profiler_set_monitor_contention_callback")
#pragma comment(linker, "/export:mono_profiler_set_monitor_failed_callback")
#pragma comment(linker, "/export:mono_profiler_set_runtime_initialized_callback")
#pragma comment(linker, "/export:mono_profiler_set_runtime_shutdown_begin_callback")
#pragma comment(linker, "/export:mono_profiler_set_runtime_shutdown_end_callback")
#pragma comment(linker, "/export:mono_profiler_set_sample_hit_callback")
#pragma comment(linker, "/export:mono_profiler_set_sample_mode")
#pragma comment(linker, "/export:mono_profiler_set_thread_exited_callback")
#pragma comment(linker, "/export:mono_profiler_set_thread_name_callback")
#pragma comment(linker, "/export:mono_profiler_set_thread_started_callback")
#pragma comment(linker, "/export:mono_profiler_set_thread_stopped_callback")
#pragma comment(linker, "/export:mono_profiler_set_thread_stopping_callback")
#pragma comment(linker, "/export:mono_profiler_set_vtable_failed_callback")
#pragma comment(linker, "/export:mono_profiler_set_vtable_loaded_callback")
#pragma comment(linker, "/export:mono_profiler_set_vtable_loading_callback")
#pragma comment(linker, "/export:mono_profiler_started")
#pragma comment(linker, "/export:mono_profiler_state")
#pragma comment(linker, "/export:mono_property_bag_add")
#pragma comment(linker, "/export:mono_property_bag_get")
#pragma comment(linker, "/export:mono_property_get_flags")
#pragma comment(linker, "/export:mono_property_get_get_method")
#pragma comment(linker, "/export:mono_property_get_name")
#pragma comment(linker, "/export:mono_property_get_object")
#pragma comment(linker, "/export:mono_property_get_object_checked")
#pragma comment(linker, "/export:mono_property_get_object_handle")
#pragma comment(linker, "/export:mono_property_get_parent")
#pragma comment(linker, "/export:mono_property_get_set_method")
#pragma comment(linker, "/export:mono_property_get_value")
#pragma comment(linker, "/export:mono_property_get_value_checked")
#pragma comment(linker, "/export:mono_property_hash_destroy")
#pragma comment(linker, "/export:mono_property_hash_insert")
#pragma comment(linker, "/export:mono_property_hash_lookup")
#pragma comment(linker, "/export:mono_property_hash_new")
#pragma comment(linker, "/export:mono_property_hash_remove_object")
#pragma comment(linker, "/export:mono_property_set_value")
#pragma comment(linker, "/export:mono_property_set_value_handle")
#pragma comment(linker, "/export:mono_raise_exception")
#pragma comment(linker, "/export:mono_raise_exception_deprecated")
#pragma comment(linker, "/export:mono_raise_exception_with_context")
#pragma comment(linker, "/export:mono_reflection_assembly_get_assembly")
#pragma comment(linker, "/export:mono_reflection_bind_generic_parameters")
#pragma comment(linker, "/export:mono_reflection_call_is_assignable_to")
#pragma comment(linker, "/export:mono_reflection_cleanup_assembly")
#pragma comment(linker, "/export:mono_reflection_cleanup_domain")
#pragma comment(linker, "/export:mono_reflection_create_custom_attr_data_args")
#pragma comment(linker, "/export:mono_reflection_create_custom_attr_data_args_noalloc")
#pragma comment(linker, "/export:mono_reflection_dynimage_basic_init")
#pragma comment(linker, "/export:mono_reflection_emit_init")
#pragma comment(linker, "/export:mono_reflection_free_type_info")
#pragma comment(linker, "/export:mono_reflection_get_custom_attrs")
#pragma comment(linker, "/export:mono_reflection_get_custom_attrs_blob")
#pragma comment(linker, "/export:mono_reflection_get_custom_attrs_blob_checked")
#pragma comment(linker, "/export:mono_reflection_get_custom_attrs_by_type")
#pragma comment(linker, "/export:mono_reflection_get_custom_attrs_by_type_handle")
#pragma comment(linker, "/export:mono_reflection_get_custom_attrs_data")
#pragma comment(linker, "/export:mono_reflection_get_custom_attrs_data_checked")
#pragma comment(linker, "/export:mono_reflection_get_custom_attrs_info")
#pragma comment(linker, "/export:mono_reflection_get_custom_attrs_info_checked")
#pragma comment(linker, "/export:mono_reflection_get_dynamic_overrides")
#pragma comment(linker, "/export:mono_reflection_get_token")
#pragma comment(linker, "/export:mono_reflection_get_token_checked")
#pragma comment(linker, "/export:mono_reflection_get_type")
#pragma comment(linker, "/export:mono_reflection_get_type_checked")
#pragma comment(linker, "/export:mono_reflection_init")
#pragma comment(linker, "/export:mono_reflection_is_usertype")
#pragma comment(linker, "/export:mono_reflection_lookup_dynamic_token")
#pragma comment(linker, "/export:mono_reflection_lookup_signature")
#pragma comment(linker, "/export:mono_reflection_marshal_as_attribute_from_marshal_spec")
#pragma comment(linker, "/export:mono_reflection_method_count_clauses")
#pragma comment(linker, "/export:mono_reflection_methodbuilder_from_ctor_builder")
#pragma comment(linker, "/export:mono_reflection_methodbuilder_from_method_builder")
#pragma comment(linker, "/export:mono_reflection_parse_type")
#pragma comment(linker, "/export:mono_reflection_parse_type_checked")
#pragma comment(linker, "/export:mono_reflection_resolution_scope_from_image")
#pragma comment(linker, "/export:mono_reflection_resolve_object")
#pragma comment(linker, "/export:mono_reflection_resolve_object_handle")
#pragma comment(linker, "/export:mono_reflection_type_from_name")
#pragma comment(linker, "/export:mono_reflection_type_from_name_checked")
#pragma comment(linker, "/export:mono_reflection_type_get_handle")
#pragma comment(linker, "/export:mono_reflection_type_get_type")
#pragma comment(linker, "/export:mono_reflection_type_handle_mono_type")
#pragma comment(linker, "/export:mono_runtime_class_init")
#pragma comment(linker, "/export:mono_runtime_class_init_full")
#pragma comment(linker, "/export:mono_runtime_cleanup")
#pragma comment(linker, "/export:mono_runtime_cleanup_handlers")
#pragma comment(linker, "/export:mono_runtime_create_delegate_trampoline")
#pragma comment(linker, "/export:mono_runtime_create_jump_trampoline")
#pragma comment(linker, "/export:mono_runtime_delegate_invoke")
#pragma comment(linker, "/export:mono_runtime_delegate_invoke_checked")
#pragma comment(linker, "/export:mono_runtime_delegate_try_invoke")
#pragma comment(linker, "/export:mono_runtime_exec_main")
#pragma comment(linker, "/export:mono_runtime_exec_main_checked")
#pragma comment(linker, "/export:mono_runtime_exec_managed_code")
#pragma comment(linker, "/export:mono_runtime_free_method")
#pragma comment(linker, "/export:mono_runtime_get_aotid")
#pragma comment(linker, "/export:mono_runtime_get_caller_no_system_or_reflection")
#pragma comment(linker, "/export:mono_runtime_get_main_args")
#pragma comment(linker, "/export:mono_runtime_get_main_args_handle")
#pragma comment(linker, "/export:mono_runtime_get_no_exec")
#pragma comment(linker, "/export:mono_runtime_init")
#pragma comment(linker, "/export:mono_runtime_init_checked")
#pragma comment(linker, "/export:mono_runtime_init_tls")
#pragma comment(linker, "/export:mono_runtime_install_custom_handlers")
#pragma comment(linker, "/export:mono_runtime_install_custom_handlers_usage")
#pragma comment(linker, "/export:mono_runtime_install_handlers")
#pragma comment(linker, "/export:mono_runtime_invoke")
#pragma comment(linker, "/export:mono_runtime_invoke_array")
#pragma comment(linker, "/export:mono_runtime_invoke_array_checked")
#pragma comment(linker, "/export:mono_runtime_invoke_checked")
#pragma comment(linker, "/export:mono_runtime_invoke_handle")
#pragma comment(linker, "/export:mono_runtime_is_shutting_down")
#pragma comment(linker, "/export:mono_runtime_load")
#pragma comment(linker, "/export:mono_runtime_object_init")
#pragma comment(linker, "/export:mono_runtime_object_init_checked")
#pragma comment(linker, "/export:mono_runtime_object_init_handle")
#pragma comment(linker, "/export:mono_runtime_quit")
#pragma comment(linker, "/export:mono_runtime_resource_check_limit")
#pragma comment(linker, "/export:mono_runtime_resource_limit")
#pragma comment(linker, "/export:mono_runtime_resource_set_callback")
#pragma comment(linker, "/export:mono_runtime_run_main")
#pragma comment(linker, "/export:mono_runtime_run_main_checked")
#pragma comment(linker, "/export:mono_runtime_run_module_cctor")
#pragma comment(linker, "/export:mono_runtime_set_main_args")
#pragma comment(linker, "/export:mono_runtime_set_no_exec")
#pragma comment(linker, "/export:mono_runtime_set_pending_exception")
#pragma comment(linker, "/export:mono_runtime_set_shutting_down")
#pragma comment(linker, "/export:mono_runtime_setup_stat_profiler")
#pragma comment(linker, "/export:mono_runtime_shutdown_stat_profiler")
#pragma comment(linker, "/export:mono_runtime_try_exec_main")
#pragma comment(linker, "/export:mono_runtime_try_invoke")
#pragma comment(linker, "/export:mono_runtime_try_invoke_array")
#pragma comment(linker, "/export:mono_runtime_try_invoke_handle")
#pragma comment(linker, "/export:mono_runtime_try_run_main")
#pragma comment(linker, "/export:mono_runtime_try_shutdown")
#pragma comment(linker, "/export:mono_runtime_unhandled_exception_policy_get")
#pragma comment(linker, "/export:mono_runtime_unhandled_exception_policy_set")
#pragma comment(linker, "/export:mono_signature_explicit_this")
#pragma comment(linker, "/export:mono_signature_full_name")
#pragma comment(linker, "/export:mono_signature_get_call_conv")
#pragma comment(linker, "/export:mono_signature_get_desc")
#pragma comment(linker, "/export:mono_signature_get_param_count")
#pragma comment(linker, "/export:mono_signature_get_params")
#pragma comment(linker, "/export:mono_signature_get_return_type")
#pragma comment(linker, "/export:mono_signature_hash")
#pragma comment(linker, "/export:mono_signature_is_instance")
#pragma comment(linker, "/export:mono_signature_no_pinvoke")
#pragma comment(linker, "/export:mono_signature_param_is_out")
#pragma comment(linker, "/export:mono_signature_vararg_start")
#pragma comment(linker, "/export:mono_stack_mark_pop_value")
#pragma comment(linker, "/export:mono_stack_mark_record_size")
#pragma comment(linker, "/export:mono_stack_walk")
#pragma comment(linker, "/export:mono_stack_walk_async_safe")
#pragma comment(linker, "/export:mono_stack_walk_no_il")
#pragma comment(linker, "/export:mono_string_builder_to_utf16")
#pragma comment(linker, "/export:mono_string_builder_to_utf8")
#pragma comment(linker, "/export:mono_string_chars")
#pragma comment(linker, "/export:mono_string_empty")
#pragma comment(linker, "/export:mono_string_empty_handle")
#pragma comment(linker, "/export:mono_string_empty_wrapper")
#pragma comment(linker, "/export:mono_string_equal")
#pragma comment(linker, "/export:mono_string_from_blob")
#pragma comment(linker, "/export:mono_string_from_bstr")
#pragma comment(linker, "/export:mono_string_from_bstr_icall")
#pragma comment(linker, "/export:mono_string_from_byvalstr")
#pragma comment(linker, "/export:mono_string_from_byvalwstr")
#pragma comment(linker, "/export:mono_string_from_utf16")
#pragma comment(linker, "/export:mono_string_from_utf16_checked")
#pragma comment(linker, "/export:mono_string_from_utf32")
#pragma comment(linker, "/export:mono_string_from_utf32_checked")
#pragma comment(linker, "/export:mono_string_handle_length")
#pragma comment(linker, "/export:mono_string_handle_pin_chars")
#pragma comment(linker, "/export:mono_string_handle_to_utf8")
#pragma comment(linker, "/export:mono_string_hash")
#pragma comment(linker, "/export:mono_string_intern")
#pragma comment(linker, "/export:mono_string_intern_checked")
#pragma comment(linker, "/export:mono_string_is_interned")
#pragma comment(linker, "/export:mono_string_length")
#pragma comment(linker, "/export:mono_string_new")
#pragma comment(linker, "/export:mono_string_new_checked")
#pragma comment(linker, "/export:mono_string_new_handle")
#pragma comment(linker, "/export:mono_string_new_len")
#pragma comment(linker, "/export:mono_string_new_len_checked")
#pragma comment(linker, "/export:mono_string_new_len_wrapper")
#pragma comment(linker, "/export:mono_string_new_size")
#pragma comment(linker, "/export:mono_string_new_size_checked")
#pragma comment(linker, "/export:mono_string_new_utf16")
#pragma comment(linker, "/export:mono_string_new_utf16_checked")
#pragma comment(linker, "/export:mono_string_new_utf16_handle")
#pragma comment(linker, "/export:mono_string_new_utf32")
#pragma comment(linker, "/export:mono_string_new_utf8_len_handle")
#pragma comment(linker, "/export:mono_string_new_wrapper")
#pragma comment(linker, "/export:mono_string_new_wtf8_len_checked")
#pragma comment(linker, "/export:mono_string_to_ansibstr")
#pragma comment(linker, "/export:mono_string_to_bstr")
#pragma comment(linker, "/export:mono_string_to_byvalstr")
#pragma comment(linker, "/export:mono_string_to_byvalwstr")
#pragma comment(linker, "/export:mono_string_to_utf16")
#pragma comment(linker, "/export:mono_string_to_utf32")
#pragma comment(linker, "/export:mono_string_to_utf8")
#pragma comment(linker, "/export:mono_string_to_utf8_checked")
#pragma comment(linker, "/export:mono_string_to_utf8_ignore")
#pragma comment(linker, "/export:mono_string_to_utf8_image")
#pragma comment(linker, "/export:mono_string_to_utf8str")
#pragma comment(linker, "/export:mono_string_to_utf8str_handle")
#pragma comment(linker, "/export:mono_string_utf16_to_builder")
#pragma comment(linker, "/export:mono_string_utf16_to_builder2")
#pragma comment(linker, "/export:mono_string_utf8_to_builder")
#pragma comment(linker, "/export:mono_string_utf8_to_builder2")
#pragma comment(linker, "/export:mono_thread_attach")
#pragma comment(linker, "/export:mono_thread_attach_aborted_cb")
#pragma comment(linker, "/export:mono_thread_callbacks_init")
#pragma comment(linker, "/export:mono_thread_cleanup")
#pragma comment(linker, "/export:mono_thread_cleanup_apartment_state")
#pragma comment(linker, "/export:mono_thread_clear_and_set_state")
#pragma comment(linker, "/export:mono_thread_clr_state")
#pragma comment(linker, "/export:mono_thread_create")
#pragma comment(linker, "/export:mono_thread_create_checked")
#pragma comment(linker, "/export:mono_thread_create_internal")
#pragma comment(linker, "/export:mono_thread_create_internal_handle")
#pragma comment(linker, "/export:mono_thread_current")
#pragma comment(linker, "/export:mono_thread_current_check_pending_interrupt")
#pragma comment(linker, "/export:mono_thread_detach")
#pragma comment(linker, "/export:mono_thread_detach_if_exiting")
#pragma comment(linker, "/export:mono_thread_exit")
#pragma comment(linker, "/export:mono_thread_force_interruption_checkpoint_noraise")
#pragma comment(linker, "/export:mono_thread_get_main")
#pragma comment(linker, "/export:mono_thread_get_managed_id")
#pragma comment(linker, "/export:mono_thread_get_name")
#pragma comment(linker, "/export:mono_thread_get_name_utf8")
#pragma comment(linker, "/export:mono_thread_get_undeniable_exception")
#pragma comment(linker, "/export:mono_thread_has_appdomain_ref")
#pragma comment(linker, "/export:mono_thread_hazardous_queue_free")
#pragma comment(linker, "/export:mono_thread_hazardous_try_free")
#pragma comment(linker, "/export:mono_thread_hazardous_try_free_all")
#pragma comment(linker, "/export:mono_thread_hazardous_try_free_some")
#pragma comment(linker, "/export:mono_thread_init")
#pragma comment(linker, "/export:mono_thread_init_apartment_state")
#pragma comment(linker, "/export:mono_thread_interruption_checkpoint")
#pragma comment(linker, "/export:mono_thread_interruption_checkpoint_bool")
#pragma comment(linker, "/export:mono_thread_interruption_checkpoint_void")
#pragma comment(linker, "/export:mono_thread_interruption_request_flag")
#pragma comment(linker, "/export:mono_thread_interruption_requested")
#pragma comment(linker, "/export:mono_thread_is_foreign")
#pragma comment(linker, "/export:mono_thread_is_gc_unsafe_mode")
#pragma comment(linker, "/export:mono_thread_join")
#pragma comment(linker, "/export:mono_thread_manage")
#pragma comment(linker, "/export:mono_thread_new_init")
#pragma comment(linker, "/export:mono_thread_platform_create_thread")
#pragma comment(linker, "/export:mono_thread_pop_appdomain_ref")
#pragma comment(linker, "/export:mono_thread_push_appdomain_ref")
#pragma comment(linker, "/export:mono_thread_set_main")
#pragma comment(linker, "/export:mono_thread_set_manage_callback")
#pragma comment(linker, "/export:mono_thread_set_name_internal")
#pragma comment(linker, "/export:mono_thread_set_state")
#pragma comment(linker, "/export:mono_thread_small_id_alloc")
#pragma comment(linker, "/export:mono_thread_small_id_free")
#pragma comment(linker, "/export:mono_thread_smr_cleanup")
#pragma comment(linker, "/export:mono_thread_smr_init")
#pragma comment(linker, "/export:mono_thread_stop")
#pragma comment(linker, "/export:mono_thread_test_and_set_state")
#pragma comment(linker, "/export:mono_thread_test_state")
#pragma comment(linker, "/export:mono_type_array_get_and_resolve")
#pragma comment(linker, "/export:mono_type_create_from_typespec")
#pragma comment(linker, "/export:mono_type_create_from_typespec_checked")
#pragma comment(linker, "/export:mono_type_full_name")
#pragma comment(linker, "/export:mono_type_generic_inst_is_valuetype")
#pragma comment(linker, "/export:mono_type_get_array_type")
#pragma comment(linker, "/export:mono_type_get_basic_type_from_generic")
#pragma comment(linker, "/export:mono_type_get_checked")
#pragma comment(linker, "/export:mono_type_get_class")
#pragma comment(linker, "/export:mono_type_get_cmods")
#pragma comment(linker, "/export:mono_type_get_desc")
#pragma comment(linker, "/export:mono_type_get_full_name")
#pragma comment(linker, "/export:mono_type_get_modifiers")
#pragma comment(linker, "/export:mono_type_get_name")
#pragma comment(linker, "/export:mono_type_get_name_full")
#pragma comment(linker, "/export:mono_type_get_object")
#pragma comment(linker, "/export:mono_type_get_object_checked")
#pragma comment(linker, "/export:mono_type_get_object_handle")
#pragma comment(linker, "/export:mono_type_get_ptr_type")
#pragma comment(linker, "/export:mono_type_get_signature")
#pragma comment(linker, "/export:mono_type_get_type")
#pragma comment(linker, "/export:mono_type_get_underlying_type")
#pragma comment(linker, "/export:mono_type_has_exceptions")
#pragma comment(linker, "/export:mono_type_in_image")
#pragma comment(linker, "/export:mono_type_initialization_cleanup")
#pragma comment(linker, "/export:mono_type_initialization_init")
#pragma comment(linker, "/export:mono_type_is_byref")
#pragma comment(linker, "/export:mono_type_is_from_assembly")
#pragma comment(linker, "/export:mono_type_is_generic_parameter")
#pragma comment(linker, "/export:mono_type_is_pointer")
#pragma comment(linker, "/export:mono_type_is_primitive")
#pragma comment(linker, "/export:mono_type_is_reference")
#pragma comment(linker, "/export:mono_type_is_struct")
#pragma comment(linker, "/export:mono_type_is_valid_enum_basetype")
#pragma comment(linker, "/export:mono_type_is_void")
#pragma comment(linker, "/export:mono_type_native_stack_size")
#pragma comment(linker, "/export:mono_type_set_alignment")
#pragma comment(linker, "/export:mono_type_size")
#pragma comment(linker, "/export:mono_type_stack_size")
#pragma comment(linker, "/export:mono_type_stack_size_internal")
#pragma comment(linker, "/export:mono_value_box")
#pragma comment(linker, "/export:mono_value_copy")
#pragma comment(linker, "/export:mono_value_copy_array")
#pragma comment(linker, "/export:mono_jit_info_get_code_start")
#pragma comment(linker, "/export:mono_jit_info_get_code_size")

#endif