Il2CppInspectorRedux/Il2CppTests/TestExpectedResults/GameAssembly-CSharp1-x64.h

// Generated C++ file by Il2CppInspector - http://www.djkaty.com - https://github.com/djkaty
// Target Unity version: 2020.1.5 - 2020.1.10

#if defined(_GHIDRA_) || defined(_IDA_)
typedef unsigned __int8 uint8_t;
typedef unsigned __int16 uint16_t;
typedef unsigned __int32 uint32_t;
typedef unsigned __int64 uint64_t;
typedef __int8 int8_t;
typedef __int16 int16_t;
typedef __int32 int32_t;
typedef __int64 int64_t;
#endif

#if defined(_GHIDRA_)
typedef __int64 size_t;
typedef size_t intptr_t;
typedef size_t uintptr_t;
#else
#define _CPLUSPLUS_
#endif

// ******************************************************************************
// * IL2CPP internal types
// ******************************************************************************

typedef struct Il2CppClass Il2CppClass;
typedef struct Il2CppType Il2CppType;
typedef struct EventInfo EventInfo;
typedef struct MethodInfo MethodInfo;
typedef struct FieldInfo FieldInfo;
typedef struct PropertyInfo PropertyInfo;
typedef struct Il2CppAssembly Il2CppAssembly;
typedef struct Il2CppArray Il2CppArray;
typedef struct Il2CppDelegate Il2CppDelegate;
typedef struct Il2CppDomain Il2CppDomain;
typedef struct Il2CppImage Il2CppImage;
typedef struct Il2CppException Il2CppException;
typedef struct Il2CppProfiler Il2CppProfiler;
typedef struct Il2CppObject Il2CppObject;
typedef struct Il2CppReflectionMethod Il2CppReflectionMethod;
typedef struct Il2CppReflectionType Il2CppReflectionType;
typedef struct Il2CppString Il2CppString;
typedef struct Il2CppThread Il2CppThread;
typedef struct Il2CppAsyncResult Il2CppAsyncResult;
typedef struct Il2CppManagedMemorySnapshot Il2CppManagedMemorySnapshot;
typedef struct Il2CppCustomAttrInfo Il2CppCustomAttrInfo;
typedef enum
{
    IL2CPP_PROFILE_NONE = 0,
    IL2CPP_PROFILE_APPDOMAIN_EVENTS = 1 << 0,
    IL2CPP_PROFILE_ASSEMBLY_EVENTS = 1 << 1,
    IL2CPP_PROFILE_MODULE_EVENTS = 1 << 2,
    IL2CPP_PROFILE_CLASS_EVENTS = 1 << 3,
    IL2CPP_PROFILE_JIT_COMPILATION = 1 << 4,
    IL2CPP_PROFILE_INLINING = 1 << 5,
    IL2CPP_PROFILE_EXCEPTIONS = 1 << 6,
    IL2CPP_PROFILE_ALLOCATIONS = 1 << 7,
    IL2CPP_PROFILE_GC = 1 << 8,
    IL2CPP_PROFILE_THREADS = 1 << 9,
    IL2CPP_PROFILE_REMOTING = 1 << 10,
    IL2CPP_PROFILE_TRANSITIONS = 1 << 11,
    IL2CPP_PROFILE_ENTER_LEAVE = 1 << 12,
    IL2CPP_PROFILE_COVERAGE = 1 << 13,
    IL2CPP_PROFILE_INS_COVERAGE = 1 << 14,
    IL2CPP_PROFILE_STATISTICAL = 1 << 15,
    IL2CPP_PROFILE_METHOD_EVENTS = 1 << 16,
    IL2CPP_PROFILE_MONITOR_EVENTS = 1 << 17,
    IL2CPP_PROFILE_IOMAP_EVENTS = 1 << 18,
    IL2CPP_PROFILE_GC_MOVES = 1 << 19,
    IL2CPP_PROFILE_FILEIO = 1 << 20
} Il2CppProfileFlags;
typedef enum
{
    IL2CPP_PROFILE_FILEIO_WRITE = 0,
    IL2CPP_PROFILE_FILEIO_READ
} Il2CppProfileFileIOKind;
typedef enum
{
    IL2CPP_GC_EVENT_START,
    IL2CPP_GC_EVENT_MARK_START,
    IL2CPP_GC_EVENT_MARK_END,
    IL2CPP_GC_EVENT_RECLAIM_START,
    IL2CPP_GC_EVENT_RECLAIM_END,
    IL2CPP_GC_EVENT_END,
    IL2CPP_GC_EVENT_PRE_STOP_WORLD,
    IL2CPP_GC_EVENT_POST_STOP_WORLD,
    IL2CPP_GC_EVENT_PRE_START_WORLD,
    IL2CPP_GC_EVENT_POST_START_WORLD
} Il2CppGCEvent;
typedef enum
{
    IL2CPP_STAT_NEW_OBJECT_COUNT,
    IL2CPP_STAT_INITIALIZED_CLASS_COUNT,
    IL2CPP_STAT_METHOD_COUNT,
    IL2CPP_STAT_CLASS_STATIC_DATA_SIZE,
    IL2CPP_STAT_GENERIC_INSTANCE_COUNT,
    IL2CPP_STAT_GENERIC_CLASS_COUNT,
    IL2CPP_STAT_INFLATED_METHOD_COUNT,
    IL2CPP_STAT_INFLATED_TYPE_COUNT,
} Il2CppStat;
typedef enum
{
    IL2CPP_UNHANDLED_POLICY_LEGACY,
    IL2CPP_UNHANDLED_POLICY_CURRENT
} Il2CppRuntimeUnhandledExceptionPolicy;
typedef struct Il2CppStackFrameInfo
{
    const MethodInfo *method;
    uintptr_t raw_ip;
} Il2CppStackFrameInfo;
typedef void(*Il2CppMethodPointer)();
typedef struct Il2CppMethodDebugInfo
{
    Il2CppMethodPointer methodPointer;
    int32_t code_size;
    const char *file;
} Il2CppMethodDebugInfo;
typedef struct
{
    void* (*malloc_func)(size_t size);
    void* (*aligned_malloc_func)(size_t size, size_t alignment);
    void (*free_func)(void *ptr);
    void (*aligned_free_func)(void *ptr);
    void* (*calloc_func)(size_t nmemb, size_t size);
    void* (*realloc_func)(void *ptr, size_t size);
    void* (*aligned_realloc_func)(void *ptr, size_t size, size_t alignment);
} Il2CppMemoryCallbacks;
typedef struct
{
    const char *name;
    void(*connect)(const char *address);
    int(*wait_for_attach)(void);
    void(*close1)(void);
    void(*close2)(void);
    int(*send)(void *buf, int len);
    int(*recv)(void *buf, int len);
} Il2CppDebuggerTransport;
typedef uint16_t Il2CppChar;
typedef char Il2CppNativeChar;
typedef void (*il2cpp_register_object_callback)(Il2CppObject** arr, int size, void* userdata);
typedef void (*il2cpp_WorldChangedCallback)();
typedef void (*Il2CppFrameWalkFunc) (const Il2CppStackFrameInfo *info, void *user_data);
typedef void (*Il2CppProfileFunc) (Il2CppProfiler* prof);
typedef void (*Il2CppProfileMethodFunc) (Il2CppProfiler* prof, const MethodInfo *method);
typedef void (*Il2CppProfileAllocFunc) (Il2CppProfiler* prof, Il2CppObject *obj, Il2CppClass *klass);
typedef void (*Il2CppProfileGCFunc) (Il2CppProfiler* prof, Il2CppGCEvent event, int generation);
typedef void (*Il2CppProfileGCResizeFunc) (Il2CppProfiler* prof, int64_t new_size);
typedef void (*Il2CppProfileFileIOFunc) (Il2CppProfiler* prof, Il2CppProfileFileIOKind kind, int count);
typedef void (*Il2CppProfileThreadFunc) (Il2CppProfiler *prof, unsigned long tid);
typedef const Il2CppNativeChar* (*Il2CppSetFindPlugInCallback)(const Il2CppNativeChar*);
typedef void (*Il2CppLogCallback)(const char*);
typedef size_t(*Il2CppBacktraceFunc) (Il2CppMethodPointer* buffer, size_t maxSize);
typedef struct Il2CppManagedMemorySnapshot Il2CppManagedMemorySnapshot;
typedef uintptr_t il2cpp_array_size_t;
typedef void ( *SynchronizationContextCallback)(intptr_t arg);
typedef uint16_t Il2CppMethodSlot;
static const uint16_t kInvalidIl2CppMethodSlot = 65535;
static const int ipv6AddressSize = 16;
typedef int32_t il2cpp_hresult_t;
typedef struct Il2CppMetadataField
{
    uint32_t offset;
    uint32_t typeIndex;
    const char* name;
    uint8_t isStatic;
} Il2CppMetadataField;
typedef enum Il2CppMetadataTypeFlags
{
    kNone = 0,
    kValueType = 1 << 0,
    kArray = 1 << 1,
    kArrayRankMask = 0xFFFF0000
} Il2CppMetadataTypeFlags;
typedef struct Il2CppMetadataType
{
    Il2CppMetadataTypeFlags flags;
    Il2CppMetadataField* fields;
    uint32_t fieldCount;
    uint32_t staticsSize;
    uint8_t* statics;
    uint32_t baseOrElementTypeIndex;
    char* name;
    const char* assemblyName;
    uint64_t typeInfoAddress;
    uint32_t size;
} Il2CppMetadataType;
typedef struct Il2CppMetadataSnapshot
{
    uint32_t typeCount;
    Il2CppMetadataType* types;
} Il2CppMetadataSnapshot;
typedef struct Il2CppManagedMemorySection
{
    uint64_t sectionStartAddress;
    uint32_t sectionSize;
    uint8_t* sectionBytes;
} Il2CppManagedMemorySection;
typedef struct Il2CppManagedHeap
{
    uint32_t sectionCount;
    Il2CppManagedMemorySection* sections;
} Il2CppManagedHeap;
typedef struct Il2CppStacks
{
    uint32_t stackCount;
    Il2CppManagedMemorySection* stacks;
} Il2CppStacks;
typedef struct NativeObject
{
    uint32_t gcHandleIndex;
    uint32_t size;
    uint32_t instanceId;
    uint32_t classId;
    uint32_t referencedNativeObjectIndicesCount;
    uint32_t* referencedNativeObjectIndices;
} NativeObject;
typedef struct Il2CppGCHandles
{
    uint32_t trackedObjectCount;
    uint64_t* pointersToObjects;
} Il2CppGCHandles;
typedef struct Il2CppRuntimeInformation
{
    uint32_t pointerSize;
    uint32_t objectHeaderSize;
    uint32_t arrayHeaderSize;
    uint32_t arrayBoundsOffsetInHeader;
    uint32_t arraySizeOffsetInHeader;
    uint32_t allocationGranularity;
} Il2CppRuntimeInformation;
typedef struct Il2CppManagedMemorySnapshot
{
    Il2CppManagedHeap heap;
    Il2CppStacks stacks;
    Il2CppMetadataSnapshot metadata;
    Il2CppGCHandles gcHandles;
    Il2CppRuntimeInformation runtimeInformation;
    void* additionalUserInformation;
} Il2CppManagedMemorySnapshot;
typedef enum Il2CppTypeEnum
{
    IL2CPP_TYPE_END = 0x00,
    IL2CPP_TYPE_VOID = 0x01,
    IL2CPP_TYPE_BOOLEAN = 0x02,
    IL2CPP_TYPE_CHAR = 0x03,
    IL2CPP_TYPE_I1 = 0x04,
    IL2CPP_TYPE_U1 = 0x05,
    IL2CPP_TYPE_I2 = 0x06,
    IL2CPP_TYPE_U2 = 0x07,
    IL2CPP_TYPE_I4 = 0x08,
    IL2CPP_TYPE_U4 = 0x09,
    IL2CPP_TYPE_I8 = 0x0a,
    IL2CPP_TYPE_U8 = 0x0b,
    IL2CPP_TYPE_R4 = 0x0c,
    IL2CPP_TYPE_R8 = 0x0d,
    IL2CPP_TYPE_STRING = 0x0e,
    IL2CPP_TYPE_PTR = 0x0f,
    IL2CPP_TYPE_BYREF = 0x10,
    IL2CPP_TYPE_VALUETYPE = 0x11,
    IL2CPP_TYPE_CLASS = 0x12,
    IL2CPP_TYPE_VAR = 0x13,
    IL2CPP_TYPE_ARRAY = 0x14,
    IL2CPP_TYPE_GENERICINST = 0x15,
    IL2CPP_TYPE_TYPEDBYREF = 0x16,
    IL2CPP_TYPE_I = 0x18,
    IL2CPP_TYPE_U = 0x19,
    IL2CPP_TYPE_FNPTR = 0x1b,
    IL2CPP_TYPE_OBJECT = 0x1c,
    IL2CPP_TYPE_SZARRAY = 0x1d,
    IL2CPP_TYPE_MVAR = 0x1e,
    IL2CPP_TYPE_CMOD_REQD = 0x1f,
    IL2CPP_TYPE_CMOD_OPT = 0x20,
    IL2CPP_TYPE_INTERNAL = 0x21,
    IL2CPP_TYPE_MODIFIER = 0x40,
    IL2CPP_TYPE_SENTINEL = 0x41,
    IL2CPP_TYPE_PINNED = 0x45,
    IL2CPP_TYPE_ENUM = 0x55
} Il2CppTypeEnum;
typedef enum
{
    IL2CPP_TOKEN_MODULE = 0x00000000,
    IL2CPP_TOKEN_TYPE_REF = 0x01000000,
    IL2CPP_TOKEN_TYPE_DEF = 0x02000000,
    IL2CPP_TOKEN_FIELD_DEF = 0x04000000,
    IL2CPP_TOKEN_METHOD_DEF = 0x06000000,
    IL2CPP_TOKEN_PARAM_DEF = 0x08000000,
    IL2CPP_TOKEN_INTERFACE_IMPL = 0x09000000,
    IL2CPP_TOKEN_MEMBER_REF = 0x0a000000,
    IL2CPP_TOKEN_CUSTOM_ATTRIBUTE = 0x0c000000,
    IL2CPP_TOKEN_PERMISSION = 0x0e000000,
    IL2CPP_TOKEN_SIGNATURE = 0x11000000,
    IL2CPP_TOKEN_EVENT = 0x14000000,
    IL2CPP_TOKEN_PROPERTY = 0x17000000,
    IL2CPP_TOKEN_MODULE_REF = 0x1a000000,
    IL2CPP_TOKEN_TYPE_SPEC = 0x1b000000,
    IL2CPP_TOKEN_ASSEMBLY = 0x20000000,
    IL2CPP_TOKEN_ASSEMBLY_REF = 0x23000000,
    IL2CPP_TOKEN_FILE = 0x26000000,
    IL2CPP_TOKEN_EXPORTED_TYPE = 0x27000000,
    IL2CPP_TOKEN_MANIFEST_RESOURCE = 0x28000000,
    IL2CPP_TOKEN_GENERIC_PARAM = 0x2a000000,
    IL2CPP_TOKEN_METHOD_SPEC = 0x2b000000,
} Il2CppTokenType;
typedef int32_t TypeIndex;
typedef int32_t TypeDefinitionIndex;
typedef int32_t FieldIndex;
typedef int32_t DefaultValueIndex;
typedef int32_t DefaultValueDataIndex;
typedef int32_t CustomAttributeIndex;
typedef int32_t ParameterIndex;
typedef int32_t MethodIndex;
typedef int32_t GenericMethodIndex;
typedef int32_t PropertyIndex;
typedef int32_t EventIndex;
typedef int32_t GenericContainerIndex;
typedef int32_t GenericParameterIndex;
typedef int16_t GenericParameterConstraintIndex;
typedef int32_t NestedTypeIndex;
typedef int32_t InterfacesIndex;
typedef int32_t VTableIndex;
typedef int32_t InterfaceOffsetIndex;
typedef int32_t RGCTXIndex;
typedef int32_t StringIndex;
typedef int32_t StringLiteralIndex;
typedef int32_t GenericInstIndex;
typedef int32_t ImageIndex;
typedef int32_t AssemblyIndex;
typedef int32_t InteropDataIndex;
static const TypeIndex kTypeIndexInvalid = -1;
static const TypeDefinitionIndex kTypeDefinitionIndexInvalid = -1;
static const DefaultValueDataIndex kDefaultValueIndexNull = -1;
static const CustomAttributeIndex kCustomAttributeIndexInvalid = -1;
static const EventIndex kEventIndexInvalid = -1;
static const FieldIndex kFieldIndexInvalid = -1;
static const MethodIndex kMethodIndexInvalid = -1;
static const PropertyIndex kPropertyIndexInvalid = -1;
static const GenericContainerIndex kGenericContainerIndexInvalid = -1;
static const GenericParameterIndex kGenericParameterIndexInvalid = -1;
static const RGCTXIndex kRGCTXIndexInvalid = -1;
static const StringLiteralIndex kStringLiteralIndexInvalid = -1;
static const InteropDataIndex kInteropDataIndexInvalid = -1;
typedef uint32_t EncodedMethodIndex;
typedef enum Il2CppMetadataUsage
{
    kIl2CppMetadataUsageInvalid,
    kIl2CppMetadataUsageTypeInfo,
    kIl2CppMetadataUsageIl2CppType,
    kIl2CppMetadataUsageMethodDef,
    kIl2CppMetadataUsageFieldInfo,
    kIl2CppMetadataUsageStringLiteral,
    kIl2CppMetadataUsageMethodRef,
} Il2CppMetadataUsage;
typedef struct Il2CppImage Il2CppImage;
typedef struct Il2CppType Il2CppType;
typedef struct Il2CppTypeDefinitionMetadata Il2CppTypeDefinitionMetadata;
typedef union Il2CppRGCTXDefinitionData
{
    int32_t rgctxDataDummy;
    MethodIndex methodIndex;
    TypeIndex typeIndex;
} Il2CppRGCTXDefinitionData;
typedef enum Il2CppRGCTXDataType
{
    IL2CPP_RGCTX_DATA_INVALID,
    IL2CPP_RGCTX_DATA_TYPE,
    IL2CPP_RGCTX_DATA_CLASS,
    IL2CPP_RGCTX_DATA_METHOD,
    IL2CPP_RGCTX_DATA_ARRAY,
} Il2CppRGCTXDataType;
typedef struct Il2CppRGCTXDefinition
{
    Il2CppRGCTXDataType type;
    Il2CppRGCTXDefinitionData data;
} Il2CppRGCTXDefinition;
typedef struct Il2CppInterfaceOffsetPair
{
    TypeIndex interfaceTypeIndex;
    int32_t offset;
} Il2CppInterfaceOffsetPair;
typedef struct Il2CppTypeDefinition
{
    StringIndex nameIndex;
    StringIndex namespaceIndex;
    TypeIndex byvalTypeIndex;
    TypeIndex byrefTypeIndex;
    TypeIndex declaringTypeIndex;
    TypeIndex parentIndex;
    TypeIndex elementTypeIndex;
    GenericContainerIndex genericContainerIndex;
    uint32_t flags;
    FieldIndex fieldStart;
    MethodIndex methodStart;
    EventIndex eventStart;
    PropertyIndex propertyStart;
    NestedTypeIndex nestedTypesStart;
    InterfacesIndex interfacesStart;
    VTableIndex vtableStart;
    InterfacesIndex interfaceOffsetsStart;
    uint16_t method_count;
    uint16_t property_count;
    uint16_t field_count;
    uint16_t event_count;
    uint16_t nested_type_count;
    uint16_t vtable_count;
    uint16_t interfaces_count;
    uint16_t interface_offsets_count;
    uint32_t bitfield;
    uint32_t token;
} Il2CppTypeDefinition;
typedef struct Il2CppFieldDefinition
{
    StringIndex nameIndex;
    TypeIndex typeIndex;
    uint32_t token;
} Il2CppFieldDefinition;
typedef struct Il2CppFieldDefaultValue
{
    FieldIndex fieldIndex;
    TypeIndex typeIndex;
    DefaultValueDataIndex dataIndex;
} Il2CppFieldDefaultValue;
typedef struct Il2CppFieldMarshaledSize
{
    FieldIndex fieldIndex;
    TypeIndex typeIndex;
    int32_t size;
} Il2CppFieldMarshaledSize;
typedef struct Il2CppFieldRef
{
    TypeIndex typeIndex;
    FieldIndex fieldIndex;
} Il2CppFieldRef;
typedef struct Il2CppParameterDefinition
{
    StringIndex nameIndex;
    uint32_t token;
    TypeIndex typeIndex;
} Il2CppParameterDefinition;
typedef struct Il2CppParameterDefaultValue
{
    ParameterIndex parameterIndex;
    TypeIndex typeIndex;
    DefaultValueDataIndex dataIndex;
} Il2CppParameterDefaultValue;
typedef struct Il2CppMethodDefinition
{
    StringIndex nameIndex;
    TypeDefinitionIndex declaringType;
    TypeIndex returnType;
    ParameterIndex parameterStart;
    GenericContainerIndex genericContainerIndex;
    uint32_t token;
    uint16_t flags;
    uint16_t iflags;
    uint16_t slot;
    uint16_t parameterCount;
} Il2CppMethodDefinition;
typedef struct Il2CppEventDefinition
{
    StringIndex nameIndex;
    TypeIndex typeIndex;
    MethodIndex add;
    MethodIndex remove;
    MethodIndex raise;
    uint32_t token;
} Il2CppEventDefinition;
typedef struct Il2CppPropertyDefinition
{
    StringIndex nameIndex;
    MethodIndex get;
    MethodIndex set;
    uint32_t attrs;
    uint32_t token;
} Il2CppPropertyDefinition;
typedef struct Il2CppMethodSpec
{
    MethodIndex methodDefinitionIndex;
    GenericInstIndex classIndexIndex;
    GenericInstIndex methodIndexIndex;
} Il2CppMethodSpec;
typedef struct Il2CppStringLiteral
{
    uint32_t length;
    StringLiteralIndex dataIndex;
} Il2CppStringLiteral;
typedef struct
{
    MethodIndex methodIndex;
    MethodIndex invokerIndex;
} Il2CppGenericMethodIndices;
typedef struct Il2CppGenericMethodFunctionsDefinitions
{
    GenericMethodIndex genericMethodIndex;
    Il2CppGenericMethodIndices indices;
} Il2CppGenericMethodFunctionsDefinitions;
static const int kPublicKeyByteLength = 8;
typedef struct Il2CppAssemblyNameDefinition
{
    StringIndex nameIndex;
    StringIndex cultureIndex;
    StringIndex hashValueIndex;
    StringIndex publicKeyIndex;
    uint32_t hash_alg;
    int32_t hash_len;
    uint32_t flags;
    int32_t major;
    int32_t minor;
    int32_t build;
    int32_t revision;
    uint8_t public_key_token[8];
} Il2CppAssemblyNameDefinition;
typedef struct Il2CppImageDefinition
{
    StringIndex nameIndex;
    AssemblyIndex assemblyIndex;
    TypeDefinitionIndex typeStart;
    uint32_t typeCount;
    TypeDefinitionIndex exportedTypeStart;
    uint32_t exportedTypeCount;
    MethodIndex entryPointIndex;
    uint32_t token;
    CustomAttributeIndex customAttributeStart;
    uint32_t customAttributeCount;
} Il2CppImageDefinition;
typedef struct Il2CppAssemblyDefinition
{
    ImageIndex imageIndex;
    uint32_t token;
    int32_t referencedAssemblyStart;
    int32_t referencedAssemblyCount;
    Il2CppAssemblyNameDefinition aname;
} Il2CppAssemblyDefinition;
typedef struct Il2CppMetadataUsageList
{
    uint32_t start;
    uint32_t count;
} Il2CppMetadataUsageList;
typedef struct Il2CppMetadataUsagePair
{
    uint32_t destinationIndex;
    uint32_t encodedSourceIndex;
} Il2CppMetadataUsagePair;
typedef struct Il2CppCustomAttributeTypeRange
{
    uint32_t token;
    int32_t start;
    int32_t count;
} Il2CppCustomAttributeTypeRange;
typedef struct Il2CppRange
{
    int32_t start;
    int32_t length;
} Il2CppRange;
typedef struct Il2CppWindowsRuntimeTypeNamePair
{
    StringIndex nameIndex;
    TypeIndex typeIndex;
} Il2CppWindowsRuntimeTypeNamePair;
#pragma pack(push, p1,4)
typedef struct Il2CppGlobalMetadataHeader
{
    int32_t sanity;
    int32_t version;
    int32_t stringLiteralOffset;
    int32_t stringLiteralCount;
    int32_t stringLiteralDataOffset;
    int32_t stringLiteralDataCount;
    int32_t stringOffset;
    int32_t stringCount;
    int32_t eventsOffset;
    int32_t eventsCount;
    int32_t propertiesOffset;
    int32_t propertiesCount;
    int32_t methodsOffset;
    int32_t methodsCount;
    int32_t parameterDefaultValuesOffset;
    int32_t parameterDefaultValuesCount;
    int32_t fieldDefaultValuesOffset;
    int32_t fieldDefaultValuesCount;
    int32_t fieldAndParameterDefaultValueDataOffset;
    int32_t fieldAndParameterDefaultValueDataCount;
    int32_t fieldMarshaledSizesOffset;
    int32_t fieldMarshaledSizesCount;
    int32_t parametersOffset;
    int32_t parametersCount;
    int32_t fieldsOffset;
    int32_t fieldsCount;
    int32_t genericParametersOffset;
    int32_t genericParametersCount;
    int32_t genericParameterConstraintsOffset;
    int32_t genericParameterConstraintsCount;
    int32_t genericContainersOffset;
    int32_t genericContainersCount;
    int32_t nestedTypesOffset;
    int32_t nestedTypesCount;
    int32_t interfacesOffset;
    int32_t interfacesCount;
    int32_t vtableMethodsOffset;
    int32_t vtableMethodsCount;
    int32_t interfaceOffsetsOffset;
    int32_t interfaceOffsetsCount;
    int32_t typeDefinitionsOffset;
    int32_t typeDefinitionsCount;
    int32_t imagesOffset;
    int32_t imagesCount;
    int32_t assembliesOffset;
    int32_t assembliesCount;
    int32_t metadataUsageListsOffset;
    int32_t metadataUsageListsCount;
    int32_t metadataUsagePairsOffset;
    int32_t metadataUsagePairsCount;
    int32_t fieldRefsOffset;
    int32_t fieldRefsCount;
    int32_t referencedAssembliesOffset;
    int32_t referencedAssembliesCount;
    int32_t attributesInfoOffset;
    int32_t attributesInfoCount;
    int32_t attributeTypesOffset;
    int32_t attributeTypesCount;
    int32_t unresolvedVirtualCallParameterTypesOffset;
    int32_t unresolvedVirtualCallParameterTypesCount;
    int32_t unresolvedVirtualCallParameterRangesOffset;
    int32_t unresolvedVirtualCallParameterRangesCount;
    int32_t windowsRuntimeTypeNamesOffset;
    int32_t windowsRuntimeTypeNamesSize;
    int32_t exportedTypeDefinitionsOffset;
    int32_t exportedTypeDefinitionsCount;
} Il2CppGlobalMetadataHeader;
#pragma pack(pop, p1)
typedef struct Il2CppClass Il2CppClass;
typedef struct MethodInfo MethodInfo;
typedef struct Il2CppType Il2CppType;
typedef struct Il2CppArrayType
{
    const Il2CppType* etype;
    uint8_t rank;
    uint8_t numsizes;
    uint8_t numlobounds;
    int *sizes;
    int *lobounds;
} Il2CppArrayType;
typedef struct Il2CppGenericInst
{
    uint32_t type_argc;
    const Il2CppType **type_argv;
} Il2CppGenericInst;
typedef struct Il2CppGenericContext
{
    const Il2CppGenericInst *class_inst;
    const Il2CppGenericInst *method_inst;
} Il2CppGenericContext;
typedef struct Il2CppGenericParameter
{
    GenericContainerIndex ownerIndex;
    StringIndex nameIndex;
    GenericParameterConstraintIndex constraintsStart;
    int16_t constraintsCount;
    uint16_t num;
    uint16_t flags;
} Il2CppGenericParameter;
typedef struct Il2CppGenericContainer
{
    int32_t ownerIndex;
    int32_t type_argc;
    int32_t is_method;
    GenericParameterIndex genericParameterStart;
} Il2CppGenericContainer;
typedef struct Il2CppGenericClass
{
    TypeDefinitionIndex typeDefinitionIndex;
    Il2CppGenericContext context;
    Il2CppClass *cached_class;
} Il2CppGenericClass;
typedef struct Il2CppGenericMethod
{
    const MethodInfo* methodDefinition;
    Il2CppGenericContext context;
} Il2CppGenericMethod;
typedef struct Il2CppType
{
    union
    {
        void* dummy;
        TypeDefinitionIndex klassIndex;
        const Il2CppType *type;
        Il2CppArrayType *array;
        GenericParameterIndex genericParameterIndex;
        Il2CppGenericClass *generic_class;
    } data;
    unsigned int attrs : 16;
    Il2CppTypeEnum type : 8;
    unsigned int num_mods : 6;
    unsigned int byref : 1;
    unsigned int pinned : 1;
} Il2CppType;
typedef enum Il2CppCallConvention
{
    IL2CPP_CALL_DEFAULT,
    IL2CPP_CALL_C,
    IL2CPP_CALL_STDCALL,
    IL2CPP_CALL_THISCALL,
    IL2CPP_CALL_FASTCALL,
    IL2CPP_CALL_VARARG
} Il2CppCallConvention;
typedef enum Il2CppCharSet
{
    CHARSET_ANSI,
    CHARSET_UNICODE,
    CHARSET_NOT_SPECIFIED
} Il2CppCharSet;
typedef struct Il2CppHString__
{
    int unused;
} Il2CppHString__;
typedef Il2CppHString__* Il2CppHString;
typedef struct Il2CppHStringHeader
{
    union
    {
        void* Reserved1;
        char Reserved2[24];
    } Reserved;
} Il2CppHStringHeader;
typedef struct Il2CppGuid
{
    uint32_t data1;
    uint16_t data2;
    uint16_t data3;
    uint8_t data4[8];
} Il2CppGuid;
typedef struct Il2CppSafeArrayBound
{
    uint32_t element_count;
    int32_t lower_bound;
} Il2CppSafeArrayBound;
typedef struct Il2CppSafeArray
{
    uint16_t dimension_count;
    uint16_t features;
    uint32_t element_size;
    uint32_t lock_count;
    void* data;
    Il2CppSafeArrayBound bounds[1];
} Il2CppSafeArray;
typedef struct Il2CppWin32Decimal
{
    uint16_t reserved;
    union
    {
        struct
        {
            uint8_t scale;
            uint8_t sign;
        } s;
        uint16_t signscale;
    } u;
    uint32_t hi32;
    union
    {
        struct
        {
            uint32_t lo32;
            uint32_t mid32;
        } s2;
        uint64_t lo64;
    } u2;
} Il2CppWin32Decimal;
typedef int16_t IL2CPP_VARIANT_BOOL;
typedef enum Il2CppVarType
{
    IL2CPP_VT_EMPTY = 0,
    IL2CPP_VT_NULL = 1,
    IL2CPP_VT_I2 = 2,
    IL2CPP_VT_I4 = 3,
    IL2CPP_VT_R4 = 4,
    IL2CPP_VT_R8 = 5,
    IL2CPP_VT_CY = 6,
    IL2CPP_VT_DATE = 7,
    IL2CPP_VT_BSTR = 8,
    IL2CPP_VT_DISPATCH = 9,
    IL2CPP_VT_ERROR = 10,
    IL2CPP_VT_BOOL = 11,
    IL2CPP_VT_VARIANT = 12,
    IL2CPP_VT_UNKNOWN = 13,
    IL2CPP_VT_DECIMAL = 14,
    IL2CPP_VT_I1 = 16,
    IL2CPP_VT_UI1 = 17,
    IL2CPP_VT_UI2 = 18,
    IL2CPP_VT_UI4 = 19,
    IL2CPP_VT_I8 = 20,
    IL2CPP_VT_UI8 = 21,
    IL2CPP_VT_INT = 22,
    IL2CPP_VT_UINT = 23,
    IL2CPP_VT_VOID = 24,
    IL2CPP_VT_HRESULT = 25,
    IL2CPP_VT_PTR = 26,
    IL2CPP_VT_SAFEARRAY = 27,
    IL2CPP_VT_CARRAY = 28,
    IL2CPP_VT_USERDEFINED = 29,
    IL2CPP_VT_LPSTR = 30,
    IL2CPP_VT_LPWSTR = 31,
    IL2CPP_VT_RECORD = 36,
    IL2CPP_VT_INT_PTR = 37,
    IL2CPP_VT_UINT_PTR = 38,
    IL2CPP_VT_FILETIME = 64,
    IL2CPP_VT_BLOB = 65,
    IL2CPP_VT_STREAM = 66,
    IL2CPP_VT_STORAGE = 67,
    IL2CPP_VT_STREAMED_OBJECT = 68,
    IL2CPP_VT_STORED_OBJECT = 69,
    IL2CPP_VT_BLOB_OBJECT = 70,
    IL2CPP_VT_CF = 71,
    IL2CPP_VT_CLSID = 72,
    IL2CPP_VT_VERSIONED_STREAM = 73,
    IL2CPP_VT_BSTR_BLOB = 0xfff,
    IL2CPP_VT_VECTOR = 0x1000,
    IL2CPP_VT_ARRAY = 0x2000,
    IL2CPP_VT_BYREF = 0x4000,
    IL2CPP_VT_RESERVED = 0x8000,
    IL2CPP_VT_ILLEGAL = 0xffff,
    IL2CPP_VT_ILLEGALMASKED = 0xfff,
    IL2CPP_VT_TYPEMASK = 0xfff,
} Il2CppVarType;
typedef struct Il2CppVariant Il2CppVariant;
typedef struct Il2CppIUnknown Il2CppIUnknown;
typedef struct Il2CppVariant
{
    union
    {
        struct __tagVARIANT
        {
            uint16_t type;
            uint16_t reserved1;
            uint16_t reserved2;
            uint16_t reserved3;
            union
            {
                int64_t llVal;
                int32_t lVal;
                uint8_t bVal;
                int16_t iVal;
                float fltVal;
                double dblVal;
                IL2CPP_VARIANT_BOOL boolVal;
                int32_t scode;
                int64_t cyVal;
                double date;
                Il2CppChar* bstrVal;
                Il2CppIUnknown* punkVal;
                void* pdispVal;
                Il2CppSafeArray* parray;
                uint8_t* pbVal;
                int16_t* piVal;
                int32_t* plVal;
                int64_t* pllVal;
                float* pfltVal;
                double* pdblVal;
                IL2CPP_VARIANT_BOOL* pboolVal;
                int32_t* pscode;
                int64_t* pcyVal;
                double* pdate;
                Il2CppChar* pbstrVal;
                Il2CppIUnknown** ppunkVal;
                void** ppdispVal;
                Il2CppSafeArray** pparray;
                struct Il2CppVariant* pvarVal;
                void* byref;
                char cVal;
                uint16_t uiVal;
                uint32_t ulVal;
                uint64_t ullVal;
                int intVal;
                unsigned int uintVal;
                Il2CppWin32Decimal* pdecVal;
                char* pcVal;
                uint16_t* puiVal;
                uint32_t* pulVal;
                uint64_t* pullVal;
                int* pintVal;
                unsigned int* puintVal;
                struct __tagBRECORD
                {
                    void* pvRecord;
                    void* pRecInfo;
                } n4;
            } n3;
        } n2;
        Il2CppWin32Decimal decVal;
    } n1;
} Il2CppVariant;
typedef struct Il2CppFileTime
{
    uint32_t low;
    uint32_t high;
} Il2CppFileTime;
typedef struct Il2CppStatStg
{
    Il2CppChar* name;
    uint32_t type;
    uint64_t size;
    Il2CppFileTime mtime;
    Il2CppFileTime ctime;
    Il2CppFileTime atime;
    uint32_t mode;
    uint32_t locks;
    Il2CppGuid clsid;
    uint32_t state;
    uint32_t reserved;
} Il2CppStatStg;
typedef enum Il2CppWindowsRuntimeTypeKind
{
    kTypeKindPrimitive = 0,
    kTypeKindMetadata,
    kTypeKindCustom
} Il2CppWindowsRuntimeTypeKind;
typedef struct Il2CppWindowsRuntimeTypeName
{
    Il2CppHString typeName;
    enum Il2CppWindowsRuntimeTypeKind typeKind;
} Il2CppWindowsRuntimeTypeName;
typedef void (*PInvokeMarshalToNativeFunc)(void* managedStructure, void* marshaledStructure);
typedef void (*PInvokeMarshalFromNativeFunc)(void* marshaledStructure, void* managedStructure);
typedef void (*PInvokeMarshalCleanupFunc)(void* marshaledStructure);
typedef struct Il2CppIUnknown* (*CreateCCWFunc)(Il2CppObject* obj);
typedef struct Il2CppInteropData
{
    Il2CppMethodPointer delegatePInvokeWrapperFunction;
    PInvokeMarshalToNativeFunc pinvokeMarshalToNativeFunction;
    PInvokeMarshalFromNativeFunc pinvokeMarshalFromNativeFunction;
    PInvokeMarshalCleanupFunc pinvokeMarshalCleanupFunction;
    CreateCCWFunc createCCWFunction;
    const Il2CppGuid* guid;
    const Il2CppType* type;
} Il2CppInteropData;
typedef struct Il2CppClass Il2CppClass;
typedef struct Il2CppGuid Il2CppGuid;
typedef struct Il2CppImage Il2CppImage;
typedef struct Il2CppAppDomain Il2CppAppDomain;
typedef struct Il2CppAppDomainSetup Il2CppAppDomainSetup;
typedef struct Il2CppDelegate Il2CppDelegate;
typedef struct Il2CppAppContext Il2CppAppContext;
typedef struct Il2CppNameToTypeDefinitionIndexHashTable Il2CppNameToTypeDefinitionIndexHashTable;
typedef struct Il2CppCodeGenModule Il2CppCodeGenModule;
typedef struct VirtualInvokeData
{
    Il2CppMethodPointer methodPtr;
    const MethodInfo* method;
} VirtualInvokeData;
typedef enum Il2CppTypeNameFormat
{
    IL2CPP_TYPE_NAME_FORMAT_IL,
    IL2CPP_TYPE_NAME_FORMAT_REFLECTION,
    IL2CPP_TYPE_NAME_FORMAT_FULL_NAME,
    IL2CPP_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED
} Il2CppTypeNameFormat;
typedef struct Il2CppDefaults
{
    Il2CppImage *corlib;
    Il2CppClass *object_class;
    Il2CppClass *byte_class;
    Il2CppClass *void_class;
    Il2CppClass *boolean_class;
    Il2CppClass *sbyte_class;
    Il2CppClass *int16_class;
    Il2CppClass *uint16_class;
    Il2CppClass *int32_class;
    Il2CppClass *uint32_class;
    Il2CppClass *int_class;
    Il2CppClass *uint_class;
    Il2CppClass *int64_class;
    Il2CppClass *uint64_class;
    Il2CppClass *single_class;
    Il2CppClass *double_class;
    Il2CppClass *char_class;
    Il2CppClass *string_class;
    Il2CppClass *enum_class;
    Il2CppClass *array_class;
    Il2CppClass *delegate_class;
    Il2CppClass *multicastdelegate_class;
    Il2CppClass *asyncresult_class;
    Il2CppClass *manualresetevent_class;
    Il2CppClass *typehandle_class;
    Il2CppClass *fieldhandle_class;
    Il2CppClass *methodhandle_class;
    Il2CppClass *systemtype_class;
    Il2CppClass *monotype_class;
    Il2CppClass *exception_class;
    Il2CppClass *threadabortexception_class;
    Il2CppClass *thread_class;
    Il2CppClass *internal_thread_class;
    Il2CppClass *appdomain_class;
    Il2CppClass *appdomain_setup_class;
    Il2CppClass *field_info_class;
    Il2CppClass *method_info_class;
    Il2CppClass *property_info_class;
    Il2CppClass *event_info_class;
    Il2CppClass *mono_event_info_class;
    Il2CppClass *stringbuilder_class;
    Il2CppClass *stack_frame_class;
    Il2CppClass *stack_trace_class;
    Il2CppClass *marshal_class;
    Il2CppClass *typed_reference_class;
    Il2CppClass *marshalbyrefobject_class;
    Il2CppClass *generic_ilist_class;
    Il2CppClass *generic_icollection_class;
    Il2CppClass *generic_ienumerable_class;
    Il2CppClass *generic_ireadonlylist_class;
    Il2CppClass *generic_ireadonlycollection_class;
    Il2CppClass *runtimetype_class;
    Il2CppClass *generic_nullable_class;
    Il2CppClass *il2cpp_com_object_class;
    Il2CppClass *attribute_class;
    Il2CppClass *customattribute_data_class;
    Il2CppClass *version;
    Il2CppClass *culture_info;
    Il2CppClass *async_call_class;
    Il2CppClass *assembly_class;
    Il2CppClass *mono_assembly_class;
    Il2CppClass *assembly_name_class;
    Il2CppClass *mono_field_class;
    Il2CppClass *mono_method_class;
    Il2CppClass *mono_method_info_class;
    Il2CppClass *mono_property_info_class;
    Il2CppClass *parameter_info_class;
    Il2CppClass *mono_parameter_info_class;
    Il2CppClass *module_class;
    Il2CppClass *pointer_class;
    Il2CppClass *system_exception_class;
    Il2CppClass *argument_exception_class;
    Il2CppClass *wait_handle_class;
    Il2CppClass *safe_handle_class;
    Il2CppClass *sort_key_class;
    Il2CppClass *dbnull_class;
    Il2CppClass *error_wrapper_class;
    Il2CppClass *missing_class;
    Il2CppClass *value_type_class;
    Il2CppClass *threadpool_wait_callback_class;
    MethodInfo *threadpool_perform_wait_callback_method;
    Il2CppClass *mono_method_message_class;
    Il2CppClass* ireference_class;
    Il2CppClass* ireferencearray_class;
    Il2CppClass* ikey_value_pair_class;
    Il2CppClass* key_value_pair_class;
    Il2CppClass* windows_foundation_uri_class;
    Il2CppClass* windows_foundation_iuri_runtime_class_class;
    Il2CppClass* system_uri_class;
    Il2CppClass* system_guid_class;
    Il2CppClass* sbyte_shared_enum;
    Il2CppClass* int16_shared_enum;
    Il2CppClass* int32_shared_enum;
    Il2CppClass* int64_shared_enum;
    Il2CppClass* byte_shared_enum;
    Il2CppClass* uint16_shared_enum;
    Il2CppClass* uint32_shared_enum;
    Il2CppClass* uint64_shared_enum;
} Il2CppDefaults;
extern Il2CppDefaults il2cpp_defaults;
typedef struct Il2CppClass Il2CppClass;
typedef struct MethodInfo MethodInfo;
typedef struct FieldInfo FieldInfo;
typedef struct Il2CppObject Il2CppObject;
typedef struct MemberInfo MemberInfo;
typedef struct CustomAttributesCache
{
    int count;
    Il2CppObject** attributes;
} CustomAttributesCache;
typedef void (*CustomAttributesCacheGenerator)(CustomAttributesCache*);
typedef struct FieldInfo
{
    const char* name;
    const Il2CppType* type;
    Il2CppClass *parent;
    int32_t offset;
    uint32_t token;
} FieldInfo;
typedef struct PropertyInfo
{
    Il2CppClass *parent;
    const char *name;
    const MethodInfo *get;
    const MethodInfo *set;
    uint32_t attrs;
    uint32_t token;
} PropertyInfo;
typedef struct EventInfo
{
    const char* name;
    const Il2CppType* eventType;
    Il2CppClass* parent;
    const MethodInfo* add;
    const MethodInfo* remove;
    const MethodInfo* raise;
    uint32_t token;
} EventInfo;
typedef struct ParameterInfo
{
    const char* name;
    int32_t position;
    uint32_t token;
    const Il2CppType* parameter_type;
} ParameterInfo;
typedef void* (*InvokerMethod)(Il2CppMethodPointer, const MethodInfo*, void*, void**);
typedef enum MethodVariableKind
{
    kMethodVariableKind_This,
    kMethodVariableKind_Parameter,
    kMethodVariableKind_LocalVariable
} MethodVariableKind;
typedef enum SequencePointKind
{
    kSequencePointKind_Normal,
    kSequencePointKind_StepOut
} SequencePointKind;
typedef struct Il2CppMethodExecutionContextInfo
{
    TypeIndex typeIndex;
    int32_t nameIndex;
    int32_t scopeIndex;
} Il2CppMethodExecutionContextInfo;
typedef struct Il2CppMethodExecutionContextInfoIndex
{
    int32_t startIndex;
    int32_t count;
} Il2CppMethodExecutionContextInfoIndex;
typedef struct Il2CppMethodScope
{
    int32_t startOffset;
    int32_t endOffset;
} Il2CppMethodScope;
typedef struct Il2CppMethodHeaderInfo
{
    int32_t code_size;
    int32_t startScope;
    int32_t numScopes;
} Il2CppMethodHeaderInfo;
typedef struct Il2CppSequencePointSourceFile
{
    const char *file;
    uint8_t hash[16];
} Il2CppSequencePointSourceFile;
typedef struct Il2CppTypeSourceFilePair
{
    TypeDefinitionIndex klassIndex;
    int32_t sourceFileIndex;
} Il2CppTypeSourceFilePair;
typedef struct Il2CppSequencePoint
{
    MethodIndex methodDefinitionIndex;
    int32_t sourceFileIndex;
    int32_t lineStart, lineEnd;
    int32_t columnStart, columnEnd;
    int32_t ilOffset;
    SequencePointKind kind;
    int32_t isActive;
    int32_t id;
} Il2CppSequencePoint;
typedef struct Il2CppCatchPoint
{
    MethodIndex methodDefinitionIndex;
    TypeIndex catchTypeIndex;
    int32_t ilOffset;
    int32_t tryId;
    int32_t parentTryId;
} Il2CppCatchPoint;
typedef struct Il2CppDebuggerMetadataRegistration
{
    Il2CppMethodExecutionContextInfo* methodExecutionContextInfos;
    Il2CppMethodExecutionContextInfoIndex* methodExecutionContextInfoIndexes;
    Il2CppMethodScope* methodScopes;
    Il2CppMethodHeaderInfo* methodHeaderInfos;
    Il2CppSequencePointSourceFile* sequencePointSourceFiles;
    int32_t numSequencePoints;
    Il2CppSequencePoint* sequencePoints;
    int32_t numCatchPoints;
    Il2CppCatchPoint* catchPoints;
    int32_t numTypeSourceFileEntries;
    Il2CppTypeSourceFilePair* typeSourceFiles;
    const char** methodExecutionContextInfoStrings;
} Il2CppDebuggerMetadataRegistration;
typedef union Il2CppRGCTXData
{
    void* rgctxDataDummy;
    const MethodInfo* method;
    const Il2CppType* type;
    Il2CppClass* klass;
} Il2CppRGCTXData;
typedef struct MethodInfo
{
    Il2CppMethodPointer methodPointer;
    InvokerMethod invoker_method;
    const char* name;
    Il2CppClass *klass;
    const Il2CppType *return_type;
    const ParameterInfo* parameters;
    union
    {
        const Il2CppRGCTXData* rgctx_data;
        const Il2CppMethodDefinition* methodDefinition;
    };
    union
    {
        const Il2CppGenericMethod* genericMethod;
        const Il2CppGenericContainer* genericContainer;
    };
    uint32_t token;
    uint16_t flags;
    uint16_t iflags;
    uint16_t slot;
    uint8_t parameters_count;
    uint8_t is_generic : 1;
    uint8_t is_inflated : 1;
    uint8_t wrapper_type : 1;
    uint8_t is_marshaled_from_native : 1;
} MethodInfo;
typedef struct Il2CppRuntimeInterfaceOffsetPair
{
    Il2CppClass* interfaceType;
    int32_t offset;
} Il2CppRuntimeInterfaceOffsetPair;
typedef struct Il2CppClass
{
    const Il2CppImage* image;
    void* gc_desc;
    const char* name;
    const char* namespaze;
    Il2CppType byval_arg;
    Il2CppType this_arg;
    Il2CppClass* element_class;
    Il2CppClass* castClass;
    Il2CppClass* declaringType;
    Il2CppClass* parent;
    Il2CppGenericClass *generic_class;
    const Il2CppTypeDefinition* typeDefinition;
    const Il2CppInteropData* interopData;
    Il2CppClass* klass;
    FieldInfo* fields;
    const EventInfo* events;
    const PropertyInfo* properties;
    const MethodInfo** methods;
    Il2CppClass** nestedTypes;
    Il2CppClass** implementedInterfaces;
    Il2CppRuntimeInterfaceOffsetPair* interfaceOffsets;
    void* static_fields;
    const Il2CppRGCTXData* rgctx_data;
    struct Il2CppClass** typeHierarchy;
    void *unity_user_data;
    uint32_t initializationExceptionGCHandle;
    uint32_t cctor_started;
    uint32_t cctor_finished;
    __declspec(align(8)) size_t cctor_thread;
    GenericContainerIndex genericContainerIndex;
    uint32_t instance_size;
    uint32_t actualSize;
    uint32_t element_size;
    int32_t native_size;
    uint32_t static_fields_size;
    uint32_t thread_static_fields_size;
    int32_t thread_static_fields_offset;
    uint32_t flags;
    uint32_t token;
    uint16_t method_count;
    uint16_t property_count;
    uint16_t field_count;
    uint16_t event_count;
    uint16_t nested_type_count;
    uint16_t vtable_count;
    uint16_t interfaces_count;
    uint16_t interface_offsets_count;
    uint8_t typeHierarchyDepth;
    uint8_t genericRecursionDepth;
    uint8_t rank;
    uint8_t minimumAlignment;
    uint8_t naturalAligment;
    uint8_t packingSize;
    uint8_t initialized_and_no_error : 1;
    uint8_t valuetype : 1;
    uint8_t initialized : 1;
    uint8_t enumtype : 1;
    uint8_t is_generic : 1;
    uint8_t has_references : 1;
    uint8_t init_pending : 1;
    uint8_t size_inited : 1;
    uint8_t has_finalize : 1;
    uint8_t has_cctor : 1;
    uint8_t is_blittable : 1;
    uint8_t is_import_or_windows_runtime : 1;
    uint8_t is_vtable_initialized : 1;
    uint8_t has_initialization_error : 1;
    VirtualInvokeData vtable[32];
} Il2CppClass;

typedef struct Il2CppClass_0 {
    const Il2CppImage* image;
    void* gc_desc;
    const char* name;
    const char* namespaze;
    Il2CppType byval_arg;
    Il2CppType this_arg;
    Il2CppClass* element_class;
    Il2CppClass* castClass;
    Il2CppClass* declaringType;
    Il2CppClass* parent;
    Il2CppGenericClass * generic_class;
    const Il2CppTypeDefinition* typeDefinition;
    const Il2CppInteropData* interopData;
    Il2CppClass* klass;
    FieldInfo* fields;
    const EventInfo* events;
    const PropertyInfo* properties;
    const MethodInfo** methods;
    Il2CppClass** nestedTypes;
    Il2CppClass** implementedInterfaces;
} Il2CppClass_0;

typedef struct Il2CppClass_1 {
    struct Il2CppClass** typeHierarchy;
    void * unity_user_data;
    uint32_t initializationExceptionGCHandle;
    uint32_t cctor_started;
    uint32_t cctor_finished;
#ifdef IS_32BIT
    uint32_t cctor_thread;
#else
    __declspec(align(8)) size_t cctor_thread;
#endif
    GenericContainerIndex genericContainerIndex;
    uint32_t instance_size;
    uint32_t actualSize;
    uint32_t element_size;
    int32_t native_size;
    uint32_t static_fields_size;
    uint32_t thread_static_fields_size;
    int32_t thread_static_fields_offset;
    uint32_t flags;
    uint32_t token;
    uint16_t method_count;
    uint16_t property_count;
    uint16_t field_count;
    uint16_t event_count;
    uint16_t nested_type_count;
    uint16_t vtable_count;
    uint16_t interfaces_count;
    uint16_t interface_offsets_count;
    uint8_t typeHierarchyDepth;
    uint8_t genericRecursionDepth;
    uint8_t rank;
    uint8_t minimumAlignment;
    uint8_t naturalAligment;
    uint8_t packingSize;
    uint8_t initialized_and_no_error : 1;
    uint8_t valuetype : 1;
    uint8_t initialized : 1;
    uint8_t enumtype : 1;
    uint8_t is_generic : 1;
    uint8_t has_references : 1;
    uint8_t init_pending : 1;
    uint8_t size_inited : 1;
    uint8_t has_finalize : 1;
    uint8_t has_cctor : 1;
    uint8_t is_blittable : 1;
    uint8_t is_import_or_windows_runtime : 1;
    uint8_t is_vtable_initialized : 1;
    uint8_t has_initialization_error : 1;
} Il2CppClass_1;

typedef struct __declspec(align(8)) Il2CppClass_Merged {
    struct Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair* interfaceOffsets;
    void* static_fields;
    const Il2CppRGCTXData* rgctx_data;
    struct Il2CppClass_1 _1;
    VirtualInvokeData vtable[32];
} Il2CppClass_Merged;

typedef struct Il2CppTypeDefinitionSizes
{
    uint32_t instance_size;
    int32_t native_size;
    uint32_t static_fields_size;
    uint32_t thread_static_fields_size;
} Il2CppTypeDefinitionSizes;
typedef struct Il2CppDomain
{
    Il2CppAppDomain* domain;
    Il2CppAppDomainSetup* setup;
    Il2CppAppContext* default_context;
    const char* friendly_name;
    uint32_t domain_id;
    volatile int threadpool_jobs;
    void* agent_info;
} Il2CppDomain;
typedef struct Il2CppAssemblyName
{
    const char* name;
    const char* culture;
    const char* hash_value;
    const char* public_key;
    uint32_t hash_alg;
    int32_t hash_len;
    uint32_t flags;
    int32_t major;
    int32_t minor;
    int32_t build;
    int32_t revision;
    uint8_t public_key_token[8];
} Il2CppAssemblyName;
typedef struct Il2CppImage
{
    const char* name;
    const char *nameNoExt;
    Il2CppAssembly* assembly;
    TypeDefinitionIndex typeStart;
    uint32_t typeCount;
    TypeDefinitionIndex exportedTypeStart;
    uint32_t exportedTypeCount;
    CustomAttributeIndex customAttributeStart;
    uint32_t customAttributeCount;
    MethodIndex entryPointIndex;
    Il2CppNameToTypeDefinitionIndexHashTable * nameToClassHashTable;
    const Il2CppCodeGenModule* codeGenModule;
    uint32_t token;
    uint8_t dynamic;
} Il2CppImage;
typedef struct Il2CppAssembly
{
    Il2CppImage* image;
    uint32_t token;
    int32_t referencedAssemblyStart;
    int32_t referencedAssemblyCount;
    Il2CppAssemblyName aname;
} Il2CppAssembly;
typedef struct Il2CppCodeGenOptions
{
    uint8_t enablePrimitiveValueTypeGenericSharing;
} Il2CppCodeGenOptions;
typedef struct Il2CppTokenIndexPair
{
    uint32_t token;
    int32_t index;
} Il2CppTokenIndexPair;
typedef struct Il2CppTokenRangePair
{
    uint32_t token;
    Il2CppRange range;
} Il2CppTokenRangePair;
typedef struct Il2CppTokenIndexMethodTuple
{
    uint32_t token;
    int32_t index;
    void** method;
    uint32_t genericMethodIndex;
} Il2CppTokenIndexMethodTuple;
typedef struct Il2CppWindowsRuntimeFactoryTableEntry
{
    const Il2CppType* type;
    Il2CppMethodPointer createFactoryFunction;
} Il2CppWindowsRuntimeFactoryTableEntry;
typedef struct Il2CppCodeGenModule
{
    const char* moduleName;
    const uint32_t methodPointerCount;
    const Il2CppMethodPointer* methodPointers;
    const int32_t* invokerIndices;
    const uint32_t reversePInvokeWrapperCount;
    const Il2CppTokenIndexMethodTuple* reversePInvokeWrapperIndices;
    const uint32_t rgctxRangesCount;
    const Il2CppTokenRangePair* rgctxRanges;
    const uint32_t rgctxsCount;
    const Il2CppRGCTXDefinition* rgctxs;
    const Il2CppDebuggerMetadataRegistration *debuggerMetadata;
} Il2CppCodeGenModule;
typedef struct Il2CppCodeRegistration
{
    uint32_t reversePInvokeWrapperCount;
    const Il2CppMethodPointer* reversePInvokeWrappers;
    uint32_t genericMethodPointersCount;
    const Il2CppMethodPointer* genericMethodPointers;
    uint32_t invokerPointersCount;
    const InvokerMethod* invokerPointers;
    CustomAttributeIndex customAttributeCount;
    const CustomAttributesCacheGenerator* customAttributeGenerators;
    uint32_t unresolvedVirtualCallCount;
    const Il2CppMethodPointer* unresolvedVirtualCallPointers;
    uint32_t interopDataCount;
    Il2CppInteropData* interopData;
    uint32_t windowsRuntimeFactoryCount;
    Il2CppWindowsRuntimeFactoryTableEntry* windowsRuntimeFactoryTable;
    uint32_t codeGenModulesCount;
    const Il2CppCodeGenModule** codeGenModules;
} Il2CppCodeRegistration;
typedef struct Il2CppMetadataRegistration
{
    int32_t genericClassesCount;
    Il2CppGenericClass* const * genericClasses;
    int32_t genericInstsCount;
    const Il2CppGenericInst* const * genericInsts;
    int32_t genericMethodTableCount;
    const Il2CppGenericMethodFunctionsDefinitions* genericMethodTable;
    int32_t typesCount;
    const Il2CppType* const * types;
    int32_t methodSpecsCount;
    const Il2CppMethodSpec* methodSpecs;
    FieldIndex fieldOffsetsCount;
    const int32_t** fieldOffsets;
    TypeDefinitionIndex typeDefinitionsSizesCount;
    const Il2CppTypeDefinitionSizes** typeDefinitionsSizes;
    const size_t metadataUsagesCount;
    void** const* metadataUsages;
} Il2CppMetadataRegistration;
typedef struct Il2CppPerfCounters
{
    uint32_t jit_methods;
    uint32_t jit_bytes;
    uint32_t jit_time;
    uint32_t jit_failures;
    uint32_t exceptions_thrown;
    uint32_t exceptions_filters;
    uint32_t exceptions_finallys;
    uint32_t exceptions_depth;
    uint32_t aspnet_requests_queued;
    uint32_t aspnet_requests;
    uint32_t gc_collections0;
    uint32_t gc_collections1;
    uint32_t gc_collections2;
    uint32_t gc_promotions0;
    uint32_t gc_promotions1;
    uint32_t gc_promotion_finalizers;
    uint32_t gc_gen0size;
    uint32_t gc_gen1size;
    uint32_t gc_gen2size;
    uint32_t gc_lossize;
    uint32_t gc_fin_survivors;
    uint32_t gc_num_handles;
    uint32_t gc_allocated;
    uint32_t gc_induced;
    uint32_t gc_time;
    uint32_t gc_total_bytes;
    uint32_t gc_committed_bytes;
    uint32_t gc_reserved_bytes;
    uint32_t gc_num_pinned;
    uint32_t gc_sync_blocks;
    uint32_t remoting_calls;
    uint32_t remoting_channels;
    uint32_t remoting_proxies;
    uint32_t remoting_classes;
    uint32_t remoting_objects;
    uint32_t remoting_contexts;
    uint32_t loader_classes;
    uint32_t loader_total_classes;
    uint32_t loader_appdomains;
    uint32_t loader_total_appdomains;
    uint32_t loader_assemblies;
    uint32_t loader_total_assemblies;
    uint32_t loader_failures;
    uint32_t loader_bytes;
    uint32_t loader_appdomains_uloaded;
    uint32_t thread_contentions;
    uint32_t thread_queue_len;
    uint32_t thread_queue_max;
    uint32_t thread_num_logical;
    uint32_t thread_num_physical;
    uint32_t thread_cur_recognized;
    uint32_t thread_num_recognized;
    uint32_t interop_num_ccw;
    uint32_t interop_num_stubs;
    uint32_t interop_num_marshals;
    uint32_t security_num_checks;
    uint32_t security_num_link_checks;
    uint32_t security_time;
    uint32_t security_depth;
    uint32_t unused;
    uint64_t threadpool_workitems;
    uint64_t threadpool_ioworkitems;
    unsigned int threadpool_threads;
    unsigned int threadpool_iothreads;
} Il2CppPerfCounters;
typedef struct Il2CppClass Il2CppClass;
typedef struct MethodInfo MethodInfo;
typedef struct PropertyInfo PropertyInfo;
typedef struct FieldInfo FieldInfo;
typedef struct EventInfo EventInfo;
typedef struct Il2CppType Il2CppType;
typedef struct Il2CppAssembly Il2CppAssembly;
typedef struct Il2CppException Il2CppException;
typedef struct Il2CppImage Il2CppImage;
typedef struct Il2CppDomain Il2CppDomain;
typedef struct Il2CppString Il2CppString;
typedef struct Il2CppReflectionMethod Il2CppReflectionMethod;
typedef struct Il2CppAsyncCall Il2CppAsyncCall;
typedef struct Il2CppIUnknown Il2CppIUnknown;
typedef struct Il2CppWaitHandle Il2CppWaitHandle;
typedef struct MonitorData MonitorData;
typedef struct Il2CppReflectionAssembly Il2CppReflectionAssembly;
typedef Il2CppClass Il2CppVTable;
typedef struct Il2CppObject
{
    union
    {
        Il2CppClass *klass;
        Il2CppVTable *vtable;
    };
    MonitorData *monitor;
} Il2CppObject;
typedef int32_t il2cpp_array_lower_bound_t;
typedef struct Il2CppArrayBounds
{
    il2cpp_array_size_t length;
    il2cpp_array_lower_bound_t lower_bound;
} Il2CppArrayBounds;
typedef struct Il2CppArray
{
    Il2CppObject obj;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
} Il2CppArray;
typedef struct Il2CppArraySize
{
    Il2CppObject obj;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    __declspec(align(8)) void* vector[32];
} Il2CppArraySize;
typedef struct Il2CppString
{
    Il2CppObject object;
    int32_t length;
    Il2CppChar chars[32];
} Il2CppString;
typedef struct Il2CppReflectionType
{
    Il2CppObject object;
    const Il2CppType *type;
} Il2CppReflectionType;
typedef struct Il2CppReflectionRuntimeType
{
    Il2CppReflectionType type;
    Il2CppObject* type_info;
    Il2CppObject* genericCache;
    Il2CppObject* serializationCtor;
} Il2CppReflectionRuntimeType;
typedef struct Il2CppReflectionMonoType
{
    Il2CppReflectionRuntimeType type;
} Il2CppReflectionMonoType;
typedef struct Il2CppReflectionEvent
{
    Il2CppObject object;
    Il2CppObject *cached_add_event;
} Il2CppReflectionEvent;
typedef struct Il2CppReflectionMonoEvent
{
    Il2CppReflectionEvent event;
    Il2CppReflectionType* reflectedType;
    const EventInfo* eventInfo;
} Il2CppReflectionMonoEvent;
typedef struct Il2CppReflectionMonoEventInfo
{
    Il2CppReflectionType* declaringType;
    Il2CppReflectionType* reflectedType;
    Il2CppString* name;
    Il2CppReflectionMethod* addMethod;
    Il2CppReflectionMethod* removeMethod;
    Il2CppReflectionMethod* raiseMethod;
    uint32_t eventAttributes;
    Il2CppArray* otherMethods;
} Il2CppReflectionMonoEventInfo;
typedef struct Il2CppReflectionField
{
    Il2CppObject object;
    Il2CppClass *klass;
    FieldInfo *field;
    Il2CppString *name;
    Il2CppReflectionType *type;
    uint32_t attrs;
} Il2CppReflectionField;
typedef struct Il2CppReflectionProperty
{
    Il2CppObject object;
    Il2CppClass *klass;
    const PropertyInfo *property;
} Il2CppReflectionProperty;
typedef struct Il2CppReflectionMethod
{
    Il2CppObject object;
    const MethodInfo *method;
    Il2CppString *name;
    Il2CppReflectionType *reftype;
} Il2CppReflectionMethod;
typedef struct Il2CppReflectionGenericMethod
{
    Il2CppReflectionMethod base;
} Il2CppReflectionGenericMethod;
typedef struct Il2CppMethodInfo
{
    Il2CppReflectionType *parent;
    Il2CppReflectionType *ret;
    uint32_t attrs;
    uint32_t implattrs;
    uint32_t callconv;
} Il2CppMethodInfo;
typedef struct Il2CppPropertyInfo
{
    Il2CppReflectionType* parent;
    Il2CppReflectionType* declaringType;
    Il2CppString *name;
    Il2CppReflectionMethod *get;
    Il2CppReflectionMethod *set;
    uint32_t attrs;
} Il2CppPropertyInfo;
typedef struct Il2CppReflectionParameter
{
    Il2CppObject object;
    Il2CppReflectionType *ClassImpl;
    Il2CppObject *DefaultValueImpl;
    Il2CppObject *MemberImpl;
    Il2CppString *NameImpl;
    int32_t PositionImpl;
    uint32_t AttrsImpl;
    Il2CppObject *MarshalAsImpl;
} Il2CppReflectionParameter;
typedef struct Il2CppReflectionModule
{
    Il2CppObject obj;
    const Il2CppImage* image;
    Il2CppReflectionAssembly* assembly;
    Il2CppString* fqname;
    Il2CppString* name;
    Il2CppString* scopename;
    uint8_t is_resource;
    uint32_t token;
} Il2CppReflectionModule;
typedef struct Il2CppReflectionAssemblyName
{
    Il2CppObject obj;
    Il2CppString *name;
    Il2CppString *codebase;
    int32_t major, minor, build, revision;
    Il2CppObject *cultureInfo;
    uint32_t flags;
    uint32_t hashalg;
    Il2CppObject *keypair;
    Il2CppArray *publicKey;
    Il2CppArray *keyToken;
    uint32_t versioncompat;
    Il2CppObject *version;
    uint32_t processor_architecture;
    uint32_t contentType;
} Il2CppReflectionAssemblyName;
typedef struct Il2CppReflectionAssembly
{
    Il2CppObject object;
    const Il2CppAssembly *assembly;
    Il2CppObject *resolve_event_holder;
    Il2CppObject *evidence;
    Il2CppObject *minimum;
    Il2CppObject *optional;
    Il2CppObject *refuse;
    Il2CppObject *granted;
    Il2CppObject *denied;
    uint8_t from_byte_array;
    Il2CppString *name;
} Il2CppReflectionAssembly;
typedef struct Il2CppReflectionMarshal
{
    Il2CppObject object;
    int32_t count;
    int32_t type;
    int32_t eltype;
    Il2CppString* guid;
    Il2CppString* mcookie;
    Il2CppString* marshaltype;
    Il2CppObject* marshaltyperef;
    int32_t param_num;
    uint8_t has_size;
} Il2CppReflectionMarshal;
typedef struct Il2CppReflectionPointer
{
    Il2CppObject object;
    void* data;
    Il2CppReflectionType* type;
} Il2CppReflectionPointer;
typedef struct Il2CppInternalThread
{
    Il2CppObject obj;
    int lock_thread_id;
    void* handle;
    void* native_handle;
    Il2CppArray* cached_culture_info;
    Il2CppChar* name;
    int name_len;
    uint32_t state;
    Il2CppObject* abort_exc;
    int abort_state_handle;
    uint64_t tid;
    intptr_t debugger_thread;
    void** static_data;
    void* runtime_thread_info;
    Il2CppObject* current_appcontext;
    Il2CppObject* root_domain_thread;
    Il2CppArray* _serialized_principal;
    int _serialized_principal_version;
    void* appdomain_refs;
    int32_t interruption_requested;
    void* synch_cs;
    uint8_t threadpool_thread;
    uint8_t thread_interrupt_requested;
    int stack_size;
    uint8_t apartment_state;
    int critical_region_level;
    int managed_id;
    uint32_t small_id;
    void* manage_callback;
    void* interrupt_on_stop;
    intptr_t flags;
    void* thread_pinning_ref;
    void* abort_protected_block_count;
    int32_t priority;
    void* owned_mutexes;
    void * suspended;
    int32_t self_suspended;
    size_t thread_state;
    size_t unused2;
    void* last;
} Il2CppInternalThread;
typedef struct Il2CppIOSelectorJob
{
    Il2CppObject object;
    int32_t operation;
    Il2CppObject *callback;
    Il2CppObject *state;
} Il2CppIOSelectorJob;
typedef enum
{
    Il2Cpp_CallType_Sync = 0,
    Il2Cpp_CallType_BeginInvoke = 1,
    Il2Cpp_CallType_EndInvoke = 2,
    Il2Cpp_CallType_OneWay = 3
} Il2CppCallType;
typedef struct Il2CppMethodMessage
{
    Il2CppObject obj;
    Il2CppReflectionMethod *method;
    Il2CppArray *args;
    Il2CppArray *names;
    Il2CppArray *arg_types;
    Il2CppObject *ctx;
    Il2CppObject *rval;
    Il2CppObject *exc;
    Il2CppAsyncResult *async_result;
    uint32_t call_type;
} Il2CppMethodMessage;
typedef struct Il2CppAppDomainSetup
{
    Il2CppObject object;
    Il2CppString* application_base;
    Il2CppString* application_name;
    Il2CppString* cache_path;
    Il2CppString* configuration_file;
    Il2CppString* dynamic_base;
    Il2CppString* license_file;
    Il2CppString* private_bin_path;
    Il2CppString* private_bin_path_probe;
    Il2CppString* shadow_copy_directories;
    Il2CppString* shadow_copy_files;
    uint8_t publisher_policy;
    uint8_t path_changed;
    int loader_optimization;
    uint8_t disallow_binding_redirects;
    uint8_t disallow_code_downloads;
    Il2CppObject* activation_arguments;
    Il2CppObject* domain_initializer;
    Il2CppObject* application_trust;
    Il2CppArray* domain_initializer_args;
    uint8_t disallow_appbase_probe;
    Il2CppArray* configuration_bytes;
    Il2CppArray* serialized_non_primitives;
} Il2CppAppDomainSetup;
typedef struct Il2CppThread
{
    Il2CppObject obj;
    Il2CppInternalThread* internal_thread;
    Il2CppObject* start_obj;
    Il2CppException* pending_exception;
    Il2CppObject* principal;
    int32_t principal_version;
    Il2CppDelegate* delegate;
    Il2CppObject* executionContext;
    uint8_t executionContextBelongsToOuterScope;
} Il2CppThread;
typedef struct Il2CppException
{
    Il2CppObject object;
    Il2CppString* className;
    Il2CppString* message;
    Il2CppObject* _data;
    struct Il2CppException* inner_ex;
    Il2CppString* _helpURL;
    Il2CppArray* trace_ips;
    Il2CppString* stack_trace;
    Il2CppString* remote_stack_trace;
    int remote_stack_index;
    Il2CppObject* _dynamicMethods;
    il2cpp_hresult_t hresult;
    Il2CppString* source;
    Il2CppObject* safeSerializationManager;
    Il2CppArray* captured_traces;
    Il2CppArray* native_trace_ips;
} Il2CppException;
typedef struct Il2CppSystemException
{
    Il2CppException base;
} Il2CppSystemException;
typedef struct Il2CppArgumentException
{
    Il2CppException base;
    Il2CppString *argName;
} Il2CppArgumentException;
typedef struct Il2CppTypedRef
{
    const Il2CppType *type;
    void* value;
    Il2CppClass *klass;
} Il2CppTypedRef;
typedef struct Il2CppDelegate
{
    Il2CppObject object;
    Il2CppMethodPointer method_ptr;
    InvokerMethod invoke_impl;
    Il2CppObject *target;
    const MethodInfo *method;
    void* delegate_trampoline;
    intptr_t extraArg;
    uint8_t **method_code;
    Il2CppReflectionMethod *method_info;
    Il2CppReflectionMethod *original_method_info;
    Il2CppObject *data;
    uint8_t method_is_virtual;
} Il2CppDelegate;
typedef struct Il2CppMulticastDelegate
{
    Il2CppDelegate delegate;
    Il2CppArray *delegates;
} Il2CppMulticastDelegate;
typedef struct Il2CppMarshalByRefObject
{
    Il2CppObject obj;
    Il2CppObject *identity;
} Il2CppMarshalByRefObject;
typedef struct Il2CppAppDomain
{
    Il2CppMarshalByRefObject mbr;
    Il2CppDomain *data;
} Il2CppAppDomain;
typedef struct Il2CppStackFrame
{
    Il2CppObject obj;
    int32_t il_offset;
    int32_t native_offset;
    uint64_t methodAddress;
    uint32_t methodIndex;
    Il2CppReflectionMethod *method;
    Il2CppString *filename;
    int32_t line;
    int32_t column;
    Il2CppString *internal_method_name;
} Il2CppStackFrame;
typedef struct Il2CppDateTimeFormatInfo
{
    Il2CppObject obj;
    Il2CppObject* CultureData;
    Il2CppString* Name;
    Il2CppString* LangName;
    Il2CppObject* CompareInfo;
    Il2CppObject* CultureInfo;
    Il2CppString* AMDesignator;
    Il2CppString* PMDesignator;
    Il2CppString* DateSeparator;
    Il2CppString* GeneralShortTimePattern;
    Il2CppString* GeneralLongTimePattern;
    Il2CppString* TimeSeparator;
    Il2CppString* MonthDayPattern;
    Il2CppString* DateTimeOffsetPattern;
    Il2CppObject* Calendar;
    uint32_t FirstDayOfWeek;
    uint32_t CalendarWeekRule;
    Il2CppString* FullDateTimePattern;
    Il2CppArray* AbbreviatedDayNames;
    Il2CppArray* ShortDayNames;
    Il2CppArray* DayNames;
    Il2CppArray* AbbreviatedMonthNames;
    Il2CppArray* MonthNames;
    Il2CppArray* GenitiveMonthNames;
    Il2CppArray* GenitiveAbbreviatedMonthNames;
    Il2CppArray* LeapYearMonthNames;
    Il2CppString* LongDatePattern;
    Il2CppString* ShortDatePattern;
    Il2CppString* YearMonthPattern;
    Il2CppString* LongTimePattern;
    Il2CppString* ShortTimePattern;
    Il2CppArray* YearMonthPatterns;
    Il2CppArray* ShortDatePatterns;
    Il2CppArray* LongDatePatterns;
    Il2CppArray* ShortTimePatterns;
    Il2CppArray* LongTimePatterns;
    Il2CppArray* EraNames;
    Il2CppArray* AbbrevEraNames;
    Il2CppArray* AbbrevEnglishEraNames;
    Il2CppArray* OptionalCalendars;
    uint8_t readOnly;
    int32_t FormatFlags;
    int32_t CultureID;
    uint8_t UseUserOverride;
    uint8_t UseCalendarInfo;
    int32_t DataItem;
    uint8_t IsDefaultCalendar;
    Il2CppArray* DateWords;
    Il2CppString* FullTimeSpanPositivePattern;
    Il2CppString* FullTimeSpanNegativePattern;
    Il2CppArray* dtfiTokenHash;
} Il2CppDateTimeFormatInfo;
typedef struct Il2CppNumberFormatInfo
{
    Il2CppObject obj;
    Il2CppArray* numberGroupSizes;
    Il2CppArray* currencyGroupSizes;
    Il2CppArray* percentGroupSizes;
    Il2CppString* positiveSign;
    Il2CppString* negativeSign;
    Il2CppString* numberDecimalSeparator;
    Il2CppString* numberGroupSeparator;
    Il2CppString* currencyGroupSeparator;
    Il2CppString* currencyDecimalSeparator;
    Il2CppString* currencySymbol;
    Il2CppString* ansiCurrencySymbol;
    Il2CppString* naNSymbol;
    Il2CppString* positiveInfinitySymbol;
    Il2CppString* negativeInfinitySymbol;
    Il2CppString* percentDecimalSeparator;
    Il2CppString* percentGroupSeparator;
    Il2CppString* percentSymbol;
    Il2CppString* perMilleSymbol;
    Il2CppArray* nativeDigits;
    int dataItem;
    int numberDecimalDigits;
    int currencyDecimalDigits;
    int currencyPositivePattern;
    int currencyNegativePattern;
    int numberNegativePattern;
    int percentPositivePattern;
    int percentNegativePattern;
    int percentDecimalDigits;
    int digitSubstitution;
    uint8_t readOnly;
    uint8_t useUserOverride;
    uint8_t isInvariant;
    uint8_t validForParseAsNumber;
    uint8_t validForParseAsCurrency;
} Il2CppNumberFormatInfo;
typedef struct Il2CppCultureData
{
    Il2CppObject obj;
    Il2CppString *AMDesignator;
    Il2CppString *PMDesignator;
    Il2CppString *TimeSeparator;
    Il2CppArray *LongTimePatterns;
    Il2CppArray *ShortTimePatterns;
    uint32_t FirstDayOfWeek;
    uint32_t CalendarWeekRule;
} Il2CppCultureData;
typedef struct Il2CppCalendarData
{
    Il2CppObject obj;
    Il2CppString *NativeName;
    Il2CppArray *ShortDatePatterns;
    Il2CppArray *YearMonthPatterns;
    Il2CppArray *LongDatePatterns;
    Il2CppString *MonthDayPattern;
    Il2CppArray *EraNames;
    Il2CppArray *AbbreviatedEraNames;
    Il2CppArray *AbbreviatedEnglishEraNames;
    Il2CppArray *DayNames;
    Il2CppArray *AbbreviatedDayNames;
    Il2CppArray *SuperShortDayNames;
    Il2CppArray *MonthNames;
    Il2CppArray *AbbreviatedMonthNames;
    Il2CppArray *GenitiveMonthNames;
    Il2CppArray *GenitiveAbbreviatedMonthNames;
} Il2CppCalendarData;
typedef struct Il2CppCultureInfo
{
    Il2CppObject obj;
    uint8_t is_read_only;
    int32_t lcid;
    int32_t parent_lcid;
    int32_t datetime_index;
    int32_t number_index;
    int32_t default_calendar_type;
    uint8_t use_user_override;
    Il2CppNumberFormatInfo* number_format;
    Il2CppDateTimeFormatInfo* datetime_format;
    Il2CppObject* textinfo;
    Il2CppString* name;
    Il2CppString* englishname;
    Il2CppString* nativename;
    Il2CppString* iso3lang;
    Il2CppString* iso2lang;
    Il2CppString* win3lang;
    Il2CppString* territory;
    Il2CppArray* native_calendar_names;
    Il2CppString* compareinfo;
    const void* text_info_data;
    int dataItem;
    Il2CppObject* calendar;
    Il2CppObject* parent_culture;
    uint8_t constructed;
    Il2CppArray* cached_serialized_form;
    Il2CppObject* cultureData;
    uint8_t isInherited;
} Il2CppCultureInfo;
typedef struct Il2CppRegionInfo
{
    Il2CppObject obj;
    int32_t geo_id;
    Il2CppString* iso2name;
    Il2CppString* iso3name;
    Il2CppString* win3name;
    Il2CppString* english_name;
    Il2CppString* native_name;
    Il2CppString* currency_symbol;
    Il2CppString* iso_currency_symbol;
    Il2CppString* currency_english_name;
    Il2CppString* currency_native_name;
} Il2CppRegionInfo;
typedef struct Il2CppSafeHandle
{
    Il2CppObject base;
    void* handle;
    int state;
    uint8_t owns_handle;
    uint8_t fullyInitialized;
} Il2CppSafeHandle;
typedef struct Il2CppStringBuilder Il2CppStringBuilder;
typedef struct Il2CppStringBuilder
{
    Il2CppObject object;
    Il2CppArray* chunkChars;
    struct Il2CppStringBuilder* chunkPrevious;
    int chunkLength;
    int chunkOffset;
    int maxCapacity;
} Il2CppStringBuilder;
typedef struct Il2CppSocketAddress
{
    Il2CppObject base;
    int m_Size;
    Il2CppArray* data;
    uint8_t m_changed;
    int m_hash;
} Il2CppSocketAddress;
typedef struct Il2CppSortKey
{
    Il2CppObject base;
    Il2CppString *str;
    Il2CppArray *key;
    int32_t options;
    int32_t lcid;
} Il2CppSortKey;
typedef struct Il2CppErrorWrapper
{
    Il2CppObject base;
    int32_t errorCode;
} Il2CppErrorWrapper;
typedef struct Il2CppAsyncResult
{
    Il2CppObject base;
    Il2CppObject *async_state;
    Il2CppWaitHandle *handle;
    Il2CppDelegate *async_delegate;
    void* data;
    Il2CppAsyncCall *object_data;
    uint8_t sync_completed;
    uint8_t completed;
    uint8_t endinvoke_called;
    Il2CppObject *async_callback;
    Il2CppObject *execution_context;
    Il2CppObject *original_context;
} Il2CppAsyncResult;
typedef struct Il2CppAsyncCall
{
    Il2CppObject base;
    Il2CppMethodMessage *msg;
    MethodInfo *cb_method;
    Il2CppDelegate *cb_target;
    Il2CppObject *state;
    Il2CppObject *res;
    Il2CppArray *out_args;
} Il2CppAsyncCall;
typedef struct Il2CppExceptionWrapper Il2CppExceptionWrapper;
typedef struct Il2CppExceptionWrapper
{
    Il2CppException* ex;
} Il2CppExceptionWrapper;
typedef struct Il2CppIOAsyncResult
{
    Il2CppObject base;
    Il2CppDelegate* callback;
    Il2CppObject* state;
    Il2CppWaitHandle* wait_handle;
    uint8_t completed_synchronously;
    uint8_t completed;
} Il2CppIOAsyncResult;
typedef struct Il2CppSocketAsyncResult
{
    Il2CppIOAsyncResult base;
    Il2CppObject* socket;
    int32_t operation;
    Il2CppException* delayedException;
    Il2CppObject* endPoint;
    Il2CppArray* buffer;
    int32_t offset;
    int32_t size;
    int32_t socket_flags;
    Il2CppObject* acceptSocket;
    Il2CppArray* addresses;
    int32_t port;
    Il2CppObject* buffers;
    uint8_t reuseSocket;
    int32_t currentAddress;
    Il2CppObject* acceptedSocket;
    int32_t total;
    int32_t error;
    int32_t endCalled;
} Il2CppSocketAsyncResult;
typedef enum Il2CppResourceLocation
{
    IL2CPP_RESOURCE_LOCATION_EMBEDDED = 1,
    IL2CPP_RESOURCE_LOCATION_ANOTHER_ASSEMBLY = 2,
    IL2CPP_RESOURCE_LOCATION_IN_MANIFEST = 4
} Il2CppResourceLocation;
typedef struct Il2CppManifestResourceInfo
{
    Il2CppObject object;
    Il2CppReflectionAssembly* assembly;
    Il2CppString* filename;
    uint32_t location;
} Il2CppManifestResourceInfo;
typedef struct Il2CppAppContext
{
    Il2CppObject obj;
    int32_t domain_id;
    int32_t context_id;
    void* static_data;
} Il2CppAppContext;
typedef struct Il2CppDecimal
{
    uint16_t reserved;
    union
    {
        struct
        {
            uint8_t scale;
            uint8_t sign;
        } u;
        uint16_t signscale;
    } u;
    uint32_t Hi32;
    union
    {
        struct
        {
            uint32_t Lo32;
            uint32_t Mid32;
        } v;
        uint64_t Lo64;
    } v;
} Il2CppDecimal;
typedef struct Il2CppDouble
{
    uint32_t mantLo : 32;
    uint32_t mantHi : 20;
    uint32_t exp : 11;
    uint32_t sign : 1;
} Il2CppDouble;
typedef union Il2CppDouble_double
{
    Il2CppDouble s;
    double d;
} Il2CppDouble_double;
typedef enum Il2CppDecimalCompareResult
{
    IL2CPP_DECIMAL_CMP_LT = -1,
    IL2CPP_DECIMAL_CMP_EQ,
    IL2CPP_DECIMAL_CMP_GT
} Il2CppDecimalCompareResult;
typedef struct Il2CppSingle
{
    uint32_t mant : 23;
    uint32_t exp : 8;
    uint32_t sign : 1;
} Il2CppSingle;
typedef union Il2CppSingle_float
{
    Il2CppSingle s;
    float f;
} Il2CppSingle_float;

#pragma warning(disable : 4369)
#pragma warning(disable : 4309)
#pragma warning(disable : 4359)
#if !defined(_GHIDRA_) && !defined(_IDA_)
namespace app {
#endif

// ******************************************************************************
// * Application types from method calls
// ******************************************************************************

struct Object {
    struct Object__Class *klass;
    MonitorData *monitor;
};

struct Locale {
    struct Locale__Class *klass;
    MonitorData *monitor;
};

struct ValueType {
    struct ValueType__Class *klass;
    MonitorData *monitor;
};

struct Boolean {
    bool m_value;
};

struct Boolean__Boxed {
    struct Boolean__Class *klass;
    MonitorData *monitor;
    bool fields;
};

struct Void {
};

struct Void__Boxed {
    struct Void__Class *klass;
    MonitorData *monitor;
    struct Void fields;
};

struct Int32 {
    int32_t m_value;
};

struct Int32__Boxed {
    struct Int32__Class *klass;
    MonitorData *monitor;
    int32_t fields;
};

struct Char {
    uint16_t m_value;
};

struct Char__Boxed {
    struct Char__Class *klass;
    MonitorData *monitor;
    uint16_t fields;
};

struct __declspec(align(8)) String__Fields {
    int32_t m_stringLength;
    uint16_t m_firstChar;
};

struct String {
    struct String__Class *klass;
    MonitorData *monitor;
    struct String__Fields fields;
};

struct Byte {
    uint8_t m_value;
};

struct Byte__Boxed {
    struct Byte__Class *klass;
    MonitorData *monitor;
    uint8_t fields;
};

struct IFormatProvider {
    struct IFormatProvider__Class *klass;
    MonitorData *monitor;
};

struct Enum {
};

struct Enum__Boxed {
    struct Enum__Class *klass;
    MonitorData *monitor;
    struct Enum fields;
};

#if defined(_CPLUSPLUS_)
enum TypeCode__Enum : int32_t {
    TypeCode__Enum_Empty = 0x00000000,
    TypeCode__Enum_Object = 0x00000001,
    TypeCode__Enum_DBNull = 0x00000002,
    TypeCode__Enum_Boolean = 0x00000003,
    TypeCode__Enum_Char = 0x00000004,
    TypeCode__Enum_SByte = 0x00000005,
    TypeCode__Enum_Byte = 0x00000006,
    TypeCode__Enum_Int16 = 0x00000007,
    TypeCode__Enum_UInt16 = 0x00000008,
    TypeCode__Enum_Int32 = 0x00000009,
    TypeCode__Enum_UInt32 = 0x0000000a,
    TypeCode__Enum_Int64 = 0x0000000b,
    TypeCode__Enum_UInt64 = 0x0000000c,
    TypeCode__Enum_Single = 0x0000000d,
    TypeCode__Enum_Double = 0x0000000e,
    TypeCode__Enum_Decimal = 0x0000000f,
    TypeCode__Enum_DateTime = 0x00000010,
    TypeCode__Enum_String = 0x00000012,
};

#else
enum TypeCode__Enum {
    TypeCode__Enum_Empty = 0x00000000,
    TypeCode__Enum_Object = 0x00000001,
    TypeCode__Enum_DBNull = 0x00000002,
    TypeCode__Enum_Boolean = 0x00000003,
    TypeCode__Enum_Char = 0x00000004,
    TypeCode__Enum_SByte = 0x00000005,
    TypeCode__Enum_Byte = 0x00000006,
    TypeCode__Enum_Int16 = 0x00000007,
    TypeCode__Enum_UInt16 = 0x00000008,
    TypeCode__Enum_Int32 = 0x00000009,
    TypeCode__Enum_UInt32 = 0x0000000a,
    TypeCode__Enum_Int64 = 0x0000000b,
    TypeCode__Enum_UInt64 = 0x0000000c,
    TypeCode__Enum_Single = 0x0000000d,
    TypeCode__Enum_Double = 0x0000000e,
    TypeCode__Enum_Decimal = 0x0000000f,
    TypeCode__Enum_DateTime = 0x00000010,
    TypeCode__Enum_String = 0x00000012,
};

#endif
struct TypeCode__Enum__Boxed {
    struct TypeCode__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum TypeCode__Enum value;
    #else
    uint32_t value;
    #endif
};

struct Array {
    struct Array__Class *klass;
    MonitorData *monitor;
};

struct Char__Array {
    struct Char__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    uint16_t vector[32];
};

struct IEnumerator {
    struct IEnumerator__Class *klass;
    MonitorData *monitor;
};

struct IComparer {
    struct IComparer__Class *klass;
    MonitorData *monitor;
};

struct IEqualityComparer {
    struct IEqualityComparer__Class *klass;
    MonitorData *monitor;
};

struct SByte {
    int8_t m_value;
};

struct SByte__Boxed {
    struct SByte__Class *klass;
    MonitorData *monitor;
    int8_t fields;
};

struct Int16 {
    int16_t m_value;
};

struct Int16__Boxed {
    struct Int16__Class *klass;
    MonitorData *monitor;
    int16_t fields;
};

struct UInt16 {
    uint16_t m_value;
};

struct UInt16__Boxed {
    struct UInt16__Class *klass;
    MonitorData *monitor;
    uint16_t fields;
};

struct UInt32 {
    uint32_t m_value;
};

struct UInt32__Boxed {
    struct UInt32__Class *klass;
    MonitorData *monitor;
    uint32_t fields;
};

struct Int64 {
    int64_t m_value;
};

struct Int64__Boxed {
    struct Int64__Class *klass;
    MonitorData *monitor;
    int64_t fields;
};

struct UInt64 {
    uint64_t m_value;
};

struct UInt64__Boxed {
    struct UInt64__Class *klass;
    MonitorData *monitor;
    uint64_t fields;
};

struct Single {
    float m_value;
};

struct Single__Boxed {
    struct Single__Class *klass;
    MonitorData *monitor;
    float fields;
};

struct Double {
    double m_value;
};

struct Double__Boxed {
    struct Double__Class *klass;
    MonitorData *monitor;
    double fields;
};

struct Decimal {
    int32_t flags;
    int32_t hi;
    int32_t lo;
    int32_t mid;
};

struct Decimal__Boxed {
    struct Decimal__Class *klass;
    MonitorData *monitor;
    struct Decimal fields;
};

struct UInt32__Array {
    struct UInt32__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    uint32_t vector[32];
};

struct DateTime {
    uint64_t dateData;
};

struct DateTime__Boxed {
    struct DateTime__Class *klass;
    MonitorData *monitor;
    struct DateTime fields;
};

struct Int32__Array {
    struct Int32__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    int32_t vector[32];
};

struct MemberInfo_1 {
    struct MemberInfo_1__Class *klass;
    MonitorData *monitor;
};

struct IntPtr {
    struct Void *m_value;
};

struct IntPtr__Boxed {
    struct IntPtr__Class *klass;
    MonitorData *monitor;
    void *fields;
};

struct RuntimeTypeHandle {
    void *value;
};

struct RuntimeTypeHandle__Boxed {
    struct RuntimeTypeHandle__Class *klass;
    MonitorData *monitor;
    struct RuntimeTypeHandle fields;
};

struct __declspec(align(8)) Type__Fields {
    struct RuntimeTypeHandle _impl;
};

struct Type {
    struct Type__Class *klass;
    MonitorData *monitor;
    struct Type__Fields fields;
};

struct Object__Array {
    struct Object__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Object *vector[32];
};

#if defined(_CPLUSPLUS_)
enum MemberTypes__Enum : int32_t {
    MemberTypes__Enum_Constructor = 0x00000001,
    MemberTypes__Enum_Event = 0x00000002,
    MemberTypes__Enum_Field = 0x00000004,
    MemberTypes__Enum_Method = 0x00000008,
    MemberTypes__Enum_Property = 0x00000010,
    MemberTypes__Enum_TypeInfo = 0x00000020,
    MemberTypes__Enum_Custom = 0x00000040,
    MemberTypes__Enum_NestedType = 0x00000080,
    MemberTypes__Enum_All = 0x000000bf,
};

#else
enum MemberTypes__Enum {
    MemberTypes__Enum_Constructor = 0x00000001,
    MemberTypes__Enum_Event = 0x00000002,
    MemberTypes__Enum_Field = 0x00000004,
    MemberTypes__Enum_Method = 0x00000008,
    MemberTypes__Enum_Property = 0x00000010,
    MemberTypes__Enum_TypeInfo = 0x00000020,
    MemberTypes__Enum_Custom = 0x00000040,
    MemberTypes__Enum_NestedType = 0x00000080,
    MemberTypes__Enum_All = 0x000000bf,
};

#endif
struct MemberTypes__Enum__Boxed {
    struct MemberTypes__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum MemberTypes__Enum value;
    #else
    uint32_t value;
    #endif
};

struct Guid {
    int32_t _a;
    int16_t _b;
    int16_t _c;
    uint8_t _d;
    uint8_t _e;
    uint8_t _f;
    uint8_t _g;
    uint8_t _h;
    uint8_t _i;
    uint8_t _j;
    uint8_t _k;
};

struct Guid__Boxed {
    struct Guid__Class *klass;
    MonitorData *monitor;
    struct Guid fields;
};

struct RandomNumberGenerator {
    struct RandomNumberGenerator__Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) RNGCryptoServiceProvider__Fields {
    void *_handle;
};

struct RNGCryptoServiceProvider {
    struct RNGCryptoServiceProvider__Class *klass;
    MonitorData *monitor;
    struct RNGCryptoServiceProvider__Fields fields;
};

struct VoidPtr {
    struct VoidPtr__Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) SerializationInfo__Fields {
    struct String__Array *m_members;
    struct Object__Array *m_data;
    struct Type__Array *m_types;
    struct Dictionary_2_System_String_System_Int32_ *m_nameToIndex;
    int32_t m_currMember;
    struct IFormatterConverter *m_converter;
    struct String *m_fullTypeName;
    struct String *m_assemName;
    struct Type *objectType;
    bool isFullTypeNameSetExplicit;
    bool isAssemblyNameSetExplicit;
    bool requireSameTokenInPartialTrust;
};

struct SerializationInfo {
    struct SerializationInfo__Class *klass;
    MonitorData *monitor;
    struct SerializationInfo__Fields fields;
};

struct String__Array {
    struct String__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct String *vector[32];
};

struct Type__Array {
    struct Type__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Type *vector[32];
};

struct __declspec(align(8)) Dictionary_2_System_String_System_Int32___Fields {
    struct Int32__Array *buckets;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Int32___Array *entries;
    int32_t count;
    int32_t version;
    int32_t freeList;
    int32_t freeCount;
    struct IEqualityComparer_1_System_String_ *comparer;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Int32_ *keys;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Int32_ *values;
    struct Object *_syncRoot;
};

struct Dictionary_2_System_String_System_Int32_ {
    struct Dictionary_2_System_String_System_Int32___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_System_String_System_Int32___Fields fields;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Int32_ {
    int32_t hashCode;
    int32_t next;
    struct String *key;
    int32_t value;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Int32___Boxed {
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Int32___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Int32_ fields;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Int32___Array {
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Int32___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Int32_ vector[32];
};

struct IEqualityComparer_1_System_String_ {
    struct IEqualityComparer_1_System_String___Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Int32___Fields {
    struct Dictionary_2_System_String_System_Int32_ *dictionary;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Int32_ {
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Int32___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Int32___Fields fields;
};

struct IEnumerator_1_System_String_ {
    struct IEnumerator_1_System_String___Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Int32___Fields {
    struct Dictionary_2_System_String_System_Int32_ *dictionary;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Int32_ {
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Int32___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Int32___Fields fields;
};

struct IEnumerator_1_System_Int32_ {
    struct IEnumerator_1_System_Int32___Class *klass;
    MonitorData *monitor;
};

struct ICollection_1_System_String_ {
    struct ICollection_1_System_String___Class *klass;
    MonitorData *monitor;
};

struct ICollection_1_System_Int32_ {
    struct ICollection_1_System_Int32___Class *klass;
    MonitorData *monitor;
};

struct KeyValuePair_2_System_String_System_Int32_ {
    struct String *key;
    int32_t value;
};

struct KeyValuePair_2_System_String_System_Int32___Boxed {
    struct KeyValuePair_2_System_String_System_Int32___Class *klass;
    MonitorData *monitor;
    struct KeyValuePair_2_System_String_System_Int32_ fields;
};

struct KeyValuePair_2_System_String_System_Int32___Array {
    struct KeyValuePair_2_System_String_System_Int32___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct KeyValuePair_2_System_String_System_Int32_ vector[32];
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_Int32_ {
    struct IEnumerator_1_KeyValuePair_2_System_String_System_Int32___Class *klass;
    MonitorData *monitor;
};

struct ICollection {
    struct ICollection__Class *klass;
    MonitorData *monitor;
};

struct IDictionaryEnumerator {
    struct IDictionaryEnumerator__Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_String_ {
    struct IEnumerable_1_System_String___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_Int32_ {
    struct IEnumerable_1_System_Int32___Class *klass;
    MonitorData *monitor;
};

#if defined(_CPLUSPLUS_)
enum StreamingContextStates__Enum : int32_t {
    StreamingContextStates__Enum_CrossProcess = 0x00000001,
    StreamingContextStates__Enum_CrossMachine = 0x00000002,
    StreamingContextStates__Enum_File = 0x00000004,
    StreamingContextStates__Enum_Persistence = 0x00000008,
    StreamingContextStates__Enum_Remoting = 0x00000010,
    StreamingContextStates__Enum_Other = 0x00000020,
    StreamingContextStates__Enum_Clone = 0x00000040,
    StreamingContextStates__Enum_CrossAppDomain = 0x00000080,
    StreamingContextStates__Enum_All = 0x000000ff,
};

#else
enum StreamingContextStates__Enum {
    StreamingContextStates__Enum_CrossProcess = 0x00000001,
    StreamingContextStates__Enum_CrossMachine = 0x00000002,
    StreamingContextStates__Enum_File = 0x00000004,
    StreamingContextStates__Enum_Persistence = 0x00000008,
    StreamingContextStates__Enum_Remoting = 0x00000010,
    StreamingContextStates__Enum_Other = 0x00000020,
    StreamingContextStates__Enum_Clone = 0x00000040,
    StreamingContextStates__Enum_CrossAppDomain = 0x00000080,
    StreamingContextStates__Enum_All = 0x000000ff,
};

#endif
struct StreamingContextStates__Enum__Boxed {
    struct StreamingContextStates__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum StreamingContextStates__Enum value;
    #else
    uint32_t value;
    #endif
};

struct StreamingContext {
    struct Object *m_additionalContext;
    #if defined(_CPLUSPLUS_)
    enum StreamingContextStates__Enum m_state;
    #else
    uint32_t m_state;
    #endif
};

struct StreamingContext__Boxed {
    struct StreamingContext__Class *klass;
    MonitorData *monitor;
    struct StreamingContext fields;
};

struct IFormatterConverter {
    struct IFormatterConverter__Class *klass;
    MonitorData *monitor;
};

struct TypeInfo__Fields {
    struct Type__Fields _;
};

struct TypeInfo {
    struct TypeInfo__Class *klass;
    MonitorData *monitor;
    struct TypeInfo__Fields fields;
};

struct RuntimeType__Fields {
    struct TypeInfo__Fields _;
    struct MonoTypeInfo *type_info;
    struct Object *GenericCache;
    struct RuntimeConstructorInfo *m_serializationCtor;
};

struct RuntimeType {
    struct RuntimeType__Class *klass;
    MonitorData *monitor;
    struct RuntimeType__Fields fields;
};

struct IEnumerable_1_System_Reflection_CustomAttributeData_ {
    struct IEnumerable_1_System_Reflection_CustomAttributeData___Class *klass;
    MonitorData *monitor;
};

struct IList_1_System_Reflection_CustomAttributeData_ {
    struct IList_1_System_Reflection_CustomAttributeData___Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) Module__Fields {
    void *_impl;
    struct Assembly *assembly;
    struct String *fqname;
    struct String *name;
    struct String *scopename;
    bool is_resource;
    int32_t token;
};

struct Module {
    struct Module__Class *klass;
    MonitorData *monitor;
    struct Module__Fields fields;
};

struct __declspec(align(8)) Delegate__Fields {
    void *method_ptr;
    void *invoke_impl;
    struct Object *m_target;
    void *method;
    void *delegate_trampoline;
    void *extra_arg;
    void *method_code;
    struct MethodInfo_1 *method_info;
    struct MethodInfo_1 *original_method_info;
    struct DelegateData *data;
    bool method_is_virtual;
};

struct Delegate {
    struct Delegate__Class *klass;
    MonitorData *monitor;
    struct Delegate__Fields fields;
};

struct MulticastDelegate__Fields {
    struct Delegate__Fields _;
    struct Delegate__Array *delegates;
};

struct MulticastDelegate {
    struct MulticastDelegate__Class *klass;
    MonitorData *monitor;
    struct MulticastDelegate__Fields fields;
};

struct TypeFilter__Fields {
    struct MulticastDelegate__Fields _;
};

struct TypeFilter {
    struct TypeFilter__Class *klass;
    MonitorData *monitor;
    struct TypeFilter__Fields fields;
};

struct MethodBase {
    struct MethodBase__Class *klass;
    MonitorData *monitor;
};

struct MethodInfo_1 {
    struct MethodInfo_1__Class *klass;
    MonitorData *monitor;
};

struct RuntimeMethodInfo {
    struct RuntimeMethodInfo__Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) MonoMethod__Fields {
    void *mhandle;
    struct String *name;
    struct Type *reftype;
};

struct MonoMethod {
    struct MonoMethod__Class *klass;
    MonitorData *monitor;
    struct MonoMethod__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum MethodImplAttributes__Enum : int32_t {
    MethodImplAttributes__Enum_CodeTypeMask = 0x00000003,
    MethodImplAttributes__Enum_IL = 0x00000000,
    MethodImplAttributes__Enum_Native = 0x00000001,
    MethodImplAttributes__Enum_OPTIL = 0x00000002,
    MethodImplAttributes__Enum_Runtime = 0x00000003,
    MethodImplAttributes__Enum_ManagedMask = 0x00000004,
    MethodImplAttributes__Enum_Unmanaged = 0x00000004,
    MethodImplAttributes__Enum_Managed = 0x00000000,
    MethodImplAttributes__Enum_ForwardRef = 0x00000010,
    MethodImplAttributes__Enum_PreserveSig = 0x00000080,
    MethodImplAttributes__Enum_InternalCall = 0x00001000,
    MethodImplAttributes__Enum_Synchronized = 0x00000020,
    MethodImplAttributes__Enum_NoInlining = 0x00000008,
    MethodImplAttributes__Enum_AggressiveInlining = 0x00000100,
    MethodImplAttributes__Enum_NoOptimization = 0x00000040,
    MethodImplAttributes__Enum_MaxMethodImplVal = 0x0000ffff,
};

#else
enum MethodImplAttributes__Enum {
    MethodImplAttributes__Enum_CodeTypeMask = 0x00000003,
    MethodImplAttributes__Enum_IL = 0x00000000,
    MethodImplAttributes__Enum_Native = 0x00000001,
    MethodImplAttributes__Enum_OPTIL = 0x00000002,
    MethodImplAttributes__Enum_Runtime = 0x00000003,
    MethodImplAttributes__Enum_ManagedMask = 0x00000004,
    MethodImplAttributes__Enum_Unmanaged = 0x00000004,
    MethodImplAttributes__Enum_Managed = 0x00000000,
    MethodImplAttributes__Enum_ForwardRef = 0x00000010,
    MethodImplAttributes__Enum_PreserveSig = 0x00000080,
    MethodImplAttributes__Enum_InternalCall = 0x00001000,
    MethodImplAttributes__Enum_Synchronized = 0x00000020,
    MethodImplAttributes__Enum_NoInlining = 0x00000008,
    MethodImplAttributes__Enum_AggressiveInlining = 0x00000100,
    MethodImplAttributes__Enum_NoOptimization = 0x00000040,
    MethodImplAttributes__Enum_MaxMethodImplVal = 0x0000ffff,
};

#endif
struct MethodImplAttributes__Enum__Boxed {
    struct MethodImplAttributes__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum MethodImplAttributes__Enum value;
    #else
    uint32_t value;
    #endif
};

#if defined(_CPLUSPLUS_)
enum ParameterAttributes__Enum : int32_t {
    ParameterAttributes__Enum_None = 0x00000000,
    ParameterAttributes__Enum_In = 0x00000001,
    ParameterAttributes__Enum_Out = 0x00000002,
    ParameterAttributes__Enum_Lcid = 0x00000004,
    ParameterAttributes__Enum_Retval = 0x00000008,
    ParameterAttributes__Enum_Optional = 0x00000010,
    ParameterAttributes__Enum_ReservedMask = 0x0000f000,
    ParameterAttributes__Enum_HasDefault = 0x00001000,
    ParameterAttributes__Enum_HasFieldMarshal = 0x00002000,
    ParameterAttributes__Enum_Reserved3 = 0x00004000,
    ParameterAttributes__Enum_Reserved4 = 0x00008000,
};

#else
enum ParameterAttributes__Enum {
    ParameterAttributes__Enum_None = 0x00000000,
    ParameterAttributes__Enum_In = 0x00000001,
    ParameterAttributes__Enum_Out = 0x00000002,
    ParameterAttributes__Enum_Lcid = 0x00000004,
    ParameterAttributes__Enum_Retval = 0x00000008,
    ParameterAttributes__Enum_Optional = 0x00000010,
    ParameterAttributes__Enum_ReservedMask = 0x0000f000,
    ParameterAttributes__Enum_HasDefault = 0x00001000,
    ParameterAttributes__Enum_HasFieldMarshal = 0x00002000,
    ParameterAttributes__Enum_Reserved3 = 0x00004000,
    ParameterAttributes__Enum_Reserved4 = 0x00008000,
};

#endif
struct ParameterAttributes__Enum__Boxed {
    struct ParameterAttributes__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum ParameterAttributes__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) ParameterInfo_1__Fields {
    struct Type *ClassImpl;
    struct Object *DefaultValueImpl;
    struct MemberInfo_1 *MemberImpl;
    struct String *NameImpl;
    int32_t PositionImpl;
    #if defined(_CPLUSPLUS_)
    enum ParameterAttributes__Enum AttrsImpl;
    #else
    uint32_t AttrsImpl;
    #endif
    struct MarshalAsAttribute *marshalAs;
};

struct ParameterInfo_1 {
    struct ParameterInfo_1__Class *klass;
    MonitorData *monitor;
    struct ParameterInfo_1__Fields fields;
};

struct Attribute {
    struct Attribute__Class *klass;
    MonitorData *monitor;
};

#if defined(_CPLUSPLUS_)
enum UnmanagedType__Enum : int32_t {
    UnmanagedType__Enum_Bool = 0x00000002,
    UnmanagedType__Enum_I1 = 0x00000003,
    UnmanagedType__Enum_U1 = 0x00000004,
    UnmanagedType__Enum_I2 = 0x00000005,
    UnmanagedType__Enum_U2 = 0x00000006,
    UnmanagedType__Enum_I4 = 0x00000007,
    UnmanagedType__Enum_U4 = 0x00000008,
    UnmanagedType__Enum_I8 = 0x00000009,
    UnmanagedType__Enum_U8 = 0x0000000a,
    UnmanagedType__Enum_R4 = 0x0000000b,
    UnmanagedType__Enum_R8 = 0x0000000c,
    UnmanagedType__Enum_Currency = 0x0000000f,
    UnmanagedType__Enum_BStr = 0x00000013,
    UnmanagedType__Enum_LPStr = 0x00000014,
    UnmanagedType__Enum_LPWStr = 0x00000015,
    UnmanagedType__Enum_LPTStr = 0x00000016,
    UnmanagedType__Enum_ByValTStr = 0x00000017,
    UnmanagedType__Enum_IUnknown = 0x00000019,
    UnmanagedType__Enum_IDispatch = 0x0000001a,
    UnmanagedType__Enum_Struct = 0x0000001b,
    UnmanagedType__Enum_Interface = 0x0000001c,
    UnmanagedType__Enum_SafeArray = 0x0000001d,
    UnmanagedType__Enum_ByValArray = 0x0000001e,
    UnmanagedType__Enum_SysInt = 0x0000001f,
    UnmanagedType__Enum_SysUInt = 0x00000020,
    UnmanagedType__Enum_VBByRefStr = 0x00000022,
    UnmanagedType__Enum_AnsiBStr = 0x00000023,
    UnmanagedType__Enum_TBStr = 0x00000024,
    UnmanagedType__Enum_VariantBool = 0x00000025,
    UnmanagedType__Enum_FunctionPtr = 0x00000026,
    UnmanagedType__Enum_AsAny = 0x00000028,
    UnmanagedType__Enum_LPArray = 0x0000002a,
    UnmanagedType__Enum_LPStruct = 0x0000002b,
    UnmanagedType__Enum_CustomMarshaler = 0x0000002c,
    UnmanagedType__Enum_Error = 0x0000002d,
    UnmanagedType__Enum_IInspectable = 0x0000002e,
    UnmanagedType__Enum_HString = 0x0000002f,
    UnmanagedType__Enum_LPUTF8Str = 0x00000030,
};

#else
enum UnmanagedType__Enum {
    UnmanagedType__Enum_Bool = 0x00000002,
    UnmanagedType__Enum_I1 = 0x00000003,
    UnmanagedType__Enum_U1 = 0x00000004,
    UnmanagedType__Enum_I2 = 0x00000005,
    UnmanagedType__Enum_U2 = 0x00000006,
    UnmanagedType__Enum_I4 = 0x00000007,
    UnmanagedType__Enum_U4 = 0x00000008,
    UnmanagedType__Enum_I8 = 0x00000009,
    UnmanagedType__Enum_U8 = 0x0000000a,
    UnmanagedType__Enum_R4 = 0x0000000b,
    UnmanagedType__Enum_R8 = 0x0000000c,
    UnmanagedType__Enum_Currency = 0x0000000f,
    UnmanagedType__Enum_BStr = 0x00000013,
    UnmanagedType__Enum_LPStr = 0x00000014,
    UnmanagedType__Enum_LPWStr = 0x00000015,
    UnmanagedType__Enum_LPTStr = 0x00000016,
    UnmanagedType__Enum_ByValTStr = 0x00000017,
    UnmanagedType__Enum_IUnknown = 0x00000019,
    UnmanagedType__Enum_IDispatch = 0x0000001a,
    UnmanagedType__Enum_Struct = 0x0000001b,
    UnmanagedType__Enum_Interface = 0x0000001c,
    UnmanagedType__Enum_SafeArray = 0x0000001d,
    UnmanagedType__Enum_ByValArray = 0x0000001e,
    UnmanagedType__Enum_SysInt = 0x0000001f,
    UnmanagedType__Enum_SysUInt = 0x00000020,
    UnmanagedType__Enum_VBByRefStr = 0x00000022,
    UnmanagedType__Enum_AnsiBStr = 0x00000023,
    UnmanagedType__Enum_TBStr = 0x00000024,
    UnmanagedType__Enum_VariantBool = 0x00000025,
    UnmanagedType__Enum_FunctionPtr = 0x00000026,
    UnmanagedType__Enum_AsAny = 0x00000028,
    UnmanagedType__Enum_LPArray = 0x0000002a,
    UnmanagedType__Enum_LPStruct = 0x0000002b,
    UnmanagedType__Enum_CustomMarshaler = 0x0000002c,
    UnmanagedType__Enum_Error = 0x0000002d,
    UnmanagedType__Enum_IInspectable = 0x0000002e,
    UnmanagedType__Enum_HString = 0x0000002f,
    UnmanagedType__Enum_LPUTF8Str = 0x00000030,
};

#endif
struct UnmanagedType__Enum__Boxed {
    struct UnmanagedType__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum UnmanagedType__Enum value;
    #else
    uint32_t value;
    #endif
};

#if defined(_CPLUSPLUS_)
enum VarEnum__Enum : int32_t {
    VarEnum__Enum_VT_EMPTY = 0x00000000,
    VarEnum__Enum_VT_NULL = 0x00000001,
    VarEnum__Enum_VT_I2 = 0x00000002,
    VarEnum__Enum_VT_I4 = 0x00000003,
    VarEnum__Enum_VT_R4 = 0x00000004,
    VarEnum__Enum_VT_R8 = 0x00000005,
    VarEnum__Enum_VT_CY = 0x00000006,
    VarEnum__Enum_VT_DATE = 0x00000007,
    VarEnum__Enum_VT_BSTR = 0x00000008,
    VarEnum__Enum_VT_DISPATCH = 0x00000009,
    VarEnum__Enum_VT_ERROR = 0x0000000a,
    VarEnum__Enum_VT_BOOL = 0x0000000b,
    VarEnum__Enum_VT_VARIANT = 0x0000000c,
    VarEnum__Enum_VT_UNKNOWN = 0x0000000d,
    VarEnum__Enum_VT_DECIMAL = 0x0000000e,
    VarEnum__Enum_VT_I1 = 0x00000010,
    VarEnum__Enum_VT_UI1 = 0x00000011,
    VarEnum__Enum_VT_UI2 = 0x00000012,
    VarEnum__Enum_VT_UI4 = 0x00000013,
    VarEnum__Enum_VT_I8 = 0x00000014,
    VarEnum__Enum_VT_UI8 = 0x00000015,
    VarEnum__Enum_VT_INT = 0x00000016,
    VarEnum__Enum_VT_UINT = 0x00000017,
    VarEnum__Enum_VT_VOID = 0x00000018,
    VarEnum__Enum_VT_HRESULT = 0x00000019,
    VarEnum__Enum_VT_PTR = 0x0000001a,
    VarEnum__Enum_VT_SAFEARRAY = 0x0000001b,
    VarEnum__Enum_VT_CARRAY = 0x0000001c,
    VarEnum__Enum_VT_USERDEFINED = 0x0000001d,
    VarEnum__Enum_VT_LPSTR = 0x0000001e,
    VarEnum__Enum_VT_LPWSTR = 0x0000001f,
    VarEnum__Enum_VT_RECORD = 0x00000024,
    VarEnum__Enum_VT_FILETIME = 0x00000040,
    VarEnum__Enum_VT_BLOB = 0x00000041,
    VarEnum__Enum_VT_STREAM = 0x00000042,
    VarEnum__Enum_VT_STORAGE = 0x00000043,
    VarEnum__Enum_VT_STREAMED_OBJECT = 0x00000044,
    VarEnum__Enum_VT_STORED_OBJECT = 0x00000045,
    VarEnum__Enum_VT_BLOB_OBJECT = 0x00000046,
    VarEnum__Enum_VT_CF = 0x00000047,
    VarEnum__Enum_VT_CLSID = 0x00000048,
    VarEnum__Enum_VT_VECTOR = 0x00001000,
    VarEnum__Enum_VT_ARRAY = 0x00002000,
    VarEnum__Enum_VT_BYREF = 0x00004000,
};

#else
enum VarEnum__Enum {
    VarEnum__Enum_VT_EMPTY = 0x00000000,
    VarEnum__Enum_VT_NULL = 0x00000001,
    VarEnum__Enum_VT_I2 = 0x00000002,
    VarEnum__Enum_VT_I4 = 0x00000003,
    VarEnum__Enum_VT_R4 = 0x00000004,
    VarEnum__Enum_VT_R8 = 0x00000005,
    VarEnum__Enum_VT_CY = 0x00000006,
    VarEnum__Enum_VT_DATE = 0x00000007,
    VarEnum__Enum_VT_BSTR = 0x00000008,
    VarEnum__Enum_VT_DISPATCH = 0x00000009,
    VarEnum__Enum_VT_ERROR = 0x0000000a,
    VarEnum__Enum_VT_BOOL = 0x0000000b,
    VarEnum__Enum_VT_VARIANT = 0x0000000c,
    VarEnum__Enum_VT_UNKNOWN = 0x0000000d,
    VarEnum__Enum_VT_DECIMAL = 0x0000000e,
    VarEnum__Enum_VT_I1 = 0x00000010,
    VarEnum__Enum_VT_UI1 = 0x00000011,
    VarEnum__Enum_VT_UI2 = 0x00000012,
    VarEnum__Enum_VT_UI4 = 0x00000013,
    VarEnum__Enum_VT_I8 = 0x00000014,
    VarEnum__Enum_VT_UI8 = 0x00000015,
    VarEnum__Enum_VT_INT = 0x00000016,
    VarEnum__Enum_VT_UINT = 0x00000017,
    VarEnum__Enum_VT_VOID = 0x00000018,
    VarEnum__Enum_VT_HRESULT = 0x00000019,
    VarEnum__Enum_VT_PTR = 0x0000001a,
    VarEnum__Enum_VT_SAFEARRAY = 0x0000001b,
    VarEnum__Enum_VT_CARRAY = 0x0000001c,
    VarEnum__Enum_VT_USERDEFINED = 0x0000001d,
    VarEnum__Enum_VT_LPSTR = 0x0000001e,
    VarEnum__Enum_VT_LPWSTR = 0x0000001f,
    VarEnum__Enum_VT_RECORD = 0x00000024,
    VarEnum__Enum_VT_FILETIME = 0x00000040,
    VarEnum__Enum_VT_BLOB = 0x00000041,
    VarEnum__Enum_VT_STREAM = 0x00000042,
    VarEnum__Enum_VT_STORAGE = 0x00000043,
    VarEnum__Enum_VT_STREAMED_OBJECT = 0x00000044,
    VarEnum__Enum_VT_STORED_OBJECT = 0x00000045,
    VarEnum__Enum_VT_BLOB_OBJECT = 0x00000046,
    VarEnum__Enum_VT_CF = 0x00000047,
    VarEnum__Enum_VT_CLSID = 0x00000048,
    VarEnum__Enum_VT_VECTOR = 0x00001000,
    VarEnum__Enum_VT_ARRAY = 0x00002000,
    VarEnum__Enum_VT_BYREF = 0x00004000,
};

#endif
struct VarEnum__Enum__Boxed {
    struct VarEnum__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum VarEnum__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) MarshalAsAttribute__Fields {
    struct String *MarshalCookie;
    struct String *MarshalType;
    struct Type *MarshalTypeRef;
    struct Type *SafeArrayUserDefinedSubType;
    #if defined(_CPLUSPLUS_)
    enum UnmanagedType__Enum utype;
    #else
    uint32_t utype;
    #endif
    #if defined(_CPLUSPLUS_)
    enum UnmanagedType__Enum ArraySubType;
    #else
    uint32_t ArraySubType;
    #endif
    #if defined(_CPLUSPLUS_)
    enum VarEnum__Enum SafeArraySubType;
    #else
    uint32_t SafeArraySubType;
    #endif
    int32_t SizeConst;
    int32_t IidParameterIndex;
    int16_t SizeParamIndex;
};

struct MarshalAsAttribute {
    struct MarshalAsAttribute__Class *klass;
    MonitorData *monitor;
    struct MarshalAsAttribute__Fields fields;
};

struct ParameterInfo_1__Array {
    struct ParameterInfo_1__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct ParameterInfo_1 *vector[32];
};

#if defined(_CPLUSPLUS_)
enum BindingFlags__Enum : int32_t {
    BindingFlags__Enum_Default = 0x00000000,
    BindingFlags__Enum_IgnoreCase = 0x00000001,
    BindingFlags__Enum_DeclaredOnly = 0x00000002,
    BindingFlags__Enum_Instance = 0x00000004,
    BindingFlags__Enum_Static = 0x00000008,
    BindingFlags__Enum_Public = 0x00000010,
    BindingFlags__Enum_NonPublic = 0x00000020,
    BindingFlags__Enum_FlattenHierarchy = 0x00000040,
    BindingFlags__Enum_InvokeMethod = 0x00000100,
    BindingFlags__Enum_CreateInstance = 0x00000200,
    BindingFlags__Enum_GetField = 0x00000400,
    BindingFlags__Enum_SetField = 0x00000800,
    BindingFlags__Enum_GetProperty = 0x00001000,
    BindingFlags__Enum_SetProperty = 0x00002000,
    BindingFlags__Enum_PutDispProperty = 0x00004000,
    BindingFlags__Enum_PutRefDispProperty = 0x00008000,
    BindingFlags__Enum_ExactBinding = 0x00010000,
    BindingFlags__Enum_SuppressChangeType = 0x00020000,
    BindingFlags__Enum_OptionalParamBinding = 0x00040000,
    BindingFlags__Enum_IgnoreReturn = 0x01000000,
};

#else
enum BindingFlags__Enum {
    BindingFlags__Enum_Default = 0x00000000,
    BindingFlags__Enum_IgnoreCase = 0x00000001,
    BindingFlags__Enum_DeclaredOnly = 0x00000002,
    BindingFlags__Enum_Instance = 0x00000004,
    BindingFlags__Enum_Static = 0x00000008,
    BindingFlags__Enum_Public = 0x00000010,
    BindingFlags__Enum_NonPublic = 0x00000020,
    BindingFlags__Enum_FlattenHierarchy = 0x00000040,
    BindingFlags__Enum_InvokeMethod = 0x00000100,
    BindingFlags__Enum_CreateInstance = 0x00000200,
    BindingFlags__Enum_GetField = 0x00000400,
    BindingFlags__Enum_SetField = 0x00000800,
    BindingFlags__Enum_GetProperty = 0x00001000,
    BindingFlags__Enum_SetProperty = 0x00002000,
    BindingFlags__Enum_PutDispProperty = 0x00004000,
    BindingFlags__Enum_PutRefDispProperty = 0x00008000,
    BindingFlags__Enum_ExactBinding = 0x00010000,
    BindingFlags__Enum_SuppressChangeType = 0x00020000,
    BindingFlags__Enum_OptionalParamBinding = 0x00040000,
    BindingFlags__Enum_IgnoreReturn = 0x01000000,
};

#endif
struct BindingFlags__Enum__Boxed {
    struct BindingFlags__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum BindingFlags__Enum value;
    #else
    uint32_t value;
    #endif
};

struct Binder {
    struct Binder__Class *klass;
    MonitorData *monitor;
};

struct DefaultBinder {
    struct DefaultBinder__Class *klass;
    MonitorData *monitor;
};

struct MethodBase__Array {
    struct MethodBase__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct MethodBase *vector[32];
};

struct ParameterModifier {
    struct Boolean__Array *_byRef;
};

struct ParameterModifier__Boxed {
    struct ParameterModifier__Class *klass;
    MonitorData *monitor;
    struct ParameterModifier fields;
};

struct Boolean__Array {
    struct Boolean__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    bool vector[32];
};

struct ParameterModifier__Array {
    struct ParameterModifier__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct ParameterModifier vector[32];
};

struct __declspec(align(8)) CultureInfo__Fields {
    bool m_isReadOnly;
    int32_t cultureID;
    int32_t parent_lcid;
    int32_t datetime_index;
    int32_t number_index;
    int32_t default_calendar_type;
    bool m_useUserOverride;
    struct NumberFormatInfo *numInfo;
    struct DateTimeFormatInfo *dateTimeInfo;
    struct TextInfo *textInfo;
    struct String *m_name;
    struct String *englishname;
    struct String *nativename;
    struct String *iso3lang;
    struct String *iso2lang;
    struct String *win3lang;
    struct String *territory;
    struct String__Array *native_calendar_names;
    struct CompareInfo *compareInfo;
    struct Void *textinfo_data;
    int32_t m_dataItem;
    struct Calendar *calendar;
    struct CultureInfo *parent_culture;
    bool constructed;
    struct Byte__Array *cached_serialized_form;
    struct CultureData *m_cultureData;
    bool m_isInherited;
};

struct CultureInfo {
    struct CultureInfo__Class *klass;
    MonitorData *monitor;
    struct CultureInfo__Fields fields;
};

struct __declspec(align(8)) NumberFormatInfo__Fields {
    struct Int32__Array *numberGroupSizes;
    struct Int32__Array *currencyGroupSizes;
    struct Int32__Array *percentGroupSizes;
    struct String *positiveSign;
    struct String *negativeSign;
    struct String *numberDecimalSeparator;
    struct String *numberGroupSeparator;
    struct String *currencyGroupSeparator;
    struct String *currencyDecimalSeparator;
    struct String *currencySymbol;
    struct String *ansiCurrencySymbol;
    struct String *nanSymbol;
    struct String *positiveInfinitySymbol;
    struct String *negativeInfinitySymbol;
    struct String *percentDecimalSeparator;
    struct String *percentGroupSeparator;
    struct String *percentSymbol;
    struct String *perMilleSymbol;
    struct String__Array *nativeDigits;
    int32_t m_dataItem;
    int32_t numberDecimalDigits;
    int32_t currencyDecimalDigits;
    int32_t currencyPositivePattern;
    int32_t currencyNegativePattern;
    int32_t numberNegativePattern;
    int32_t percentPositivePattern;
    int32_t percentNegativePattern;
    int32_t percentDecimalDigits;
    int32_t digitSubstitution;
    bool isReadOnly;
    bool m_useUserOverride;
    bool m_isInvariant;
    bool validForParseAsNumber;
    bool validForParseAsCurrency;
};

struct NumberFormatInfo {
    struct NumberFormatInfo__Class *klass;
    MonitorData *monitor;
    struct NumberFormatInfo__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum NumberStyles__Enum : int32_t {
    NumberStyles__Enum_None = 0x00000000,
    NumberStyles__Enum_AllowLeadingWhite = 0x00000001,
    NumberStyles__Enum_AllowTrailingWhite = 0x00000002,
    NumberStyles__Enum_AllowLeadingSign = 0x00000004,
    NumberStyles__Enum_AllowTrailingSign = 0x00000008,
    NumberStyles__Enum_AllowParentheses = 0x00000010,
    NumberStyles__Enum_AllowDecimalPoint = 0x00000020,
    NumberStyles__Enum_AllowThousands = 0x00000040,
    NumberStyles__Enum_AllowExponent = 0x00000080,
    NumberStyles__Enum_AllowCurrencySymbol = 0x00000100,
    NumberStyles__Enum_AllowHexSpecifier = 0x00000200,
    NumberStyles__Enum_Integer = 0x00000007,
    NumberStyles__Enum_HexNumber = 0x00000203,
    NumberStyles__Enum_Number = 0x0000006f,
    NumberStyles__Enum_Float = 0x000000a7,
    NumberStyles__Enum_Currency = 0x0000017f,
    NumberStyles__Enum_Any = 0x000001ff,
};

#else
enum NumberStyles__Enum {
    NumberStyles__Enum_None = 0x00000000,
    NumberStyles__Enum_AllowLeadingWhite = 0x00000001,
    NumberStyles__Enum_AllowTrailingWhite = 0x00000002,
    NumberStyles__Enum_AllowLeadingSign = 0x00000004,
    NumberStyles__Enum_AllowTrailingSign = 0x00000008,
    NumberStyles__Enum_AllowParentheses = 0x00000010,
    NumberStyles__Enum_AllowDecimalPoint = 0x00000020,
    NumberStyles__Enum_AllowThousands = 0x00000040,
    NumberStyles__Enum_AllowExponent = 0x00000080,
    NumberStyles__Enum_AllowCurrencySymbol = 0x00000100,
    NumberStyles__Enum_AllowHexSpecifier = 0x00000200,
    NumberStyles__Enum_Integer = 0x00000007,
    NumberStyles__Enum_HexNumber = 0x00000203,
    NumberStyles__Enum_Number = 0x0000006f,
    NumberStyles__Enum_Float = 0x000000a7,
    NumberStyles__Enum_Currency = 0x0000017f,
    NumberStyles__Enum_Any = 0x000001ff,
};

#endif
struct NumberStyles__Enum__Boxed {
    struct NumberStyles__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum NumberStyles__Enum value;
    #else
    uint32_t value;
    #endif
};

#if defined(_CPLUSPLUS_)
enum DateTimeFormatFlags__Enum : int32_t {
    DateTimeFormatFlags__Enum_None = 0x00000000,
    DateTimeFormatFlags__Enum_UseGenitiveMonth = 0x00000001,
    DateTimeFormatFlags__Enum_UseLeapYearMonth = 0x00000002,
    DateTimeFormatFlags__Enum_UseSpacesInMonthNames = 0x00000004,
    DateTimeFormatFlags__Enum_UseHebrewRule = 0x00000008,
    DateTimeFormatFlags__Enum_UseSpacesInDayNames = 0x00000010,
    DateTimeFormatFlags__Enum_UseDigitPrefixInTokens = 0x00000020,
    DateTimeFormatFlags__Enum_NotInitialized = 0xffffffff,
};

#else
enum DateTimeFormatFlags__Enum {
    DateTimeFormatFlags__Enum_None = 0x00000000,
    DateTimeFormatFlags__Enum_UseGenitiveMonth = 0x00000001,
    DateTimeFormatFlags__Enum_UseLeapYearMonth = 0x00000002,
    DateTimeFormatFlags__Enum_UseSpacesInMonthNames = 0x00000004,
    DateTimeFormatFlags__Enum_UseHebrewRule = 0x00000008,
    DateTimeFormatFlags__Enum_UseSpacesInDayNames = 0x00000010,
    DateTimeFormatFlags__Enum_UseDigitPrefixInTokens = 0x00000020,
    DateTimeFormatFlags__Enum_NotInitialized = 0xffffffff,
};

#endif
struct DateTimeFormatFlags__Enum__Boxed {
    struct DateTimeFormatFlags__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum DateTimeFormatFlags__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) DateTimeFormatInfo__Fields {
    struct CultureData *m_cultureData;
    struct String *m_name;
    struct String *m_langName;
    struct CompareInfo *m_compareInfo;
    struct CultureInfo *m_cultureInfo;
    struct String *amDesignator;
    struct String *pmDesignator;
    struct String *dateSeparator;
    struct String *generalShortTimePattern;
    struct String *generalLongTimePattern;
    struct String *timeSeparator;
    struct String *monthDayPattern;
    struct String *dateTimeOffsetPattern;
    struct Calendar *calendar;
    int32_t firstDayOfWeek;
    int32_t calendarWeekRule;
    struct String *fullDateTimePattern;
    struct String__Array *abbreviatedDayNames;
    struct String__Array *m_superShortDayNames;
    struct String__Array *dayNames;
    struct String__Array *abbreviatedMonthNames;
    struct String__Array *monthNames;
    struct String__Array *genitiveMonthNames;
    struct String__Array *m_genitiveAbbreviatedMonthNames;
    struct String__Array *leapYearMonthNames;
    struct String *longDatePattern;
    struct String *shortDatePattern;
    struct String *yearMonthPattern;
    struct String *longTimePattern;
    struct String *shortTimePattern;
    struct String__Array *allYearMonthPatterns;
    struct String__Array *allShortDatePatterns;
    struct String__Array *allLongDatePatterns;
    struct String__Array *allShortTimePatterns;
    struct String__Array *allLongTimePatterns;
    struct String__Array *m_eraNames;
    struct String__Array *m_abbrevEraNames;
    struct String__Array *m_abbrevEnglishEraNames;
    struct Int32__Array *optionalCalendars;
    bool m_isReadOnly;
    #if defined(_CPLUSPLUS_)
    enum DateTimeFormatFlags__Enum formatFlags;
    #else
    uint32_t formatFlags;
    #endif
    int32_t CultureID;
    bool m_useUserOverride;
    bool bUseCalendarInfo;
    int32_t nDataItem;
    bool m_isDefaultCalendar;
    struct String__Array *m_dateWords;
    struct String *m_fullTimeSpanPositivePattern;
    struct String *m_fullTimeSpanNegativePattern;
    struct TokenHashValue__Array *m_dtfiTokenHash;
};

struct DateTimeFormatInfo {
    struct DateTimeFormatInfo__Class *klass;
    MonitorData *monitor;
    struct DateTimeFormatInfo__Fields fields;
};

struct __declspec(align(8)) CultureData__Fields {
    struct String *sAM1159;
    struct String *sPM2359;
    struct String *sTimeSeparator;
    struct String__Array *saLongTimes;
    struct String__Array *saShortTimes;
    int32_t iFirstDayOfWeek;
    int32_t iFirstWeekOfYear;
    struct Int32__Array *waCalendars;
    struct CalendarData__Array *calendars;
    struct String *sISO639Language;
    struct String *sRealName;
    bool bUseOverrides;
    int32_t calendarId;
    int32_t numberIndex;
    int32_t iDefaultAnsiCodePage;
    int32_t iDefaultOemCodePage;
    int32_t iDefaultMacCodePage;
    int32_t iDefaultEbcdicCodePage;
    bool isRightToLeft;
    struct String *sListSeparator;
};

struct CultureData {
    struct CultureData__Class *klass;
    MonitorData *monitor;
    struct CultureData__Fields fields;
};

struct __declspec(align(8)) CalendarData__Fields {
    struct String *sNativeName;
    struct String__Array *saShortDates;
    struct String__Array *saYearMonths;
    struct String__Array *saLongDates;
    struct String *sMonthDay;
    struct String__Array *saEraNames;
    struct String__Array *saAbbrevEraNames;
    struct String__Array *saAbbrevEnglishEraNames;
    struct String__Array *saDayNames;
    struct String__Array *saAbbrevDayNames;
    struct String__Array *saSuperShortDayNames;
    struct String__Array *saMonthNames;
    struct String__Array *saAbbrevMonthNames;
    struct String__Array *saMonthGenitiveNames;
    struct String__Array *saAbbrevMonthGenitiveNames;
    struct String__Array *saLeapYearMonthNames;
    int32_t iTwoDigitYearMax;
    int32_t iCurrentEra;
    bool bUseUserOverrides;
};

struct CalendarData {
    struct CalendarData__Class *klass;
    MonitorData *monitor;
    struct CalendarData__Fields fields;
};

struct CalendarData__Array {
    struct CalendarData__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct CalendarData *vector[32];
};

struct __declspec(align(8)) CompareInfo__Fields {
    struct String *m_name;
    struct String *m_sortName;
    int32_t win32LCID;
    int32_t culture;
    struct SortVersion *m_SortVersion;
    struct SimpleCollator *collator;
};

struct CompareInfo {
    struct CompareInfo__Class *klass;
    MonitorData *monitor;
    struct CompareInfo__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum CompareOptions__Enum : int32_t {
    CompareOptions__Enum_None = 0x00000000,
    CompareOptions__Enum_IgnoreCase = 0x00000001,
    CompareOptions__Enum_IgnoreNonSpace = 0x00000002,
    CompareOptions__Enum_IgnoreSymbols = 0x00000004,
    CompareOptions__Enum_IgnoreKanaType = 0x00000008,
    CompareOptions__Enum_IgnoreWidth = 0x00000010,
    CompareOptions__Enum_OrdinalIgnoreCase = 0x10000000,
    CompareOptions__Enum_StringSort = 0x20000000,
    CompareOptions__Enum_Ordinal = 0x40000000,
};

#else
enum CompareOptions__Enum {
    CompareOptions__Enum_None = 0x00000000,
    CompareOptions__Enum_IgnoreCase = 0x00000001,
    CompareOptions__Enum_IgnoreNonSpace = 0x00000002,
    CompareOptions__Enum_IgnoreSymbols = 0x00000004,
    CompareOptions__Enum_IgnoreKanaType = 0x00000008,
    CompareOptions__Enum_IgnoreWidth = 0x00000010,
    CompareOptions__Enum_OrdinalIgnoreCase = 0x10000000,
    CompareOptions__Enum_StringSort = 0x20000000,
    CompareOptions__Enum_Ordinal = 0x40000000,
};

#endif
struct CompareOptions__Enum__Boxed {
    struct CompareOptions__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum CompareOptions__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) SortVersion__Fields {
    int32_t m_NlsVersion;
    struct Guid m_SortId;
};

struct SortVersion {
    struct SortVersion__Class *klass;
    MonitorData *monitor;
    struct SortVersion__Fields fields;
};

struct __declspec(align(8)) SimpleCollator__Fields {
    struct TextInfo *textInfo;
    struct CodePointIndexer *cjkIndexer;
    struct Contraction__Array *contractions;
    struct Level2Map__Array *level2Maps;
    struct Byte__Array *unsafeFlags;
    uint8_t *cjkCatTable;
    uint8_t *cjkLv1Table;
    uint8_t *cjkLv2Table;
    struct CodePointIndexer *cjkLv2Indexer;
    int32_t lcid;
    bool frenchSort;
};

struct SimpleCollator {
    struct SimpleCollator__Class *klass;
    MonitorData *monitor;
    struct SimpleCollator__Fields fields;
};

struct Nullable_1_Boolean_ {
    bool value;
    bool has_value;
};

struct Nullable_1_Boolean___Boxed {
    struct Nullable_1_Boolean___Class *klass;
    MonitorData *monitor;
    struct Nullable_1_Boolean_ fields;
};

struct __declspec(align(8)) TextInfo__Fields {
    struct String *m_listSeparator;
    bool m_isReadOnly;
    struct String *m_cultureName;
    struct CultureData *m_cultureData;
    struct String *m_textInfoName;
    struct Nullable_1_Boolean_ m_IsAsciiCasingSameAsInvariant;
    struct String *customCultureName;
    int32_t m_nDataItem;
    bool m_useUserOverride;
    int32_t m_win32LangID;
};

struct TextInfo {
    struct TextInfo__Class *klass;
    MonitorData *monitor;
    struct TextInfo__Fields fields;
};

struct __declspec(align(8)) CodePointIndexer__Fields {
    struct CodePointIndexer_TableRange__Array *ranges;
    int32_t TotalCount;
    int32_t defaultIndex;
    int32_t defaultCP;
};

struct CodePointIndexer {
    struct CodePointIndexer__Class *klass;
    MonitorData *monitor;
    struct CodePointIndexer__Fields fields;
};

struct CodePointIndexer_TableRange {
    int32_t Start;
    int32_t End;
    int32_t Count;
    int32_t IndexStart;
    int32_t IndexEnd;
};

struct CodePointIndexer_TableRange__Boxed {
    struct CodePointIndexer_TableRange__Class *klass;
    MonitorData *monitor;
    struct CodePointIndexer_TableRange fields;
};

struct CodePointIndexer_TableRange__Array {
    struct CodePointIndexer_TableRange__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct CodePointIndexer_TableRange vector[32];
};

struct __declspec(align(8)) Contraction__Fields {
    int32_t Index;
    struct Char__Array *Source;
    struct String *Replacement;
    struct Byte__Array *SortKey;
};

struct Contraction {
    struct Contraction__Class *klass;
    MonitorData *monitor;
    struct Contraction__Fields fields;
};

struct Contraction__Array {
    struct Contraction__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Contraction *vector[32];
};

struct __declspec(align(8)) Level2Map__Fields {
    uint8_t Source;
    uint8_t Replace;
};

struct Level2Map {
    struct Level2Map__Class *klass;
    MonitorData *monitor;
    struct Level2Map__Fields fields;
};

struct Level2Map__Array {
    struct Level2Map__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Level2Map *vector[32];
};

struct BytePtr {
    struct BytePtr__Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) Dictionary_2_System_String_Mono_Globalization_Unicode_SimpleCollator___Fields {
    struct Int32__Array *buckets;
    struct Dictionary_2_TKey_TValue_Entry_System_String_Mono_Globalization_Unicode_SimpleCollator___Array *entries;
    int32_t count;
    int32_t version;
    int32_t freeList;
    int32_t freeCount;
    struct IEqualityComparer_1_System_String_ *comparer;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_Mono_Globalization_Unicode_SimpleCollator_ *keys;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_Mono_Globalization_Unicode_SimpleCollator_ *values;
    struct Object *_syncRoot;
};

struct Dictionary_2_System_String_Mono_Globalization_Unicode_SimpleCollator_ {
    struct Dictionary_2_System_String_Mono_Globalization_Unicode_SimpleCollator___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_System_String_Mono_Globalization_Unicode_SimpleCollator___Fields fields;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_Mono_Globalization_Unicode_SimpleCollator_ {
    int32_t hashCode;
    int32_t next;
    struct String *key;
    struct SimpleCollator *value;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_Mono_Globalization_Unicode_SimpleCollator___Boxed {
    struct Dictionary_2_TKey_TValue_Entry_System_String_Mono_Globalization_Unicode_SimpleCollator___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_Entry_System_String_Mono_Globalization_Unicode_SimpleCollator_ fields;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_Mono_Globalization_Unicode_SimpleCollator___Array {
    struct Dictionary_2_TKey_TValue_Entry_System_String_Mono_Globalization_Unicode_SimpleCollator___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Dictionary_2_TKey_TValue_Entry_System_String_Mono_Globalization_Unicode_SimpleCollator_ vector[32];
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_KeyCollection_System_String_Mono_Globalization_Unicode_SimpleCollator___Fields {
    struct Dictionary_2_System_String_Mono_Globalization_Unicode_SimpleCollator_ *dictionary;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_Mono_Globalization_Unicode_SimpleCollator_ {
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_Mono_Globalization_Unicode_SimpleCollator___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_Mono_Globalization_Unicode_SimpleCollator___Fields fields;
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_ValueCollection_System_String_Mono_Globalization_Unicode_SimpleCollator___Fields {
    struct Dictionary_2_System_String_Mono_Globalization_Unicode_SimpleCollator_ *dictionary;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_Mono_Globalization_Unicode_SimpleCollator_ {
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_Mono_Globalization_Unicode_SimpleCollator___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_Mono_Globalization_Unicode_SimpleCollator___Fields fields;
};

struct SimpleCollator__Array {
    struct SimpleCollator__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct SimpleCollator *vector[32];
};

struct IEnumerator_1_Mono_Globalization_Unicode_SimpleCollator_ {
    struct IEnumerator_1_Mono_Globalization_Unicode_SimpleCollator___Class *klass;
    MonitorData *monitor;
};

struct ICollection_1_Mono_Globalization_Unicode_SimpleCollator_ {
    struct ICollection_1_Mono_Globalization_Unicode_SimpleCollator___Class *klass;
    MonitorData *monitor;
};

struct KeyValuePair_2_System_String_Mono_Globalization_Unicode_SimpleCollator_ {
    struct String *key;
    struct SimpleCollator *value;
};

struct KeyValuePair_2_System_String_Mono_Globalization_Unicode_SimpleCollator___Boxed {
    struct KeyValuePair_2_System_String_Mono_Globalization_Unicode_SimpleCollator___Class *klass;
    MonitorData *monitor;
    struct KeyValuePair_2_System_String_Mono_Globalization_Unicode_SimpleCollator_ fields;
};

struct KeyValuePair_2_System_String_Mono_Globalization_Unicode_SimpleCollator___Array {
    struct KeyValuePair_2_System_String_Mono_Globalization_Unicode_SimpleCollator___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct KeyValuePair_2_System_String_Mono_Globalization_Unicode_SimpleCollator_ vector[32];
};

struct IEnumerator_1_KeyValuePair_2_System_String_Mono_Globalization_Unicode_SimpleCollator_ {
    struct IEnumerator_1_KeyValuePair_2_System_String_Mono_Globalization_Unicode_SimpleCollator___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_Mono_Globalization_Unicode_SimpleCollator_ {
    struct IEnumerable_1_Mono_Globalization_Unicode_SimpleCollator___Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) SortKey__Fields {
    struct String *source;
    struct Byte__Array *key;
    #if defined(_CPLUSPLUS_)
    enum CompareOptions__Enum options;
    #else
    uint32_t options;
    #endif
    int32_t lcid;
};

struct SortKey {
    struct SortKey__Class *klass;
    MonitorData *monitor;
    struct SortKey__Fields fields;
};

struct __declspec(align(8)) Calendar__Fields {
    int32_t m_currentEraValue;
    bool m_isReadOnly;
    int32_t twoDigitYearMax;
};

struct Calendar {
    struct Calendar__Class *klass;
    MonitorData *monitor;
    struct Calendar__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum CalendarAlgorithmType__Enum : int32_t {
    CalendarAlgorithmType__Enum_Unknown = 0x00000000,
    CalendarAlgorithmType__Enum_SolarCalendar = 0x00000001,
    CalendarAlgorithmType__Enum_LunarCalendar = 0x00000002,
    CalendarAlgorithmType__Enum_LunisolarCalendar = 0x00000003,
};

#else
enum CalendarAlgorithmType__Enum {
    CalendarAlgorithmType__Enum_Unknown = 0x00000000,
    CalendarAlgorithmType__Enum_SolarCalendar = 0x00000001,
    CalendarAlgorithmType__Enum_LunarCalendar = 0x00000002,
    CalendarAlgorithmType__Enum_LunisolarCalendar = 0x00000003,
};

#endif
struct CalendarAlgorithmType__Enum__Boxed {
    struct CalendarAlgorithmType__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum CalendarAlgorithmType__Enum value;
    #else
    uint32_t value;
    #endif
};

struct PersianCalendar__Fields {
    struct Calendar__Fields _;
};

struct PersianCalendar {
    struct PersianCalendar__Class *klass;
    MonitorData *monitor;
    struct PersianCalendar__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum DayOfWeek__Enum : int32_t {
    DayOfWeek__Enum_Sunday = 0x00000000,
    DayOfWeek__Enum_Monday = 0x00000001,
    DayOfWeek__Enum_Tuesday = 0x00000002,
    DayOfWeek__Enum_Wednesday = 0x00000003,
    DayOfWeek__Enum_Thursday = 0x00000004,
    DayOfWeek__Enum_Friday = 0x00000005,
    DayOfWeek__Enum_Saturday = 0x00000006,
};

#else
enum DayOfWeek__Enum {
    DayOfWeek__Enum_Sunday = 0x00000000,
    DayOfWeek__Enum_Monday = 0x00000001,
    DayOfWeek__Enum_Tuesday = 0x00000002,
    DayOfWeek__Enum_Wednesday = 0x00000003,
    DayOfWeek__Enum_Thursday = 0x00000004,
    DayOfWeek__Enum_Friday = 0x00000005,
    DayOfWeek__Enum_Saturday = 0x00000006,
};

#endif
struct DayOfWeek__Enum__Boxed {
    struct DayOfWeek__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum DayOfWeek__Enum value;
    #else
    uint32_t value;
    #endif
};

#if defined(_CPLUSPLUS_)
enum CalendarWeekRule__Enum : int32_t {
    CalendarWeekRule__Enum_FirstDay = 0x00000000,
    CalendarWeekRule__Enum_FirstFullWeek = 0x00000001,
    CalendarWeekRule__Enum_FirstFourDayWeek = 0x00000002,
};

#else
enum CalendarWeekRule__Enum {
    CalendarWeekRule__Enum_FirstDay = 0x00000000,
    CalendarWeekRule__Enum_FirstFullWeek = 0x00000001,
    CalendarWeekRule__Enum_FirstFourDayWeek = 0x00000002,
};

#endif
struct CalendarWeekRule__Enum__Boxed {
    struct CalendarWeekRule__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum CalendarWeekRule__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) Hashtable__Fields {
    struct Hashtable_bucket__Array *buckets;
    int32_t count;
    int32_t occupancy;
    int32_t loadsize;
    float loadFactor;
    int32_t version;
    bool isWriterInProgress;
    struct ICollection *keys;
    struct ICollection *values;
    struct IEqualityComparer *_keycomparer;
    struct Object *_syncRoot;
};

struct Hashtable {
    struct Hashtable__Class *klass;
    MonitorData *monitor;
    struct Hashtable__Fields fields;
};

struct Hashtable_bucket {
    struct Object *key;
    struct Object *val;
    int32_t hash_coll;
};

struct Hashtable_bucket__Boxed {
    struct Hashtable_bucket__Class *klass;
    MonitorData *monitor;
    struct Hashtable_bucket fields;
};

struct Hashtable_bucket__Array {
    struct Hashtable_bucket__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Hashtable_bucket vector[32];
};

struct __declspec(align(8)) KeyValuePairs__Fields {
    struct Object *key;
    struct Object *value;
};

struct KeyValuePairs {
    struct KeyValuePairs__Class *klass;
    MonitorData *monitor;
    struct KeyValuePairs__Fields fields;
};

struct KeyValuePairs__Array {
    struct KeyValuePairs__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct KeyValuePairs *vector[32];
};

#if defined(_CPLUSPLUS_)
enum DateTimeStyles__Enum : int32_t {
    DateTimeStyles__Enum_None = 0x00000000,
    DateTimeStyles__Enum_AllowLeadingWhite = 0x00000001,
    DateTimeStyles__Enum_AllowTrailingWhite = 0x00000002,
    DateTimeStyles__Enum_AllowInnerWhite = 0x00000004,
    DateTimeStyles__Enum_AllowWhiteSpaces = 0x00000007,
    DateTimeStyles__Enum_NoCurrentDateDefault = 0x00000008,
    DateTimeStyles__Enum_AdjustToUniversal = 0x00000010,
    DateTimeStyles__Enum_AssumeLocal = 0x00000020,
    DateTimeStyles__Enum_AssumeUniversal = 0x00000040,
    DateTimeStyles__Enum_RoundtripKind = 0x00000080,
};

#else
enum DateTimeStyles__Enum {
    DateTimeStyles__Enum_None = 0x00000000,
    DateTimeStyles__Enum_AllowLeadingWhite = 0x00000001,
    DateTimeStyles__Enum_AllowTrailingWhite = 0x00000002,
    DateTimeStyles__Enum_AllowInnerWhite = 0x00000004,
    DateTimeStyles__Enum_AllowWhiteSpaces = 0x00000007,
    DateTimeStyles__Enum_NoCurrentDateDefault = 0x00000008,
    DateTimeStyles__Enum_AdjustToUniversal = 0x00000010,
    DateTimeStyles__Enum_AssumeLocal = 0x00000020,
    DateTimeStyles__Enum_AssumeUniversal = 0x00000040,
    DateTimeStyles__Enum_RoundtripKind = 0x00000080,
};

#endif
struct DateTimeStyles__Enum__Boxed {
    struct DateTimeStyles__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum DateTimeStyles__Enum value;
    #else
    uint32_t value;
    #endif
};

#if defined(_CPLUSPLUS_)
enum TokenType__Enum : int32_t {
    TokenType__Enum_NumberToken = 0x00000001,
    TokenType__Enum_YearNumberToken = 0x00000002,
    TokenType__Enum_Am = 0x00000003,
    TokenType__Enum_Pm = 0x00000004,
    TokenType__Enum_MonthToken = 0x00000005,
    TokenType__Enum_EndOfString = 0x00000006,
    TokenType__Enum_DayOfWeekToken = 0x00000007,
    TokenType__Enum_TimeZoneToken = 0x00000008,
    TokenType__Enum_EraToken = 0x00000009,
    TokenType__Enum_DateWordToken = 0x0000000a,
    TokenType__Enum_UnknownToken = 0x0000000b,
    TokenType__Enum_HebrewNumber = 0x0000000c,
    TokenType__Enum_JapaneseEraToken = 0x0000000d,
    TokenType__Enum_TEraToken = 0x0000000e,
    TokenType__Enum_IgnorableSymbol = 0x0000000f,
    TokenType__Enum_SEP_Unk = 0x00000100,
    TokenType__Enum_SEP_End = 0x00000200,
    TokenType__Enum_SEP_Space = 0x00000300,
    TokenType__Enum_SEP_Am = 0x00000400,
    TokenType__Enum_SEP_Pm = 0x00000500,
    TokenType__Enum_SEP_Date = 0x00000600,
    TokenType__Enum_SEP_Time = 0x00000700,
    TokenType__Enum_SEP_YearSuff = 0x00000800,
    TokenType__Enum_SEP_MonthSuff = 0x00000900,
    TokenType__Enum_SEP_DaySuff = 0x00000a00,
    TokenType__Enum_SEP_HourSuff = 0x00000b00,
    TokenType__Enum_SEP_MinuteSuff = 0x00000c00,
    TokenType__Enum_SEP_SecondSuff = 0x00000d00,
    TokenType__Enum_SEP_LocalTimeMark = 0x00000e00,
    TokenType__Enum_SEP_DateOrOffset = 0x00000f00,
    TokenType__Enum_RegularTokenMask = 0x000000ff,
    TokenType__Enum_SeparatorTokenMask = 0x0000ff00,
};

#else
enum TokenType__Enum {
    TokenType__Enum_NumberToken = 0x00000001,
    TokenType__Enum_YearNumberToken = 0x00000002,
    TokenType__Enum_Am = 0x00000003,
    TokenType__Enum_Pm = 0x00000004,
    TokenType__Enum_MonthToken = 0x00000005,
    TokenType__Enum_EndOfString = 0x00000006,
    TokenType__Enum_DayOfWeekToken = 0x00000007,
    TokenType__Enum_TimeZoneToken = 0x00000008,
    TokenType__Enum_EraToken = 0x00000009,
    TokenType__Enum_DateWordToken = 0x0000000a,
    TokenType__Enum_UnknownToken = 0x0000000b,
    TokenType__Enum_HebrewNumber = 0x0000000c,
    TokenType__Enum_JapaneseEraToken = 0x0000000d,
    TokenType__Enum_TEraToken = 0x0000000e,
    TokenType__Enum_IgnorableSymbol = 0x0000000f,
    TokenType__Enum_SEP_Unk = 0x00000100,
    TokenType__Enum_SEP_End = 0x00000200,
    TokenType__Enum_SEP_Space = 0x00000300,
    TokenType__Enum_SEP_Am = 0x00000400,
    TokenType__Enum_SEP_Pm = 0x00000500,
    TokenType__Enum_SEP_Date = 0x00000600,
    TokenType__Enum_SEP_Time = 0x00000700,
    TokenType__Enum_SEP_YearSuff = 0x00000800,
    TokenType__Enum_SEP_MonthSuff = 0x00000900,
    TokenType__Enum_SEP_DaySuff = 0x00000a00,
    TokenType__Enum_SEP_HourSuff = 0x00000b00,
    TokenType__Enum_SEP_MinuteSuff = 0x00000c00,
    TokenType__Enum_SEP_SecondSuff = 0x00000d00,
    TokenType__Enum_SEP_LocalTimeMark = 0x00000e00,
    TokenType__Enum_SEP_DateOrOffset = 0x00000f00,
    TokenType__Enum_RegularTokenMask = 0x000000ff,
    TokenType__Enum_SeparatorTokenMask = 0x0000ff00,
};

#endif
struct TokenType__Enum__Boxed {
    struct TokenType__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum TokenType__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) TokenHashValue__Fields {
    struct String *tokenString;
    #if defined(_CPLUSPLUS_)
    enum TokenType__Enum tokenType;
    #else
    uint32_t tokenType;
    #endif
    int32_t tokenValue;
};

struct TokenHashValue {
    struct TokenHashValue__Class *klass;
    MonitorData *monitor;
    struct TokenHashValue__Fields fields;
};

struct TokenHashValue__Array {
    struct TokenHashValue__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct TokenHashValue *vector[32];
};

struct __declspec(align(8)) Dictionary_2_System_Int32_System_Globalization_CultureInfo___Fields {
    struct Int32__Array *buckets;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Globalization_CultureInfo___Array *entries;
    int32_t count;
    int32_t version;
    int32_t freeList;
    int32_t freeCount;
    struct IEqualityComparer_1_System_Int32_ *comparer;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_Globalization_CultureInfo_ *keys;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_Globalization_CultureInfo_ *values;
    struct Object *_syncRoot;
};

struct Dictionary_2_System_Int32_System_Globalization_CultureInfo_ {
    struct Dictionary_2_System_Int32_System_Globalization_CultureInfo___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_System_Int32_System_Globalization_CultureInfo___Fields fields;
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Globalization_CultureInfo_ {
    int32_t hashCode;
    int32_t next;
    int32_t key;
    struct CultureInfo *value;
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Globalization_CultureInfo___Boxed {
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Globalization_CultureInfo___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Globalization_CultureInfo_ fields;
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Globalization_CultureInfo___Array {
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Globalization_CultureInfo___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Globalization_CultureInfo_ vector[32];
};

struct IEqualityComparer_1_System_Int32_ {
    struct IEqualityComparer_1_System_Int32___Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_Globalization_CultureInfo___Fields {
    struct Dictionary_2_System_Int32_System_Globalization_CultureInfo_ *dictionary;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_Globalization_CultureInfo_ {
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_Globalization_CultureInfo___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_Globalization_CultureInfo___Fields fields;
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_Globalization_CultureInfo___Fields {
    struct Dictionary_2_System_Int32_System_Globalization_CultureInfo_ *dictionary;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_Globalization_CultureInfo_ {
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_Globalization_CultureInfo___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_Globalization_CultureInfo___Fields fields;
};

struct CultureInfo__Array {
    struct CultureInfo__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct CultureInfo *vector[32];
};

struct IEnumerator_1_System_Globalization_CultureInfo_ {
    struct IEnumerator_1_System_Globalization_CultureInfo___Class *klass;
    MonitorData *monitor;
};

struct ICollection_1_System_Globalization_CultureInfo_ {
    struct ICollection_1_System_Globalization_CultureInfo___Class *klass;
    MonitorData *monitor;
};

struct KeyValuePair_2_System_Int32_System_Globalization_CultureInfo_ {
    int32_t key;
    struct CultureInfo *value;
};

struct KeyValuePair_2_System_Int32_System_Globalization_CultureInfo___Boxed {
    struct KeyValuePair_2_System_Int32_System_Globalization_CultureInfo___Class *klass;
    MonitorData *monitor;
    struct KeyValuePair_2_System_Int32_System_Globalization_CultureInfo_ fields;
};

struct KeyValuePair_2_System_Int32_System_Globalization_CultureInfo___Array {
    struct KeyValuePair_2_System_Int32_System_Globalization_CultureInfo___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct KeyValuePair_2_System_Int32_System_Globalization_CultureInfo_ vector[32];
};

struct IEnumerator_1_KeyValuePair_2_System_Int32_System_Globalization_CultureInfo_ {
    struct IEnumerator_1_KeyValuePair_2_System_Int32_System_Globalization_CultureInfo___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_Globalization_CultureInfo_ {
    struct IEnumerable_1_System_Globalization_CultureInfo___Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) Dictionary_2_System_String_System_Globalization_CultureInfo___Fields {
    struct Int32__Array *buckets;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Globalization_CultureInfo___Array *entries;
    int32_t count;
    int32_t version;
    int32_t freeList;
    int32_t freeCount;
    struct IEqualityComparer_1_System_String_ *comparer;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Globalization_CultureInfo_ *keys;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Globalization_CultureInfo_ *values;
    struct Object *_syncRoot;
};

struct Dictionary_2_System_String_System_Globalization_CultureInfo_ {
    struct Dictionary_2_System_String_System_Globalization_CultureInfo___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_System_String_System_Globalization_CultureInfo___Fields fields;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Globalization_CultureInfo_ {
    int32_t hashCode;
    int32_t next;
    struct String *key;
    struct CultureInfo *value;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Globalization_CultureInfo___Boxed {
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Globalization_CultureInfo___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Globalization_CultureInfo_ fields;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Globalization_CultureInfo___Array {
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Globalization_CultureInfo___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Globalization_CultureInfo_ vector[32];
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Globalization_CultureInfo___Fields {
    struct Dictionary_2_System_String_System_Globalization_CultureInfo_ *dictionary;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Globalization_CultureInfo_ {
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Globalization_CultureInfo___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Globalization_CultureInfo___Fields fields;
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Globalization_CultureInfo___Fields {
    struct Dictionary_2_System_String_System_Globalization_CultureInfo_ *dictionary;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Globalization_CultureInfo_ {
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Globalization_CultureInfo___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Globalization_CultureInfo___Fields fields;
};

struct KeyValuePair_2_System_String_System_Globalization_CultureInfo_ {
    struct String *key;
    struct CultureInfo *value;
};

struct KeyValuePair_2_System_String_System_Globalization_CultureInfo___Boxed {
    struct KeyValuePair_2_System_String_System_Globalization_CultureInfo___Class *klass;
    MonitorData *monitor;
    struct KeyValuePair_2_System_String_System_Globalization_CultureInfo_ fields;
};

struct KeyValuePair_2_System_String_System_Globalization_CultureInfo___Array {
    struct KeyValuePair_2_System_String_System_Globalization_CultureInfo___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct KeyValuePair_2_System_String_System_Globalization_CultureInfo_ vector[32];
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_Globalization_CultureInfo_ {
    struct IEnumerator_1_KeyValuePair_2_System_String_System_Globalization_CultureInfo___Class *klass;
    MonitorData *monitor;
};

struct Calendar__Array {
    struct Calendar__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Calendar *vector[32];
};

struct FieldInfo_1 {
    struct FieldInfo_1__Class *klass;
    MonitorData *monitor;
};

struct RuntimeFieldInfo {
    struct RuntimeFieldInfo__Class *klass;
    MonitorData *monitor;
};

struct RtFieldInfo {
    struct RtFieldInfo__Class *klass;
    MonitorData *monitor;
};

struct RuntimeFieldHandle {
    void *value;
};

struct RuntimeFieldHandle__Boxed {
    struct RuntimeFieldHandle__Class *klass;
    MonitorData *monitor;
    struct RuntimeFieldHandle fields;
};

#if defined(_CPLUSPLUS_)
enum FieldAttributes__Enum : int32_t {
    FieldAttributes__Enum_FieldAccessMask = 0x00000007,
    FieldAttributes__Enum_PrivateScope = 0x00000000,
    FieldAttributes__Enum_Private = 0x00000001,
    FieldAttributes__Enum_FamANDAssem = 0x00000002,
    FieldAttributes__Enum_Assembly = 0x00000003,
    FieldAttributes__Enum_Family = 0x00000004,
    FieldAttributes__Enum_FamORAssem = 0x00000005,
    FieldAttributes__Enum_Public = 0x00000006,
    FieldAttributes__Enum_Static = 0x00000010,
    FieldAttributes__Enum_InitOnly = 0x00000020,
    FieldAttributes__Enum_Literal = 0x00000040,
    FieldAttributes__Enum_NotSerialized = 0x00000080,
    FieldAttributes__Enum_SpecialName = 0x00000200,
    FieldAttributes__Enum_PinvokeImpl = 0x00002000,
    FieldAttributes__Enum_ReservedMask = 0x00009500,
    FieldAttributes__Enum_RTSpecialName = 0x00000400,
    FieldAttributes__Enum_HasFieldMarshal = 0x00001000,
    FieldAttributes__Enum_HasDefault = 0x00008000,
    FieldAttributes__Enum_HasFieldRVA = 0x00000100,
};

#else
enum FieldAttributes__Enum {
    FieldAttributes__Enum_FieldAccessMask = 0x00000007,
    FieldAttributes__Enum_PrivateScope = 0x00000000,
    FieldAttributes__Enum_Private = 0x00000001,
    FieldAttributes__Enum_FamANDAssem = 0x00000002,
    FieldAttributes__Enum_Assembly = 0x00000003,
    FieldAttributes__Enum_Family = 0x00000004,
    FieldAttributes__Enum_FamORAssem = 0x00000005,
    FieldAttributes__Enum_Public = 0x00000006,
    FieldAttributes__Enum_Static = 0x00000010,
    FieldAttributes__Enum_InitOnly = 0x00000020,
    FieldAttributes__Enum_Literal = 0x00000040,
    FieldAttributes__Enum_NotSerialized = 0x00000080,
    FieldAttributes__Enum_SpecialName = 0x00000200,
    FieldAttributes__Enum_PinvokeImpl = 0x00002000,
    FieldAttributes__Enum_ReservedMask = 0x00009500,
    FieldAttributes__Enum_RTSpecialName = 0x00000400,
    FieldAttributes__Enum_HasFieldMarshal = 0x00001000,
    FieldAttributes__Enum_HasDefault = 0x00008000,
    FieldAttributes__Enum_HasFieldRVA = 0x00000100,
};

#endif
struct FieldAttributes__Enum__Boxed {
    struct FieldAttributes__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum FieldAttributes__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) MonoField__Fields {
    void *klass;
    struct RuntimeFieldHandle fhandle;
    struct String *name;
    struct Type *type;
    #if defined(_CPLUSPLUS_)
    enum FieldAttributes__Enum attrs;
    #else
    uint32_t attrs;
    #endif
};

struct MonoField {
    struct MonoField__Class *klass;
    MonitorData *monitor;
    struct MonoField__Fields fields;
};

struct TypedReference {
    struct RuntimeTypeHandle type;
    void *Value;
    void *Type;
};

struct TypedReference__Boxed {
    struct TypedReference__Class *klass;
    MonitorData *monitor;
    struct TypedReference fields;
};

struct FieldInfo_1__Array {
    struct FieldInfo_1__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct FieldInfo_1 *vector[32];
};

struct PropertyInfo_1 {
    struct PropertyInfo_1__Class *klass;
    MonitorData *monitor;
};

struct RuntimePropertyInfo {
    struct RuntimePropertyInfo__Class *klass;
    MonitorData *monitor;
};

#if defined(_CPLUSPLUS_)
enum PropertyAttributes__Enum : int32_t {
    PropertyAttributes__Enum_None = 0x00000000,
    PropertyAttributes__Enum_SpecialName = 0x00000200,
    PropertyAttributes__Enum_ReservedMask = 0x0000f400,
    PropertyAttributes__Enum_RTSpecialName = 0x00000400,
    PropertyAttributes__Enum_HasDefault = 0x00001000,
    PropertyAttributes__Enum_Reserved2 = 0x00002000,
    PropertyAttributes__Enum_Reserved3 = 0x00004000,
    PropertyAttributes__Enum_Reserved4 = 0x00008000,
};

#else
enum PropertyAttributes__Enum {
    PropertyAttributes__Enum_None = 0x00000000,
    PropertyAttributes__Enum_SpecialName = 0x00000200,
    PropertyAttributes__Enum_ReservedMask = 0x0000f400,
    PropertyAttributes__Enum_RTSpecialName = 0x00000400,
    PropertyAttributes__Enum_HasDefault = 0x00001000,
    PropertyAttributes__Enum_Reserved2 = 0x00002000,
    PropertyAttributes__Enum_Reserved3 = 0x00004000,
    PropertyAttributes__Enum_Reserved4 = 0x00008000,
};

#endif
struct PropertyAttributes__Enum__Boxed {
    struct PropertyAttributes__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum PropertyAttributes__Enum value;
    #else
    uint32_t value;
    #endif
};

struct MonoPropertyInfo {
    struct Type *parent;
    struct Type *declaring_type;
    struct String *name;
    struct MethodInfo_1 *get_method;
    struct MethodInfo_1 *set_method;
    #if defined(_CPLUSPLUS_)
    enum PropertyAttributes__Enum attrs;
    #else
    uint32_t attrs;
    #endif
};

struct MonoPropertyInfo__Boxed {
    struct MonoPropertyInfo__Class *klass;
    MonitorData *monitor;
    struct MonoPropertyInfo fields;
};

#if defined(_CPLUSPLUS_)
enum PInfo__Enum : int32_t {
    PInfo__Enum_Attributes = 0x00000001,
    PInfo__Enum_GetMethod = 0x00000002,
    PInfo__Enum_SetMethod = 0x00000004,
    PInfo__Enum_ReflectedType = 0x00000008,
    PInfo__Enum_DeclaringType = 0x00000010,
    PInfo__Enum_Name = 0x00000020,
};

#else
enum PInfo__Enum {
    PInfo__Enum_Attributes = 0x00000001,
    PInfo__Enum_GetMethod = 0x00000002,
    PInfo__Enum_SetMethod = 0x00000004,
    PInfo__Enum_ReflectedType = 0x00000008,
    PInfo__Enum_DeclaringType = 0x00000010,
    PInfo__Enum_Name = 0x00000020,
};

#endif
struct PInfo__Enum__Boxed {
    struct PInfo__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum PInfo__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) MonoProperty__Fields {
    void *klass;
    void *prop;
    struct MonoPropertyInfo info;
    #if defined(_CPLUSPLUS_)
    enum PInfo__Enum cached;
    #else
    uint32_t cached;
    #endif
    struct MonoProperty_GetterAdapter *cached_getter;
};

struct MonoProperty {
    struct MonoProperty__Class *klass;
    MonitorData *monitor;
    struct MonoProperty__Fields fields;
};

struct MethodInfo_1__Array {
    struct MethodInfo_1__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct MethodInfo_1 *vector[32];
};

struct MonoProperty_GetterAdapter__Fields {
    struct MulticastDelegate__Fields _;
};

struct MonoProperty_GetterAdapter {
    struct MonoProperty_GetterAdapter__Class *klass;
    MonitorData *monitor;
    struct MonoProperty_GetterAdapter__Fields fields;
};

struct Delegate__Array {
    struct Delegate__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Delegate *vector[32];
};

struct IAsyncResult {
    struct IAsyncResult__Class *klass;
    MonitorData *monitor;
};

struct AsyncCallback__Fields {
    struct MulticastDelegate__Fields _;
};

struct AsyncCallback {
    struct AsyncCallback__Class *klass;
    MonitorData *monitor;
    struct AsyncCallback__Fields fields;
};

struct PropertyInfo_1__Array {
    struct PropertyInfo_1__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct PropertyInfo_1 *vector[32];
};

#if defined(_CPLUSPLUS_)
enum MethodAttributes__Enum : int32_t {
    MethodAttributes__Enum_MemberAccessMask = 0x00000007,
    MethodAttributes__Enum_PrivateScope = 0x00000000,
    MethodAttributes__Enum_Private = 0x00000001,
    MethodAttributes__Enum_FamANDAssem = 0x00000002,
    MethodAttributes__Enum_Assembly = 0x00000003,
    MethodAttributes__Enum_Family = 0x00000004,
    MethodAttributes__Enum_FamORAssem = 0x00000005,
    MethodAttributes__Enum_Public = 0x00000006,
    MethodAttributes__Enum_Static = 0x00000010,
    MethodAttributes__Enum_Final = 0x00000020,
    MethodAttributes__Enum_Virtual = 0x00000040,
    MethodAttributes__Enum_HideBySig = 0x00000080,
    MethodAttributes__Enum_CheckAccessOnOverride = 0x00000200,
    MethodAttributes__Enum_VtableLayoutMask = 0x00000100,
    MethodAttributes__Enum_ReuseSlot = 0x00000000,
    MethodAttributes__Enum_NewSlot = 0x00000100,
    MethodAttributes__Enum_Abstract = 0x00000400,
    MethodAttributes__Enum_SpecialName = 0x00000800,
    MethodAttributes__Enum_PinvokeImpl = 0x00002000,
    MethodAttributes__Enum_UnmanagedExport = 0x00000008,
    MethodAttributes__Enum_RTSpecialName = 0x00001000,
    MethodAttributes__Enum_ReservedMask = 0x0000d000,
    MethodAttributes__Enum_HasSecurity = 0x00004000,
    MethodAttributes__Enum_RequireSecObject = 0x00008000,
};

#else
enum MethodAttributes__Enum {
    MethodAttributes__Enum_MemberAccessMask = 0x00000007,
    MethodAttributes__Enum_PrivateScope = 0x00000000,
    MethodAttributes__Enum_Private = 0x00000001,
    MethodAttributes__Enum_FamANDAssem = 0x00000002,
    MethodAttributes__Enum_Assembly = 0x00000003,
    MethodAttributes__Enum_Family = 0x00000004,
    MethodAttributes__Enum_FamORAssem = 0x00000005,
    MethodAttributes__Enum_Public = 0x00000006,
    MethodAttributes__Enum_Static = 0x00000010,
    MethodAttributes__Enum_Final = 0x00000020,
    MethodAttributes__Enum_Virtual = 0x00000040,
    MethodAttributes__Enum_HideBySig = 0x00000080,
    MethodAttributes__Enum_CheckAccessOnOverride = 0x00000200,
    MethodAttributes__Enum_VtableLayoutMask = 0x00000100,
    MethodAttributes__Enum_ReuseSlot = 0x00000000,
    MethodAttributes__Enum_NewSlot = 0x00000100,
    MethodAttributes__Enum_Abstract = 0x00000400,
    MethodAttributes__Enum_SpecialName = 0x00000800,
    MethodAttributes__Enum_PinvokeImpl = 0x00002000,
    MethodAttributes__Enum_UnmanagedExport = 0x00000008,
    MethodAttributes__Enum_RTSpecialName = 0x00001000,
    MethodAttributes__Enum_ReservedMask = 0x0000d000,
    MethodAttributes__Enum_HasSecurity = 0x00004000,
    MethodAttributes__Enum_RequireSecObject = 0x00008000,
};

#endif
struct MethodAttributes__Enum__Boxed {
    struct MethodAttributes__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum MethodAttributes__Enum value;
    #else
    uint32_t value;
    #endif
};

#if defined(_CPLUSPLUS_)
enum CallingConventions__Enum : int32_t {
    CallingConventions__Enum_Standard = 0x00000001,
    CallingConventions__Enum_VarArgs = 0x00000002,
    CallingConventions__Enum_Any = 0x00000003,
    CallingConventions__Enum_HasThis = 0x00000020,
    CallingConventions__Enum_ExplicitThis = 0x00000040,
};

#else
enum CallingConventions__Enum {
    CallingConventions__Enum_Standard = 0x00000001,
    CallingConventions__Enum_VarArgs = 0x00000002,
    CallingConventions__Enum_Any = 0x00000003,
    CallingConventions__Enum_HasThis = 0x00000020,
    CallingConventions__Enum_ExplicitThis = 0x00000040,
};

#endif
struct CallingConventions__Enum__Boxed {
    struct CallingConventions__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum CallingConventions__Enum value;
    #else
    uint32_t value;
    #endif
};

struct RuntimeMethodHandle {
    void *value;
};

struct RuntimeMethodHandle__Boxed {
    struct RuntimeMethodHandle__Class *klass;
    MonitorData *monitor;
    struct RuntimeMethodHandle fields;
};

struct __declspec(align(8)) MethodBody__Fields {
    struct ExceptionHandlingClause__Array *clauses;
    struct LocalVariableInfo__Array *locals;
    struct Byte__Array *il;
    bool init_locals;
    int32_t sig_token;
    int32_t max_stack;
};

struct MethodBody {
    struct MethodBody__Class *klass;
    MonitorData *monitor;
    struct MethodBody__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum ExceptionHandlingClauseOptions__Enum : int32_t {
    ExceptionHandlingClauseOptions__Enum_Clause = 0x00000000,
    ExceptionHandlingClauseOptions__Enum_Filter = 0x00000001,
    ExceptionHandlingClauseOptions__Enum_Finally = 0x00000002,
    ExceptionHandlingClauseOptions__Enum_Fault = 0x00000004,
};

#else
enum ExceptionHandlingClauseOptions__Enum {
    ExceptionHandlingClauseOptions__Enum_Clause = 0x00000000,
    ExceptionHandlingClauseOptions__Enum_Filter = 0x00000001,
    ExceptionHandlingClauseOptions__Enum_Finally = 0x00000002,
    ExceptionHandlingClauseOptions__Enum_Fault = 0x00000004,
};

#endif
struct ExceptionHandlingClauseOptions__Enum__Boxed {
    struct ExceptionHandlingClauseOptions__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum ExceptionHandlingClauseOptions__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) ExceptionHandlingClause__Fields {
    struct Type *catch_type;
    int32_t filter_offset;
    #if defined(_CPLUSPLUS_)
    enum ExceptionHandlingClauseOptions__Enum flags;
    #else
    uint32_t flags;
    #endif
    int32_t try_offset;
    int32_t try_length;
    int32_t handler_offset;
    int32_t handler_length;
};

struct ExceptionHandlingClause {
    struct ExceptionHandlingClause__Class *klass;
    MonitorData *monitor;
    struct ExceptionHandlingClause__Fields fields;
};

struct ExceptionHandlingClause__Array {
    struct ExceptionHandlingClause__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct ExceptionHandlingClause *vector[32];
};

struct __declspec(align(8)) LocalVariableInfo__Fields {
    struct Type *type;
    bool is_pinned;
    uint16_t position;
};

struct LocalVariableInfo {
    struct LocalVariableInfo__Class *klass;
    MonitorData *monitor;
    struct LocalVariableInfo__Fields fields;
};

struct LocalVariableInfo__Array {
    struct LocalVariableInfo__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct LocalVariableInfo *vector[32];
};

struct IList_1_System_Reflection_ExceptionHandlingClause_ {
    struct IList_1_System_Reflection_ExceptionHandlingClause___Class *klass;
    MonitorData *monitor;
};

struct IList_1_System_Reflection_LocalVariableInfo_ {
    struct IList_1_System_Reflection_LocalVariableInfo___Class *klass;
    MonitorData *monitor;
};

struct ICustomAttributeProvider {
    struct ICustomAttributeProvider__Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) DelegateData__Fields {
    struct Type *target_type;
    struct String *method_name;
    bool curried_first_arg;
};

struct DelegateData {
    struct DelegateData__Class *klass;
    MonitorData *monitor;
    struct DelegateData__Fields fields;
};

struct __declspec(align(8)) Assembly__Fields {
    void *_mono_assembly;
    struct Assembly_ResolveEventHolder *resolve_event_holder;
    struct Object *_evidence;
    struct Object *_minimum;
    struct Object *_optional;
    struct Object *_refuse;
    struct Object *_granted;
    struct Object *_denied;
    bool fromByteArray;
    struct String *assemblyName;
};

struct Assembly {
    struct Assembly__Class *klass;
    MonitorData *monitor;
    struct Assembly__Fields fields;
};

struct __declspec(align(8)) Assembly_ResolveEventHolder__Fields {
    struct ModuleResolveEventHandler *ModuleResolve;
};

struct Assembly_ResolveEventHolder {
    struct Assembly_ResolveEventHolder__Class *klass;
    MonitorData *monitor;
    struct Assembly_ResolveEventHolder__Fields fields;
};

struct ModuleResolveEventHandler__Fields {
    struct MulticastDelegate__Fields _;
};

struct ModuleResolveEventHandler {
    struct ModuleResolveEventHandler__Class *klass;
    MonitorData *monitor;
    struct ModuleResolveEventHandler__Fields fields;
};

struct EventArgs {
    struct EventArgs__Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) ResolveEventArgs__Fields {
    struct String *m_Name;
    struct Assembly *m_Requesting;
};

struct ResolveEventArgs {
    struct ResolveEventArgs__Class *klass;
    MonitorData *monitor;
    struct ResolveEventArgs__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum AssemblyNameFlags__Enum : int32_t {
    AssemblyNameFlags__Enum_None = 0x00000000,
    AssemblyNameFlags__Enum_PublicKey = 0x00000001,
    AssemblyNameFlags__Enum_EnableJITcompileOptimizer = 0x00004000,
    AssemblyNameFlags__Enum_EnableJITcompileTracking = 0x00008000,
    AssemblyNameFlags__Enum_Retargetable = 0x00000100,
};

#else
enum AssemblyNameFlags__Enum {
    AssemblyNameFlags__Enum_None = 0x00000000,
    AssemblyNameFlags__Enum_PublicKey = 0x00000001,
    AssemblyNameFlags__Enum_EnableJITcompileOptimizer = 0x00004000,
    AssemblyNameFlags__Enum_EnableJITcompileTracking = 0x00008000,
    AssemblyNameFlags__Enum_Retargetable = 0x00000100,
};

#endif
struct AssemblyNameFlags__Enum__Boxed {
    struct AssemblyNameFlags__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum AssemblyNameFlags__Enum value;
    #else
    uint32_t value;
    #endif
};

#if defined(_CPLUSPLUS_)
enum AssemblyHashAlgorithm__Enum : int32_t {
    AssemblyHashAlgorithm__Enum_None = 0x00000000,
    AssemblyHashAlgorithm__Enum_MD5 = 0x00008003,
    AssemblyHashAlgorithm__Enum_SHA1 = 0x00008004,
    AssemblyHashAlgorithm__Enum_SHA256 = 0x0000800c,
    AssemblyHashAlgorithm__Enum_SHA384 = 0x0000800d,
    AssemblyHashAlgorithm__Enum_SHA512 = 0x0000800e,
};

#else
enum AssemblyHashAlgorithm__Enum {
    AssemblyHashAlgorithm__Enum_None = 0x00000000,
    AssemblyHashAlgorithm__Enum_MD5 = 0x00008003,
    AssemblyHashAlgorithm__Enum_SHA1 = 0x00008004,
    AssemblyHashAlgorithm__Enum_SHA256 = 0x0000800c,
    AssemblyHashAlgorithm__Enum_SHA384 = 0x0000800d,
    AssemblyHashAlgorithm__Enum_SHA512 = 0x0000800e,
};

#endif
struct AssemblyHashAlgorithm__Enum__Boxed {
    struct AssemblyHashAlgorithm__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum AssemblyHashAlgorithm__Enum value;
    #else
    uint32_t value;
    #endif
};

#if defined(_CPLUSPLUS_)
enum AssemblyVersionCompatibility__Enum : int32_t {
    AssemblyVersionCompatibility__Enum_SameMachine = 0x00000001,
    AssemblyVersionCompatibility__Enum_SameProcess = 0x00000002,
    AssemblyVersionCompatibility__Enum_SameDomain = 0x00000003,
};

#else
enum AssemblyVersionCompatibility__Enum {
    AssemblyVersionCompatibility__Enum_SameMachine = 0x00000001,
    AssemblyVersionCompatibility__Enum_SameProcess = 0x00000002,
    AssemblyVersionCompatibility__Enum_SameDomain = 0x00000003,
};

#endif
struct AssemblyVersionCompatibility__Enum__Boxed {
    struct AssemblyVersionCompatibility__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum AssemblyVersionCompatibility__Enum value;
    #else
    uint32_t value;
    #endif
};

#if defined(_CPLUSPLUS_)
enum ProcessorArchitecture__Enum : int32_t {
    ProcessorArchitecture__Enum_None = 0x00000000,
    ProcessorArchitecture__Enum_MSIL = 0x00000001,
    ProcessorArchitecture__Enum_X86 = 0x00000002,
    ProcessorArchitecture__Enum_IA64 = 0x00000003,
    ProcessorArchitecture__Enum_Amd64 = 0x00000004,
    ProcessorArchitecture__Enum_Arm = 0x00000005,
};

#else
enum ProcessorArchitecture__Enum {
    ProcessorArchitecture__Enum_None = 0x00000000,
    ProcessorArchitecture__Enum_MSIL = 0x00000001,
    ProcessorArchitecture__Enum_X86 = 0x00000002,
    ProcessorArchitecture__Enum_IA64 = 0x00000003,
    ProcessorArchitecture__Enum_Amd64 = 0x00000004,
    ProcessorArchitecture__Enum_Arm = 0x00000005,
};

#endif
struct ProcessorArchitecture__Enum__Boxed {
    struct ProcessorArchitecture__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum ProcessorArchitecture__Enum value;
    #else
    uint32_t value;
    #endif
};

#if defined(_CPLUSPLUS_)
enum AssemblyContentType__Enum : int32_t {
    AssemblyContentType__Enum_Default = 0x00000000,
    AssemblyContentType__Enum_WindowsRuntime = 0x00000001,
};

#else
enum AssemblyContentType__Enum {
    AssemblyContentType__Enum_Default = 0x00000000,
    AssemblyContentType__Enum_WindowsRuntime = 0x00000001,
};

#endif
struct AssemblyContentType__Enum__Boxed {
    struct AssemblyContentType__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum AssemblyContentType__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) AssemblyName__Fields {
    struct String *name;
    struct String *codebase;
    int32_t major;
    int32_t minor;
    int32_t build;
    int32_t revision;
    struct CultureInfo *cultureinfo;
    #if defined(_CPLUSPLUS_)
    enum AssemblyNameFlags__Enum flags;
    #else
    uint32_t flags;
    #endif
    #if defined(_CPLUSPLUS_)
    enum AssemblyHashAlgorithm__Enum hashalg;
    #else
    uint32_t hashalg;
    #endif
    struct StrongNameKeyPair *keypair;
    struct Byte__Array *publicKey;
    struct Byte__Array *keyToken;
    #if defined(_CPLUSPLUS_)
    enum AssemblyVersionCompatibility__Enum versioncompat;
    #else
    uint32_t versioncompat;
    #endif
    struct Version *version;
    #if defined(_CPLUSPLUS_)
    enum ProcessorArchitecture__Enum processor_architecture;
    #else
    uint32_t processor_architecture;
    #endif
    #if defined(_CPLUSPLUS_)
    enum AssemblyContentType__Enum contentType;
    #else
    uint32_t contentType;
    #endif
};

struct AssemblyName {
    struct AssemblyName__Class *klass;
    MonitorData *monitor;
    struct AssemblyName__Fields fields;
};

struct __declspec(align(8)) StrongNameKeyPair__Fields {
    struct Byte__Array *_publicKey;
    struct String *_keyPairContainer;
    bool _keyPairExported;
    struct Byte__Array *_keyPairArray;
    struct RSA *_rsa;
};

struct StrongNameKeyPair {
    struct StrongNameKeyPair__Class *klass;
    MonitorData *monitor;
    struct StrongNameKeyPair__Fields fields;
};

struct __declspec(align(8)) AsymmetricAlgorithm__Fields {
    int32_t KeySizeValue;
    struct KeySizes__Array *LegalKeySizesValue;
};

struct AsymmetricAlgorithm {
    struct AsymmetricAlgorithm__Class *klass;
    MonitorData *monitor;
    struct AsymmetricAlgorithm__Fields fields;
};

struct RSA__Fields {
    struct AsymmetricAlgorithm__Fields _;
};

struct RSA {
    struct RSA__Class *klass;
    MonitorData *monitor;
    struct RSA__Fields fields;
};

struct __declspec(align(8)) KeySizes__Fields {
    int32_t m_minSize;
    int32_t m_maxSize;
    int32_t m_skipSize;
};

struct KeySizes {
    struct KeySizes__Class *klass;
    MonitorData *monitor;
    struct KeySizes__Fields fields;
};

struct KeySizes__Array {
    struct KeySizes__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct KeySizes *vector[32];
};

#if defined(_CPLUSPLUS_)
enum RSAEncryptionPaddingMode__Enum : int32_t {
    RSAEncryptionPaddingMode__Enum_Pkcs1 = 0x00000000,
    RSAEncryptionPaddingMode__Enum_Oaep = 0x00000001,
};

#else
enum RSAEncryptionPaddingMode__Enum {
    RSAEncryptionPaddingMode__Enum_Pkcs1 = 0x00000000,
    RSAEncryptionPaddingMode__Enum_Oaep = 0x00000001,
};

#endif
struct RSAEncryptionPaddingMode__Enum__Boxed {
    struct RSAEncryptionPaddingMode__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum RSAEncryptionPaddingMode__Enum value;
    #else
    uint32_t value;
    #endif
};

struct HashAlgorithmName {
    struct String *_name;
};

struct HashAlgorithmName__Boxed {
    struct HashAlgorithmName__Class *klass;
    MonitorData *monitor;
    struct HashAlgorithmName fields;
};

struct __declspec(align(8)) RSAEncryptionPadding__Fields {
    #if defined(_CPLUSPLUS_)
    enum RSAEncryptionPaddingMode__Enum _mode;
    #else
    uint32_t _mode;
    #endif
    struct HashAlgorithmName _oaepHashAlgorithm;
};

struct RSAEncryptionPadding {
    struct RSAEncryptionPadding__Class *klass;
    MonitorData *monitor;
    struct RSAEncryptionPadding__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum RSASignaturePaddingMode__Enum : int32_t {
    RSASignaturePaddingMode__Enum_Pkcs1 = 0x00000000,
    RSASignaturePaddingMode__Enum_Pss = 0x00000001,
};

#else
enum RSASignaturePaddingMode__Enum {
    RSASignaturePaddingMode__Enum_Pkcs1 = 0x00000000,
    RSASignaturePaddingMode__Enum_Pss = 0x00000001,
};

#endif
struct RSASignaturePaddingMode__Enum__Boxed {
    struct RSASignaturePaddingMode__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum RSASignaturePaddingMode__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) RSASignaturePadding__Fields {
    #if defined(_CPLUSPLUS_)
    enum RSASignaturePaddingMode__Enum _mode;
    #else
    uint32_t _mode;
    #endif
};

struct RSASignaturePadding {
    struct RSASignaturePadding__Class *klass;
    MonitorData *monitor;
    struct RSASignaturePadding__Fields fields;
};

struct __declspec(align(8)) MarshalByRefObject__Fields {
    struct Object *_identity;
};

struct MarshalByRefObject {
    struct MarshalByRefObject__Class *klass;
    MonitorData *monitor;
    struct MarshalByRefObject__Fields fields;
};

struct Stream__Fields {
    struct MarshalByRefObject__Fields _;
    struct Stream_ReadWriteTask *_activeReadWriteTask;
    struct SemaphoreSlim *_asyncActiveSemaphore;
};

struct Stream {
    struct Stream__Class *klass;
    MonitorData *monitor;
    struct Stream__Fields fields;
};

struct __declspec(align(8)) ObjRef__Fields {
    struct IChannelInfo *channel_info;
    struct String *uri;
    struct IRemotingTypeInfo *typeInfo;
    struct IEnvoyInfo *envoyInfo;
    int32_t flags;
    struct Type *_serverType;
};

struct ObjRef {
    struct ObjRef__Class *klass;
    MonitorData *monitor;
    struct ObjRef__Fields fields;
};

struct IChannelInfo {
    struct IChannelInfo__Class *klass;
    MonitorData *monitor;
};

struct IRemotingTypeInfo {
    struct IRemotingTypeInfo__Class *klass;
    MonitorData *monitor;
};

struct IEnvoyInfo {
    struct IEnvoyInfo__Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) Task__Fields {
    int32_t m_taskId;
    struct Object *m_action;
    struct Object *m_stateObject;
    struct TaskScheduler *m_taskScheduler;
    struct Task *m_parent;
    int32_t m_stateFlags;
    struct Object *m_continuationObject;
    struct Task_ContingentProperties *m_contingentProperties;
};

struct Task {
    struct Task__Class *klass;
    MonitorData *monitor;
    struct Task__Fields fields;
};

struct Task_1_System_Int32___Fields {
    struct Task__Fields _;
    int32_t m_result;
};

struct Task_1_System_Int32_ {
    struct Task_1_System_Int32___Class *klass;
    MonitorData *monitor;
    struct Task_1_System_Int32___Fields fields;
};

struct Stream_ReadWriteTask__Fields {
    struct Task_1_System_Int32___Fields _;
    bool _isRead;
    struct Stream *_stream;
    struct Byte__Array *_buffer;
    int32_t _offset;
    int32_t _count;
    struct AsyncCallback *_callback;
    struct ExecutionContext *_context;
};

struct Stream_ReadWriteTask {
    struct Stream_ReadWriteTask__Class *klass;
    MonitorData *monitor;
    struct Stream_ReadWriteTask__Fields fields;
};

struct __declspec(align(8)) StackGuard__Fields {
    int32_t m_inliningDepth;
};

struct StackGuard {
    struct StackGuard__Class *klass;
    MonitorData *monitor;
    struct StackGuard__Fields fields;
};

struct CancellationToken {
    struct CancellationTokenSource *m_source;
};

struct CancellationToken__Boxed {
    struct CancellationToken__Class *klass;
    MonitorData *monitor;
    struct CancellationToken fields;
};

#if defined(_CPLUSPLUS_)
enum TaskCreationOptions__Enum : int32_t {
    TaskCreationOptions__Enum_None = 0x00000000,
    TaskCreationOptions__Enum_PreferFairness = 0x00000001,
    TaskCreationOptions__Enum_LongRunning = 0x00000002,
    TaskCreationOptions__Enum_AttachedToParent = 0x00000004,
    TaskCreationOptions__Enum_DenyChildAttach = 0x00000008,
    TaskCreationOptions__Enum_HideScheduler = 0x00000010,
    TaskCreationOptions__Enum_RunContinuationsAsynchronously = 0x00000040,
};

#else
enum TaskCreationOptions__Enum {
    TaskCreationOptions__Enum_None = 0x00000000,
    TaskCreationOptions__Enum_PreferFairness = 0x00000001,
    TaskCreationOptions__Enum_LongRunning = 0x00000002,
    TaskCreationOptions__Enum_AttachedToParent = 0x00000004,
    TaskCreationOptions__Enum_DenyChildAttach = 0x00000008,
    TaskCreationOptions__Enum_HideScheduler = 0x00000010,
    TaskCreationOptions__Enum_RunContinuationsAsynchronously = 0x00000040,
};

#endif
struct TaskCreationOptions__Enum__Boxed {
    struct TaskCreationOptions__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum TaskCreationOptions__Enum value;
    #else
    uint32_t value;
    #endif
};

#if defined(_CPLUSPLUS_)
enum TaskContinuationOptions__Enum : int32_t {
    TaskContinuationOptions__Enum_None = 0x00000000,
    TaskContinuationOptions__Enum_PreferFairness = 0x00000001,
    TaskContinuationOptions__Enum_LongRunning = 0x00000002,
    TaskContinuationOptions__Enum_AttachedToParent = 0x00000004,
    TaskContinuationOptions__Enum_DenyChildAttach = 0x00000008,
    TaskContinuationOptions__Enum_HideScheduler = 0x00000010,
    TaskContinuationOptions__Enum_LazyCancellation = 0x00000020,
    TaskContinuationOptions__Enum_RunContinuationsAsynchronously = 0x00000040,
    TaskContinuationOptions__Enum_NotOnRanToCompletion = 0x00010000,
    TaskContinuationOptions__Enum_NotOnFaulted = 0x00020000,
    TaskContinuationOptions__Enum_NotOnCanceled = 0x00040000,
    TaskContinuationOptions__Enum_OnlyOnRanToCompletion = 0x00060000,
    TaskContinuationOptions__Enum_OnlyOnFaulted = 0x00050000,
    TaskContinuationOptions__Enum_OnlyOnCanceled = 0x00030000,
    TaskContinuationOptions__Enum_ExecuteSynchronously = 0x00080000,
};

#else
enum TaskContinuationOptions__Enum {
    TaskContinuationOptions__Enum_None = 0x00000000,
    TaskContinuationOptions__Enum_PreferFairness = 0x00000001,
    TaskContinuationOptions__Enum_LongRunning = 0x00000002,
    TaskContinuationOptions__Enum_AttachedToParent = 0x00000004,
    TaskContinuationOptions__Enum_DenyChildAttach = 0x00000008,
    TaskContinuationOptions__Enum_HideScheduler = 0x00000010,
    TaskContinuationOptions__Enum_LazyCancellation = 0x00000020,
    TaskContinuationOptions__Enum_RunContinuationsAsynchronously = 0x00000040,
    TaskContinuationOptions__Enum_NotOnRanToCompletion = 0x00010000,
    TaskContinuationOptions__Enum_NotOnFaulted = 0x00020000,
    TaskContinuationOptions__Enum_NotOnCanceled = 0x00040000,
    TaskContinuationOptions__Enum_OnlyOnRanToCompletion = 0x00060000,
    TaskContinuationOptions__Enum_OnlyOnFaulted = 0x00050000,
    TaskContinuationOptions__Enum_OnlyOnCanceled = 0x00030000,
    TaskContinuationOptions__Enum_ExecuteSynchronously = 0x00080000,
};

#endif
struct TaskContinuationOptions__Enum__Boxed {
    struct TaskContinuationOptions__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum TaskContinuationOptions__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) TaskFactory__Fields {
    struct CancellationToken m_defaultCancellationToken;
    struct TaskScheduler *m_defaultScheduler;
    #if defined(_CPLUSPLUS_)
    enum TaskCreationOptions__Enum m_defaultCreationOptions;
    #else
    uint32_t m_defaultCreationOptions;
    #endif
    #if defined(_CPLUSPLUS_)
    enum TaskContinuationOptions__Enum m_defaultContinuationOptions;
    #else
    uint32_t m_defaultContinuationOptions;
    #endif
};

struct TaskFactory {
    struct TaskFactory__Class *klass;
    MonitorData *monitor;
    struct TaskFactory__Fields fields;
};

struct __declspec(align(8)) CancellationTokenSource__Fields {
    struct ManualResetEvent *m_kernelEvent;
    struct SparselyPopulatedArray_1_CancellationCallbackInfo___Array *m_registeredCallbacksLists;
    int32_t m_state;
    int32_t m_threadIDExecutingCallbacks;
    bool m_disposed;
    struct CancellationTokenRegistration__Array *m_linkingRegistrations;
    struct CancellationCallbackInfo *m_executingCallback;
    struct Timer *m_timer;
};

struct CancellationTokenSource {
    struct CancellationTokenSource__Class *klass;
    MonitorData *monitor;
    struct CancellationTokenSource__Fields fields;
};

struct WaitHandle__Fields {
    struct MarshalByRefObject__Fields _;
    void *waitHandle;
    struct SafeWaitHandle *safeWaitHandle;
    bool hasThreadAffinity;
};

struct WaitHandle {
    struct WaitHandle__Class *klass;
    MonitorData *monitor;
    struct WaitHandle__Fields fields;
};

struct EventWaitHandle__Fields {
    struct WaitHandle__Fields _;
};

struct EventWaitHandle {
    struct EventWaitHandle__Class *klass;
    MonitorData *monitor;
    struct EventWaitHandle__Fields fields;
};

struct ManualResetEvent__Fields {
    struct EventWaitHandle__Fields _;
};

struct ManualResetEvent {
    struct ManualResetEvent__Class *klass;
    MonitorData *monitor;
    struct ManualResetEvent__Fields fields;
};

struct CriticalFinalizerObject {
    struct CriticalFinalizerObject__Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) SafeHandle__Fields {
    void *handle;
    int32_t _state;
    bool _ownsHandle;
    bool _fullyInitialized;
};

struct SafeHandle {
    struct SafeHandle__Class *klass;
    MonitorData *monitor;
    struct SafeHandle__Fields fields;
};

struct SafeHandleZeroOrMinusOneIsInvalid__Fields {
    struct SafeHandle__Fields _;
};

struct SafeHandleZeroOrMinusOneIsInvalid {
    struct SafeHandleZeroOrMinusOneIsInvalid__Class *klass;
    MonitorData *monitor;
    struct SafeHandleZeroOrMinusOneIsInvalid__Fields fields;
};

struct SafeWaitHandle__Fields {
    struct SafeHandleZeroOrMinusOneIsInvalid__Fields _;
};

struct SafeWaitHandle {
    struct SafeWaitHandle__Class *klass;
    MonitorData *monitor;
    struct SafeWaitHandle__Fields fields;
};

struct SafeFileHandle__Fields {
    struct SafeHandleZeroOrMinusOneIsInvalid__Fields _;
};

struct SafeFileHandle {
    struct SafeFileHandle__Class *klass;
    MonitorData *monitor;
    struct SafeFileHandle__Fields fields;
};

struct TimeSpan {
    int64_t _ticks;
};

struct TimeSpan__Boxed {
    struct TimeSpan__Class *klass;
    MonitorData *monitor;
    struct TimeSpan fields;
};

struct __declspec(align(8)) SparselyPopulatedArray_1_CancellationCallbackInfo___Fields {
    struct SparselyPopulatedArrayFragment_1_CancellationCallbackInfo_ *m_tail;
};

struct SparselyPopulatedArray_1_CancellationCallbackInfo_ {
    struct SparselyPopulatedArray_1_CancellationCallbackInfo___Class *klass;
    MonitorData *monitor;
    struct SparselyPopulatedArray_1_CancellationCallbackInfo___Fields fields;
};

struct __declspec(align(8)) SparselyPopulatedArrayFragment_1_CancellationCallbackInfo___Fields {
    struct CancellationCallbackInfo__Array *m_elements;
    int32_t m_freeCount;
    struct SparselyPopulatedArrayFragment_1_CancellationCallbackInfo_ *m_next;
    struct SparselyPopulatedArrayFragment_1_CancellationCallbackInfo_ *m_prev;
};

struct SparselyPopulatedArrayFragment_1_CancellationCallbackInfo_ {
    struct SparselyPopulatedArrayFragment_1_CancellationCallbackInfo___Class *klass;
    MonitorData *monitor;
    struct SparselyPopulatedArrayFragment_1_CancellationCallbackInfo___Fields fields;
};

struct __declspec(align(8)) CancellationCallbackInfo__Fields {
    struct Action_1_Object_ *Callback;
    struct Object *StateForCallback;
    struct SynchronizationContext *TargetSyncContext;
    struct ExecutionContext *TargetExecutionContext;
    struct CancellationTokenSource *CancellationTokenSource;
};

struct CancellationCallbackInfo {
    struct CancellationCallbackInfo__Class *klass;
    MonitorData *monitor;
    struct CancellationCallbackInfo__Fields fields;
};

struct Action_1_Object___Fields {
    struct MulticastDelegate__Fields _;
};

struct Action_1_Object_ {
    struct Action_1_Object___Class *klass;
    MonitorData *monitor;
    struct Action_1_Object___Fields fields;
};

#if defined(_CPLUSPLUS_)
enum SynchronizationContextProperties__Enum : int32_t {
    SynchronizationContextProperties__Enum_None = 0x00000000,
    SynchronizationContextProperties__Enum_RequireWaitNotification = 0x00000001,
};

#else
enum SynchronizationContextProperties__Enum {
    SynchronizationContextProperties__Enum_None = 0x00000000,
    SynchronizationContextProperties__Enum_RequireWaitNotification = 0x00000001,
};

#endif
struct SynchronizationContextProperties__Enum__Boxed {
    struct SynchronizationContextProperties__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum SynchronizationContextProperties__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) SynchronizationContext__Fields {
    #if defined(_CPLUSPLUS_)
    enum SynchronizationContextProperties__Enum _props;
    #else
    uint32_t _props;
    #endif
};

struct SynchronizationContext {
    struct SynchronizationContext__Class *klass;
    MonitorData *monitor;
    struct SynchronizationContext__Fields fields;
};

struct SendOrPostCallback__Fields {
    struct MulticastDelegate__Fields _;
};

struct SendOrPostCallback {
    struct SendOrPostCallback__Class *klass;
    MonitorData *monitor;
    struct SendOrPostCallback__Fields fields;
};

struct IntPtr__Array {
    struct IntPtr__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    void *vector[32];
};

#if defined(_CPLUSPLUS_)
enum ExecutionContext_Flags__Enum : int32_t {
    ExecutionContext_Flags__Enum_None = 0x00000000,
    ExecutionContext_Flags__Enum_IsNewCapture = 0x00000001,
    ExecutionContext_Flags__Enum_IsFlowSuppressed = 0x00000002,
    ExecutionContext_Flags__Enum_IsPreAllocatedDefault = 0x00000004,
};

#else
enum ExecutionContext_Flags__Enum {
    ExecutionContext_Flags__Enum_None = 0x00000000,
    ExecutionContext_Flags__Enum_IsNewCapture = 0x00000001,
    ExecutionContext_Flags__Enum_IsFlowSuppressed = 0x00000002,
    ExecutionContext_Flags__Enum_IsPreAllocatedDefault = 0x00000004,
};

#endif
struct ExecutionContext_Flags__Enum__Boxed {
    struct ExecutionContext_Flags__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum ExecutionContext_Flags__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) ExecutionContext__Fields {
    struct SynchronizationContext *_syncContext;
    struct SynchronizationContext *_syncContextNoFlow;
    struct LogicalCallContext *_logicalCallContext;
    struct IllogicalCallContext *_illogicalCallContext;
    #if defined(_CPLUSPLUS_)
    enum ExecutionContext_Flags__Enum _flags;
    #else
    uint32_t _flags;
    #endif
    struct Dictionary_2_System_Threading_IAsyncLocal_System_Object_ *_localValues;
    struct List_1_System_Threading_IAsyncLocal_ *_localChangeNotifications;
};

struct ExecutionContext {
    struct ExecutionContext__Class *klass;
    MonitorData *monitor;
    struct ExecutionContext__Fields fields;
};

struct __declspec(align(8)) LogicalCallContext__Fields {
    struct Hashtable *m_Datastore;
    struct CallContextRemotingData *m_RemotingData;
    struct CallContextSecurityData *m_SecurityData;
    struct Object *m_HostContext;
    bool m_IsCorrelationMgr;
    struct Header__Array *_sendHeaders;
    struct Header__Array *_recvHeaders;
};

struct LogicalCallContext {
    struct LogicalCallContext__Class *klass;
    MonitorData *monitor;
    struct LogicalCallContext__Fields fields;
};

struct __declspec(align(8)) CallContextRemotingData__Fields {
    struct String *_logicalCallID;
};

struct CallContextRemotingData {
    struct CallContextRemotingData__Class *klass;
    MonitorData *monitor;
    struct CallContextRemotingData__Fields fields;
};

struct __declspec(align(8)) CallContextSecurityData__Fields {
    struct IPrincipal *_principal;
};

struct CallContextSecurityData {
    struct CallContextSecurityData__Class *klass;
    MonitorData *monitor;
    struct CallContextSecurityData__Fields fields;
};

struct IPrincipal {
    struct IPrincipal__Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) Header__Fields {
    struct String *HeaderNamespace;
    bool MustUnderstand;
    struct String *Name;
    struct Object *Value;
};

struct Header {
    struct Header__Class *klass;
    MonitorData *monitor;
    struct Header__Fields fields;
};

struct Header__Array {
    struct Header__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Header *vector[32];
};

struct __declspec(align(8)) IllogicalCallContext__Fields {
    struct Hashtable *m_Datastore;
    struct Object *m_HostContext;
};

struct IllogicalCallContext {
    struct IllogicalCallContext__Class *klass;
    MonitorData *monitor;
    struct IllogicalCallContext__Fields fields;
};

struct __declspec(align(8)) Dictionary_2_System_Threading_IAsyncLocal_System_Object___Fields {
    struct Int32__Array *buckets;
    struct Dictionary_2_TKey_TValue_Entry_System_Threading_IAsyncLocal_System_Object___Array *entries;
    int32_t count;
    int32_t version;
    int32_t freeList;
    int32_t freeCount;
    struct IEqualityComparer_1_System_Threading_IAsyncLocal_ *comparer;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Threading_IAsyncLocal_System_Object_ *keys;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Threading_IAsyncLocal_System_Object_ *values;
    struct Object *_syncRoot;
};

struct Dictionary_2_System_Threading_IAsyncLocal_System_Object_ {
    struct Dictionary_2_System_Threading_IAsyncLocal_System_Object___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_System_Threading_IAsyncLocal_System_Object___Fields fields;
};

struct Dictionary_2_TKey_TValue_Entry_System_Threading_IAsyncLocal_System_Object_ {
    int32_t hashCode;
    int32_t next;
    struct IAsyncLocal *key;
    struct Object *value;
};

struct Dictionary_2_TKey_TValue_Entry_System_Threading_IAsyncLocal_System_Object___Boxed {
    struct Dictionary_2_TKey_TValue_Entry_System_Threading_IAsyncLocal_System_Object___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_Entry_System_Threading_IAsyncLocal_System_Object_ fields;
};

struct IAsyncLocal {
    struct IAsyncLocal__Class *klass;
    MonitorData *monitor;
};

struct Dictionary_2_TKey_TValue_Entry_System_Threading_IAsyncLocal_System_Object___Array {
    struct Dictionary_2_TKey_TValue_Entry_System_Threading_IAsyncLocal_System_Object___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Dictionary_2_TKey_TValue_Entry_System_Threading_IAsyncLocal_System_Object_ vector[32];
};

struct IEqualityComparer_1_System_Threading_IAsyncLocal_ {
    struct IEqualityComparer_1_System_Threading_IAsyncLocal___Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_KeyCollection_System_Threading_IAsyncLocal_System_Object___Fields {
    struct Dictionary_2_System_Threading_IAsyncLocal_System_Object_ *dictionary;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_Threading_IAsyncLocal_System_Object_ {
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Threading_IAsyncLocal_System_Object___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Threading_IAsyncLocal_System_Object___Fields fields;
};

struct IAsyncLocal__Array {
    struct IAsyncLocal__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct IAsyncLocal *vector[32];
};

struct IEnumerator_1_System_Threading_IAsyncLocal_ {
    struct IEnumerator_1_System_Threading_IAsyncLocal___Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_ValueCollection_System_Threading_IAsyncLocal_System_Object___Fields {
    struct Dictionary_2_System_Threading_IAsyncLocal_System_Object_ *dictionary;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_Threading_IAsyncLocal_System_Object_ {
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Threading_IAsyncLocal_System_Object___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Threading_IAsyncLocal_System_Object___Fields fields;
};

struct IEnumerator_1_System_Object_ {
    struct IEnumerator_1_System_Object___Class *klass;
    MonitorData *monitor;
};

struct ICollection_1_System_Threading_IAsyncLocal_ {
    struct ICollection_1_System_Threading_IAsyncLocal___Class *klass;
    MonitorData *monitor;
};

struct ICollection_1_System_Object_ {
    struct ICollection_1_System_Object___Class *klass;
    MonitorData *monitor;
};

struct KeyValuePair_2_System_Threading_IAsyncLocal_System_Object_ {
    struct IAsyncLocal *key;
    struct Object *value;
};

struct KeyValuePair_2_System_Threading_IAsyncLocal_System_Object___Boxed {
    struct KeyValuePair_2_System_Threading_IAsyncLocal_System_Object___Class *klass;
    MonitorData *monitor;
    struct KeyValuePair_2_System_Threading_IAsyncLocal_System_Object_ fields;
};

struct KeyValuePair_2_System_Threading_IAsyncLocal_System_Object___Array {
    struct KeyValuePair_2_System_Threading_IAsyncLocal_System_Object___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct KeyValuePair_2_System_Threading_IAsyncLocal_System_Object_ vector[32];
};

struct IEnumerator_1_KeyValuePair_2_System_Threading_IAsyncLocal_System_Object_ {
    struct IEnumerator_1_KeyValuePair_2_System_Threading_IAsyncLocal_System_Object___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_Threading_IAsyncLocal_ {
    struct IEnumerable_1_System_Threading_IAsyncLocal___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_Object_ {
    struct IEnumerable_1_System_Object___Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) List_1_System_Threading_IAsyncLocal___Fields {
    struct IAsyncLocal__Array *_items;
    int32_t _size;
    int32_t _version;
    struct Object *_syncRoot;
};

struct List_1_System_Threading_IAsyncLocal_ {
    struct List_1_System_Threading_IAsyncLocal___Class *klass;
    MonitorData *monitor;
    struct List_1_System_Threading_IAsyncLocal___Fields fields;
};

struct ContextCallback__Fields {
    struct MulticastDelegate__Fields _;
};

struct ContextCallback {
    struct ContextCallback__Class *klass;
    MonitorData *monitor;
    struct ContextCallback__Fields fields;
};

struct CancellationCallbackInfo__Array {
    struct CancellationCallbackInfo__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct CancellationCallbackInfo *vector[32];
};

struct SparselyPopulatedArray_1_CancellationCallbackInfo___Array {
    struct SparselyPopulatedArray_1_CancellationCallbackInfo___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct SparselyPopulatedArray_1_CancellationCallbackInfo_ *vector[32];
};

struct SparselyPopulatedArrayAddInfo_1_CancellationCallbackInfo_ {
    struct SparselyPopulatedArrayFragment_1_CancellationCallbackInfo_ *m_source;
    int32_t m_index;
};

struct SparselyPopulatedArrayAddInfo_1_CancellationCallbackInfo___Boxed {
    struct SparselyPopulatedArrayAddInfo_1_CancellationCallbackInfo___Class *klass;
    MonitorData *monitor;
    struct SparselyPopulatedArrayAddInfo_1_CancellationCallbackInfo_ fields;
};

struct CancellationTokenRegistration {
    struct CancellationCallbackInfo *m_callbackInfo;
    struct SparselyPopulatedArrayAddInfo_1_CancellationCallbackInfo_ m_registrationInfo;
};

struct CancellationTokenRegistration__Boxed {
    struct CancellationTokenRegistration__Class *klass;
    MonitorData *monitor;
    struct CancellationTokenRegistration fields;
};

struct CancellationTokenRegistration__Array {
    struct CancellationTokenRegistration__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct CancellationTokenRegistration vector[32];
};

struct Timer__Fields {
    struct MarshalByRefObject__Fields _;
    struct TimerCallback *callback;
    struct Object *state;
    int64_t due_time_ms;
    int64_t period_ms;
    int64_t next_run;
    bool disposed;
};

struct Timer {
    struct Timer__Class *klass;
    MonitorData *monitor;
    struct Timer__Fields fields;
};

struct __declspec(align(8)) Timer_Scheduler__Fields {
    struct SortedList *list;
    struct ManualResetEvent *changed;
};

struct Timer_Scheduler {
    struct Timer_Scheduler__Class *klass;
    MonitorData *monitor;
    struct Timer_Scheduler__Fields fields;
};

struct __declspec(align(8)) SortedList__Fields {
    struct Object__Array *keys;
    struct Object__Array *values;
    int32_t _size;
    int32_t version;
    struct IComparer *comparer;
    struct SortedList_KeyList *keyList;
    struct SortedList_ValueList *valueList;
    struct Object *_syncRoot;
};

struct SortedList {
    struct SortedList__Class *klass;
    MonitorData *monitor;
    struct SortedList__Fields fields;
};

struct __declspec(align(8)) SortedList_KeyList__Fields {
    struct SortedList *sortedList;
};

struct SortedList_KeyList {
    struct SortedList_KeyList__Class *klass;
    MonitorData *monitor;
    struct SortedList_KeyList__Fields fields;
};

struct __declspec(align(8)) SortedList_ValueList__Fields {
    struct SortedList *sortedList;
};

struct SortedList_ValueList {
    struct SortedList_ValueList__Class *klass;
    MonitorData *monitor;
    struct SortedList_ValueList__Fields fields;
};

struct IList {
    struct IList__Class *klass;
    MonitorData *monitor;
};

struct TimerCallback__Fields {
    struct MulticastDelegate__Fields _;
};

struct TimerCallback {
    struct TimerCallback__Class *klass;
    MonitorData *monitor;
    struct TimerCallback__Fields fields;
};

struct __declspec(align(8)) TaskScheduler__Fields {
    int32_t m_taskSchedulerId;
};

struct TaskScheduler {
    struct TaskScheduler__Class *klass;
    MonitorData *monitor;
    struct TaskScheduler__Fields fields;
};

struct __declspec(align(8)) ConditionalWeakTable_2_System_Threading_Tasks_TaskScheduler_System_Object___Fields {
    struct Ephemeron__Array *data;
    struct Object *_lock;
    int32_t size;
};

struct ConditionalWeakTable_2_System_Threading_Tasks_TaskScheduler_System_Object_ {
    struct ConditionalWeakTable_2_System_Threading_Tasks_TaskScheduler_System_Object___Class *klass;
    MonitorData *monitor;
    struct ConditionalWeakTable_2_System_Threading_Tasks_TaskScheduler_System_Object___Fields fields;
};

struct Ephemeron {
    struct Object *key;
    struct Object *value;
};

struct Ephemeron__Boxed {
    struct Ephemeron__Class *klass;
    MonitorData *monitor;
    struct Ephemeron fields;
};

struct Ephemeron__Array {
    struct Ephemeron__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Ephemeron vector[32];
};

struct EventHandler_1_System_Threading_Tasks_UnobservedTaskExceptionEventArgs___Fields {
    struct MulticastDelegate__Fields _;
};

struct EventHandler_1_System_Threading_Tasks_UnobservedTaskExceptionEventArgs_ {
    struct EventHandler_1_System_Threading_Tasks_UnobservedTaskExceptionEventArgs___Class *klass;
    MonitorData *monitor;
    struct EventHandler_1_System_Threading_Tasks_UnobservedTaskExceptionEventArgs___Fields fields;
};

struct __declspec(align(8)) UnobservedTaskExceptionEventArgs__Fields {
    struct AggregateException *m_exception;
    bool m_observed;
};

struct UnobservedTaskExceptionEventArgs {
    struct UnobservedTaskExceptionEventArgs__Class *klass;
    MonitorData *monitor;
    struct UnobservedTaskExceptionEventArgs__Fields fields;
};

struct __declspec(align(8)) Exception__Fields {
    struct String *_className;
    struct String *_message;
    struct IDictionary *_data;
    struct Exception *_innerException;
    struct String *_helpURL;
    struct Object *_stackTrace;
    struct String *_stackTraceString;
    struct String *_remoteStackTraceString;
    int32_t _remoteStackIndex;
    struct Object *_dynamicMethods;
    int32_t _HResult;
    struct String *_source;
    struct SafeSerializationManager *_safeSerializationManager;
    struct StackTrace__Array *captured_traces;
    struct IntPtr__Array *native_trace_ips;
};

struct Exception {
    struct Exception__Class *klass;
    MonitorData *monitor;
    struct Exception__Fields fields;
};

struct AggregateException__Fields {
    struct Exception__Fields _;
    struct ReadOnlyCollection_1_System_Exception_ *m_innerExceptions;
};

struct AggregateException {
    struct AggregateException__Class *klass;
    MonitorData *monitor;
    struct AggregateException__Fields fields;
};

struct IDictionary {
    struct IDictionary__Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) SafeSerializationManager__Fields {
    struct IList_1_System_Object_ *m_serializedStates;
    struct SerializationInfo *m_savedSerializationInfo;
    struct Object *m_realObject;
    struct RuntimeType *m_realType;
    struct EventHandler_1_System_Runtime_Serialization_SafeSerializationEventArgs_ *SerializeObjectState;
};

struct SafeSerializationManager {
    struct SafeSerializationManager__Class *klass;
    MonitorData *monitor;
    struct SafeSerializationManager__Fields fields;
};

struct IList_1_System_Object_ {
    struct IList_1_System_Object___Class *klass;
    MonitorData *monitor;
};

struct EventHandler_1_System_Runtime_Serialization_SafeSerializationEventArgs___Fields {
    struct MulticastDelegate__Fields _;
};

struct EventHandler_1_System_Runtime_Serialization_SafeSerializationEventArgs_ {
    struct EventHandler_1_System_Runtime_Serialization_SafeSerializationEventArgs___Class *klass;
    MonitorData *monitor;
    struct EventHandler_1_System_Runtime_Serialization_SafeSerializationEventArgs___Fields fields;
};

struct __declspec(align(8)) SafeSerializationEventArgs__Fields {
    struct StreamingContext m_streamingContext;
    struct List_1_System_Object_ *m_serializedStates;
};

struct SafeSerializationEventArgs {
    struct SafeSerializationEventArgs__Class *klass;
    MonitorData *monitor;
    struct SafeSerializationEventArgs__Fields fields;
};

struct __declspec(align(8)) List_1_System_Object___Fields {
    struct Object__Array *_items;
    int32_t _size;
    int32_t _version;
    struct Object *_syncRoot;
};

struct List_1_System_Object_ {
    struct List_1_System_Object___Class *klass;
    MonitorData *monitor;
    struct List_1_System_Object___Fields fields;
};

struct __declspec(align(8)) StackTrace__Fields {
    struct StackFrame__Array *frames;
    struct StackTrace__Array *captured_traces;
    bool debug_info;
};

struct StackTrace {
    struct StackTrace__Class *klass;
    MonitorData *monitor;
    struct StackTrace__Fields fields;
};

struct __declspec(align(8)) StackFrame__Fields {
    int32_t ilOffset;
    int32_t nativeOffset;
    int64_t methodAddress;
    uint32_t methodIndex;
    struct MethodBase *methodBase;
    struct String *fileName;
    int32_t lineNumber;
    int32_t columnNumber;
    struct String *internalMethodName;
};

struct StackFrame {
    struct StackFrame__Class *klass;
    MonitorData *monitor;
    struct StackFrame__Fields fields;
};

struct StackFrame__Array {
    struct StackFrame__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct StackFrame *vector[32];
};

struct StackTrace__Array {
    struct StackTrace__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct StackTrace *vector[32];
};

struct __declspec(align(8)) ReadOnlyCollection_1_System_Exception___Fields {
    struct IList_1_System_Exception_ *list;
    struct Object *_syncRoot;
};

struct ReadOnlyCollection_1_System_Exception_ {
    struct ReadOnlyCollection_1_System_Exception___Class *klass;
    MonitorData *monitor;
    struct ReadOnlyCollection_1_System_Exception___Fields fields;
};

struct IList_1_System_Exception_ {
    struct IList_1_System_Exception___Class *klass;
    MonitorData *monitor;
};

struct Exception__Array {
    struct Exception__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Exception *vector[32];
};

struct IEnumerator_1_System_Exception_ {
    struct IEnumerator_1_System_Exception___Class *klass;
    MonitorData *monitor;
};

#if defined(_CPLUSPLUS_)
enum ConcurrentExclusiveSchedulerPair_ProcessingMode__Enum : uint8_t {
    ConcurrentExclusiveSchedulerPair_ProcessingMode__Enum_NotCurrentlyProcessing = 0x00000000,
    ConcurrentExclusiveSchedulerPair_ProcessingMode__Enum_ProcessingExclusiveTask = 0x00000001,
    ConcurrentExclusiveSchedulerPair_ProcessingMode__Enum_ProcessingConcurrentTasks = 0x00000002,
    ConcurrentExclusiveSchedulerPair_ProcessingMode__Enum_Completing = 0x00000004,
    ConcurrentExclusiveSchedulerPair_ProcessingMode__Enum_Completed = 0x00000008,
};

#else
enum ConcurrentExclusiveSchedulerPair_ProcessingMode__Enum {
    ConcurrentExclusiveSchedulerPair_ProcessingMode__Enum_NotCurrentlyProcessing = 0x00000000,
    ConcurrentExclusiveSchedulerPair_ProcessingMode__Enum_ProcessingExclusiveTask = 0x00000001,
    ConcurrentExclusiveSchedulerPair_ProcessingMode__Enum_ProcessingConcurrentTasks = 0x00000002,
    ConcurrentExclusiveSchedulerPair_ProcessingMode__Enum_Completing = 0x00000004,
    ConcurrentExclusiveSchedulerPair_ProcessingMode__Enum_Completed = 0x00000008,
};

#endif
struct ConcurrentExclusiveSchedulerPair_ProcessingMode__Enum__Boxed {
    struct ConcurrentExclusiveSchedulerPair_ProcessingMode__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum ConcurrentExclusiveSchedulerPair_ProcessingMode__Enum value;
    #else
    uint8_t value;
    #endif
};

struct ConcurrentExclusiveSchedulerPair_ConcurrentExclusiveTaskScheduler__Fields {
    struct TaskScheduler__Fields _;
    struct ConcurrentExclusiveSchedulerPair *m_pair;
    int32_t m_maxConcurrencyLevel;
    #if defined(_CPLUSPLUS_)
    enum ConcurrentExclusiveSchedulerPair_ProcessingMode__Enum m_processingMode;
    #else
    uint8_t m_processingMode;
    #endif
    struct IProducerConsumerQueue_1_Task_ *m_tasks;
};

struct ConcurrentExclusiveSchedulerPair_ConcurrentExclusiveTaskScheduler {
    struct ConcurrentExclusiveSchedulerPair_ConcurrentExclusiveTaskScheduler__Class *klass;
    MonitorData *monitor;
    struct ConcurrentExclusiveSchedulerPair_ConcurrentExclusiveTaskScheduler__Fields fields;
};

struct Func_2_Object_Boolean___Fields {
    struct MulticastDelegate__Fields _;
};

struct Func_2_Object_Boolean_ {
    struct Func_2_Object_Boolean___Class *klass;
    MonitorData *monitor;
    struct Func_2_Object_Boolean___Fields fields;
};

struct __declspec(align(8)) ConcurrentExclusiveSchedulerPair__Fields {
    struct ConcurrentDictionary_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode_ *m_threadProcessingMapping;
    struct ConcurrentExclusiveSchedulerPair_ConcurrentExclusiveTaskScheduler *m_concurrentTaskScheduler;
    struct ConcurrentExclusiveSchedulerPair_ConcurrentExclusiveTaskScheduler *m_exclusiveTaskScheduler;
    struct TaskScheduler *m_underlyingTaskScheduler;
    int32_t m_maxConcurrencyLevel;
    int32_t m_maxItemsPerTask;
    int32_t m_processingCount;
    struct ConcurrentExclusiveSchedulerPair_CompletionState *m_completionState;
};

struct ConcurrentExclusiveSchedulerPair {
    struct ConcurrentExclusiveSchedulerPair__Class *klass;
    MonitorData *monitor;
    struct ConcurrentExclusiveSchedulerPair__Fields fields;
};

struct __declspec(align(8)) ConcurrentDictionary_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Fields {
    struct ConcurrentDictionary_2_TKey_TValue_Tables_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode_ *_tables;
    struct IEqualityComparer_1_System_Int32_ *_comparer;
    bool _growLockArray;
    int32_t _budget;
};

struct ConcurrentDictionary_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode_ {
    struct ConcurrentDictionary_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Class *klass;
    MonitorData *monitor;
    struct ConcurrentDictionary_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Fields fields;
};

struct __declspec(align(8)) ConcurrentDictionary_2_TKey_TValue_Tables_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Fields {
    struct ConcurrentDictionary_2_TKey_TValue_Node_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Array *_buckets;
    struct Object__Array *_locks;
    struct Int32__Array *_countPerLock;
};

struct ConcurrentDictionary_2_TKey_TValue_Tables_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode_ {
    struct ConcurrentDictionary_2_TKey_TValue_Tables_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Class *klass;
    MonitorData *monitor;
    struct ConcurrentDictionary_2_TKey_TValue_Tables_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Fields fields;
};

struct __declspec(align(8)) ConcurrentDictionary_2_TKey_TValue_Node_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Fields {
    int32_t _key;
    #if defined(_CPLUSPLUS_)
    enum ConcurrentExclusiveSchedulerPair_ProcessingMode__Enum _value;
    #else
    uint8_t _value;
    #endif
    struct ConcurrentDictionary_2_TKey_TValue_Node_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode_ *_next;
    int32_t _hashcode;
};

struct ConcurrentDictionary_2_TKey_TValue_Node_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode_ {
    struct ConcurrentDictionary_2_TKey_TValue_Node_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Class *klass;
    MonitorData *monitor;
    struct ConcurrentDictionary_2_TKey_TValue_Node_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Fields fields;
};

struct ConcurrentDictionary_2_TKey_TValue_Node_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Array {
    struct ConcurrentDictionary_2_TKey_TValue_Node_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct ConcurrentDictionary_2_TKey_TValue_Node_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode_ *vector[32];
};

struct ICollection_1_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode_ {
    struct ICollection_1_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Class *klass;
    MonitorData *monitor;
};

struct KeyValuePair_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode_ {
    int32_t key;
    #if defined(_CPLUSPLUS_)
    enum ConcurrentExclusiveSchedulerPair_ProcessingMode__Enum value;
    #else
    uint8_t value;
    #endif
};

struct KeyValuePair_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Boxed {
    struct KeyValuePair_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Class *klass;
    MonitorData *monitor;
    struct KeyValuePair_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode_ fields;
};

struct KeyValuePair_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Array {
    struct KeyValuePair_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct KeyValuePair_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode_ vector[32];
};

struct IEnumerator_1_KeyValuePair_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode_ {
    struct IEnumerator_1_KeyValuePair_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode_ {
    struct IEnumerable_1_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) TaskCompletionSource_1_VoidTaskResult___Fields {
    struct Task_1_VoidTaskResult_ *m_task;
};

struct TaskCompletionSource_1_VoidTaskResult_ {
    struct TaskCompletionSource_1_VoidTaskResult___Class *klass;
    MonitorData *monitor;
    struct TaskCompletionSource_1_VoidTaskResult___Fields fields;
};

struct ConcurrentExclusiveSchedulerPair_CompletionState__Fields {
    struct TaskCompletionSource_1_VoidTaskResult___Fields _;
    bool m_completionRequested;
    bool m_completionQueued;
    struct List_1_System_Exception_ *m_exceptions;
};

struct ConcurrentExclusiveSchedulerPair_CompletionState {
    struct ConcurrentExclusiveSchedulerPair_CompletionState__Class *klass;
    MonitorData *monitor;
    struct ConcurrentExclusiveSchedulerPair_CompletionState__Fields fields;
};

struct VoidTaskResult {
};

struct VoidTaskResult__Boxed {
    struct VoidTaskResult__Class *klass;
    MonitorData *monitor;
    struct VoidTaskResult fields;
};

struct Task_1_VoidTaskResult___Fields {
    struct Task__Fields _;
    struct VoidTaskResult m_result;
};

struct Task_1_VoidTaskResult_ {
    struct Task_1_VoidTaskResult___Class *klass;
    MonitorData *monitor;
    struct Task_1_VoidTaskResult___Fields fields;
};

struct __declspec(align(8)) TaskFactory_1_VoidTaskResult___Fields {
    struct CancellationToken m_defaultCancellationToken;
    struct TaskScheduler *m_defaultScheduler;
    #if defined(_CPLUSPLUS_)
    enum TaskCreationOptions__Enum m_defaultCreationOptions;
    #else
    uint32_t m_defaultCreationOptions;
    #endif
    #if defined(_CPLUSPLUS_)
    enum TaskContinuationOptions__Enum m_defaultContinuationOptions;
    #else
    uint32_t m_defaultContinuationOptions;
    #endif
};

struct TaskFactory_1_VoidTaskResult_ {
    struct TaskFactory_1_VoidTaskResult___Class *klass;
    MonitorData *monitor;
    struct TaskFactory_1_VoidTaskResult___Fields fields;
};

struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1___Fields {
    struct MulticastDelegate__Fields _;
};

struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1_ {
    struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1___Class *klass;
    MonitorData *monitor;
    struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1___Fields fields;
};

struct Task_1_Task___Fields {
    struct Task__Fields _;
    struct Task *m_result;
};

struct Task_1_Task_ {
    struct Task_1_Task___Class *klass;
    MonitorData *monitor;
    struct Task_1_Task___Fields fields;
};

struct __declspec(align(8)) TaskFactory_1_Task___Fields {
    struct CancellationToken m_defaultCancellationToken;
    struct TaskScheduler *m_defaultScheduler;
    #if defined(_CPLUSPLUS_)
    enum TaskCreationOptions__Enum m_defaultCreationOptions;
    #else
    uint32_t m_defaultCreationOptions;
    #endif
    #if defined(_CPLUSPLUS_)
    enum TaskContinuationOptions__Enum m_defaultContinuationOptions;
    #else
    uint32_t m_defaultContinuationOptions;
    #endif
};

struct TaskFactory_1_Task_ {
    struct TaskFactory_1_Task___Class *klass;
    MonitorData *monitor;
    struct TaskFactory_1_Task___Fields fields;
};

struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__1__Fields {
    struct MulticastDelegate__Fields _;
};

struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__1 {
    struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__1__Class *klass;
    MonitorData *monitor;
    struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__1__Fields fields;
};

struct SystemException__Fields {
    struct Exception__Fields _;
};

struct SystemException {
    struct SystemException__Class *klass;
    MonitorData *monitor;
    struct SystemException__Fields fields;
};

struct ThreadAbortException__Fields {
    struct SystemException__Fields _;
};

struct ThreadAbortException {
    struct ThreadAbortException__Class *klass;
    MonitorData *monitor;
    struct ThreadAbortException__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum InternalTaskOptions__Enum : int32_t {
    InternalTaskOptions__Enum_None = 0x00000000,
    InternalTaskOptions__Enum_InternalOptionsMask = 0x0000ff00,
    InternalTaskOptions__Enum_ChildReplica = 0x00000100,
    InternalTaskOptions__Enum_ContinuationTask = 0x00000200,
    InternalTaskOptions__Enum_PromiseTask = 0x00000400,
    InternalTaskOptions__Enum_SelfReplicating = 0x00000800,
    InternalTaskOptions__Enum_LazyCancellation = 0x00001000,
    InternalTaskOptions__Enum_QueuedByRuntime = 0x00002000,
    InternalTaskOptions__Enum_DoNotDispose = 0x00004000,
};

#else
enum InternalTaskOptions__Enum {
    InternalTaskOptions__Enum_None = 0x00000000,
    InternalTaskOptions__Enum_InternalOptionsMask = 0x0000ff00,
    InternalTaskOptions__Enum_ChildReplica = 0x00000100,
    InternalTaskOptions__Enum_ContinuationTask = 0x00000200,
    InternalTaskOptions__Enum_PromiseTask = 0x00000400,
    InternalTaskOptions__Enum_SelfReplicating = 0x00000800,
    InternalTaskOptions__Enum_LazyCancellation = 0x00001000,
    InternalTaskOptions__Enum_QueuedByRuntime = 0x00002000,
    InternalTaskOptions__Enum_DoNotDispose = 0x00004000,
};

#endif
struct InternalTaskOptions__Enum__Boxed {
    struct InternalTaskOptions__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum InternalTaskOptions__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) List_1_System_Exception___Fields {
    struct Exception__Array *_items;
    int32_t _size;
    int32_t _version;
    struct Object *_syncRoot;
};

struct List_1_System_Exception_ {
    struct List_1_System_Exception___Class *klass;
    MonitorData *monitor;
    struct List_1_System_Exception___Fields fields;
};

struct IProducerConsumerQueue_1_Task_ {
    struct IProducerConsumerQueue_1_Task___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_Threading_Tasks_Task_ {
    struct IEnumerable_1_System_Threading_Tasks_Task___Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) Dictionary_2_System_Int32_System_Threading_Tasks_Task___Fields {
    struct Int32__Array *buckets;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Threading_Tasks_Task___Array *entries;
    int32_t count;
    int32_t version;
    int32_t freeList;
    int32_t freeCount;
    struct IEqualityComparer_1_System_Int32_ *comparer;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_Threading_Tasks_Task_ *keys;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_Threading_Tasks_Task_ *values;
    struct Object *_syncRoot;
};

struct Dictionary_2_System_Int32_System_Threading_Tasks_Task_ {
    struct Dictionary_2_System_Int32_System_Threading_Tasks_Task___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_System_Int32_System_Threading_Tasks_Task___Fields fields;
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Threading_Tasks_Task_ {
    int32_t hashCode;
    int32_t next;
    int32_t key;
    struct Task *value;
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Threading_Tasks_Task___Boxed {
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Threading_Tasks_Task___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Threading_Tasks_Task_ fields;
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Threading_Tasks_Task___Array {
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Threading_Tasks_Task___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Threading_Tasks_Task_ vector[32];
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_Threading_Tasks_Task___Fields {
    struct Dictionary_2_System_Int32_System_Threading_Tasks_Task_ *dictionary;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_Threading_Tasks_Task_ {
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_Threading_Tasks_Task___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_Threading_Tasks_Task___Fields fields;
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_Threading_Tasks_Task___Fields {
    struct Dictionary_2_System_Int32_System_Threading_Tasks_Task_ *dictionary;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_Threading_Tasks_Task_ {
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_Threading_Tasks_Task___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_Threading_Tasks_Task___Fields fields;
};

struct Task__Array {
    struct Task__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Task *vector[32];
};

struct IEnumerator_1_System_Threading_Tasks_Task_ {
    struct IEnumerator_1_System_Threading_Tasks_Task___Class *klass;
    MonitorData *monitor;
};

struct ICollection_1_System_Threading_Tasks_Task_ {
    struct ICollection_1_System_Threading_Tasks_Task___Class *klass;
    MonitorData *monitor;
};

struct KeyValuePair_2_System_Int32_System_Threading_Tasks_Task_ {
    int32_t key;
    struct Task *value;
};

struct KeyValuePair_2_System_Int32_System_Threading_Tasks_Task___Boxed {
    struct KeyValuePair_2_System_Int32_System_Threading_Tasks_Task___Class *klass;
    MonitorData *monitor;
    struct KeyValuePair_2_System_Int32_System_Threading_Tasks_Task_ fields;
};

struct KeyValuePair_2_System_Int32_System_Threading_Tasks_Task___Array {
    struct KeyValuePair_2_System_Int32_System_Threading_Tasks_Task___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct KeyValuePair_2_System_Int32_System_Threading_Tasks_Task_ vector[32];
};

struct IEnumerator_1_KeyValuePair_2_System_Int32_System_Threading_Tasks_Task_ {
    struct IEnumerator_1_KeyValuePair_2_System_Int32_System_Threading_Tasks_Task___Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) Task_ContingentProperties__Fields {
    struct ExecutionContext *m_capturedContext;
    struct ManualResetEventSlim *m_completionEvent;
    struct TaskExceptionHolder *m_exceptionsHolder;
    struct CancellationToken m_cancellationToken;
    struct Shared_1_System_Threading_CancellationTokenRegistration_ *m_cancellationRegistration;
    int32_t m_internalCancellationRequested;
    int32_t m_completionCountdown;
    struct List_1_System_Threading_Tasks_Task_ *m_exceptionalChildren;
};

struct Task_ContingentProperties {
    struct Task_ContingentProperties__Class *klass;
    MonitorData *monitor;
    struct Task_ContingentProperties__Fields fields;
};

struct __declspec(align(8)) ManualResetEventSlim__Fields {
    struct Object *m_lock;
    struct ManualResetEvent *m_eventObj;
    int32_t m_combinedState;
};

struct ManualResetEventSlim {
    struct ManualResetEventSlim__Class *klass;
    MonitorData *monitor;
    struct ManualResetEventSlim__Fields fields;
};

struct __declspec(align(8)) TaskExceptionHolder__Fields {
    struct Task *m_task;
    struct List_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo_ *m_faultExceptions;
    struct ExceptionDispatchInfo *m_cancellationException;
    bool m_isHandled;
};

struct TaskExceptionHolder {
    struct TaskExceptionHolder__Class *klass;
    MonitorData *monitor;
    struct TaskExceptionHolder__Fields fields;
};

struct EventHandler__Fields {
    struct MulticastDelegate__Fields _;
};

struct EventHandler {
    struct EventHandler__Class *klass;
    MonitorData *monitor;
    struct EventHandler__Fields fields;
};

struct __declspec(align(8)) List_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo___Fields {
    struct ExceptionDispatchInfo__Array *_items;
    int32_t _size;
    int32_t _version;
    struct Object *_syncRoot;
};

struct List_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo_ {
    struct List_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo___Class *klass;
    MonitorData *monitor;
    struct List_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo___Fields fields;
};

struct __declspec(align(8)) ExceptionDispatchInfo__Fields {
    struct Exception *m_Exception;
    struct Object *m_stackTrace;
};

struct ExceptionDispatchInfo {
    struct ExceptionDispatchInfo__Class *klass;
    MonitorData *monitor;
    struct ExceptionDispatchInfo__Fields fields;
};

struct ExceptionDispatchInfo__Array {
    struct ExceptionDispatchInfo__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct ExceptionDispatchInfo *vector[32];
};

struct IEnumerator_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo_ {
    struct IEnumerator_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo___Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) Shared_1_System_Threading_CancellationTokenRegistration___Fields {
    struct CancellationTokenRegistration Value;
};

struct Shared_1_System_Threading_CancellationTokenRegistration_ {
    struct Shared_1_System_Threading_CancellationTokenRegistration___Class *klass;
    MonitorData *monitor;
    struct Shared_1_System_Threading_CancellationTokenRegistration___Fields fields;
};

struct __declspec(align(8)) List_1_System_Threading_Tasks_Task___Fields {
    struct Task__Array *_items;
    int32_t _size;
    int32_t _version;
    struct Object *_syncRoot;
};

struct List_1_System_Threading_Tasks_Task_ {
    struct List_1_System_Threading_Tasks_Task___Class *klass;
    MonitorData *monitor;
    struct List_1_System_Threading_Tasks_Task___Fields fields;
};

struct Func_1_System_Threading_Tasks_Task_ContingentProperties___Fields {
    struct MulticastDelegate__Fields _;
};

struct Func_1_System_Threading_Tasks_Task_ContingentProperties_ {
    struct Func_1_System_Threading_Tasks_Task_ContingentProperties___Class *klass;
    MonitorData *monitor;
    struct Func_1_System_Threading_Tasks_Task_ContingentProperties___Fields fields;
};

struct Predicate_1_System_Threading_Tasks_Task___Fields {
    struct MulticastDelegate__Fields _;
};

struct Predicate_1_System_Threading_Tasks_Task_ {
    struct Predicate_1_System_Threading_Tasks_Task___Class *klass;
    MonitorData *monitor;
    struct Predicate_1_System_Threading_Tasks_Task___Fields fields;
};

struct Predicate_1_Object___Fields {
    struct MulticastDelegate__Fields _;
};

struct Predicate_1_Object_ {
    struct Predicate_1_Object___Class *klass;
    MonitorData *monitor;
    struct Predicate_1_Object___Fields fields;
};

struct __declspec(align(8)) TaskFactory_1_System_Int32___Fields {
    struct CancellationToken m_defaultCancellationToken;
    struct TaskScheduler *m_defaultScheduler;
    #if defined(_CPLUSPLUS_)
    enum TaskCreationOptions__Enum m_defaultCreationOptions;
    #else
    uint32_t m_defaultCreationOptions;
    #endif
    #if defined(_CPLUSPLUS_)
    enum TaskContinuationOptions__Enum m_defaultContinuationOptions;
    #else
    uint32_t m_defaultContinuationOptions;
    #endif
};

struct TaskFactory_1_System_Int32_ {
    struct TaskFactory_1_System_Int32___Class *klass;
    MonitorData *monitor;
    struct TaskFactory_1_System_Int32___Fields fields;
};

struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__2__Fields {
    struct MulticastDelegate__Fields _;
};

struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__2 {
    struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__2__Class *klass;
    MonitorData *monitor;
    struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__2__Fields fields;
};

struct __declspec(align(8)) SemaphoreSlim__Fields {
    int32_t m_currentCount;
    int32_t m_maxCount;
    int32_t m_waitCount;
    struct Object *m_lockObj;
    struct ManualResetEvent *m_waitHandle;
    struct SemaphoreSlim_TaskNode *m_asyncHead;
    struct SemaphoreSlim_TaskNode *m_asyncTail;
};

struct SemaphoreSlim {
    struct SemaphoreSlim__Class *klass;
    MonitorData *monitor;
    struct SemaphoreSlim__Fields fields;
};

struct Task_1_System_Boolean___Fields {
    struct Task__Fields _;
    bool m_result;
};

struct Task_1_System_Boolean_ {
    struct Task_1_System_Boolean___Class *klass;
    MonitorData *monitor;
    struct Task_1_System_Boolean___Fields fields;
};

struct SemaphoreSlim_TaskNode__Fields {
    struct Task_1_System_Boolean___Fields _;
    struct SemaphoreSlim_TaskNode *Prev;
    struct SemaphoreSlim_TaskNode *Next;
};

struct SemaphoreSlim_TaskNode {
    struct SemaphoreSlim_TaskNode__Class *klass;
    MonitorData *monitor;
    struct SemaphoreSlim_TaskNode__Fields fields;
};

struct __declspec(align(8)) TaskFactory_1_System_Boolean___Fields {
    struct CancellationToken m_defaultCancellationToken;
    struct TaskScheduler *m_defaultScheduler;
    #if defined(_CPLUSPLUS_)
    enum TaskCreationOptions__Enum m_defaultCreationOptions;
    #else
    uint32_t m_defaultCreationOptions;
    #endif
    #if defined(_CPLUSPLUS_)
    enum TaskContinuationOptions__Enum m_defaultContinuationOptions;
    #else
    uint32_t m_defaultContinuationOptions;
    #endif
};

struct TaskFactory_1_System_Boolean_ {
    struct TaskFactory_1_System_Boolean___Class *klass;
    MonitorData *monitor;
    struct TaskFactory_1_System_Boolean___Fields fields;
};

struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__3__Fields {
    struct MulticastDelegate__Fields _;
};

struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__3 {
    struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__3__Class *klass;
    MonitorData *monitor;
    struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__3__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum FileAccess__Enum : int32_t {
    FileAccess__Enum_Read = 0x00000001,
    FileAccess__Enum_Write = 0x00000002,
    FileAccess__Enum_ReadWrite = 0x00000003,
};

#else
enum FileAccess__Enum {
    FileAccess__Enum_Read = 0x00000001,
    FileAccess__Enum_Write = 0x00000002,
    FileAccess__Enum_ReadWrite = 0x00000003,
};

#endif
struct FileAccess__Enum__Boxed {
    struct FileAccess__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum FileAccess__Enum value;
    #else
    uint32_t value;
    #endif
};

struct UnmanagedMemoryStream__Fields {
    struct Stream__Fields _;
    struct SafeBuffer *_buffer;
    uint8_t *_mem;
    int64_t _length;
    int64_t _capacity;
    int64_t _position;
    int64_t _offset;
    #if defined(_CPLUSPLUS_)
    enum FileAccess__Enum _access;
    #else
    uint32_t _access;
    #endif
    bool _isOpen;
    struct Task_1_System_Int32_ *_lastReadTask;
};

struct UnmanagedMemoryStream {
    struct UnmanagedMemoryStream__Class *klass;
    MonitorData *monitor;
    struct UnmanagedMemoryStream__Fields fields;
};

struct SafeBuffer__Fields {
    struct SafeHandleZeroOrMinusOneIsInvalid__Fields _;
    uint64_t byte_length;
    uint8_t *last_byte;
    bool inited;
};

struct SafeBuffer {
    struct SafeBuffer__Class *klass;
    MonitorData *monitor;
    struct SafeBuffer__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum SeekOrigin__Enum : int32_t {
    SeekOrigin__Enum_Begin = 0x00000000,
    SeekOrigin__Enum_Current = 0x00000001,
    SeekOrigin__Enum_End = 0x00000002,
};

#else
enum SeekOrigin__Enum {
    SeekOrigin__Enum_Begin = 0x00000000,
    SeekOrigin__Enum_Current = 0x00000001,
    SeekOrigin__Enum_End = 0x00000002,
};

#endif
struct SeekOrigin__Enum__Boxed {
    struct SeekOrigin__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum SeekOrigin__Enum value;
    #else
    uint32_t value;
    #endif
};

struct Span_1_Byte_ {
    struct Pinnable_1_Byte_ *_pinnable;
    void *_byteOffset;
    int32_t _length;
};

struct Span_1_Byte___Boxed {
    struct Span_1_Byte___Class *klass;
    MonitorData *monitor;
    struct Span_1_Byte_ fields;
};

struct __declspec(align(8)) Pinnable_1_Byte___Fields {
    uint8_t Data;
};

struct Pinnable_1_Byte_ {
    struct Pinnable_1_Byte___Class *klass;
    MonitorData *monitor;
    struct Pinnable_1_Byte___Fields fields;
};

struct ReadOnlySpan_1_Byte_ {
    struct Pinnable_1_Byte_ *_pinnable;
    void *_byteOffset;
    int32_t _length;
};

struct ReadOnlySpan_1_Byte___Boxed {
    struct ReadOnlySpan_1_Byte___Class *klass;
    MonitorData *monitor;
    struct ReadOnlySpan_1_Byte_ fields;
};

struct ValueTask_1_System_Int32_ {
    struct Task_1_System_Int32_ *_task;
    int32_t _result;
};

struct ValueTask_1_System_Int32___Boxed {
    struct ValueTask_1_System_Int32___Class *klass;
    MonitorData *monitor;
    struct ValueTask_1_System_Int32_ fields;
};

struct Memory_1_Byte_ {
    struct Object *_arrayOrOwnedMemory;
    int32_t _index;
    int32_t _length;
};

struct Memory_1_Byte___Boxed {
    struct Memory_1_Byte___Class *klass;
    MonitorData *monitor;
    struct Memory_1_Byte_ fields;
};

struct ReadOnlyMemory_1_Byte_ {
    struct Object *_arrayOrOwnedMemory;
    int32_t _index;
    int32_t _length;
};

struct ReadOnlyMemory_1_Byte___Boxed {
    struct ReadOnlyMemory_1_Byte___Class *klass;
    MonitorData *monitor;
    struct ReadOnlyMemory_1_Byte_ fields;
};

struct RSAManaged__Fields {
    struct RSA__Fields _;
    bool isCRTpossible;
    bool keyBlinding;
    bool keypairGenerated;
    bool m_disposed;
    struct BigInteger *d;
    struct BigInteger *p;
    struct BigInteger *q;
    struct BigInteger *dp;
    struct BigInteger *dq;
    struct BigInteger *qInv;
    struct BigInteger *n;
    struct BigInteger *e;
    struct RSAManaged_KeyGeneratedEventHandler *KeyGenerated;
};

struct RSAManaged {
    struct RSAManaged__Class *klass;
    MonitorData *monitor;
    struct RSAManaged__Fields fields;
};

struct __declspec(align(8)) BigInteger__Fields {
    uint32_t length;
    struct UInt32__Array *data;
};

struct BigInteger {
    struct BigInteger__Class *klass;
    MonitorData *monitor;
    struct BigInteger__Fields fields;
};

struct RSAManaged_KeyGeneratedEventHandler__Fields {
    struct MulticastDelegate__Fields _;
};

struct RSAManaged_KeyGeneratedEventHandler {
    struct RSAManaged_KeyGeneratedEventHandler__Class *klass;
    MonitorData *monitor;
    struct RSAManaged_KeyGeneratedEventHandler__Fields fields;
};

struct RSAParameters {
    struct Byte__Array *Exponent;
    struct Byte__Array *Modulus;
    struct Byte__Array *P;
    struct Byte__Array *Q;
    struct Byte__Array *DP;
    struct Byte__Array *DQ;
    struct Byte__Array *InverseQ;
    struct Byte__Array *D;
};

struct RSAParameters__Boxed {
    struct RSAParameters__Class *klass;
    MonitorData *monitor;
    struct RSAParameters fields;
};

struct __declspec(align(8)) Version__Fields {
    int32_t _Major;
    int32_t _Minor;
    int32_t _Build;
    int32_t _Revision;
};

struct Version {
    struct Version__Class *klass;
    MonitorData *monitor;
    struct Version__Fields fields;
};

struct FileStream__Fields {
    struct Stream__Fields _;
    struct Byte__Array *buf;
    struct String *name;
    struct SafeFileHandle *safeHandle;
    bool isExposed;
    int64_t append_startpos;
    #if defined(_CPLUSPLUS_)
    enum FileAccess__Enum access;
    #else
    uint32_t access;
    #endif
    bool owner;
    bool async;
    bool canseek;
    bool anonymous;
    bool buf_dirty;
    int32_t buf_size;
    int32_t buf_length;
    int32_t buf_offset;
    int64_t buf_start;
};

struct FileStream {
    struct FileStream__Class *klass;
    MonitorData *monitor;
    struct FileStream__Fields fields;
};

struct FileStream__Array {
    struct FileStream__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct FileStream *vector[32];
};

#if defined(_CPLUSPLUS_)
enum ResourceLocation__Enum : int32_t {
    ResourceLocation__Enum_Embedded = 0x00000001,
    ResourceLocation__Enum_ContainedInAnotherAssembly = 0x00000002,
    ResourceLocation__Enum_ContainedInManifestFile = 0x00000004,
};

#else
enum ResourceLocation__Enum {
    ResourceLocation__Enum_Embedded = 0x00000001,
    ResourceLocation__Enum_ContainedInAnotherAssembly = 0x00000002,
    ResourceLocation__Enum_ContainedInManifestFile = 0x00000004,
};

#endif
struct ResourceLocation__Enum__Boxed {
    struct ResourceLocation__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum ResourceLocation__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) ManifestResourceInfo__Fields {
    struct Assembly *_containingAssembly;
    struct String *_containingFileName;
    #if defined(_CPLUSPLUS_)
    enum ResourceLocation__Enum _resourceLocation;
    #else
    uint32_t _resourceLocation;
    #endif
};

struct ManifestResourceInfo {
    struct ManifestResourceInfo__Class *klass;
    MonitorData *monitor;
    struct ManifestResourceInfo__Fields fields;
};

struct Module__Array {
    struct Module__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Module *vector[32];
};

struct AssemblyName__Array {
    struct AssemblyName__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct AssemblyName *vector[32];
};

struct __declspec(align(8)) Evidence__Fields {
    bool _locked;
    struct ArrayList *hostEvidenceList;
    struct ArrayList *assemblyEvidenceList;
};

struct Evidence {
    struct Evidence__Class *klass;
    MonitorData *monitor;
    struct Evidence__Fields fields;
};

struct __declspec(align(8)) ArrayList__Fields {
    struct Object__Array *_items;
    int32_t _size;
    int32_t _version;
    struct Object *_syncRoot;
};

struct ArrayList {
    struct ArrayList__Class *klass;
    MonitorData *monitor;
    struct ArrayList__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum SecurityRuleSet__Enum : uint8_t {
    SecurityRuleSet__Enum_None = 0x00000000,
    SecurityRuleSet__Enum_Level1 = 0x00000001,
    SecurityRuleSet__Enum_Level2 = 0x00000002,
};

#else
enum SecurityRuleSet__Enum {
    SecurityRuleSet__Enum_None = 0x00000000,
    SecurityRuleSet__Enum_Level1 = 0x00000001,
    SecurityRuleSet__Enum_Level2 = 0x00000002,
};

#endif
struct SecurityRuleSet__Enum__Boxed {
    struct SecurityRuleSet__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum SecurityRuleSet__Enum value;
    #else
    uint8_t value;
    #endif
};

struct IEnumerable_1_System_Reflection_TypeInfo_ {
    struct IEnumerable_1_System_Reflection_TypeInfo___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_Type_ {
    struct IEnumerable_1_System_Type___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_Reflection_Module_ {
    struct IEnumerable_1_System_Reflection_Module___Class *klass;
    MonitorData *monitor;
};

#if defined(_CPLUSPLUS_)
enum PermissionState__Enum : int32_t {
    PermissionState__Enum_Unrestricted = 0x00000001,
    PermissionState__Enum_None = 0x00000000,
};

#else
enum PermissionState__Enum {
    PermissionState__Enum_Unrestricted = 0x00000001,
    PermissionState__Enum_None = 0x00000000,
};

#endif
struct PermissionState__Enum__Boxed {
    struct PermissionState__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum PermissionState__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) PermissionSet__Fields {
    #if defined(_CPLUSPLUS_)
    enum PermissionState__Enum state;
    #else
    uint32_t state;
    #endif
    struct ArrayList *list;
    struct PolicyLevel *_policyLevel;
    bool _declsec;
    bool _readOnly;
    struct Boolean__Array *_ignored;
};

struct PermissionSet {
    struct PermissionSet__Class *klass;
    MonitorData *monitor;
    struct PermissionSet__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum PolicyLevelType__Enum : int32_t {
    PolicyLevelType__Enum_User = 0x00000000,
    PolicyLevelType__Enum_Machine = 0x00000001,
    PolicyLevelType__Enum_Enterprise = 0x00000002,
    PolicyLevelType__Enum_AppDomain = 0x00000003,
};

#else
enum PolicyLevelType__Enum {
    PolicyLevelType__Enum_User = 0x00000000,
    PolicyLevelType__Enum_Machine = 0x00000001,
    PolicyLevelType__Enum_Enterprise = 0x00000002,
    PolicyLevelType__Enum_AppDomain = 0x00000003,
};

#endif
struct PolicyLevelType__Enum__Boxed {
    struct PolicyLevelType__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum PolicyLevelType__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) PolicyLevel__Fields {
    struct String *label;
    struct CodeGroup *root_code_group;
    struct ArrayList *full_trust_assemblies;
    struct ArrayList *named_permission_sets;
    struct String *_location;
    #if defined(_CPLUSPLUS_)
    enum PolicyLevelType__Enum _type;
    #else
    uint32_t _type;
    #endif
    struct Hashtable *fullNames;
    struct SecurityElement *xml;
};

struct PolicyLevel {
    struct PolicyLevel__Class *klass;
    MonitorData *monitor;
    struct PolicyLevel__Fields fields;
};

struct __declspec(align(8)) CodeGroup__Fields {
    struct PolicyStatement *m_policy;
    struct IMembershipCondition *m_membershipCondition;
    struct String *m_description;
    struct String *m_name;
    struct ArrayList *m_children;
};

struct CodeGroup {
    struct CodeGroup__Class *klass;
    MonitorData *monitor;
    struct CodeGroup__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum PolicyStatementAttribute__Enum : int32_t {
    PolicyStatementAttribute__Enum_Nothing = 0x00000000,
    PolicyStatementAttribute__Enum_Exclusive = 0x00000001,
    PolicyStatementAttribute__Enum_LevelFinal = 0x00000002,
    PolicyStatementAttribute__Enum_All = 0x00000003,
};

#else
enum PolicyStatementAttribute__Enum {
    PolicyStatementAttribute__Enum_Nothing = 0x00000000,
    PolicyStatementAttribute__Enum_Exclusive = 0x00000001,
    PolicyStatementAttribute__Enum_LevelFinal = 0x00000002,
    PolicyStatementAttribute__Enum_All = 0x00000003,
};

#endif
struct PolicyStatementAttribute__Enum__Boxed {
    struct PolicyStatementAttribute__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum PolicyStatementAttribute__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) PolicyStatement__Fields {
    struct PermissionSet *perms;
    #if defined(_CPLUSPLUS_)
    enum PolicyStatementAttribute__Enum attrs;
    #else
    uint32_t attrs;
    #endif
};

struct PolicyStatement {
    struct PolicyStatement__Class *klass;
    MonitorData *monitor;
    struct PolicyStatement__Fields fields;
};

struct __declspec(align(8)) SecurityElement__Fields {
    struct String *text;
    struct String *tag;
    struct ArrayList *attributes;
    struct ArrayList *children;
};

struct SecurityElement {
    struct SecurityElement__Class *klass;
    MonitorData *monitor;
    struct SecurityElement__Fields fields;
};

struct IMembershipCondition {
    struct IMembershipCondition__Class *klass;
    MonitorData *monitor;
};

#if defined(_CPLUSPLUS_)
enum FileIOPermissionAccess__Enum : int32_t {
    FileIOPermissionAccess__Enum_NoAccess = 0x00000000,
    FileIOPermissionAccess__Enum_Read = 0x00000001,
    FileIOPermissionAccess__Enum_Write = 0x00000002,
    FileIOPermissionAccess__Enum_Append = 0x00000004,
    FileIOPermissionAccess__Enum_PathDiscovery = 0x00000008,
    FileIOPermissionAccess__Enum_AllAccess = 0x0000000f,
};

#else
enum FileIOPermissionAccess__Enum {
    FileIOPermissionAccess__Enum_NoAccess = 0x00000000,
    FileIOPermissionAccess__Enum_Read = 0x00000001,
    FileIOPermissionAccess__Enum_Write = 0x00000002,
    FileIOPermissionAccess__Enum_Append = 0x00000004,
    FileIOPermissionAccess__Enum_PathDiscovery = 0x00000008,
    FileIOPermissionAccess__Enum_AllAccess = 0x0000000f,
};

#endif
struct FileIOPermissionAccess__Enum__Boxed {
    struct FileIOPermissionAccess__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum FileIOPermissionAccess__Enum value;
    #else
    uint32_t value;
    #endif
};

struct FileCodeGroup__Fields {
    struct CodeGroup__Fields _;
    #if defined(_CPLUSPLUS_)
    enum FileIOPermissionAccess__Enum m_access;
    #else
    uint32_t m_access;
    #endif
};

struct FileCodeGroup {
    struct FileCodeGroup__Class *klass;
    MonitorData *monitor;
    struct FileCodeGroup__Fields fields;
};

struct IPermission {
    struct IPermission__Class *klass;
    MonitorData *monitor;
};

#if defined(_CPLUSPLUS_)
enum PortableExecutableKinds__Enum : int32_t {
    PortableExecutableKinds__Enum_NotAPortableExecutableImage = 0x00000000,
    PortableExecutableKinds__Enum_ILOnly = 0x00000001,
    PortableExecutableKinds__Enum_Required32Bit = 0x00000002,
    PortableExecutableKinds__Enum_PE32Plus = 0x00000004,
    PortableExecutableKinds__Enum_Unmanaged32Bit = 0x00000008,
    PortableExecutableKinds__Enum_Preferred32Bit = 0x00000010,
};

#else
enum PortableExecutableKinds__Enum {
    PortableExecutableKinds__Enum_NotAPortableExecutableImage = 0x00000000,
    PortableExecutableKinds__Enum_ILOnly = 0x00000001,
    PortableExecutableKinds__Enum_Required32Bit = 0x00000002,
    PortableExecutableKinds__Enum_PE32Plus = 0x00000004,
    PortableExecutableKinds__Enum_Unmanaged32Bit = 0x00000008,
    PortableExecutableKinds__Enum_Preferred32Bit = 0x00000010,
};

#endif
struct PortableExecutableKinds__Enum__Boxed {
    struct PortableExecutableKinds__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum PortableExecutableKinds__Enum value;
    #else
    uint32_t value;
    #endif
};

#if defined(_CPLUSPLUS_)
enum ImageFileMachine__Enum : int32_t {
    ImageFileMachine__Enum_I386 = 0x0000014c,
    ImageFileMachine__Enum_IA64 = 0x00000200,
    ImageFileMachine__Enum_AMD64 = 0x00008664,
    ImageFileMachine__Enum_ARM = 0x000001c4,
};

#else
enum ImageFileMachine__Enum {
    ImageFileMachine__Enum_I386 = 0x0000014c,
    ImageFileMachine__Enum_IA64 = 0x00000200,
    ImageFileMachine__Enum_AMD64 = 0x00008664,
    ImageFileMachine__Enum_ARM = 0x000001c4,
};

#endif
struct ImageFileMachine__Enum__Boxed {
    struct ImageFileMachine__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum ImageFileMachine__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) X509Certificate__Fields {
    struct X509CertificateImpl *impl;
    bool hideDates;
    struct String *issuer_name;
    struct String *subject_name;
};

struct X509Certificate {
    struct X509Certificate__Class *klass;
    MonitorData *monitor;
    struct X509Certificate__Fields fields;
};

struct __declspec(align(8)) X509CertificateImpl__Fields {
    struct Byte__Array *cachedCertificateHash;
};

struct X509CertificateImpl {
    struct X509CertificateImpl__Class *klass;
    MonitorData *monitor;
    struct X509CertificateImpl__Fields fields;
};

struct X509CertificateImplMono__Fields {
    struct X509CertificateImpl__Fields _;
    struct X509Certificate_1 *x509;
};

struct X509CertificateImplMono {
    struct X509CertificateImplMono__Class *klass;
    MonitorData *monitor;
    struct X509CertificateImplMono__Fields fields;
};

struct __declspec(align(8)) X509Certificate_1__Fields {
    struct ASN1 *decoder;
    struct Byte__Array *m_encodedcert;
    struct DateTime m_from;
    struct DateTime m_until;
    struct ASN1 *issuer;
    struct String *m_issuername;
    struct String *m_keyalgo;
    struct Byte__Array *m_keyalgoparams;
    struct ASN1 *subject;
    struct String *m_subject;
    struct Byte__Array *m_publickey;
    struct Byte__Array *signature;
    struct String *m_signaturealgo;
    struct Byte__Array *m_signaturealgoparams;
    struct Byte__Array *certhash;
    struct RSA *_rsa;
    struct DSA *_dsa;
    int32_t version;
    struct Byte__Array *serialnumber;
    struct Byte__Array *issuerUniqueID;
    struct Byte__Array *subjectUniqueID;
    struct X509ExtensionCollection *extensions;
};

struct X509Certificate_1 {
    struct X509Certificate_1__Class *klass;
    MonitorData *monitor;
    struct X509Certificate_1__Fields fields;
};

struct __declspec(align(8)) ASN1__Fields {
    uint8_t m_nTag;
    struct Byte__Array *m_aValue;
    struct ArrayList *elist;
};

struct ASN1 {
    struct ASN1__Class *klass;
    MonitorData *monitor;
    struct ASN1__Fields fields;
};

struct DSA__Fields {
    struct AsymmetricAlgorithm__Fields _;
};

struct DSA {
    struct DSA__Class *klass;
    MonitorData *monitor;
    struct DSA__Fields fields;
};

struct DSAManaged__Fields {
    struct DSA__Fields _;
    bool keypairGenerated;
    bool m_disposed;
    struct BigInteger *p;
    struct BigInteger *q;
    struct BigInteger *g;
    struct BigInteger *x;
    struct BigInteger *y;
    struct BigInteger *j;
    struct BigInteger *seed;
    int32_t counter;
    bool j_missing;
    struct RandomNumberGenerator *rng;
    struct DSAManaged_KeyGeneratedEventHandler *KeyGenerated;
};

struct DSAManaged {
    struct DSAManaged__Class *klass;
    MonitorData *monitor;
    struct DSAManaged__Fields fields;
};

struct DSAManaged_KeyGeneratedEventHandler__Fields {
    struct MulticastDelegate__Fields _;
};

struct DSAManaged_KeyGeneratedEventHandler {
    struct DSAManaged_KeyGeneratedEventHandler__Class *klass;
    MonitorData *monitor;
    struct DSAManaged_KeyGeneratedEventHandler__Fields fields;
};

struct DSAParameters {
    struct Byte__Array *P;
    struct Byte__Array *Q;
    struct Byte__Array *G;
    struct Byte__Array *Y;
    struct Byte__Array *J;
    struct Byte__Array *X;
    struct Byte__Array *Seed;
    int32_t Counter;
};

struct DSAParameters__Boxed {
    struct DSAParameters__Class *klass;
    MonitorData *monitor;
    struct DSAParameters fields;
};

struct __declspec(align(8)) CollectionBase__Fields {
    struct ArrayList *list;
};

struct CollectionBase {
    struct CollectionBase__Class *klass;
    MonitorData *monitor;
    struct CollectionBase__Fields fields;
};

struct X509ExtensionCollection__Fields {
    struct CollectionBase__Fields _;
    bool readOnly;
};

struct X509ExtensionCollection {
    struct X509ExtensionCollection__Class *klass;
    MonitorData *monitor;
    struct X509ExtensionCollection__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum X509ContentType__Enum : int32_t {
    X509ContentType__Enum_Unknown = 0x00000000,
    X509ContentType__Enum_Cert = 0x00000001,
    X509ContentType__Enum_SerializedCert = 0x00000002,
    X509ContentType__Enum_Pfx = 0x00000003,
    X509ContentType__Enum_Pkcs12 = 0x00000003,
    X509ContentType__Enum_SerializedStore = 0x00000004,
    X509ContentType__Enum_Pkcs7 = 0x00000005,
    X509ContentType__Enum_Authenticode = 0x00000006,
};

#else
enum X509ContentType__Enum {
    X509ContentType__Enum_Unknown = 0x00000000,
    X509ContentType__Enum_Cert = 0x00000001,
    X509ContentType__Enum_SerializedCert = 0x00000002,
    X509ContentType__Enum_Pfx = 0x00000003,
    X509ContentType__Enum_Pkcs12 = 0x00000003,
    X509ContentType__Enum_SerializedStore = 0x00000004,
    X509ContentType__Enum_Pkcs7 = 0x00000005,
    X509ContentType__Enum_Authenticode = 0x00000006,
};

#endif
struct X509ContentType__Enum__Boxed {
    struct X509ContentType__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum X509ContentType__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) SecureString__Fields {
    int32_t length;
    bool disposed;
    bool read_only;
    struct Byte__Array *data;
};

struct SecureString {
    struct SecureString__Class *klass;
    MonitorData *monitor;
    struct SecureString__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum X509KeyStorageFlags__Enum : int32_t {
    X509KeyStorageFlags__Enum_DefaultKeySet = 0x00000000,
    X509KeyStorageFlags__Enum_UserKeySet = 0x00000001,
    X509KeyStorageFlags__Enum_MachineKeySet = 0x00000002,
    X509KeyStorageFlags__Enum_Exportable = 0x00000004,
    X509KeyStorageFlags__Enum_UserProtected = 0x00000008,
    X509KeyStorageFlags__Enum_PersistKeySet = 0x00000010,
    X509KeyStorageFlags__Enum_EphemeralKeySet = 0x00000020,
};

#else
enum X509KeyStorageFlags__Enum {
    X509KeyStorageFlags__Enum_DefaultKeySet = 0x00000000,
    X509KeyStorageFlags__Enum_UserKeySet = 0x00000001,
    X509KeyStorageFlags__Enum_MachineKeySet = 0x00000002,
    X509KeyStorageFlags__Enum_Exportable = 0x00000004,
    X509KeyStorageFlags__Enum_UserProtected = 0x00000008,
    X509KeyStorageFlags__Enum_PersistKeySet = 0x00000010,
    X509KeyStorageFlags__Enum_EphemeralKeySet = 0x00000020,
};

#endif
struct X509KeyStorageFlags__Enum__Boxed {
    struct X509KeyStorageFlags__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum X509KeyStorageFlags__Enum value;
    #else
    uint32_t value;
    #endif
};

struct MemberInfo_1__Array {
    struct MemberInfo_1__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct MemberInfo_1 *vector[32];
};

struct MemberFilter__Fields {
    struct MulticastDelegate__Fields _;
};

struct MemberFilter {
    struct MemberFilter__Class *klass;
    MonitorData *monitor;
    struct MemberFilter__Fields fields;
};

struct ConstructorInfo {
    struct ConstructorInfo__Class *klass;
    MonitorData *monitor;
};

struct RuntimeConstructorInfo {
    struct RuntimeConstructorInfo__Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) MonoCMethod__Fields {
    void *mhandle;
    struct String *name;
    struct Type *reftype;
};

struct MonoCMethod {
    struct MonoCMethod__Class *klass;
    MonitorData *monitor;
    struct MonoCMethod__Fields fields;
};

struct ConstructorInfo__Array {
    struct ConstructorInfo__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct ConstructorInfo *vector[32];
};

struct __declspec(align(8)) EventInfo_1__Fields {
    struct EventInfo_AddEventAdapter *cached_add_event;
};

struct EventInfo_1 {
    struct EventInfo_1__Class *klass;
    MonitorData *monitor;
    struct EventInfo_1__Fields fields;
};

struct EventInfo_AddEventAdapter__Fields {
    struct MulticastDelegate__Fields _;
};

struct EventInfo_AddEventAdapter {
    struct EventInfo_AddEventAdapter__Class *klass;
    MonitorData *monitor;
    struct EventInfo_AddEventAdapter__Fields fields;
};

struct RuntimeEventInfo__Fields {
    struct EventInfo_1__Fields _;
};

struct RuntimeEventInfo {
    struct RuntimeEventInfo__Class *klass;
    MonitorData *monitor;
    struct RuntimeEventInfo__Fields fields;
};

struct MonoEvent__Fields {
    struct RuntimeEventInfo__Fields _;
    void *klass;
    void *handle;
};

struct MonoEvent {
    struct MonoEvent__Class *klass;
    MonitorData *monitor;
    struct MonoEvent__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum EventAttributes__Enum : int32_t {
    EventAttributes__Enum_None = 0x00000000,
    EventAttributes__Enum_SpecialName = 0x00000200,
    EventAttributes__Enum_ReservedMask = 0x00000400,
    EventAttributes__Enum_RTSpecialName = 0x00000400,
};

#else
enum EventAttributes__Enum {
    EventAttributes__Enum_None = 0x00000000,
    EventAttributes__Enum_SpecialName = 0x00000200,
    EventAttributes__Enum_ReservedMask = 0x00000400,
    EventAttributes__Enum_RTSpecialName = 0x00000400,
};

#endif
struct EventAttributes__Enum__Boxed {
    struct EventAttributes__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum EventAttributes__Enum value;
    #else
    uint32_t value;
    #endif
};

struct EventInfo_1__Array {
    struct EventInfo_1__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct EventInfo_1 *vector[32];
};

struct InterfaceMapping {
    struct Type *TargetType;
    struct Type *InterfaceType;
    struct MethodInfo_1__Array *TargetMethods;
    struct MethodInfo_1__Array *InterfaceMethods;
};

struct InterfaceMapping__Boxed {
    struct InterfaceMapping__Class *klass;
    MonitorData *monitor;
    struct InterfaceMapping fields;
};

#if defined(_CPLUSPLUS_)
enum TypeAttributes__Enum : int32_t {
    TypeAttributes__Enum_VisibilityMask = 0x00000007,
    TypeAttributes__Enum_NotPublic = 0x00000000,
    TypeAttributes__Enum_Public = 0x00000001,
    TypeAttributes__Enum_NestedPublic = 0x00000002,
    TypeAttributes__Enum_NestedPrivate = 0x00000003,
    TypeAttributes__Enum_NestedFamily = 0x00000004,
    TypeAttributes__Enum_NestedAssembly = 0x00000005,
    TypeAttributes__Enum_NestedFamANDAssem = 0x00000006,
    TypeAttributes__Enum_NestedFamORAssem = 0x00000007,
    TypeAttributes__Enum_LayoutMask = 0x00000018,
    TypeAttributes__Enum_AutoLayout = 0x00000000,
    TypeAttributes__Enum_SequentialLayout = 0x00000008,
    TypeAttributes__Enum_ExplicitLayout = 0x00000010,
    TypeAttributes__Enum_ClassSemanticsMask = 0x00000020,
    TypeAttributes__Enum_Class = 0x00000000,
    TypeAttributes__Enum_Interface = 0x00000020,
    TypeAttributes__Enum_Abstract = 0x00000080,
    TypeAttributes__Enum_Sealed = 0x00000100,
    TypeAttributes__Enum_SpecialName = 0x00000400,
    TypeAttributes__Enum_Import = 0x00001000,
    TypeAttributes__Enum_Serializable = 0x00002000,
    TypeAttributes__Enum_WindowsRuntime = 0x00004000,
    TypeAttributes__Enum_StringFormatMask = 0x00030000,
    TypeAttributes__Enum_AnsiClass = 0x00000000,
    TypeAttributes__Enum_UnicodeClass = 0x00010000,
    TypeAttributes__Enum_AutoClass = 0x00020000,
    TypeAttributes__Enum_CustomFormatClass = 0x00030000,
    TypeAttributes__Enum_CustomFormatMask = 0x00c00000,
    TypeAttributes__Enum_BeforeFieldInit = 0x00100000,
    TypeAttributes__Enum_ReservedMask = 0x00040800,
    TypeAttributes__Enum_RTSpecialName = 0x00000800,
    TypeAttributes__Enum_HasSecurity = 0x00040000,
};

#else
enum TypeAttributes__Enum {
    TypeAttributes__Enum_VisibilityMask = 0x00000007,
    TypeAttributes__Enum_NotPublic = 0x00000000,
    TypeAttributes__Enum_Public = 0x00000001,
    TypeAttributes__Enum_NestedPublic = 0x00000002,
    TypeAttributes__Enum_NestedPrivate = 0x00000003,
    TypeAttributes__Enum_NestedFamily = 0x00000004,
    TypeAttributes__Enum_NestedAssembly = 0x00000005,
    TypeAttributes__Enum_NestedFamANDAssem = 0x00000006,
    TypeAttributes__Enum_NestedFamORAssem = 0x00000007,
    TypeAttributes__Enum_LayoutMask = 0x00000018,
    TypeAttributes__Enum_AutoLayout = 0x00000000,
    TypeAttributes__Enum_SequentialLayout = 0x00000008,
    TypeAttributes__Enum_ExplicitLayout = 0x00000010,
    TypeAttributes__Enum_ClassSemanticsMask = 0x00000020,
    TypeAttributes__Enum_Class = 0x00000000,
    TypeAttributes__Enum_Interface = 0x00000020,
    TypeAttributes__Enum_Abstract = 0x00000080,
    TypeAttributes__Enum_Sealed = 0x00000100,
    TypeAttributes__Enum_SpecialName = 0x00000400,
    TypeAttributes__Enum_Import = 0x00001000,
    TypeAttributes__Enum_Serializable = 0x00002000,
    TypeAttributes__Enum_WindowsRuntime = 0x00004000,
    TypeAttributes__Enum_StringFormatMask = 0x00030000,
    TypeAttributes__Enum_AnsiClass = 0x00000000,
    TypeAttributes__Enum_UnicodeClass = 0x00010000,
    TypeAttributes__Enum_AutoClass = 0x00020000,
    TypeAttributes__Enum_CustomFormatClass = 0x00030000,
    TypeAttributes__Enum_CustomFormatMask = 0x00c00000,
    TypeAttributes__Enum_BeforeFieldInit = 0x00100000,
    TypeAttributes__Enum_ReservedMask = 0x00040800,
    TypeAttributes__Enum_RTSpecialName = 0x00000800,
    TypeAttributes__Enum_HasSecurity = 0x00040000,
};

#endif
struct TypeAttributes__Enum__Boxed {
    struct TypeAttributes__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum TypeAttributes__Enum value;
    #else
    uint32_t value;
    #endif
};

#if defined(_CPLUSPLUS_)
enum LayoutKind__Enum : int32_t {
    LayoutKind__Enum_Sequential = 0x00000000,
    LayoutKind__Enum_Explicit = 0x00000002,
    LayoutKind__Enum_Auto = 0x00000003,
};

#else
enum LayoutKind__Enum {
    LayoutKind__Enum_Sequential = 0x00000000,
    LayoutKind__Enum_Explicit = 0x00000002,
    LayoutKind__Enum_Auto = 0x00000003,
};

#endif
struct LayoutKind__Enum__Boxed {
    struct LayoutKind__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum LayoutKind__Enum value;
    #else
    uint32_t value;
    #endif
};

#if defined(_CPLUSPLUS_)
enum CharSet__Enum : int32_t {
    CharSet__Enum_None = 0x00000001,
    CharSet__Enum_Ansi = 0x00000002,
    CharSet__Enum_Unicode = 0x00000003,
    CharSet__Enum_Auto = 0x00000004,
};

#else
enum CharSet__Enum {
    CharSet__Enum_None = 0x00000001,
    CharSet__Enum_Ansi = 0x00000002,
    CharSet__Enum_Unicode = 0x00000003,
    CharSet__Enum_Auto = 0x00000004,
};

#endif
struct CharSet__Enum__Boxed {
    struct CharSet__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum CharSet__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) StructLayoutAttribute__Fields {
    #if defined(_CPLUSPLUS_)
    enum LayoutKind__Enum _val;
    #else
    uint32_t _val;
    #endif
    int32_t Pack;
    int32_t Size;
    #if defined(_CPLUSPLUS_)
    enum CharSet__Enum CharSet;
    #else
    uint32_t CharSet;
    #endif
};

struct StructLayoutAttribute {
    struct StructLayoutAttribute__Class *klass;
    MonitorData *monitor;
    struct StructLayoutAttribute__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum GenericParameterAttributes__Enum : int32_t {
    GenericParameterAttributes__Enum_None = 0x00000000,
    GenericParameterAttributes__Enum_VarianceMask = 0x00000003,
    GenericParameterAttributes__Enum_Covariant = 0x00000001,
    GenericParameterAttributes__Enum_Contravariant = 0x00000002,
    GenericParameterAttributes__Enum_SpecialConstraintMask = 0x0000001c,
    GenericParameterAttributes__Enum_ReferenceTypeConstraint = 0x00000004,
    GenericParameterAttributes__Enum_NotNullableValueTypeConstraint = 0x00000008,
    GenericParameterAttributes__Enum_DefaultConstructorConstraint = 0x00000010,
};

#else
enum GenericParameterAttributes__Enum {
    GenericParameterAttributes__Enum_None = 0x00000000,
    GenericParameterAttributes__Enum_VarianceMask = 0x00000003,
    GenericParameterAttributes__Enum_Covariant = 0x00000001,
    GenericParameterAttributes__Enum_Contravariant = 0x00000002,
    GenericParameterAttributes__Enum_SpecialConstraintMask = 0x0000001c,
    GenericParameterAttributes__Enum_ReferenceTypeConstraint = 0x00000004,
    GenericParameterAttributes__Enum_NotNullableValueTypeConstraint = 0x00000008,
    GenericParameterAttributes__Enum_DefaultConstructorConstraint = 0x00000010,
};

#endif
struct GenericParameterAttributes__Enum__Boxed {
    struct GenericParameterAttributes__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum GenericParameterAttributes__Enum value;
    #else
    uint32_t value;
    #endif
};

struct IEnumerable_1_System_Reflection_MethodInfo_ {
    struct IEnumerable_1_System_Reflection_MethodInfo___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_Reflection_ConstructorInfo_ {
    struct IEnumerable_1_System_Reflection_ConstructorInfo___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_Reflection_EventInfo_ {
    struct IEnumerable_1_System_Reflection_EventInfo___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_Reflection_FieldInfo_ {
    struct IEnumerable_1_System_Reflection_FieldInfo___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_Reflection_MemberInfo_ {
    struct IEnumerable_1_System_Reflection_MemberInfo___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_Reflection_PropertyInfo_ {
    struct IEnumerable_1_System_Reflection_PropertyInfo___Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) MonoTypeInfo__Fields {
    struct String *full_name;
    struct MonoCMethod *default_ctor;
};

struct MonoTypeInfo {
    struct MonoTypeInfo__Class *klass;
    MonitorData *monitor;
    struct MonoTypeInfo__Fields fields;
};

struct Byte__Array {
    struct Byte__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    uint8_t vector[32];
};

struct IEnumerator_1_System_Char_ {
    struct IEnumerator_1_System_Char___Class *klass;
    MonitorData *monitor;
};

struct IFormatProvider__VTable {
    VirtualInvokeData GetFormat;
};

struct IFormatProvider__StaticFields {
};

struct IFormatProvider__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IFormatProvider__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IFormatProvider__VTable vtable;
};

struct IEnumerator__VTable {
    VirtualInvokeData MoveNext;
    VirtualInvokeData get_Current;
    VirtualInvokeData Reset;
};

struct IEnumerator__StaticFields {
};

struct IEnumerator__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator__VTable vtable;
};

struct IComparer__VTable {
    VirtualInvokeData Compare;
};

struct IComparer__StaticFields {
};

struct IComparer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IComparer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IComparer__VTable vtable;
};

struct IEqualityComparer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData GetHashCode;
};

struct IEqualityComparer__StaticFields {
};

struct IEqualityComparer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEqualityComparer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEqualityComparer__VTable vtable;
};

struct Array__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_ICollection_get_Count;
    VirtualInvokeData get_SyncRoot;
    VirtualInvokeData get_IsSynchronized;
    VirtualInvokeData GetEnumerator;
    VirtualInvokeData System_Collections_IList_get_Item;
    VirtualInvokeData System_Collections_IList_set_Item;
    VirtualInvokeData System_Collections_IList_Add;
    VirtualInvokeData System_Collections_IList_Contains;
    VirtualInvokeData System_Collections_IList_Clear;
    VirtualInvokeData System_Collections_IList_get_IsReadOnly;
    VirtualInvokeData get_IsFixedSize;
    VirtualInvokeData System_Collections_IList_IndexOf;
    VirtualInvokeData System_Collections_IList_Insert;
    VirtualInvokeData System_Collections_IList_Remove;
    VirtualInvokeData System_Collections_IList_RemoveAt;
    VirtualInvokeData System_Collections_IStructuralComparable_CompareTo;
    VirtualInvokeData System_Collections_IStructuralEquatable_Equals;
    VirtualInvokeData System_Collections_IStructuralEquatable_GetHashCode;
    VirtualInvokeData Clone;
    VirtualInvokeData get_IsReadOnly;
};

struct Array__StaticFields {
};

struct Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Array__VTable vtable;
};

struct Char__Array__VTable {
};

struct Char__Array__StaticFields {
};

struct Char__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Char__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Char__Array__VTable vtable;
};

struct UInt32__Array__VTable {
};

struct UInt32__Array__StaticFields {
};

struct UInt32__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UInt32__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UInt32__Array__VTable vtable;
};

struct Int32__Array__VTable {
};

struct Int32__Array__StaticFields {
};

struct Int32__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Int32__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Int32__Array__VTable vtable;
};

struct Object__Array__VTable {
};

struct Object__Array__StaticFields {
};

struct Object__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Object__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Object__Array__VTable vtable;
};

struct MemberTypes__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct MemberTypes__Enum__StaticFields {
};

struct MemberTypes__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MemberTypes__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MemberTypes__Enum__VTable vtable;
};

struct VoidPtr__VTable {
};

struct VoidPtr__StaticFields {
};

struct VoidPtr__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct VoidPtr__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct VoidPtr__VTable vtable;
};

struct String__Array__VTable {
};

struct String__Array__StaticFields {
};

struct String__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct String__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct String__Array__VTable vtable;
};

struct Type__Array__VTable {
};

struct Type__Array__StaticFields {
};

struct Type__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Type__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Type__Array__VTable vtable;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Int32___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Int32___StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Int32___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Int32___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Int32___VTable vtable;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Int32___Array__VTable {
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Int32___Array__StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Int32___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Int32___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Int32___Array__VTable vtable;
};

struct IEqualityComparer_1_System_String___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData GetHashCode;
};

struct IEqualityComparer_1_System_String___StaticFields {
};

struct IEqualityComparer_1_System_String___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEqualityComparer_1_System_String___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEqualityComparer_1_System_String___VTable vtable;
};

struct IEnumerator_1_System_String___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_System_String___StaticFields {
};

struct IEnumerator_1_System_String___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_System_String___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_System_String___VTable vtable;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Int32___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TKey__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Int32___StaticFields {
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Int32___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Int32___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Int32___VTable vtable;
};

struct IEnumerator_1_System_Int32___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_System_Int32___StaticFields {
};

struct IEnumerator_1_System_Int32___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_System_Int32___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_System_Int32___VTable vtable;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Int32___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TValue__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Int32___StaticFields {
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Int32___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Int32___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Int32___VTable vtable;
};

struct ICollection_1_System_String___VTable {
    VirtualInvokeData get_Count;
    VirtualInvokeData get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
};

struct ICollection_1_System_String___StaticFields {
};

struct ICollection_1_System_String___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ICollection_1_System_String___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ICollection_1_System_String___VTable vtable;
};

struct ICollection_1_System_Int32___VTable {
    VirtualInvokeData get_Count;
    VirtualInvokeData get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
};

struct ICollection_1_System_Int32___StaticFields {
};

struct ICollection_1_System_Int32___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ICollection_1_System_Int32___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ICollection_1_System_Int32___VTable vtable;
};

struct Int32___VTable {
};

struct Int32___StaticFields {
};

struct Int32___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Int32___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Int32___VTable vtable;
};

struct KeyValuePair_2_System_String_System_Int32___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct KeyValuePair_2_System_String_System_Int32___StaticFields {
};

struct KeyValuePair_2_System_String_System_Int32___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_String_System_Int32___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_String_System_Int32___VTable vtable;
};

struct KeyValuePair_2_System_String_System_Int32___Array__VTable {
};

struct KeyValuePair_2_System_String_System_Int32___Array__StaticFields {
};

struct KeyValuePair_2_System_String_System_Int32___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_String_System_Int32___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_String_System_Int32___Array__VTable vtable;
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_Int32___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_Int32___StaticFields {
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_Int32___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_KeyValuePair_2_System_String_System_Int32___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_KeyValuePair_2_System_String_System_Int32___VTable vtable;
};

struct ICollection__VTable {
    VirtualInvokeData CopyTo;
    VirtualInvokeData get_Count;
    VirtualInvokeData get_SyncRoot;
    VirtualInvokeData get_IsSynchronized;
};

struct ICollection__StaticFields {
};

struct ICollection__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ICollection__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ICollection__VTable vtable;
};

struct IDictionaryEnumerator__VTable {
    VirtualInvokeData get_Key;
    VirtualInvokeData get_Value;
    VirtualInvokeData get_Entry;
};

struct IDictionaryEnumerator__StaticFields {
};

struct IDictionaryEnumerator__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IDictionaryEnumerator__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IDictionaryEnumerator__VTable vtable;
};

struct IEnumerable_1_System_String___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_String___StaticFields {
};

struct IEnumerable_1_System_String___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_String___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_String___VTable vtable;
};

struct IEnumerable_1_System_Int32___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_Int32___StaticFields {
};

struct IEnumerable_1_System_Int32___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_Int32___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_Int32___VTable vtable;
};

struct StreamingContextStates__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct StreamingContextStates__Enum__StaticFields {
};

struct StreamingContextStates__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StreamingContextStates__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StreamingContextStates__Enum__VTable vtable;
};

struct StreamingContext__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct StreamingContext__StaticFields {
};

struct StreamingContext__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StreamingContext__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StreamingContext__VTable vtable;
};

struct Dictionary_2_System_String_System_Int32___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Values;
    VirtualInvokeData ContainsKey;
    VirtualInvokeData Add;
    VirtualInvokeData Remove;
    VirtualInvokeData TryGetValue;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Add;
    VirtualInvokeData Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Contains;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_System_Collections_Generic_KeyValuePair_TKey_TValue___GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_get_Item;
    VirtualInvokeData System_Collections_IDictionary_set_Item;
    VirtualInvokeData System_Collections_IDictionary_get_Keys;
    VirtualInvokeData System_Collections_IDictionary_get_Values;
    VirtualInvokeData System_Collections_IDictionary_Contains;
    VirtualInvokeData System_Collections_IDictionary_Add;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IDictionary_get_IsReadOnly;
    VirtualInvokeData System_Collections_IDictionary_get_IsFixedSize;
    VirtualInvokeData System_Collections_IDictionary_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_Remove;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData ContainsKey_1;
    VirtualInvokeData TryGetValue_1;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Values;
    VirtualInvokeData get_Count_2;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData OnDeserialization;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData OnDeserialization_1;
};

struct Dictionary_2_System_String_System_Int32___StaticFields {
};

struct Dictionary_2_System_String_System_Int32___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_System_String_System_Int32___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_System_String_System_Int32___VTable vtable;
};

struct IFormatterConverter__VTable {
    VirtualInvokeData Convert;
    VirtualInvokeData Convert_1;
    VirtualInvokeData ToBoolean;
    VirtualInvokeData ToChar;
    VirtualInvokeData ToSByte;
    VirtualInvokeData ToByte;
    VirtualInvokeData ToInt16;
    VirtualInvokeData ToUInt16;
    VirtualInvokeData ToInt32;
    VirtualInvokeData ToUInt32;
    VirtualInvokeData ToInt64;
    VirtualInvokeData ToUInt64;
    VirtualInvokeData ToSingle;
    VirtualInvokeData ToDouble;
    VirtualInvokeData ToDecimal;
    VirtualInvokeData ToDateTime;
    VirtualInvokeData ToString;
};

struct IFormatterConverter__StaticFields {
};

struct IFormatterConverter__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IFormatterConverter__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IFormatterConverter__VTable vtable;
};

struct SerializationInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct SerializationInfo__StaticFields {
};

struct SerializationInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SerializationInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SerializationInfo__VTable vtable;
};

struct IntPtr__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
};

struct IntPtr__StaticFields {
    void *Zero;
};

struct IntPtr__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IntPtr__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IntPtr__VTable vtable;
};

struct RNGCryptoServiceProvider__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData GetBytes;
    VirtualInvokeData GetBytes_1;
    VirtualInvokeData GetNonZeroBytes;
};

struct RNGCryptoServiceProvider__StaticFields {
    struct Object *_lock;
};

struct RNGCryptoServiceProvider__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RNGCryptoServiceProvider__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RNGCryptoServiceProvider__VTable vtable;
};

struct RandomNumberGenerator__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData __unknown;
    VirtualInvokeData GetBytes;
    VirtualInvokeData GetNonZeroBytes;
};

struct RandomNumberGenerator__StaticFields {
};

struct RandomNumberGenerator__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RandomNumberGenerator__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RandomNumberGenerator__VTable vtable;
};

struct Guid__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData ToString_1;
    VirtualInvokeData CompareTo;
    VirtualInvokeData CompareTo_1;
    VirtualInvokeData Equals_1;
};

struct Guid__StaticFields {
    struct Guid Empty;
    struct Object *_rngAccess;
    struct RandomNumberGenerator *_rng;
    struct RandomNumberGenerator *_fastRng;
};

struct Guid__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Guid__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Guid__VTable vtable;
};

struct Guid___VTable {
};

struct Guid___StaticFields {
};

struct Guid___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Guid___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Guid___VTable vtable;
};

struct UInt32___VTable {
};

struct UInt32___StaticFields {
};

struct UInt32___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UInt32___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UInt32___VTable vtable;
};

struct IEnumerable_1_System_Reflection_CustomAttributeData___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_Reflection_CustomAttributeData___StaticFields {
};

struct IEnumerable_1_System_Reflection_CustomAttributeData___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_Reflection_CustomAttributeData___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_Reflection_CustomAttributeData___VTable vtable;
};

struct IList_1_System_Reflection_CustomAttributeData___VTable {
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData RemoveAt;
};

struct IList_1_System_Reflection_CustomAttributeData___StaticFields {
};

struct IList_1_System_Reflection_CustomAttributeData___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IList_1_System_Reflection_CustomAttributeData___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IList_1_System_Reflection_CustomAttributeData___VTable vtable;
};

struct MethodImplAttributes__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct MethodImplAttributes__Enum__StaticFields {
};

struct MethodImplAttributes__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MethodImplAttributes__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MethodImplAttributes__Enum__VTable vtable;
};

struct ParameterAttributes__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct ParameterAttributes__Enum__StaticFields {
};

struct ParameterAttributes__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ParameterAttributes__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ParameterAttributes__Enum__VTable vtable;
};

struct Attribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct Attribute__StaticFields {
};

struct Attribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Attribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Attribute__VTable vtable;
};

struct UnmanagedType__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct UnmanagedType__Enum__StaticFields {
};

struct UnmanagedType__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UnmanagedType__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UnmanagedType__Enum__VTable vtable;
};

struct VarEnum__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct VarEnum__Enum__StaticFields {
};

struct VarEnum__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct VarEnum__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct VarEnum__Enum__VTable vtable;
};

struct MarshalAsAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct MarshalAsAttribute__StaticFields {
};

struct MarshalAsAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MarshalAsAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MarshalAsAttribute__VTable vtable;
};

struct ParameterInfo_1__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData GetRealObject;
    VirtualInvokeData System_Runtime_InteropServices__ParameterInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__ParameterInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__ParameterInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__ParameterInfo_Invoke;
    VirtualInvokeData get_ParameterType;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_Member;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_Position;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData get_HasDefaultValue;
    VirtualInvokeData get_DefaultValue;
    VirtualInvokeData get_RawDefaultValue;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData GetRequiredCustomModifiers;
    VirtualInvokeData GetOptionalCustomModifiers;
    VirtualInvokeData GetCustomAttributesData;
};

struct ParameterInfo_1__StaticFields {
};

struct ParameterInfo_1__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ParameterInfo_1__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ParameterInfo_1__VTable vtable;
};

struct ParameterInfo_1__Array__VTable {
};

struct ParameterInfo_1__Array__StaticFields {
};

struct ParameterInfo_1__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ParameterInfo_1__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ParameterInfo_1__Array__VTable vtable;
};

struct BindingFlags__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct BindingFlags__Enum__StaticFields {
};

struct BindingFlags__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct BindingFlags__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct BindingFlags__Enum__VTable vtable;
};

struct MethodBase__Array__VTable {
};

struct MethodBase__Array__StaticFields {
};

struct MethodBase__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MethodBase__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MethodBase__Array__VTable vtable;
};

struct Object___VTable {
};

struct Object___StaticFields {
};

struct Object___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Object___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Object___VTable vtable;
};

struct Boolean__Array__VTable {
};

struct Boolean__Array__StaticFields {
};

struct Boolean__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Boolean__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Boolean__Array__VTable vtable;
};

struct ParameterModifier__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ParameterModifier__StaticFields {
};

struct ParameterModifier__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ParameterModifier__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ParameterModifier__VTable vtable;
};

struct ParameterModifier__Array__VTable {
};

struct ParameterModifier__Array__StaticFields {
};

struct ParameterModifier__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ParameterModifier__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ParameterModifier__Array__VTable vtable;
};

struct NumberStyles__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct NumberStyles__Enum__StaticFields {
};

struct NumberStyles__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct NumberStyles__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct NumberStyles__Enum__VTable vtable;
};

struct NumberFormatInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetFormat;
};

struct NumberFormatInfo__StaticFields {
    struct NumberFormatInfo *invariantInfo;
};

struct NumberFormatInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct NumberFormatInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct NumberFormatInfo__VTable vtable;
};

struct CalendarData__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct CalendarData__StaticFields {
    struct CalendarData *Invariant;
};

struct CalendarData__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CalendarData__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CalendarData__VTable vtable;
};

struct CalendarData__Array__VTable {
};

struct CalendarData__Array__StaticFields {
};

struct CalendarData__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CalendarData__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CalendarData__Array__VTable vtable;
};

struct CultureData__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct CultureData__StaticFields {
    struct CultureData *s_Invariant;
};

struct CultureData__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CultureData__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CultureData__VTable vtable;
};

struct CompareOptions__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct CompareOptions__Enum__StaticFields {
};

struct CompareOptions__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CompareOptions__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CompareOptions__Enum__VTable vtable;
};

struct SortVersion__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Equals_1;
};

struct SortVersion__StaticFields {
};

struct SortVersion__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SortVersion__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SortVersion__VTable vtable;
};

struct Nullable_1_Boolean___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Nullable_1_Boolean___StaticFields {
};

struct Nullable_1_Boolean___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Nullable_1_Boolean___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Nullable_1_Boolean___VTable vtable;
};

struct TextInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData System_Runtime_Serialization_IDeserializationCallback_OnDeserialization;
    VirtualInvokeData get_ANSICodePage;
    VirtualInvokeData get_OEMCodePage;
    VirtualInvokeData get_MacCodePage;
    VirtualInvokeData get_EBCDICCodePage;
    VirtualInvokeData Clone_1;
    VirtualInvokeData get_ListSeparator;
    VirtualInvokeData set_ListSeparator;
    VirtualInvokeData ToLower;
    VirtualInvokeData ToLower_1;
    VirtualInvokeData ToUpper;
    VirtualInvokeData ToUpper_1;
};

struct TextInfo__StaticFields {
    struct TextInfo *s_Invariant;
};

struct TextInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TextInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TextInfo__VTable vtable;
};

struct CodePointIndexer_TableRange__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct CodePointIndexer_TableRange__StaticFields {
};

struct CodePointIndexer_TableRange__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CodePointIndexer_TableRange__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CodePointIndexer_TableRange__VTable vtable;
};

struct CodePointIndexer_TableRange__Array__VTable {
};

struct CodePointIndexer_TableRange__Array__StaticFields {
};

struct CodePointIndexer_TableRange__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CodePointIndexer_TableRange__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CodePointIndexer_TableRange__Array__VTable vtable;
};

struct CodePointIndexer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct CodePointIndexer__StaticFields {
};

struct CodePointIndexer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CodePointIndexer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CodePointIndexer__VTable vtable;
};

struct Contraction__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Contraction__StaticFields {
};

struct Contraction__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Contraction__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Contraction__VTable vtable;
};

struct Contraction__Array__VTable {
};

struct Contraction__Array__StaticFields {
};

struct Contraction__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Contraction__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Contraction__Array__VTable vtable;
};

struct Level2Map__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Level2Map__StaticFields {
};

struct Level2Map__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Level2Map__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Level2Map__VTable vtable;
};

struct Level2Map__Array__VTable {
};

struct Level2Map__Array__StaticFields {
};

struct Level2Map__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Level2Map__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Level2Map__Array__VTable vtable;
};

struct BytePtr__VTable {
};

struct BytePtr__StaticFields {
};

struct BytePtr__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct BytePtr__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct BytePtr__VTable vtable;
};

struct SimpleCollator__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct SimpleCollator__StaticFields {
    bool QuickCheckDisabled;
    struct SimpleCollator *invariant;
};

struct SimpleCollator__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SimpleCollator__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SimpleCollator__VTable vtable;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_Mono_Globalization_Unicode_SimpleCollator___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_Mono_Globalization_Unicode_SimpleCollator___StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_String_Mono_Globalization_Unicode_SimpleCollator___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_String_Mono_Globalization_Unicode_SimpleCollator___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_String_Mono_Globalization_Unicode_SimpleCollator___VTable vtable;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_Mono_Globalization_Unicode_SimpleCollator___Array__VTable {
};

struct Dictionary_2_TKey_TValue_Entry_System_String_Mono_Globalization_Unicode_SimpleCollator___Array__StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_String_Mono_Globalization_Unicode_SimpleCollator___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_String_Mono_Globalization_Unicode_SimpleCollator___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_String_Mono_Globalization_Unicode_SimpleCollator___Array__VTable vtable;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_Mono_Globalization_Unicode_SimpleCollator___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TKey__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_Mono_Globalization_Unicode_SimpleCollator___StaticFields {
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_Mono_Globalization_Unicode_SimpleCollator___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_Mono_Globalization_Unicode_SimpleCollator___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_Mono_Globalization_Unicode_SimpleCollator___VTable vtable;
};

struct SimpleCollator__Array__VTable {
};

struct SimpleCollator__Array__StaticFields {
};

struct SimpleCollator__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SimpleCollator__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SimpleCollator__Array__VTable vtable;
};

struct IEnumerator_1_Mono_Globalization_Unicode_SimpleCollator___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_Mono_Globalization_Unicode_SimpleCollator___StaticFields {
};

struct IEnumerator_1_Mono_Globalization_Unicode_SimpleCollator___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_Mono_Globalization_Unicode_SimpleCollator___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_Mono_Globalization_Unicode_SimpleCollator___VTable vtable;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_Mono_Globalization_Unicode_SimpleCollator___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TValue__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_Mono_Globalization_Unicode_SimpleCollator___StaticFields {
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_Mono_Globalization_Unicode_SimpleCollator___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_Mono_Globalization_Unicode_SimpleCollator___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_Mono_Globalization_Unicode_SimpleCollator___VTable vtable;
};

struct ICollection_1_Mono_Globalization_Unicode_SimpleCollator___VTable {
    VirtualInvokeData get_Count;
    VirtualInvokeData get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
};

struct ICollection_1_Mono_Globalization_Unicode_SimpleCollator___StaticFields {
};

struct ICollection_1_Mono_Globalization_Unicode_SimpleCollator___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ICollection_1_Mono_Globalization_Unicode_SimpleCollator___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ICollection_1_Mono_Globalization_Unicode_SimpleCollator___VTable vtable;
};

struct SimpleCollator___VTable {
};

struct SimpleCollator___StaticFields {
};

struct SimpleCollator___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SimpleCollator___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SimpleCollator___VTable vtable;
};

struct KeyValuePair_2_System_String_Mono_Globalization_Unicode_SimpleCollator___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct KeyValuePair_2_System_String_Mono_Globalization_Unicode_SimpleCollator___StaticFields {
};

struct KeyValuePair_2_System_String_Mono_Globalization_Unicode_SimpleCollator___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_String_Mono_Globalization_Unicode_SimpleCollator___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_String_Mono_Globalization_Unicode_SimpleCollator___VTable vtable;
};

struct KeyValuePair_2_System_String_Mono_Globalization_Unicode_SimpleCollator___Array__VTable {
};

struct KeyValuePair_2_System_String_Mono_Globalization_Unicode_SimpleCollator___Array__StaticFields {
};

struct KeyValuePair_2_System_String_Mono_Globalization_Unicode_SimpleCollator___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_String_Mono_Globalization_Unicode_SimpleCollator___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_String_Mono_Globalization_Unicode_SimpleCollator___Array__VTable vtable;
};

struct IEnumerator_1_KeyValuePair_2_System_String_Mono_Globalization_Unicode_SimpleCollator___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_KeyValuePair_2_System_String_Mono_Globalization_Unicode_SimpleCollator___StaticFields {
};

struct IEnumerator_1_KeyValuePair_2_System_String_Mono_Globalization_Unicode_SimpleCollator___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_KeyValuePair_2_System_String_Mono_Globalization_Unicode_SimpleCollator___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_KeyValuePair_2_System_String_Mono_Globalization_Unicode_SimpleCollator___VTable vtable;
};

struct IEnumerable_1_Mono_Globalization_Unicode_SimpleCollator___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_Mono_Globalization_Unicode_SimpleCollator___StaticFields {
};

struct IEnumerable_1_Mono_Globalization_Unicode_SimpleCollator___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_Mono_Globalization_Unicode_SimpleCollator___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_Mono_Globalization_Unicode_SimpleCollator___VTable vtable;
};

struct Dictionary_2_System_String_Mono_Globalization_Unicode_SimpleCollator___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Values;
    VirtualInvokeData ContainsKey;
    VirtualInvokeData Add;
    VirtualInvokeData Remove;
    VirtualInvokeData TryGetValue;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Add;
    VirtualInvokeData Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Contains;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_System_Collections_Generic_KeyValuePair_TKey_TValue___GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_get_Item;
    VirtualInvokeData System_Collections_IDictionary_set_Item;
    VirtualInvokeData System_Collections_IDictionary_get_Keys;
    VirtualInvokeData System_Collections_IDictionary_get_Values;
    VirtualInvokeData System_Collections_IDictionary_Contains;
    VirtualInvokeData System_Collections_IDictionary_Add;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IDictionary_get_IsReadOnly;
    VirtualInvokeData System_Collections_IDictionary_get_IsFixedSize;
    VirtualInvokeData System_Collections_IDictionary_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_Remove;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData ContainsKey_1;
    VirtualInvokeData TryGetValue_1;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Values;
    VirtualInvokeData get_Count_2;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData OnDeserialization;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData OnDeserialization_1;
};

struct Dictionary_2_System_String_Mono_Globalization_Unicode_SimpleCollator___StaticFields {
};

struct Dictionary_2_System_String_Mono_Globalization_Unicode_SimpleCollator___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_System_String_Mono_Globalization_Unicode_SimpleCollator___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_System_String_Mono_Globalization_Unicode_SimpleCollator___VTable vtable;
};

struct SortKey__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_OriginalString;
    VirtualInvokeData get_KeyData;
};

struct SortKey__StaticFields {
};

struct SortKey__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SortKey__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SortKey__VTable vtable;
};

struct CompareInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_Serialization_IDeserializationCallback_OnDeserialization;
    VirtualInvokeData get_Name;
    VirtualInvokeData Compare;
    VirtualInvokeData Compare_1;
    VirtualInvokeData Compare_2;
    VirtualInvokeData Compare_3;
    VirtualInvokeData Compare_4;
    VirtualInvokeData Compare_5;
    VirtualInvokeData IsPrefix;
    VirtualInvokeData IsPrefix_1;
    VirtualInvokeData IsSuffix;
    VirtualInvokeData IsSuffix_1;
    VirtualInvokeData IndexOf;
    VirtualInvokeData IndexOf_1;
    VirtualInvokeData IndexOf_2;
    VirtualInvokeData IndexOf_3;
    VirtualInvokeData IndexOf_4;
    VirtualInvokeData IndexOf_5;
    VirtualInvokeData IndexOf_6;
    VirtualInvokeData IndexOf_7;
    VirtualInvokeData IndexOf_8;
    VirtualInvokeData IndexOf_9;
    VirtualInvokeData IndexOf_10;
    VirtualInvokeData IndexOf_11;
    VirtualInvokeData LastIndexOf;
    VirtualInvokeData LastIndexOf_1;
    VirtualInvokeData LastIndexOf_2;
    VirtualInvokeData LastIndexOf_3;
    VirtualInvokeData LastIndexOf_4;
    VirtualInvokeData LastIndexOf_5;
    VirtualInvokeData LastIndexOf_6;
    VirtualInvokeData LastIndexOf_7;
    VirtualInvokeData LastIndexOf_8;
    VirtualInvokeData LastIndexOf_9;
    VirtualInvokeData LastIndexOf_10;
    VirtualInvokeData LastIndexOf_11;
    VirtualInvokeData GetSortKey;
    VirtualInvokeData GetSortKey_1;
    VirtualInvokeData GetHashCode_1;
};

struct CompareInfo__StaticFields {
    struct Dictionary_2_System_String_Mono_Globalization_Unicode_SimpleCollator_ *collators;
    bool managedCollation;
    bool managedCollationChecked;
};

struct CompareInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CompareInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CompareInfo__VTable vtable;
};

struct CalendarAlgorithmType__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct CalendarAlgorithmType__Enum__StaticFields {
};

struct CalendarAlgorithmType__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CalendarAlgorithmType__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CalendarAlgorithmType__Enum__VTable vtable;
};

struct DayOfWeek__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct DayOfWeek__Enum__StaticFields {
};

struct DayOfWeek__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DayOfWeek__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DayOfWeek__Enum__VTable vtable;
};

struct CalendarWeekRule__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct CalendarWeekRule__Enum__StaticFields {
};

struct CalendarWeekRule__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CalendarWeekRule__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CalendarWeekRule__Enum__VTable vtable;
};

struct DateTime___VTable {
};

struct DateTime___StaticFields {
};

struct DateTime___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DateTime___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DateTime___VTable vtable;
};

struct PersianCalendar__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData get_MinSupportedDateTime;
    VirtualInvokeData get_MaxSupportedDateTime;
    VirtualInvokeData get_ID;
    VirtualInvokeData get_BaseCalendarID;
    VirtualInvokeData get_AlgorithmType;
    VirtualInvokeData Clone_1;
    VirtualInvokeData get_CurrentEraValue;
    VirtualInvokeData AddMilliseconds;
    VirtualInvokeData AddDays;
    VirtualInvokeData AddHours;
    VirtualInvokeData AddMinutes;
    VirtualInvokeData AddMonths;
    VirtualInvokeData AddSeconds;
    VirtualInvokeData AddWeeks;
    VirtualInvokeData AddYears;
    VirtualInvokeData GetDayOfMonth;
    VirtualInvokeData GetDayOfWeek;
    VirtualInvokeData GetDayOfYear;
    VirtualInvokeData GetDaysInMonth;
    VirtualInvokeData GetDaysInMonth_1;
    VirtualInvokeData GetDaysInYear;
    VirtualInvokeData GetDaysInYear_1;
    VirtualInvokeData GetEra;
    VirtualInvokeData get_Eras;
    VirtualInvokeData GetHour;
    VirtualInvokeData GetMilliseconds;
    VirtualInvokeData GetMinute;
    VirtualInvokeData GetMonth;
    VirtualInvokeData GetMonthsInYear;
    VirtualInvokeData GetMonthsInYear_1;
    VirtualInvokeData GetSecond;
    VirtualInvokeData get_DaysInYearBeforeMinSupportedYear;
    VirtualInvokeData GetWeekOfYear;
    VirtualInvokeData GetYear;
    VirtualInvokeData IsLeapDay;
    VirtualInvokeData IsLeapDay_1;
    VirtualInvokeData IsLeapMonth;
    VirtualInvokeData IsLeapMonth_1;
    VirtualInvokeData GetLeapMonth;
    VirtualInvokeData GetLeapMonth_1;
    VirtualInvokeData IsLeapYear;
    VirtualInvokeData IsLeapYear_1;
    VirtualInvokeData ToDateTime;
    VirtualInvokeData ToDateTime_1;
    VirtualInvokeData TryToDateTime;
    VirtualInvokeData IsValidYear;
    VirtualInvokeData IsValidMonth;
    VirtualInvokeData IsValidDay;
    VirtualInvokeData get_TwoDigitYearMax;
    VirtualInvokeData set_TwoDigitYearMax;
    VirtualInvokeData ToFourDigitYear;
};

struct PersianCalendar__StaticFields {
    int32_t PersianEra;
    int64_t PersianEpoch;
    struct Int32__Array *DaysToMonth;
    struct DateTime minDate;
    struct DateTime maxDate;
};

struct PersianCalendar__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PersianCalendar__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PersianCalendar__VTable vtable;
};

struct Calendar__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData get_MinSupportedDateTime;
    VirtualInvokeData get_MaxSupportedDateTime;
    VirtualInvokeData get_ID;
    VirtualInvokeData get_BaseCalendarID;
    VirtualInvokeData get_AlgorithmType;
    VirtualInvokeData Clone_1;
    VirtualInvokeData get_CurrentEraValue;
    VirtualInvokeData AddMilliseconds;
    VirtualInvokeData AddDays;
    VirtualInvokeData AddHours;
    VirtualInvokeData AddMinutes;
    VirtualInvokeData __unknown;
    VirtualInvokeData AddSeconds;
    VirtualInvokeData AddWeeks;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData GetDaysInMonth;
    VirtualInvokeData __unknown_5;
    VirtualInvokeData GetDaysInYear;
    VirtualInvokeData __unknown_6;
    VirtualInvokeData __unknown_7;
    VirtualInvokeData __unknown_8;
    VirtualInvokeData GetHour;
    VirtualInvokeData GetMilliseconds;
    VirtualInvokeData GetMinute;
    VirtualInvokeData __unknown_9;
    VirtualInvokeData GetMonthsInYear;
    VirtualInvokeData __unknown_10;
    VirtualInvokeData GetSecond;
    VirtualInvokeData get_DaysInYearBeforeMinSupportedYear;
    VirtualInvokeData GetWeekOfYear;
    VirtualInvokeData __unknown_11;
    VirtualInvokeData IsLeapDay;
    VirtualInvokeData __unknown_12;
    VirtualInvokeData IsLeapMonth;
    VirtualInvokeData __unknown_13;
    VirtualInvokeData GetLeapMonth;
    VirtualInvokeData GetLeapMonth_1;
    VirtualInvokeData IsLeapYear;
    VirtualInvokeData __unknown_14;
    VirtualInvokeData ToDateTime;
    VirtualInvokeData __unknown_15;
    VirtualInvokeData TryToDateTime;
    VirtualInvokeData IsValidYear;
    VirtualInvokeData IsValidMonth;
    VirtualInvokeData IsValidDay;
    VirtualInvokeData get_TwoDigitYearMax;
    VirtualInvokeData set_TwoDigitYearMax;
    VirtualInvokeData ToFourDigitYear;
};

struct Calendar__StaticFields {
};

struct Calendar__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Calendar__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Calendar__VTable vtable;
};

struct DateTimeFormatFlags__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct DateTimeFormatFlags__Enum__StaticFields {
};

struct DateTimeFormatFlags__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DateTimeFormatFlags__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DateTimeFormatFlags__Enum__VTable vtable;
};

struct Hashtable_bucket__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Hashtable_bucket__StaticFields {
};

struct Hashtable_bucket__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Hashtable_bucket__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Hashtable_bucket__VTable vtable;
};

struct Hashtable_bucket__Array__VTable {
};

struct Hashtable_bucket__Array__StaticFields {
};

struct Hashtable_bucket__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Hashtable_bucket__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Hashtable_bucket__Array__VTable vtable;
};

struct KeyValuePairs__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct KeyValuePairs__StaticFields {
};

struct KeyValuePairs__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePairs__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePairs__VTable vtable;
};

struct KeyValuePairs__Array__VTable {
};

struct KeyValuePairs__Array__StaticFields {
};

struct KeyValuePairs__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePairs__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePairs__Array__VTable vtable;
};

struct Hashtable__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData get_Keys;
    VirtualInvokeData get_Values;
    VirtualInvokeData Contains;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData get_IsReadOnly;
    VirtualInvokeData get_IsFixedSize;
    VirtualInvokeData GetEnumerator;
    VirtualInvokeData Remove;
    VirtualInvokeData CopyTo;
    VirtualInvokeData get_Count;
    VirtualInvokeData get_SyncRoot;
    VirtualInvokeData get_IsSynchronized;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData OnDeserialization;
    VirtualInvokeData Clone;
    VirtualInvokeData Add_1;
    VirtualInvokeData Clear_1;
    VirtualInvokeData Clone_1;
    VirtualInvokeData Contains_1;
    VirtualInvokeData ContainsKey;
    VirtualInvokeData ContainsValue;
    VirtualInvokeData CopyTo_1;
    VirtualInvokeData ToKeyValuePairsArray;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData set_Item_1;
    VirtualInvokeData GetEnumerator_1;
    VirtualInvokeData GetHash;
    VirtualInvokeData get_IsReadOnly_1;
    VirtualInvokeData get_IsFixedSize_1;
    VirtualInvokeData get_IsSynchronized_1;
    VirtualInvokeData KeyEquals;
    VirtualInvokeData get_Keys_1;
    VirtualInvokeData get_Values_1;
    VirtualInvokeData Remove_1;
    VirtualInvokeData get_SyncRoot_1;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData OnDeserialization_1;
};

struct Hashtable__StaticFields {
};

struct Hashtable__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Hashtable__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Hashtable__VTable vtable;
};

struct DateTimeStyles__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct DateTimeStyles__Enum__StaticFields {
};

struct DateTimeStyles__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DateTimeStyles__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DateTimeStyles__Enum__VTable vtable;
};

struct TokenType__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct TokenType__Enum__StaticFields {
};

struct TokenType__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TokenType__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TokenType__Enum__VTable vtable;
};

struct TokenHashValue__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct TokenHashValue__StaticFields {
};

struct TokenHashValue__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TokenHashValue__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TokenHashValue__VTable vtable;
};

struct TokenHashValue__Array__VTable {
};

struct TokenHashValue__Array__StaticFields {
};

struct TokenHashValue__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TokenHashValue__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TokenHashValue__Array__VTable vtable;
};

struct DateTimeFormatInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetFormat;
};

struct DateTimeFormatInfo__StaticFields {
    struct DateTimeFormatInfo *invariantInfo;
    bool preferExistingTokens;
    struct Hashtable *s_calendarNativeNames;
    struct DateTimeFormatInfo *s_jajpDTFI;
    struct DateTimeFormatInfo *s_zhtwDTFI;
};

struct DateTimeFormatInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DateTimeFormatInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DateTimeFormatInfo__VTable vtable;
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Globalization_CultureInfo___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Globalization_CultureInfo___StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Globalization_CultureInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Globalization_CultureInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Globalization_CultureInfo___VTable vtable;
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Globalization_CultureInfo___Array__VTable {
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Globalization_CultureInfo___Array__StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Globalization_CultureInfo___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Globalization_CultureInfo___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Globalization_CultureInfo___Array__VTable vtable;
};

struct IEqualityComparer_1_System_Int32___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData GetHashCode;
};

struct IEqualityComparer_1_System_Int32___StaticFields {
};

struct IEqualityComparer_1_System_Int32___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEqualityComparer_1_System_Int32___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEqualityComparer_1_System_Int32___VTable vtable;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_Globalization_CultureInfo___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TKey__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_Globalization_CultureInfo___StaticFields {
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_Globalization_CultureInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_Globalization_CultureInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_Globalization_CultureInfo___VTable vtable;
};

struct CultureInfo__Array__VTable {
};

struct CultureInfo__Array__StaticFields {
};

struct CultureInfo__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CultureInfo__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CultureInfo__Array__VTable vtable;
};

struct IEnumerator_1_System_Globalization_CultureInfo___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_System_Globalization_CultureInfo___StaticFields {
};

struct IEnumerator_1_System_Globalization_CultureInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_System_Globalization_CultureInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_System_Globalization_CultureInfo___VTable vtable;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_Globalization_CultureInfo___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TValue__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_Globalization_CultureInfo___StaticFields {
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_Globalization_CultureInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_Globalization_CultureInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_Globalization_CultureInfo___VTable vtable;
};

struct ICollection_1_System_Globalization_CultureInfo___VTable {
    VirtualInvokeData get_Count;
    VirtualInvokeData get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
};

struct ICollection_1_System_Globalization_CultureInfo___StaticFields {
};

struct ICollection_1_System_Globalization_CultureInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ICollection_1_System_Globalization_CultureInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ICollection_1_System_Globalization_CultureInfo___VTable vtable;
};

struct CultureInfo___VTable {
};

struct CultureInfo___StaticFields {
};

struct CultureInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CultureInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CultureInfo___VTable vtable;
};

struct KeyValuePair_2_System_Int32_System_Globalization_CultureInfo___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct KeyValuePair_2_System_Int32_System_Globalization_CultureInfo___StaticFields {
};

struct KeyValuePair_2_System_Int32_System_Globalization_CultureInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_Int32_System_Globalization_CultureInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_Int32_System_Globalization_CultureInfo___VTable vtable;
};

struct KeyValuePair_2_System_Int32_System_Globalization_CultureInfo___Array__VTable {
};

struct KeyValuePair_2_System_Int32_System_Globalization_CultureInfo___Array__StaticFields {
};

struct KeyValuePair_2_System_Int32_System_Globalization_CultureInfo___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_Int32_System_Globalization_CultureInfo___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_Int32_System_Globalization_CultureInfo___Array__VTable vtable;
};

struct IEnumerator_1_KeyValuePair_2_System_Int32_System_Globalization_CultureInfo___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_KeyValuePair_2_System_Int32_System_Globalization_CultureInfo___StaticFields {
};

struct IEnumerator_1_KeyValuePair_2_System_Int32_System_Globalization_CultureInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_KeyValuePair_2_System_Int32_System_Globalization_CultureInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_KeyValuePair_2_System_Int32_System_Globalization_CultureInfo___VTable vtable;
};

struct IEnumerable_1_System_Globalization_CultureInfo___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_Globalization_CultureInfo___StaticFields {
};

struct IEnumerable_1_System_Globalization_CultureInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_Globalization_CultureInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_Globalization_CultureInfo___VTable vtable;
};

struct Dictionary_2_System_Int32_System_Globalization_CultureInfo___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Values;
    VirtualInvokeData ContainsKey;
    VirtualInvokeData Add;
    VirtualInvokeData Remove;
    VirtualInvokeData TryGetValue;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Add;
    VirtualInvokeData Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Contains;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_System_Collections_Generic_KeyValuePair_TKey_TValue___GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_get_Item;
    VirtualInvokeData System_Collections_IDictionary_set_Item;
    VirtualInvokeData System_Collections_IDictionary_get_Keys;
    VirtualInvokeData System_Collections_IDictionary_get_Values;
    VirtualInvokeData System_Collections_IDictionary_Contains;
    VirtualInvokeData System_Collections_IDictionary_Add;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IDictionary_get_IsReadOnly;
    VirtualInvokeData System_Collections_IDictionary_get_IsFixedSize;
    VirtualInvokeData System_Collections_IDictionary_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_Remove;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData ContainsKey_1;
    VirtualInvokeData TryGetValue_1;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Values;
    VirtualInvokeData get_Count_2;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData OnDeserialization;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData OnDeserialization_1;
};

struct Dictionary_2_System_Int32_System_Globalization_CultureInfo___StaticFields {
};

struct Dictionary_2_System_Int32_System_Globalization_CultureInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_System_Int32_System_Globalization_CultureInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_System_Int32_System_Globalization_CultureInfo___VTable vtable;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Globalization_CultureInfo___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Globalization_CultureInfo___StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Globalization_CultureInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Globalization_CultureInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Globalization_CultureInfo___VTable vtable;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Globalization_CultureInfo___Array__VTable {
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Globalization_CultureInfo___Array__StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Globalization_CultureInfo___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Globalization_CultureInfo___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Globalization_CultureInfo___Array__VTable vtable;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Globalization_CultureInfo___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TKey__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Globalization_CultureInfo___StaticFields {
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Globalization_CultureInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Globalization_CultureInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Globalization_CultureInfo___VTable vtable;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Globalization_CultureInfo___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TValue__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Globalization_CultureInfo___StaticFields {
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Globalization_CultureInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Globalization_CultureInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Globalization_CultureInfo___VTable vtable;
};

struct KeyValuePair_2_System_String_System_Globalization_CultureInfo___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct KeyValuePair_2_System_String_System_Globalization_CultureInfo___StaticFields {
};

struct KeyValuePair_2_System_String_System_Globalization_CultureInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_String_System_Globalization_CultureInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_String_System_Globalization_CultureInfo___VTable vtable;
};

struct KeyValuePair_2_System_String_System_Globalization_CultureInfo___Array__VTable {
};

struct KeyValuePair_2_System_String_System_Globalization_CultureInfo___Array__StaticFields {
};

struct KeyValuePair_2_System_String_System_Globalization_CultureInfo___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_String_System_Globalization_CultureInfo___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_String_System_Globalization_CultureInfo___Array__VTable vtable;
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_Globalization_CultureInfo___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_Globalization_CultureInfo___StaticFields {
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_Globalization_CultureInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_KeyValuePair_2_System_String_System_Globalization_CultureInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_KeyValuePair_2_System_String_System_Globalization_CultureInfo___VTable vtable;
};

struct Dictionary_2_System_String_System_Globalization_CultureInfo___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Values;
    VirtualInvokeData ContainsKey;
    VirtualInvokeData Add;
    VirtualInvokeData Remove;
    VirtualInvokeData TryGetValue;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Add;
    VirtualInvokeData Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Contains;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_System_Collections_Generic_KeyValuePair_TKey_TValue___GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_get_Item;
    VirtualInvokeData System_Collections_IDictionary_set_Item;
    VirtualInvokeData System_Collections_IDictionary_get_Keys;
    VirtualInvokeData System_Collections_IDictionary_get_Values;
    VirtualInvokeData System_Collections_IDictionary_Contains;
    VirtualInvokeData System_Collections_IDictionary_Add;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IDictionary_get_IsReadOnly;
    VirtualInvokeData System_Collections_IDictionary_get_IsFixedSize;
    VirtualInvokeData System_Collections_IDictionary_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_Remove;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData ContainsKey_1;
    VirtualInvokeData TryGetValue_1;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Values;
    VirtualInvokeData get_Count_2;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData OnDeserialization;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData OnDeserialization_1;
};

struct Dictionary_2_System_String_System_Globalization_CultureInfo___StaticFields {
};

struct Dictionary_2_System_String_System_Globalization_CultureInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_System_String_System_Globalization_CultureInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_System_String_System_Globalization_CultureInfo___VTable vtable;
};

struct Calendar__Array__VTable {
};

struct Calendar__Array__StaticFields {
};

struct Calendar__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Calendar__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Calendar__Array__VTable vtable;
};

struct CultureInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetFormat;
    VirtualInvokeData get_KeyboardLayoutId;
    VirtualInvokeData get_LCID;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_NativeName;
    VirtualInvokeData get_Calendar;
    VirtualInvokeData get_OptionalCalendars;
    VirtualInvokeData get_Parent;
    VirtualInvokeData get_TextInfo;
    VirtualInvokeData get_ThreeLetterISOLanguageName;
    VirtualInvokeData get_ThreeLetterWindowsLanguageName;
    VirtualInvokeData get_TwoLetterISOLanguageName;
    VirtualInvokeData Clone_1;
    VirtualInvokeData get_CompareInfo;
    VirtualInvokeData get_IsNeutralCulture;
    VirtualInvokeData get_NumberFormat;
    VirtualInvokeData set_NumberFormat;
    VirtualInvokeData get_DateTimeFormat;
    VirtualInvokeData set_DateTimeFormat;
    VirtualInvokeData get_DisplayName;
    VirtualInvokeData get_EnglishName;
    VirtualInvokeData GetFormat_1;
};

struct CultureInfo__StaticFields {
    struct CultureInfo *invariant_culture_info;
    struct Object *shared_table_lock;
    struct CultureInfo *default_current_culture;
    struct CultureInfo *s_DefaultThreadCurrentUICulture;
    struct CultureInfo *s_DefaultThreadCurrentCulture;
    struct Dictionary_2_System_Int32_System_Globalization_CultureInfo_ *shared_by_number;
    struct Dictionary_2_System_String_System_Globalization_CultureInfo_ *shared_by_name;
    bool IsTaiwanSku;
};

struct CultureInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CultureInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CultureInfo__VTable vtable;
};

struct Object__1__VTable {
};

struct Object__1__StaticFields {
};

struct Object__1__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Object__1__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Object__1__VTable vtable;
};

struct RuntimeTypeHandle__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
};

struct RuntimeTypeHandle__StaticFields {
};

struct RuntimeTypeHandle__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeTypeHandle__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeTypeHandle__VTable vtable;
};

struct TypedReference__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct TypedReference__StaticFields {
};

struct TypedReference__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypedReference__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypedReference__VTable vtable;
};

struct FieldAttributes__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct FieldAttributes__Enum__StaticFields {
};

struct FieldAttributes__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FieldAttributes__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FieldAttributes__Enum__VTable vtable;
};

struct RuntimeFieldHandle__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
};

struct RuntimeFieldHandle__StaticFields {
};

struct RuntimeFieldHandle__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeFieldHandle__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeFieldHandle__VTable vtable;
};

struct RuntimeFieldInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData __unknown_5;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData Equals_2;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData System_Runtime_InteropServices__FieldInfo_GetType;
    VirtualInvokeData System_Runtime_InteropServices__FieldInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__FieldInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__FieldInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__FieldInfo_Invoke;
    VirtualInvokeData GetValue;
    VirtualInvokeData GetValueDirect;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData SetValue;
    VirtualInvokeData SetValue_1;
    VirtualInvokeData SetValueDirect;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData get_FieldHandle;
    VirtualInvokeData get_FieldType;
    VirtualInvokeData get_IsAssembly;
    VirtualInvokeData get_IsFamily;
    VirtualInvokeData get_IsFamilyAndAssembly;
    VirtualInvokeData get_IsFamilyOrAssembly;
    VirtualInvokeData get_IsInitOnly;
    VirtualInvokeData get_IsLiteral;
    VirtualInvokeData get_IsNotSerialized;
    VirtualInvokeData get_IsPinvokeImpl;
    VirtualInvokeData get_IsPrivate;
    VirtualInvokeData get_IsPublic;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_IsStatic;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData __unknown_6;
    VirtualInvokeData __unknown_7;
    VirtualInvokeData __unknown_8;
    VirtualInvokeData __unknown_9;
    VirtualInvokeData __unknown_10;
    VirtualInvokeData GetFieldOffset;
    VirtualInvokeData GetValueDirect_1;
    VirtualInvokeData SetValueDirect_1;
    VirtualInvokeData GetOptionalCustomModifiers;
    VirtualInvokeData GetRequiredCustomModifiers;
    VirtualInvokeData GetRawConstantValue;
    VirtualInvokeData get_IsSecurityCritical;
    VirtualInvokeData get_IsSecuritySafeCritical;
    VirtualInvokeData get_IsSecurityTransparent;
    VirtualInvokeData GetObjectData;
};

struct RuntimeFieldInfo__StaticFields {
};

struct RuntimeFieldInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeFieldInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeFieldInfo__VTable vtable;
};

struct RtFieldInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData __unknown_5;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData Equals_2;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData System_Runtime_InteropServices__FieldInfo_GetType;
    VirtualInvokeData System_Runtime_InteropServices__FieldInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__FieldInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__FieldInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__FieldInfo_Invoke;
    VirtualInvokeData GetValue;
    VirtualInvokeData GetValueDirect;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData SetValue;
    VirtualInvokeData SetValue_1;
    VirtualInvokeData SetValueDirect;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData get_FieldHandle;
    VirtualInvokeData get_FieldType;
    VirtualInvokeData get_IsAssembly;
    VirtualInvokeData get_IsFamily;
    VirtualInvokeData get_IsFamilyAndAssembly;
    VirtualInvokeData get_IsFamilyOrAssembly;
    VirtualInvokeData get_IsInitOnly;
    VirtualInvokeData get_IsLiteral;
    VirtualInvokeData get_IsNotSerialized;
    VirtualInvokeData get_IsPinvokeImpl;
    VirtualInvokeData get_IsPrivate;
    VirtualInvokeData get_IsPublic;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_IsStatic;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData __unknown_6;
    VirtualInvokeData __unknown_7;
    VirtualInvokeData __unknown_8;
    VirtualInvokeData __unknown_9;
    VirtualInvokeData __unknown_10;
    VirtualInvokeData GetFieldOffset;
    VirtualInvokeData GetValueDirect_1;
    VirtualInvokeData SetValueDirect_1;
    VirtualInvokeData GetOptionalCustomModifiers;
    VirtualInvokeData GetRequiredCustomModifiers;
    VirtualInvokeData GetRawConstantValue;
    VirtualInvokeData get_IsSecurityCritical;
    VirtualInvokeData get_IsSecuritySafeCritical;
    VirtualInvokeData get_IsSecurityTransparent;
    VirtualInvokeData GetObjectData;
};

struct RtFieldInfo__StaticFields {
};

struct RtFieldInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RtFieldInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RtFieldInfo__VTable vtable;
};

struct MonoField__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData Equals_2;
    VirtualInvokeData GetCustomAttributes_6;
    VirtualInvokeData GetCustomAttributes_7;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData System_Runtime_InteropServices__FieldInfo_GetType;
    VirtualInvokeData System_Runtime_InteropServices__FieldInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__FieldInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__FieldInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__FieldInfo_Invoke;
    VirtualInvokeData GetValue;
    VirtualInvokeData GetValueDirect;
    VirtualInvokeData IsDefined_3;
    VirtualInvokeData SetValue;
    VirtualInvokeData SetValue_1;
    VirtualInvokeData SetValueDirect;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_DeclaringType_2;
    VirtualInvokeData get_FieldHandle;
    VirtualInvokeData get_FieldType;
    VirtualInvokeData get_IsAssembly;
    VirtualInvokeData get_IsFamily;
    VirtualInvokeData get_IsFamilyAndAssembly;
    VirtualInvokeData get_IsFamilyOrAssembly;
    VirtualInvokeData get_IsInitOnly;
    VirtualInvokeData get_IsLiteral;
    VirtualInvokeData get_IsNotSerialized;
    VirtualInvokeData get_IsPinvokeImpl;
    VirtualInvokeData get_IsPrivate;
    VirtualInvokeData get_IsPublic;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_IsStatic;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_Name_2;
    VirtualInvokeData get_ReflectedType_2;
    VirtualInvokeData get_Attributes_1;
    VirtualInvokeData get_FieldHandle_1;
    VirtualInvokeData get_FieldType_1;
    VirtualInvokeData GetValue_1;
    VirtualInvokeData SetValue_2;
    VirtualInvokeData GetFieldOffset;
    VirtualInvokeData GetValueDirect_1;
    VirtualInvokeData SetValueDirect_1;
    VirtualInvokeData GetOptionalCustomModifiers;
    VirtualInvokeData GetRequiredCustomModifiers;
    VirtualInvokeData GetRawConstantValue;
    VirtualInvokeData get_IsSecurityCritical;
    VirtualInvokeData get_IsSecuritySafeCritical;
    VirtualInvokeData get_IsSecurityTransparent;
    VirtualInvokeData GetObjectData;
};

struct MonoField__StaticFields {
};

struct MonoField__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoField__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoField__VTable vtable;
};

struct FieldInfo_1__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData __unknown_5;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData Equals_2;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData System_Runtime_InteropServices__FieldInfo_GetType;
    VirtualInvokeData System_Runtime_InteropServices__FieldInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__FieldInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__FieldInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__FieldInfo_Invoke;
    VirtualInvokeData GetValue;
    VirtualInvokeData GetValueDirect;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData SetValue;
    VirtualInvokeData SetValue_1;
    VirtualInvokeData SetValueDirect;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData get_FieldHandle;
    VirtualInvokeData get_FieldType;
    VirtualInvokeData get_IsAssembly;
    VirtualInvokeData get_IsFamily;
    VirtualInvokeData get_IsFamilyAndAssembly;
    VirtualInvokeData get_IsFamilyOrAssembly;
    VirtualInvokeData get_IsInitOnly;
    VirtualInvokeData get_IsLiteral;
    VirtualInvokeData get_IsNotSerialized;
    VirtualInvokeData get_IsPinvokeImpl;
    VirtualInvokeData get_IsPrivate;
    VirtualInvokeData get_IsPublic;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_IsStatic;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData __unknown_6;
    VirtualInvokeData __unknown_7;
    VirtualInvokeData __unknown_8;
    VirtualInvokeData __unknown_9;
    VirtualInvokeData __unknown_10;
    VirtualInvokeData GetFieldOffset;
    VirtualInvokeData GetValueDirect_1;
    VirtualInvokeData SetValueDirect_1;
    VirtualInvokeData GetOptionalCustomModifiers;
    VirtualInvokeData GetRequiredCustomModifiers;
    VirtualInvokeData GetRawConstantValue;
    VirtualInvokeData get_IsSecurityCritical;
    VirtualInvokeData get_IsSecuritySafeCritical;
    VirtualInvokeData get_IsSecurityTransparent;
};

struct FieldInfo_1__StaticFields {
};

struct FieldInfo_1__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FieldInfo_1__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FieldInfo_1__VTable vtable;
};

struct FieldInfo_1__Array__VTable {
};

struct FieldInfo_1__Array__StaticFields {
};

struct FieldInfo_1__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FieldInfo_1__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FieldInfo_1__Array__VTable vtable;
};

struct MethodInfo_1__Array__VTable {
};

struct MethodInfo_1__Array__StaticFields {
};

struct MethodInfo_1__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MethodInfo_1__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MethodInfo_1__Array__VTable vtable;
};

struct PropertyAttributes__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct PropertyAttributes__Enum__StaticFields {
};

struct PropertyAttributes__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PropertyAttributes__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PropertyAttributes__Enum__VTable vtable;
};

struct RuntimePropertyInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData __unknown_5;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData Equals_2;
    VirtualInvokeData GetAccessors;
    VirtualInvokeData GetAccessors_1;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData GetGetMethod;
    VirtualInvokeData GetGetMethod_1;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData GetIndexParameters;
    VirtualInvokeData GetSetMethod;
    VirtualInvokeData GetSetMethod_1;
    VirtualInvokeData System_Runtime_InteropServices__PropertyInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__PropertyInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__PropertyInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__PropertyInfo_Invoke;
    VirtualInvokeData System_Runtime_InteropServices__PropertyInfo_GetType;
    VirtualInvokeData GetValue;
    VirtualInvokeData GetValue_1;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData SetValue;
    VirtualInvokeData SetValue_1;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_CanRead;
    VirtualInvokeData get_CanWrite;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_PropertyType;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData __unknown_6;
    VirtualInvokeData __unknown_7;
    VirtualInvokeData __unknown_8;
    VirtualInvokeData get_GetMethod;
    VirtualInvokeData get_SetMethod;
    VirtualInvokeData __unknown_9;
    VirtualInvokeData __unknown_10;
    VirtualInvokeData __unknown_11;
    VirtualInvokeData __unknown_12;
    VirtualInvokeData __unknown_13;
    VirtualInvokeData GetValue_2;
    VirtualInvokeData __unknown_14;
    VirtualInvokeData SetValue_2;
    VirtualInvokeData __unknown_15;
    VirtualInvokeData GetOptionalCustomModifiers;
    VirtualInvokeData GetRequiredCustomModifiers;
    VirtualInvokeData GetConstantValue;
    VirtualInvokeData GetRawConstantValue;
    VirtualInvokeData GetObjectData;
};

struct RuntimePropertyInfo__StaticFields {
};

struct RuntimePropertyInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimePropertyInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimePropertyInfo__VTable vtable;
};

struct MonoPropertyInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct MonoPropertyInfo__StaticFields {
};

struct MonoPropertyInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoPropertyInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoPropertyInfo__VTable vtable;
};

struct PInfo__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct PInfo__Enum__StaticFields {
};

struct PInfo__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PInfo__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PInfo__Enum__VTable vtable;
};

struct Delegate__Array__VTable {
};

struct Delegate__Array__StaticFields {
};

struct Delegate__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Delegate__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Delegate__Array__VTable vtable;
};

struct IAsyncResult__VTable {
    VirtualInvokeData get_IsCompleted;
    VirtualInvokeData get_AsyncWaitHandle;
    VirtualInvokeData get_AsyncState;
    VirtualInvokeData get_CompletedSynchronously;
};

struct IAsyncResult__StaticFields {
};

struct IAsyncResult__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IAsyncResult__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IAsyncResult__VTable vtable;
};

struct AsyncCallback__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct AsyncCallback__StaticFields {
};

struct AsyncCallback__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AsyncCallback__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AsyncCallback__VTable vtable;
};

struct MonoProperty_GetterAdapter__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct MonoProperty_GetterAdapter__StaticFields {
};

struct MonoProperty_GetterAdapter__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoProperty_GetterAdapter__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoProperty_GetterAdapter__VTable vtable;
};

struct MonoProperty__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData Equals_2;
    VirtualInvokeData GetAccessors;
    VirtualInvokeData GetAccessors_1;
    VirtualInvokeData GetCustomAttributes_6;
    VirtualInvokeData GetCustomAttributes_7;
    VirtualInvokeData GetGetMethod;
    VirtualInvokeData GetGetMethod_1;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData GetIndexParameters;
    VirtualInvokeData GetSetMethod;
    VirtualInvokeData GetSetMethod_1;
    VirtualInvokeData System_Runtime_InteropServices__PropertyInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__PropertyInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__PropertyInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__PropertyInfo_Invoke;
    VirtualInvokeData System_Runtime_InteropServices__PropertyInfo_GetType;
    VirtualInvokeData GetValue;
    VirtualInvokeData GetValue_1;
    VirtualInvokeData IsDefined_3;
    VirtualInvokeData SetValue;
    VirtualInvokeData SetValue_1;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_CanRead;
    VirtualInvokeData get_CanWrite;
    VirtualInvokeData get_DeclaringType_2;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_Name_2;
    VirtualInvokeData get_PropertyType;
    VirtualInvokeData get_ReflectedType_2;
    VirtualInvokeData get_Attributes_1;
    VirtualInvokeData get_CanRead_1;
    VirtualInvokeData get_CanWrite_1;
    VirtualInvokeData get_GetMethod;
    VirtualInvokeData get_SetMethod;
    VirtualInvokeData get_PropertyType_1;
    VirtualInvokeData GetAccessors_2;
    VirtualInvokeData GetGetMethod_2;
    VirtualInvokeData GetIndexParameters_1;
    VirtualInvokeData GetSetMethod_2;
    VirtualInvokeData GetValue_2;
    VirtualInvokeData GetValue_3;
    VirtualInvokeData SetValue_2;
    VirtualInvokeData SetValue_3;
    VirtualInvokeData GetOptionalCustomModifiers;
    VirtualInvokeData GetRequiredCustomModifiers;
    VirtualInvokeData GetConstantValue;
    VirtualInvokeData GetRawConstantValue;
    VirtualInvokeData GetObjectData;
};

struct MonoProperty__StaticFields {
};

struct MonoProperty__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoProperty__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoProperty__VTable vtable;
};

struct PropertyInfo_1__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData __unknown_5;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData Equals_2;
    VirtualInvokeData GetAccessors;
    VirtualInvokeData GetAccessors_1;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData GetGetMethod;
    VirtualInvokeData GetGetMethod_1;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData GetIndexParameters;
    VirtualInvokeData GetSetMethod;
    VirtualInvokeData GetSetMethod_1;
    VirtualInvokeData System_Runtime_InteropServices__PropertyInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__PropertyInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__PropertyInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__PropertyInfo_Invoke;
    VirtualInvokeData System_Runtime_InteropServices__PropertyInfo_GetType;
    VirtualInvokeData GetValue;
    VirtualInvokeData GetValue_1;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData SetValue;
    VirtualInvokeData SetValue_1;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_CanRead;
    VirtualInvokeData get_CanWrite;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_PropertyType;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData __unknown_6;
    VirtualInvokeData __unknown_7;
    VirtualInvokeData __unknown_8;
    VirtualInvokeData get_GetMethod;
    VirtualInvokeData get_SetMethod;
    VirtualInvokeData __unknown_9;
    VirtualInvokeData __unknown_10;
    VirtualInvokeData __unknown_11;
    VirtualInvokeData __unknown_12;
    VirtualInvokeData __unknown_13;
    VirtualInvokeData GetValue_2;
    VirtualInvokeData __unknown_14;
    VirtualInvokeData SetValue_2;
    VirtualInvokeData __unknown_15;
    VirtualInvokeData GetOptionalCustomModifiers;
    VirtualInvokeData GetRequiredCustomModifiers;
    VirtualInvokeData GetConstantValue;
    VirtualInvokeData GetRawConstantValue;
};

struct PropertyInfo_1__StaticFields {
};

struct PropertyInfo_1__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PropertyInfo_1__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PropertyInfo_1__VTable vtable;
};

struct PropertyInfo_1__Array__VTable {
};

struct PropertyInfo_1__Array__StaticFields {
};

struct PropertyInfo_1__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PropertyInfo_1__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PropertyInfo_1__Array__VTable vtable;
};

struct DefaultBinder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData BindToMethod;
    VirtualInvokeData BindToField;
    VirtualInvokeData SelectMethod;
    VirtualInvokeData SelectProperty;
    VirtualInvokeData ChangeType;
    VirtualInvokeData ReorderArgumentArray;
};

struct DefaultBinder__StaticFields {
};

struct DefaultBinder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DefaultBinder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DefaultBinder__VTable vtable;
};

struct Binder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData __unknown_5;
};

struct Binder__StaticFields {
};

struct Binder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Binder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Binder__VTable vtable;
};

struct MethodAttributes__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct MethodAttributes__Enum__StaticFields {
};

struct MethodAttributes__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MethodAttributes__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MethodAttributes__Enum__VTable vtable;
};

struct CallingConventions__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct CallingConventions__Enum__StaticFields {
};

struct CallingConventions__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CallingConventions__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CallingConventions__Enum__VTable vtable;
};

struct RuntimeMethodHandle__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
};

struct RuntimeMethodHandle__StaticFields {
};

struct RuntimeMethodHandle__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeMethodHandle__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeMethodHandle__VTable vtable;
};

struct ExceptionHandlingClauseOptions__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct ExceptionHandlingClauseOptions__Enum__StaticFields {
};

struct ExceptionHandlingClauseOptions__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ExceptionHandlingClauseOptions__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ExceptionHandlingClauseOptions__Enum__VTable vtable;
};

struct ExceptionHandlingClause__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_CatchType;
    VirtualInvokeData get_FilterOffset;
    VirtualInvokeData get_Flags;
    VirtualInvokeData get_HandlerLength;
    VirtualInvokeData get_HandlerOffset;
    VirtualInvokeData get_TryLength;
    VirtualInvokeData get_TryOffset;
};

struct ExceptionHandlingClause__StaticFields {
};

struct ExceptionHandlingClause__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ExceptionHandlingClause__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ExceptionHandlingClause__VTable vtable;
};

struct ExceptionHandlingClause__Array__VTable {
};

struct ExceptionHandlingClause__Array__StaticFields {
};

struct ExceptionHandlingClause__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ExceptionHandlingClause__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ExceptionHandlingClause__Array__VTable vtable;
};

struct LocalVariableInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_IsPinned;
    VirtualInvokeData get_LocalIndex;
    VirtualInvokeData get_LocalType;
};

struct LocalVariableInfo__StaticFields {
};

struct LocalVariableInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct LocalVariableInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct LocalVariableInfo__VTable vtable;
};

struct LocalVariableInfo__Array__VTable {
};

struct LocalVariableInfo__Array__StaticFields {
};

struct LocalVariableInfo__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct LocalVariableInfo__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct LocalVariableInfo__Array__VTable vtable;
};

struct IList_1_System_Reflection_ExceptionHandlingClause___VTable {
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData RemoveAt;
};

struct IList_1_System_Reflection_ExceptionHandlingClause___StaticFields {
};

struct IList_1_System_Reflection_ExceptionHandlingClause___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IList_1_System_Reflection_ExceptionHandlingClause___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IList_1_System_Reflection_ExceptionHandlingClause___VTable vtable;
};

struct IList_1_System_Reflection_LocalVariableInfo___VTable {
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData RemoveAt;
};

struct IList_1_System_Reflection_LocalVariableInfo___StaticFields {
};

struct IList_1_System_Reflection_LocalVariableInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IList_1_System_Reflection_LocalVariableInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IList_1_System_Reflection_LocalVariableInfo___VTable vtable;
};

struct MethodBody__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_ExceptionHandlingClauses;
    VirtualInvokeData get_LocalVariables;
    VirtualInvokeData get_InitLocals;
    VirtualInvokeData get_LocalSignatureMetadataToken;
    VirtualInvokeData get_MaxStackSize;
    VirtualInvokeData GetILAsByteArray;
};

struct MethodBody__StaticFields {
};

struct MethodBody__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MethodBody__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MethodBody__VTable vtable;
};

struct ICustomAttributeProvider__VTable {
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
};

struct ICustomAttributeProvider__StaticFields {
};

struct ICustomAttributeProvider__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ICustomAttributeProvider__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ICustomAttributeProvider__VTable vtable;
};

struct RuntimeMethodInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData __unknown_5;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData Equals_2;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData GetMethodImplementationFlags;
    VirtualInvokeData GetParameters;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_Invoke;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetType;
    VirtualInvokeData Invoke;
    VirtualInvokeData Invoke_1;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_CallingConvention;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsAbstract;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsAssembly;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsConstructor;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFamily;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFamilyAndAssembly;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFamilyOrAssembly;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFinal;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsHideBySig;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsPrivate;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsPublic;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsSpecialName;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsStatic;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsVirtual;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_MethodHandle;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData GetParametersNoCopy;
    VirtualInvokeData __unknown_6;
    VirtualInvokeData get_MethodImplementationFlags;
    VirtualInvokeData __unknown_7;
    VirtualInvokeData __unknown_8;
    VirtualInvokeData __unknown_9;
    VirtualInvokeData __unknown_10;
    VirtualInvokeData get_CallingConvention_1;
    VirtualInvokeData GetGenericArguments;
    VirtualInvokeData get_IsGenericMethodDefinition;
    VirtualInvokeData get_ContainsGenericParameters;
    VirtualInvokeData get_IsGenericMethod;
    VirtualInvokeData get_IsSecurityCritical;
    VirtualInvokeData get_IsSecuritySafeCritical;
    VirtualInvokeData get_IsSecurityTransparent;
    VirtualInvokeData get_IsPublic;
    VirtualInvokeData get_IsPrivate;
    VirtualInvokeData get_IsFamily;
    VirtualInvokeData get_IsAssembly;
    VirtualInvokeData get_IsFamilyAndAssembly;
    VirtualInvokeData get_IsFamilyOrAssembly;
    VirtualInvokeData get_IsStatic;
    VirtualInvokeData get_IsFinal;
    VirtualInvokeData get_IsVirtual;
    VirtualInvokeData get_IsHideBySig;
    VirtualInvokeData get_IsAbstract;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_IsConstructor;
    VirtualInvokeData GetMethodBody;
    VirtualInvokeData FormatNameAndSig;
    VirtualInvokeData GetParameterTypes;
    VirtualInvokeData GetParametersInternal;
    VirtualInvokeData GetParametersCount;
    VirtualInvokeData GetParameterType;
    VirtualInvokeData get_next_table_index;
    VirtualInvokeData Equals_3;
    VirtualInvokeData GetBaseDefinition;
    VirtualInvokeData GetCustomAttributes_6;
    VirtualInvokeData GetCustomAttributes_7;
    VirtualInvokeData GetHashCode_3;
    VirtualInvokeData GetMethodImplementationFlags_1;
    VirtualInvokeData GetParameters_1;
    VirtualInvokeData System_Runtime_InteropServices__MethodInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MethodInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MethodInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MethodInfo_Invoke;
    VirtualInvokeData System_Runtime_InteropServices__MethodInfo_GetType;
    VirtualInvokeData Invoke_2;
    VirtualInvokeData Invoke_3;
    VirtualInvokeData IsDefined_3;
    VirtualInvokeData ToString_3;
    VirtualInvokeData get_Attributes_1;
    VirtualInvokeData get_CallingConvention_2;
    VirtualInvokeData get_DeclaringType_2;
    VirtualInvokeData get_IsAbstract_1;
    VirtualInvokeData get_IsAssembly_1;
    VirtualInvokeData get_IsConstructor_1;
    VirtualInvokeData get_IsFamily_1;
    VirtualInvokeData get_IsFamilyAndAssembly_1;
    VirtualInvokeData get_IsFamilyOrAssembly_1;
    VirtualInvokeData get_IsFinal_1;
    VirtualInvokeData get_IsHideBySig_1;
    VirtualInvokeData get_IsPrivate_1;
    VirtualInvokeData get_IsPublic_1;
    VirtualInvokeData get_IsSpecialName_1;
    VirtualInvokeData get_IsStatic_1;
    VirtualInvokeData get_IsVirtual_1;
    VirtualInvokeData get_MemberType_3;
    VirtualInvokeData get_MethodHandle_1;
    VirtualInvokeData get_Name_2;
    VirtualInvokeData get_ReflectedType_2;
    VirtualInvokeData get_ReturnType;
    VirtualInvokeData get_ReturnTypeCustomAttributes;
    VirtualInvokeData get_ReturnType_1;
    VirtualInvokeData get_ReturnParameter;
    VirtualInvokeData __unknown_11;
    VirtualInvokeData __unknown_12;
    VirtualInvokeData GetGenericMethodDefinition;
    VirtualInvokeData MakeGenericMethod;
    VirtualInvokeData CreateDelegate;
    VirtualInvokeData CreateDelegate_1;
    VirtualInvokeData GetBaseMethod;
    VirtualInvokeData GetObjectData;
};

struct RuntimeMethodInfo__StaticFields {
};

struct RuntimeMethodInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeMethodInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeMethodInfo__VTable vtable;
};

struct MonoMethod__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData Equals_2;
    VirtualInvokeData GetCustomAttributes_6;
    VirtualInvokeData GetCustomAttributes_7;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData GetMethodImplementationFlags;
    VirtualInvokeData GetParameters;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_Invoke;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetType;
    VirtualInvokeData Invoke;
    VirtualInvokeData Invoke_1;
    VirtualInvokeData IsDefined_3;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_CallingConvention;
    VirtualInvokeData get_DeclaringType_2;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsAbstract;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsAssembly;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsConstructor;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFamily;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFamilyAndAssembly;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFamilyOrAssembly;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFinal;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsHideBySig;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsPrivate;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsPublic;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsSpecialName;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsStatic;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsVirtual;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_MethodHandle;
    VirtualInvokeData get_Name_2;
    VirtualInvokeData get_ReflectedType_2;
    VirtualInvokeData GetParametersNoCopy;
    VirtualInvokeData GetParameters_1;
    VirtualInvokeData get_MethodImplementationFlags;
    VirtualInvokeData GetMethodImplementationFlags_1;
    VirtualInvokeData get_MethodHandle_1;
    VirtualInvokeData get_Attributes_1;
    VirtualInvokeData Invoke_2;
    VirtualInvokeData get_CallingConvention_1;
    VirtualInvokeData GetGenericArguments;
    VirtualInvokeData get_IsGenericMethodDefinition;
    VirtualInvokeData get_ContainsGenericParameters;
    VirtualInvokeData get_IsGenericMethod;
    VirtualInvokeData get_IsSecurityCritical;
    VirtualInvokeData get_IsSecuritySafeCritical;
    VirtualInvokeData get_IsSecurityTransparent;
    VirtualInvokeData get_IsPublic;
    VirtualInvokeData get_IsPrivate;
    VirtualInvokeData get_IsFamily;
    VirtualInvokeData get_IsAssembly;
    VirtualInvokeData get_IsFamilyAndAssembly;
    VirtualInvokeData get_IsFamilyOrAssembly;
    VirtualInvokeData get_IsStatic;
    VirtualInvokeData get_IsFinal;
    VirtualInvokeData get_IsVirtual;
    VirtualInvokeData get_IsHideBySig;
    VirtualInvokeData get_IsAbstract;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_IsConstructor;
    VirtualInvokeData GetMethodBody;
    VirtualInvokeData FormatNameAndSig;
    VirtualInvokeData GetParameterTypes;
    VirtualInvokeData GetParametersInternal;
    VirtualInvokeData GetParametersCount;
    VirtualInvokeData GetParameterType;
    VirtualInvokeData get_next_table_index;
    VirtualInvokeData Equals_3;
    VirtualInvokeData GetBaseDefinition;
    VirtualInvokeData GetCustomAttributes_8;
    VirtualInvokeData GetCustomAttributes_9;
    VirtualInvokeData GetHashCode_3;
    VirtualInvokeData GetMethodImplementationFlags_2;
    VirtualInvokeData GetParameters_2;
    VirtualInvokeData System_Runtime_InteropServices__MethodInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MethodInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MethodInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MethodInfo_Invoke;
    VirtualInvokeData System_Runtime_InteropServices__MethodInfo_GetType;
    VirtualInvokeData Invoke_3;
    VirtualInvokeData Invoke_4;
    VirtualInvokeData IsDefined_4;
    VirtualInvokeData ToString_3;
    VirtualInvokeData get_Attributes_2;
    VirtualInvokeData get_CallingConvention_2;
    VirtualInvokeData get_DeclaringType_3;
    VirtualInvokeData get_IsAbstract_1;
    VirtualInvokeData get_IsAssembly_1;
    VirtualInvokeData get_IsConstructor_1;
    VirtualInvokeData get_IsFamily_1;
    VirtualInvokeData get_IsFamilyAndAssembly_1;
    VirtualInvokeData get_IsFamilyOrAssembly_1;
    VirtualInvokeData get_IsFinal_1;
    VirtualInvokeData get_IsHideBySig_1;
    VirtualInvokeData get_IsPrivate_1;
    VirtualInvokeData get_IsPublic_1;
    VirtualInvokeData get_IsSpecialName_1;
    VirtualInvokeData get_IsStatic_1;
    VirtualInvokeData get_IsVirtual_1;
    VirtualInvokeData get_MemberType_3;
    VirtualInvokeData get_MethodHandle_2;
    VirtualInvokeData get_Name_3;
    VirtualInvokeData get_ReflectedType_3;
    VirtualInvokeData get_ReturnType;
    VirtualInvokeData get_ReturnTypeCustomAttributes;
    VirtualInvokeData get_ReturnType_1;
    VirtualInvokeData get_ReturnParameter;
    VirtualInvokeData get_ReturnTypeCustomAttributes_1;
    VirtualInvokeData GetBaseDefinition_1;
    VirtualInvokeData GetGenericMethodDefinition;
    VirtualInvokeData MakeGenericMethod;
    VirtualInvokeData CreateDelegate;
    VirtualInvokeData CreateDelegate_1;
    VirtualInvokeData GetBaseMethod;
    VirtualInvokeData GetObjectData;
};

struct MonoMethod__StaticFields {
};

struct MonoMethod__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoMethod__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoMethod__VTable vtable;
};

struct MethodBase__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData __unknown_5;
    VirtualInvokeData __unknown_6;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData Equals_2;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData GetMethodImplementationFlags;
    VirtualInvokeData GetParameters;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_Invoke;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetType;
    VirtualInvokeData Invoke;
    VirtualInvokeData Invoke_1;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_CallingConvention;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsAbstract;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsAssembly;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsConstructor;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFamily;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFamilyAndAssembly;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFamilyOrAssembly;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFinal;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsHideBySig;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsPrivate;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsPublic;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsSpecialName;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsStatic;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsVirtual;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData get_MethodHandle;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData GetParametersNoCopy;
    VirtualInvokeData __unknown_7;
    VirtualInvokeData get_MethodImplementationFlags;
    VirtualInvokeData __unknown_8;
    VirtualInvokeData __unknown_9;
    VirtualInvokeData __unknown_10;
    VirtualInvokeData __unknown_11;
    VirtualInvokeData get_CallingConvention_1;
    VirtualInvokeData GetGenericArguments;
    VirtualInvokeData get_IsGenericMethodDefinition;
    VirtualInvokeData get_ContainsGenericParameters;
    VirtualInvokeData get_IsGenericMethod;
    VirtualInvokeData get_IsSecurityCritical;
    VirtualInvokeData get_IsSecuritySafeCritical;
    VirtualInvokeData get_IsSecurityTransparent;
    VirtualInvokeData get_IsPublic;
    VirtualInvokeData get_IsPrivate;
    VirtualInvokeData get_IsFamily;
    VirtualInvokeData get_IsAssembly;
    VirtualInvokeData get_IsFamilyAndAssembly;
    VirtualInvokeData get_IsFamilyOrAssembly;
    VirtualInvokeData get_IsStatic;
    VirtualInvokeData get_IsFinal;
    VirtualInvokeData get_IsVirtual;
    VirtualInvokeData get_IsHideBySig;
    VirtualInvokeData get_IsAbstract;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_IsConstructor;
    VirtualInvokeData GetMethodBody;
    VirtualInvokeData FormatNameAndSig;
    VirtualInvokeData GetParameterTypes;
    VirtualInvokeData GetParametersInternal;
    VirtualInvokeData GetParametersCount;
    VirtualInvokeData GetParameterType;
    VirtualInvokeData get_next_table_index;
};

struct MethodBase__StaticFields {
};

struct MethodBase__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MethodBase__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MethodBase__VTable vtable;
};

struct MethodInfo_1__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData __unknown_5;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData Equals_2;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData GetMethodImplementationFlags;
    VirtualInvokeData GetParameters;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_Invoke;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetType;
    VirtualInvokeData Invoke;
    VirtualInvokeData Invoke_1;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_CallingConvention;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsAbstract;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsAssembly;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsConstructor;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFamily;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFamilyAndAssembly;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFamilyOrAssembly;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFinal;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsHideBySig;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsPrivate;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsPublic;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsSpecialName;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsStatic;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsVirtual;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_MethodHandle;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData GetParametersNoCopy;
    VirtualInvokeData __unknown_6;
    VirtualInvokeData get_MethodImplementationFlags;
    VirtualInvokeData __unknown_7;
    VirtualInvokeData __unknown_8;
    VirtualInvokeData __unknown_9;
    VirtualInvokeData __unknown_10;
    VirtualInvokeData get_CallingConvention_1;
    VirtualInvokeData GetGenericArguments;
    VirtualInvokeData get_IsGenericMethodDefinition;
    VirtualInvokeData get_ContainsGenericParameters;
    VirtualInvokeData get_IsGenericMethod;
    VirtualInvokeData get_IsSecurityCritical;
    VirtualInvokeData get_IsSecuritySafeCritical;
    VirtualInvokeData get_IsSecurityTransparent;
    VirtualInvokeData get_IsPublic;
    VirtualInvokeData get_IsPrivate;
    VirtualInvokeData get_IsFamily;
    VirtualInvokeData get_IsAssembly;
    VirtualInvokeData get_IsFamilyAndAssembly;
    VirtualInvokeData get_IsFamilyOrAssembly;
    VirtualInvokeData get_IsStatic;
    VirtualInvokeData get_IsFinal;
    VirtualInvokeData get_IsVirtual;
    VirtualInvokeData get_IsHideBySig;
    VirtualInvokeData get_IsAbstract;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_IsConstructor;
    VirtualInvokeData GetMethodBody;
    VirtualInvokeData FormatNameAndSig;
    VirtualInvokeData GetParameterTypes;
    VirtualInvokeData GetParametersInternal;
    VirtualInvokeData GetParametersCount;
    VirtualInvokeData GetParameterType;
    VirtualInvokeData get_next_table_index;
    VirtualInvokeData Equals_3;
    VirtualInvokeData GetBaseDefinition;
    VirtualInvokeData GetCustomAttributes_6;
    VirtualInvokeData GetCustomAttributes_7;
    VirtualInvokeData GetHashCode_3;
    VirtualInvokeData GetMethodImplementationFlags_1;
    VirtualInvokeData GetParameters_1;
    VirtualInvokeData System_Runtime_InteropServices__MethodInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MethodInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MethodInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MethodInfo_Invoke;
    VirtualInvokeData System_Runtime_InteropServices__MethodInfo_GetType;
    VirtualInvokeData Invoke_2;
    VirtualInvokeData Invoke_3;
    VirtualInvokeData IsDefined_3;
    VirtualInvokeData ToString_3;
    VirtualInvokeData get_Attributes_1;
    VirtualInvokeData get_CallingConvention_2;
    VirtualInvokeData get_DeclaringType_2;
    VirtualInvokeData get_IsAbstract_1;
    VirtualInvokeData get_IsAssembly_1;
    VirtualInvokeData get_IsConstructor_1;
    VirtualInvokeData get_IsFamily_1;
    VirtualInvokeData get_IsFamilyAndAssembly_1;
    VirtualInvokeData get_IsFamilyOrAssembly_1;
    VirtualInvokeData get_IsFinal_1;
    VirtualInvokeData get_IsHideBySig_1;
    VirtualInvokeData get_IsPrivate_1;
    VirtualInvokeData get_IsPublic_1;
    VirtualInvokeData get_IsSpecialName_1;
    VirtualInvokeData get_IsStatic_1;
    VirtualInvokeData get_IsVirtual_1;
    VirtualInvokeData get_MemberType_3;
    VirtualInvokeData get_MethodHandle_1;
    VirtualInvokeData get_Name_2;
    VirtualInvokeData get_ReflectedType_2;
    VirtualInvokeData get_ReturnType;
    VirtualInvokeData get_ReturnTypeCustomAttributes;
    VirtualInvokeData get_ReturnType_1;
    VirtualInvokeData get_ReturnParameter;
    VirtualInvokeData __unknown_11;
    VirtualInvokeData __unknown_12;
    VirtualInvokeData GetGenericMethodDefinition;
    VirtualInvokeData MakeGenericMethod;
    VirtualInvokeData CreateDelegate;
    VirtualInvokeData CreateDelegate_1;
    VirtualInvokeData GetBaseMethod;
};

struct MethodInfo_1__StaticFields {
};

struct MethodInfo_1__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MethodInfo_1__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MethodInfo_1__VTable vtable;
};

struct DelegateData__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct DelegateData__StaticFields {
};

struct DelegateData__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DelegateData__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DelegateData__VTable vtable;
};

struct Delegate__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
};

struct Delegate__StaticFields {
};

struct Delegate__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Delegate__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Delegate__VTable vtable;
};

struct MulticastDelegate__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
};

struct MulticastDelegate__StaticFields {
};

struct MulticastDelegate__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MulticastDelegate__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MulticastDelegate__VTable vtable;
};

struct TypeFilter__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct TypeFilter__StaticFields {
};

struct TypeFilter__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeFilter__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeFilter__VTable vtable;
};

struct EventArgs__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct EventArgs__StaticFields {
    struct EventArgs *Empty;
};

struct EventArgs__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EventArgs__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EventArgs__VTable vtable;
};

struct ResolveEventArgs__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ResolveEventArgs__StaticFields {
};

struct ResolveEventArgs__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ResolveEventArgs__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ResolveEventArgs__VTable vtable;
};

struct ModuleResolveEventHandler__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct ModuleResolveEventHandler__StaticFields {
};

struct ModuleResolveEventHandler__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ModuleResolveEventHandler__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ModuleResolveEventHandler__VTable vtable;
};

struct Assembly_ResolveEventHolder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Assembly_ResolveEventHolder__StaticFields {
};

struct Assembly_ResolveEventHolder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Assembly_ResolveEventHolder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Assembly_ResolveEventHolder__VTable vtable;
};

struct AssemblyNameFlags__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct AssemblyNameFlags__Enum__StaticFields {
};

struct AssemblyNameFlags__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyNameFlags__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyNameFlags__Enum__VTable vtable;
};

struct AssemblyHashAlgorithm__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct AssemblyHashAlgorithm__Enum__StaticFields {
};

struct AssemblyHashAlgorithm__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyHashAlgorithm__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyHashAlgorithm__Enum__VTable vtable;
};

struct KeySizes__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct KeySizes__StaticFields {
};

struct KeySizes__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeySizes__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeySizes__VTable vtable;
};

struct KeySizes__Array__VTable {
};

struct KeySizes__Array__StaticFields {
};

struct KeySizes__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeySizes__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeySizes__Array__VTable vtable;
};

struct AsymmetricAlgorithm__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData get_KeySize;
    VirtualInvokeData set_KeySize;
    VirtualInvokeData get_LegalKeySizes;
    VirtualInvokeData get_SignatureAlgorithm;
    VirtualInvokeData get_KeyExchangeAlgorithm;
    VirtualInvokeData FromXmlString;
    VirtualInvokeData ToXmlString;
};

struct AsymmetricAlgorithm__StaticFields {
};

struct AsymmetricAlgorithm__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AsymmetricAlgorithm__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AsymmetricAlgorithm__VTable vtable;
};

struct RSAEncryptionPaddingMode__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct RSAEncryptionPaddingMode__Enum__StaticFields {
};

struct RSAEncryptionPaddingMode__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RSAEncryptionPaddingMode__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RSAEncryptionPaddingMode__Enum__VTable vtable;
};

struct HashAlgorithmName__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Equals_1;
};

struct HashAlgorithmName__StaticFields {
};

struct HashAlgorithmName__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct HashAlgorithmName__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct HashAlgorithmName__VTable vtable;
};

struct RSAEncryptionPadding__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Equals_1;
};

struct RSAEncryptionPadding__StaticFields {
    struct RSAEncryptionPadding *s_pkcs1;
    struct RSAEncryptionPadding *s_oaepSHA1;
    struct RSAEncryptionPadding *s_oaepSHA256;
    struct RSAEncryptionPadding *s_oaepSHA384;
    struct RSAEncryptionPadding *s_oaepSHA512;
};

struct RSAEncryptionPadding__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RSAEncryptionPadding__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RSAEncryptionPadding__VTable vtable;
};

struct RSASignaturePaddingMode__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct RSASignaturePaddingMode__Enum__StaticFields {
};

struct RSASignaturePaddingMode__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RSASignaturePaddingMode__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RSASignaturePaddingMode__Enum__VTable vtable;
};

struct RSASignaturePadding__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Equals_1;
};

struct RSASignaturePadding__StaticFields {
    struct RSASignaturePadding *s_pkcs1;
    struct RSASignaturePadding *s_pss;
};

struct RSASignaturePadding__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RSASignaturePadding__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RSASignaturePadding__VTable vtable;
};

struct IChannelInfo__VTable {
    VirtualInvokeData get_ChannelData;
    VirtualInvokeData set_ChannelData;
};

struct IChannelInfo__StaticFields {
};

struct IChannelInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IChannelInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IChannelInfo__VTable vtable;
};

struct IRemotingTypeInfo__VTable {
    VirtualInvokeData get_TypeName;
    VirtualInvokeData set_TypeName;
    VirtualInvokeData CanCastTo;
};

struct IRemotingTypeInfo__StaticFields {
};

struct IRemotingTypeInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IRemotingTypeInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IRemotingTypeInfo__VTable vtable;
};

struct IEnvoyInfo__VTable {
    VirtualInvokeData get_EnvoySinks;
    VirtualInvokeData set_EnvoySinks;
};

struct IEnvoyInfo__StaticFields {
};

struct IEnvoyInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnvoyInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnvoyInfo__VTable vtable;
};

struct ObjRef__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetRealObject;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_ChannelInfo;
    VirtualInvokeData set_ChannelInfo;
    VirtualInvokeData get_EnvoyInfo;
    VirtualInvokeData set_EnvoyInfo;
    VirtualInvokeData get_TypeInfo;
    VirtualInvokeData set_TypeInfo;
    VirtualInvokeData get_URI;
    VirtualInvokeData set_URI;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetRealObject_1;
};

struct ObjRef__StaticFields {
    int32_t MarshalledObjectRef;
    int32_t WellKnowObjectRef;
};

struct ObjRef__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ObjRef__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ObjRef__VTable vtable;
};

struct MarshalByRefObject__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
};

struct MarshalByRefObject__StaticFields {
};

struct MarshalByRefObject__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MarshalByRefObject__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MarshalByRefObject__VTable vtable;
};

struct StackGuard__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct StackGuard__StaticFields {
};

struct StackGuard__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StackGuard__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StackGuard__VTable vtable;
};

struct CriticalFinalizerObject__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct CriticalFinalizerObject__StaticFields {
};

struct CriticalFinalizerObject__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CriticalFinalizerObject__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CriticalFinalizerObject__VTable vtable;
};

struct SafeFileHandle__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_IsInvalid;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData ReleaseHandle;
};

struct SafeFileHandle__StaticFields {
};

struct SafeFileHandle__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SafeFileHandle__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SafeFileHandle__VTable vtable;
};

struct SafeHandle__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData __unknown;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData __unknown_1;
};

struct SafeHandle__StaticFields {
};

struct SafeHandle__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SafeHandle__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SafeHandle__VTable vtable;
};

struct SafeHandleZeroOrMinusOneIsInvalid__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_IsInvalid;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData __unknown;
};

struct SafeHandleZeroOrMinusOneIsInvalid__StaticFields {
};

struct SafeHandleZeroOrMinusOneIsInvalid__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SafeHandleZeroOrMinusOneIsInvalid__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SafeHandleZeroOrMinusOneIsInvalid__VTable vtable;
};

struct SafeWaitHandle__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_IsInvalid;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData ReleaseHandle;
};

struct SafeWaitHandle__StaticFields {
};

struct SafeWaitHandle__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SafeWaitHandle__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SafeWaitHandle__VTable vtable;
};

struct TimeSpan__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData CompareTo_1;
    VirtualInvokeData Equals_1;
    VirtualInvokeData ToString_1;
};

struct TimeSpan__StaticFields {
    struct TimeSpan Zero;
    struct TimeSpan MaxValue;
    struct TimeSpan MinValue;
    bool _legacyConfigChecked;
    bool _legacyMode;
};

struct TimeSpan__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TimeSpan__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TimeSpan__VTable vtable;
};

struct WaitHandle__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_Handle;
    VirtualInvokeData set_Handle;
    VirtualInvokeData WaitOne;
    VirtualInvokeData WaitOne_1;
    VirtualInvokeData WaitOne_2;
    VirtualInvokeData WaitOne_3;
    VirtualInvokeData WaitOne_4;
    VirtualInvokeData Close;
    VirtualInvokeData Dispose_1;
};

struct WaitHandle__StaticFields {
    void *InvalidHandle;
};

struct WaitHandle__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct WaitHandle__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct WaitHandle__VTable vtable;
};

struct EventWaitHandle__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_Handle;
    VirtualInvokeData set_Handle;
    VirtualInvokeData WaitOne;
    VirtualInvokeData WaitOne_1;
    VirtualInvokeData WaitOne_2;
    VirtualInvokeData WaitOne_3;
    VirtualInvokeData WaitOne_4;
    VirtualInvokeData Close;
    VirtualInvokeData Dispose_1;
};

struct EventWaitHandle__StaticFields {
};

struct EventWaitHandle__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EventWaitHandle__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EventWaitHandle__VTable vtable;
};

struct ManualResetEvent__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_Handle;
    VirtualInvokeData set_Handle;
    VirtualInvokeData WaitOne;
    VirtualInvokeData WaitOne_1;
    VirtualInvokeData WaitOne_2;
    VirtualInvokeData WaitOne_3;
    VirtualInvokeData WaitOne_4;
    VirtualInvokeData Close;
    VirtualInvokeData Dispose_1;
};

struct ManualResetEvent__StaticFields {
};

struct ManualResetEvent__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ManualResetEvent__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ManualResetEvent__VTable vtable;
};

struct Action_1_Object___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Action_1_Object___StaticFields {
};

struct Action_1_Object___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Action_1_Object___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Action_1_Object___VTable vtable;
};

struct SynchronizationContextProperties__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct SynchronizationContextProperties__Enum__StaticFields {
};

struct SynchronizationContextProperties__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SynchronizationContextProperties__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SynchronizationContextProperties__Enum__VTable vtable;
};

struct SendOrPostCallback__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct SendOrPostCallback__StaticFields {
};

struct SendOrPostCallback__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SendOrPostCallback__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SendOrPostCallback__VTable vtable;
};

struct IntPtr__Array__VTable {
};

struct IntPtr__Array__StaticFields {
};

struct IntPtr__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IntPtr__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IntPtr__Array__VTable vtable;
};

struct SynchronizationContext__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Send;
    VirtualInvokeData Post;
    VirtualInvokeData OperationStarted;
    VirtualInvokeData OperationCompleted;
    VirtualInvokeData Wait;
    VirtualInvokeData CreateCopy;
};

struct SynchronizationContext__StaticFields {
    struct Type *s_cachedPreparedType1;
    struct Type *s_cachedPreparedType2;
    struct Type *s_cachedPreparedType3;
    struct Type *s_cachedPreparedType4;
    struct Type *s_cachedPreparedType5;
};

struct SynchronizationContext__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SynchronizationContext__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SynchronizationContext__VTable vtable;
};

struct CallContextRemotingData__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
};

struct CallContextRemotingData__StaticFields {
};

struct CallContextRemotingData__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CallContextRemotingData__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CallContextRemotingData__VTable vtable;
};

struct IPrincipal__VTable {
    VirtualInvokeData get_Identity;
    VirtualInvokeData IsInRole;
};

struct IPrincipal__StaticFields {
};

struct IPrincipal__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IPrincipal__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IPrincipal__VTable vtable;
};

struct CallContextSecurityData__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
};

struct CallContextSecurityData__StaticFields {
};

struct CallContextSecurityData__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CallContextSecurityData__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CallContextSecurityData__VTable vtable;
};

struct Header__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Header__StaticFields {
};

struct Header__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Header__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Header__VTable vtable;
};

struct Header__Array__VTable {
};

struct Header__Array__StaticFields {
};

struct Header__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Header__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Header__Array__VTable vtable;
};

struct LogicalCallContext__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData Clone;
};

struct LogicalCallContext__StaticFields {
    struct Type *s_callContextType;
};

struct LogicalCallContext__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct LogicalCallContext__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct LogicalCallContext__VTable vtable;
};

struct IllogicalCallContext__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct IllogicalCallContext__StaticFields {
};

struct IllogicalCallContext__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IllogicalCallContext__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IllogicalCallContext__VTable vtable;
};

struct ExecutionContext_Flags__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct ExecutionContext_Flags__Enum__StaticFields {
};

struct ExecutionContext_Flags__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ExecutionContext_Flags__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ExecutionContext_Flags__Enum__VTable vtable;
};

struct IAsyncLocal__VTable {
    VirtualInvokeData OnValueChanged;
};

struct IAsyncLocal__StaticFields {
};

struct IAsyncLocal__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IAsyncLocal__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IAsyncLocal__VTable vtable;
};

struct Dictionary_2_TKey_TValue_Entry_System_Threading_IAsyncLocal_System_Object___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Dictionary_2_TKey_TValue_Entry_System_Threading_IAsyncLocal_System_Object___StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_Threading_IAsyncLocal_System_Object___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_Threading_IAsyncLocal_System_Object___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_Threading_IAsyncLocal_System_Object___VTable vtable;
};

struct Dictionary_2_TKey_TValue_Entry_System_Threading_IAsyncLocal_System_Object___Array__VTable {
};

struct Dictionary_2_TKey_TValue_Entry_System_Threading_IAsyncLocal_System_Object___Array__StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_Threading_IAsyncLocal_System_Object___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_Threading_IAsyncLocal_System_Object___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_Threading_IAsyncLocal_System_Object___Array__VTable vtable;
};

struct IEqualityComparer_1_System_Threading_IAsyncLocal___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData GetHashCode;
};

struct IEqualityComparer_1_System_Threading_IAsyncLocal___StaticFields {
};

struct IEqualityComparer_1_System_Threading_IAsyncLocal___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEqualityComparer_1_System_Threading_IAsyncLocal___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEqualityComparer_1_System_Threading_IAsyncLocal___VTable vtable;
};

struct IAsyncLocal__Array__VTable {
};

struct IAsyncLocal__Array__StaticFields {
};

struct IAsyncLocal__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IAsyncLocal__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IAsyncLocal__Array__VTable vtable;
};

struct IEnumerator_1_System_Threading_IAsyncLocal___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_System_Threading_IAsyncLocal___StaticFields {
};

struct IEnumerator_1_System_Threading_IAsyncLocal___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_System_Threading_IAsyncLocal___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_System_Threading_IAsyncLocal___VTable vtable;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_Threading_IAsyncLocal_System_Object___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TKey__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_Threading_IAsyncLocal_System_Object___StaticFields {
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_Threading_IAsyncLocal_System_Object___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Threading_IAsyncLocal_System_Object___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Threading_IAsyncLocal_System_Object___VTable vtable;
};

struct IEnumerator_1_System_Object___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_System_Object___StaticFields {
};

struct IEnumerator_1_System_Object___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_System_Object___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_System_Object___VTable vtable;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_Threading_IAsyncLocal_System_Object___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TValue__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_Threading_IAsyncLocal_System_Object___StaticFields {
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_Threading_IAsyncLocal_System_Object___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Threading_IAsyncLocal_System_Object___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Threading_IAsyncLocal_System_Object___VTable vtable;
};

struct ICollection_1_System_Threading_IAsyncLocal___VTable {
    VirtualInvokeData get_Count;
    VirtualInvokeData get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
};

struct ICollection_1_System_Threading_IAsyncLocal___StaticFields {
};

struct ICollection_1_System_Threading_IAsyncLocal___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ICollection_1_System_Threading_IAsyncLocal___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ICollection_1_System_Threading_IAsyncLocal___VTable vtable;
};

struct ICollection_1_System_Object___VTable {
    VirtualInvokeData get_Count;
    VirtualInvokeData get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
};

struct ICollection_1_System_Object___StaticFields {
};

struct ICollection_1_System_Object___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ICollection_1_System_Object___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ICollection_1_System_Object___VTable vtable;
};

struct KeyValuePair_2_System_Threading_IAsyncLocal_System_Object___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct KeyValuePair_2_System_Threading_IAsyncLocal_System_Object___StaticFields {
};

struct KeyValuePair_2_System_Threading_IAsyncLocal_System_Object___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_Threading_IAsyncLocal_System_Object___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_Threading_IAsyncLocal_System_Object___VTable vtable;
};

struct KeyValuePair_2_System_Threading_IAsyncLocal_System_Object___Array__VTable {
};

struct KeyValuePair_2_System_Threading_IAsyncLocal_System_Object___Array__StaticFields {
};

struct KeyValuePair_2_System_Threading_IAsyncLocal_System_Object___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_Threading_IAsyncLocal_System_Object___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_Threading_IAsyncLocal_System_Object___Array__VTable vtable;
};

struct IEnumerator_1_KeyValuePair_2_System_Threading_IAsyncLocal_System_Object___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_KeyValuePair_2_System_Threading_IAsyncLocal_System_Object___StaticFields {
};

struct IEnumerator_1_KeyValuePair_2_System_Threading_IAsyncLocal_System_Object___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_KeyValuePair_2_System_Threading_IAsyncLocal_System_Object___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_KeyValuePair_2_System_Threading_IAsyncLocal_System_Object___VTable vtable;
};

struct IEnumerable_1_System_Threading_IAsyncLocal___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_Threading_IAsyncLocal___StaticFields {
};

struct IEnumerable_1_System_Threading_IAsyncLocal___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_Threading_IAsyncLocal___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_Threading_IAsyncLocal___VTable vtable;
};

struct IEnumerable_1_System_Object___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_Object___StaticFields {
};

struct IEnumerable_1_System_Object___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_Object___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_Object___VTable vtable;
};

struct Dictionary_2_System_Threading_IAsyncLocal_System_Object___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Values;
    VirtualInvokeData ContainsKey;
    VirtualInvokeData Add;
    VirtualInvokeData Remove;
    VirtualInvokeData TryGetValue;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Add;
    VirtualInvokeData Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Contains;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_System_Collections_Generic_KeyValuePair_TKey_TValue___GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_get_Item;
    VirtualInvokeData System_Collections_IDictionary_set_Item;
    VirtualInvokeData System_Collections_IDictionary_get_Keys;
    VirtualInvokeData System_Collections_IDictionary_get_Values;
    VirtualInvokeData System_Collections_IDictionary_Contains;
    VirtualInvokeData System_Collections_IDictionary_Add;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IDictionary_get_IsReadOnly;
    VirtualInvokeData System_Collections_IDictionary_get_IsFixedSize;
    VirtualInvokeData System_Collections_IDictionary_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_Remove;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData ContainsKey_1;
    VirtualInvokeData TryGetValue_1;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Values;
    VirtualInvokeData get_Count_2;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData OnDeserialization;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData OnDeserialization_1;
};

struct Dictionary_2_System_Threading_IAsyncLocal_System_Object___StaticFields {
};

struct Dictionary_2_System_Threading_IAsyncLocal_System_Object___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_System_Threading_IAsyncLocal_System_Object___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_System_Threading_IAsyncLocal_System_Object___VTable vtable;
};

struct List_1_System_Threading_IAsyncLocal___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData RemoveAt;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_T__get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_T__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IList_get_Item;
    VirtualInvokeData System_Collections_IList_set_Item;
    VirtualInvokeData System_Collections_IList_Add;
    VirtualInvokeData System_Collections_IList_Contains;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IList_get_IsReadOnly;
    VirtualInvokeData System_Collections_IList_get_IsFixedSize;
    VirtualInvokeData System_Collections_IList_IndexOf;
    VirtualInvokeData System_Collections_IList_Insert;
    VirtualInvokeData System_Collections_IList_Remove;
    VirtualInvokeData RemoveAt_1;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData get_Count_2;
};

struct List_1_System_Threading_IAsyncLocal___StaticFields {
    struct IAsyncLocal__Array *_emptyArray;
};

struct List_1_System_Threading_IAsyncLocal___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct List_1_System_Threading_IAsyncLocal___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct List_1_System_Threading_IAsyncLocal___VTable vtable;
};

struct ExecutionContext__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData GetObjectData;
};

struct ExecutionContext__StaticFields {
    struct ExecutionContext *s_dummyDefaultEC;
};

struct ExecutionContext__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ExecutionContext__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ExecutionContext__VTable vtable;
};

struct ContextCallback__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct ContextCallback__StaticFields {
};

struct ContextCallback__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ContextCallback__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ContextCallback__VTable vtable;
};

struct CancellationCallbackInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct CancellationCallbackInfo__StaticFields {
    struct ContextCallback *s_executionContextCallback;
};

struct CancellationCallbackInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CancellationCallbackInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CancellationCallbackInfo__VTable vtable;
};

struct CancellationCallbackInfo__Array__VTable {
};

struct CancellationCallbackInfo__Array__StaticFields {
};

struct CancellationCallbackInfo__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CancellationCallbackInfo__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CancellationCallbackInfo__Array__VTable vtable;
};

struct SparselyPopulatedArrayFragment_1_CancellationCallbackInfo___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct SparselyPopulatedArrayFragment_1_CancellationCallbackInfo___StaticFields {
};

struct SparselyPopulatedArrayFragment_1_CancellationCallbackInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SparselyPopulatedArrayFragment_1_CancellationCallbackInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SparselyPopulatedArrayFragment_1_CancellationCallbackInfo___VTable vtable;
};

struct SparselyPopulatedArray_1_CancellationCallbackInfo___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct SparselyPopulatedArray_1_CancellationCallbackInfo___StaticFields {
};

struct SparselyPopulatedArray_1_CancellationCallbackInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SparselyPopulatedArray_1_CancellationCallbackInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SparselyPopulatedArray_1_CancellationCallbackInfo___VTable vtable;
};

struct SparselyPopulatedArray_1_CancellationCallbackInfo___Array__VTable {
};

struct SparselyPopulatedArray_1_CancellationCallbackInfo___Array__StaticFields {
};

struct SparselyPopulatedArray_1_CancellationCallbackInfo___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SparselyPopulatedArray_1_CancellationCallbackInfo___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SparselyPopulatedArray_1_CancellationCallbackInfo___Array__VTable vtable;
};

struct SparselyPopulatedArrayAddInfo_1_CancellationCallbackInfo___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct SparselyPopulatedArrayAddInfo_1_CancellationCallbackInfo___StaticFields {
};

struct SparselyPopulatedArrayAddInfo_1_CancellationCallbackInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SparselyPopulatedArrayAddInfo_1_CancellationCallbackInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SparselyPopulatedArrayAddInfo_1_CancellationCallbackInfo___VTable vtable;
};

struct CancellationTokenRegistration__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Equals_1;
    VirtualInvokeData Dispose;
};

struct CancellationTokenRegistration__StaticFields {
};

struct CancellationTokenRegistration__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CancellationTokenRegistration__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CancellationTokenRegistration__VTable vtable;
};

struct CancellationTokenRegistration__Array__VTable {
};

struct CancellationTokenRegistration__Array__StaticFields {
};

struct CancellationTokenRegistration__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CancellationTokenRegistration__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CancellationTokenRegistration__Array__VTable vtable;
};

struct SortedList_KeyList__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData Add;
    VirtualInvokeData Contains;
    VirtualInvokeData Clear;
    VirtualInvokeData get_IsReadOnly;
    VirtualInvokeData get_IsFixedSize;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData Remove;
    VirtualInvokeData RemoveAt;
    VirtualInvokeData CopyTo;
    VirtualInvokeData get_Count;
    VirtualInvokeData get_SyncRoot;
    VirtualInvokeData get_IsSynchronized;
    VirtualInvokeData GetEnumerator;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData get_IsReadOnly_1;
    VirtualInvokeData get_IsFixedSize_1;
    VirtualInvokeData get_IsSynchronized_1;
    VirtualInvokeData get_SyncRoot_1;
    VirtualInvokeData Add_1;
    VirtualInvokeData Clear_1;
    VirtualInvokeData Contains_1;
    VirtualInvokeData CopyTo_1;
    VirtualInvokeData Insert_1;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData set_Item_1;
    VirtualInvokeData GetEnumerator_1;
    VirtualInvokeData IndexOf_1;
    VirtualInvokeData Remove_1;
    VirtualInvokeData RemoveAt_1;
};

struct SortedList_KeyList__StaticFields {
};

struct SortedList_KeyList__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SortedList_KeyList__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SortedList_KeyList__VTable vtable;
};

struct SortedList_ValueList__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData Add;
    VirtualInvokeData Contains;
    VirtualInvokeData Clear;
    VirtualInvokeData get_IsReadOnly;
    VirtualInvokeData get_IsFixedSize;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData Remove;
    VirtualInvokeData RemoveAt;
    VirtualInvokeData CopyTo;
    VirtualInvokeData get_Count;
    VirtualInvokeData get_SyncRoot;
    VirtualInvokeData get_IsSynchronized;
    VirtualInvokeData GetEnumerator;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData get_IsReadOnly_1;
    VirtualInvokeData get_IsFixedSize_1;
    VirtualInvokeData get_IsSynchronized_1;
    VirtualInvokeData get_SyncRoot_1;
    VirtualInvokeData Add_1;
    VirtualInvokeData Clear_1;
    VirtualInvokeData Contains_1;
    VirtualInvokeData CopyTo_1;
    VirtualInvokeData Insert_1;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData set_Item_1;
    VirtualInvokeData GetEnumerator_1;
    VirtualInvokeData IndexOf_1;
    VirtualInvokeData Remove_1;
    VirtualInvokeData RemoveAt_1;
};

struct SortedList_ValueList__StaticFields {
};

struct SortedList_ValueList__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SortedList_ValueList__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SortedList_ValueList__VTable vtable;
};

struct IList__VTable {
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData Add;
    VirtualInvokeData Contains;
    VirtualInvokeData Clear;
    VirtualInvokeData get_IsReadOnly;
    VirtualInvokeData get_IsFixedSize;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData Remove;
    VirtualInvokeData RemoveAt;
};

struct IList__StaticFields {
};

struct IList__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IList__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IList__VTable vtable;
};

struct SortedList__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData get_Keys;
    VirtualInvokeData get_Values;
    VirtualInvokeData Contains;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData get_IsReadOnly;
    VirtualInvokeData get_IsFixedSize;
    VirtualInvokeData GetEnumerator;
    VirtualInvokeData Remove;
    VirtualInvokeData CopyTo;
    VirtualInvokeData get_Count;
    VirtualInvokeData get_SyncRoot;
    VirtualInvokeData get_IsSynchronized;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData Clone;
    VirtualInvokeData Add_1;
    VirtualInvokeData get_Capacity;
    VirtualInvokeData set_Capacity;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData get_Keys_1;
    VirtualInvokeData get_Values_1;
    VirtualInvokeData get_IsReadOnly_1;
    VirtualInvokeData get_IsFixedSize_1;
    VirtualInvokeData get_IsSynchronized_1;
    VirtualInvokeData get_SyncRoot_1;
    VirtualInvokeData Clear_1;
    VirtualInvokeData Clone_1;
    VirtualInvokeData Contains_1;
    VirtualInvokeData ContainsKey;
    VirtualInvokeData ContainsValue;
    VirtualInvokeData CopyTo_1;
    VirtualInvokeData ToKeyValuePairsArray;
    VirtualInvokeData GetByIndex;
    VirtualInvokeData GetEnumerator_1;
    VirtualInvokeData GetKey;
    VirtualInvokeData GetKeyList;
    VirtualInvokeData GetValueList;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData set_Item_1;
    VirtualInvokeData IndexOfKey;
    VirtualInvokeData IndexOfValue;
    VirtualInvokeData RemoveAt;
    VirtualInvokeData Remove_1;
    VirtualInvokeData SetByIndex;
    VirtualInvokeData TrimToSize;
};

struct SortedList__StaticFields {
    struct Object__Array *emptyArray;
};

struct SortedList__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SortedList__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SortedList__VTable vtable;
};

struct Timer_Scheduler__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Timer_Scheduler__StaticFields {
    struct Timer_Scheduler *instance;
};

struct Timer_Scheduler__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Timer_Scheduler__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Timer_Scheduler__VTable vtable;
};

struct TimerCallback__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct TimerCallback__StaticFields {
};

struct TimerCallback__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TimerCallback__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TimerCallback__VTable vtable;
};

struct Timer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData Dispose;
};

struct Timer__StaticFields {
    struct Timer_Scheduler *scheduler;
};

struct Timer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Timer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Timer__VTable vtable;
};

struct CancellationTokenSource__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData Dispose_1;
};

struct CancellationTokenSource__StaticFields {
    struct CancellationTokenSource *_staticSource_Set;
    struct CancellationTokenSource *_staticSource_NotCancelable;
    int32_t s_nLists;
    struct Action_1_Object_ *s_LinkedTokenCancelDelegate;
    struct TimerCallback *s_timerCallback;
};

struct CancellationTokenSource__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CancellationTokenSource__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CancellationTokenSource__VTable vtable;
};

struct CancellationToken__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct CancellationToken__StaticFields {
    struct Action_1_Object_ *s_ActionToActionObjShunt;
};

struct CancellationToken__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CancellationToken__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CancellationToken__VTable vtable;
};

struct Ephemeron__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Ephemeron__StaticFields {
};

struct Ephemeron__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Ephemeron__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Ephemeron__VTable vtable;
};

struct Ephemeron__Array__VTable {
};

struct Ephemeron__Array__StaticFields {
};

struct Ephemeron__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Ephemeron__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Ephemeron__Array__VTable vtable;
};

struct ConditionalWeakTable_2_System_Threading_Tasks_TaskScheduler_System_Object___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ConditionalWeakTable_2_System_Threading_Tasks_TaskScheduler_System_Object___StaticFields {
};

struct ConditionalWeakTable_2_System_Threading_Tasks_TaskScheduler_System_Object___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ConditionalWeakTable_2_System_Threading_Tasks_TaskScheduler_System_Object___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ConditionalWeakTable_2_System_Threading_Tasks_TaskScheduler_System_Object___VTable vtable;
};

struct IDictionary__VTable {
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData get_Keys;
    VirtualInvokeData get_Values;
    VirtualInvokeData Contains;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData get_IsReadOnly;
    VirtualInvokeData get_IsFixedSize;
    VirtualInvokeData GetEnumerator;
    VirtualInvokeData Remove;
};

struct IDictionary__StaticFields {
};

struct IDictionary__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IDictionary__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IDictionary__VTable vtable;
};

struct IList_1_System_Object___VTable {
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData RemoveAt;
};

struct IList_1_System_Object___StaticFields {
};

struct IList_1_System_Object___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IList_1_System_Object___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IList_1_System_Object___VTable vtable;
};

struct List_1_System_Object___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData RemoveAt;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_T__get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_T__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IList_get_Item;
    VirtualInvokeData System_Collections_IList_set_Item;
    VirtualInvokeData System_Collections_IList_Add;
    VirtualInvokeData System_Collections_IList_Contains;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IList_get_IsReadOnly;
    VirtualInvokeData System_Collections_IList_get_IsFixedSize;
    VirtualInvokeData System_Collections_IList_IndexOf;
    VirtualInvokeData System_Collections_IList_Insert;
    VirtualInvokeData System_Collections_IList_Remove;
    VirtualInvokeData RemoveAt_1;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData get_Count_2;
};

struct List_1_System_Object___StaticFields {
    struct Object__Array *_emptyArray;
};

struct List_1_System_Object___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct List_1_System_Object___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct List_1_System_Object___VTable vtable;
};

struct SafeSerializationEventArgs__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct SafeSerializationEventArgs__StaticFields {
};

struct SafeSerializationEventArgs__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SafeSerializationEventArgs__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SafeSerializationEventArgs__VTable vtable;
};

struct EventHandler_1_System_Runtime_Serialization_SafeSerializationEventArgs___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct EventHandler_1_System_Runtime_Serialization_SafeSerializationEventArgs___StaticFields {
};

struct EventHandler_1_System_Runtime_Serialization_SafeSerializationEventArgs___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EventHandler_1_System_Runtime_Serialization_SafeSerializationEventArgs___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EventHandler_1_System_Runtime_Serialization_SafeSerializationEventArgs___VTable vtable;
};

struct SafeSerializationManager__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_Serialization_IObjectReference_GetRealObject;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
};

struct SafeSerializationManager__StaticFields {
};

struct SafeSerializationManager__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SafeSerializationManager__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SafeSerializationManager__VTable vtable;
};

struct StackFrame__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetFileLineNumber;
    VirtualInvokeData GetFileColumnNumber;
    VirtualInvokeData GetFileName;
    VirtualInvokeData GetILOffset;
    VirtualInvokeData GetMethod;
    VirtualInvokeData GetNativeOffset;
};

struct StackFrame__StaticFields {
};

struct StackFrame__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StackFrame__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StackFrame__VTable vtable;
};

struct StackFrame__Array__VTable {
};

struct StackFrame__Array__StaticFields {
};

struct StackFrame__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StackFrame__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StackFrame__Array__VTable vtable;
};

struct StackTrace__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_FrameCount;
    VirtualInvokeData GetFrame;
    VirtualInvokeData GetFrames;
};

struct StackTrace__StaticFields {
    bool isAotidSet;
    struct String *aotid;
};

struct StackTrace__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StackTrace__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StackTrace__VTable vtable;
};

struct StackTrace__Array__VTable {
};

struct StackTrace__Array__StaticFields {
};

struct StackTrace__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StackTrace__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StackTrace__Array__VTable vtable;
};

struct Exception__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct Exception__StaticFields {
    struct Object *s_EDILock;
};

struct Exception__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Exception__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Exception__VTable vtable;
};

struct IList_1_System_Exception___VTable {
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData RemoveAt;
};

struct IList_1_System_Exception___StaticFields {
};

struct IList_1_System_Exception___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IList_1_System_Exception___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IList_1_System_Exception___VTable vtable;
};

struct Exception__Array__VTable {
};

struct Exception__Array__StaticFields {
};

struct Exception__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Exception__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Exception__Array__VTable vtable;
};

struct IEnumerator_1_System_Exception___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_System_Exception___StaticFields {
};

struct IEnumerator_1_System_Exception___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_System_Exception___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_System_Exception___VTable vtable;
};

struct ReadOnlyCollection_1_System_Exception___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Collections_Generic_IList_T__get_Item;
    VirtualInvokeData System_Collections_Generic_IList_T__set_Item;
    VirtualInvokeData IndexOf;
    VirtualInvokeData System_Collections_Generic_IList_T__Insert;
    VirtualInvokeData System_Collections_Generic_IList_T__RemoveAt;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_T__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_T__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_T__Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_T__Remove;
    VirtualInvokeData GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IList_get_Item;
    VirtualInvokeData System_Collections_IList_set_Item;
    VirtualInvokeData System_Collections_IList_Add;
    VirtualInvokeData System_Collections_IList_Contains;
    VirtualInvokeData System_Collections_IList_Clear;
    VirtualInvokeData System_Collections_IList_get_IsReadOnly;
    VirtualInvokeData System_Collections_IList_get_IsFixedSize;
    VirtualInvokeData System_Collections_IList_IndexOf;
    VirtualInvokeData System_Collections_IList_Insert;
    VirtualInvokeData System_Collections_IList_Remove;
    VirtualInvokeData System_Collections_IList_RemoveAt;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Item;
    VirtualInvokeData get_Count_2;
};

struct ReadOnlyCollection_1_System_Exception___StaticFields {
};

struct ReadOnlyCollection_1_System_Exception___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ReadOnlyCollection_1_System_Exception___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ReadOnlyCollection_1_System_Exception___VTable vtable;
};

struct AggregateException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct AggregateException__StaticFields {
};

struct AggregateException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AggregateException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AggregateException__VTable vtable;
};

struct UnobservedTaskExceptionEventArgs__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct UnobservedTaskExceptionEventArgs__StaticFields {
};

struct UnobservedTaskExceptionEventArgs__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UnobservedTaskExceptionEventArgs__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UnobservedTaskExceptionEventArgs__VTable vtable;
};

struct EventHandler_1_System_Threading_Tasks_UnobservedTaskExceptionEventArgs___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct EventHandler_1_System_Threading_Tasks_UnobservedTaskExceptionEventArgs___StaticFields {
};

struct EventHandler_1_System_Threading_Tasks_UnobservedTaskExceptionEventArgs___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EventHandler_1_System_Threading_Tasks_UnobservedTaskExceptionEventArgs___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EventHandler_1_System_Threading_Tasks_UnobservedTaskExceptionEventArgs___VTable vtable;
};

struct Func_2_Object_Boolean___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Func_2_Object_Boolean___StaticFields {
};

struct Func_2_Object_Boolean___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Func_2_Object_Boolean___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Func_2_Object_Boolean___VTable vtable;
};

struct ConcurrentExclusiveSchedulerPair_ProcessingMode__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct ConcurrentExclusiveSchedulerPair_ProcessingMode__Enum__StaticFields {
};

struct ConcurrentExclusiveSchedulerPair_ProcessingMode__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ConcurrentExclusiveSchedulerPair_ProcessingMode__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ConcurrentExclusiveSchedulerPair_ProcessingMode__Enum__VTable vtable;
};

struct ConcurrentDictionary_2_TKey_TValue_Node_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ConcurrentDictionary_2_TKey_TValue_Node_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___StaticFields {
};

struct ConcurrentDictionary_2_TKey_TValue_Node_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ConcurrentDictionary_2_TKey_TValue_Node_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ConcurrentDictionary_2_TKey_TValue_Node_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___VTable vtable;
};

struct ConcurrentDictionary_2_TKey_TValue_Node_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Array__VTable {
};

struct ConcurrentDictionary_2_TKey_TValue_Node_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Array__StaticFields {
};

struct ConcurrentDictionary_2_TKey_TValue_Node_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ConcurrentDictionary_2_TKey_TValue_Node_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ConcurrentDictionary_2_TKey_TValue_Node_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Array__VTable vtable;
};

struct ConcurrentDictionary_2_TKey_TValue_Tables_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ConcurrentDictionary_2_TKey_TValue_Tables_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___StaticFields {
};

struct ConcurrentDictionary_2_TKey_TValue_Tables_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ConcurrentDictionary_2_TKey_TValue_Tables_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ConcurrentDictionary_2_TKey_TValue_Tables_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___VTable vtable;
};

struct ICollection_1_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___VTable {
    VirtualInvokeData get_Count;
    VirtualInvokeData get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
};

struct ICollection_1_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___StaticFields {
};

struct ICollection_1_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ICollection_1_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ICollection_1_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___VTable vtable;
};

struct ConcurrentExclusiveSchedulerPair_ProcessingMode___VTable {
};

struct ConcurrentExclusiveSchedulerPair_ProcessingMode___StaticFields {
};

struct ConcurrentExclusiveSchedulerPair_ProcessingMode___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ConcurrentExclusiveSchedulerPair_ProcessingMode___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ConcurrentExclusiveSchedulerPair_ProcessingMode___VTable vtable;
};

struct KeyValuePair_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct KeyValuePair_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___StaticFields {
};

struct KeyValuePair_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___VTable vtable;
};

struct KeyValuePair_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Array__VTable {
};

struct KeyValuePair_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Array__StaticFields {
};

struct KeyValuePair_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Array__VTable vtable;
};

struct IEnumerator_1_KeyValuePair_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_KeyValuePair_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___StaticFields {
};

struct IEnumerator_1_KeyValuePair_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_KeyValuePair_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_KeyValuePair_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___VTable vtable;
};

struct IEnumerable_1_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___StaticFields {
};

struct IEnumerable_1_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___VTable vtable;
};

struct ConcurrentDictionary_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData get_Keys;
    VirtualInvokeData get_Values;
    VirtualInvokeData ContainsKey;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__Add;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__Remove;
    VirtualInvokeData TryGetValue;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Add;
    VirtualInvokeData Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Contains;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Remove;
    VirtualInvokeData GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_get_Item;
    VirtualInvokeData System_Collections_IDictionary_set_Item;
    VirtualInvokeData System_Collections_IDictionary_get_Keys;
    VirtualInvokeData System_Collections_IDictionary_get_Values;
    VirtualInvokeData System_Collections_IDictionary_Contains;
    VirtualInvokeData System_Collections_IDictionary_Add;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IDictionary_get_IsReadOnly;
    VirtualInvokeData System_Collections_IDictionary_get_IsFixedSize;
    VirtualInvokeData System_Collections_IDictionary_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_Remove;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData ContainsKey_1;
    VirtualInvokeData TryGetValue_1;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Values;
    VirtualInvokeData get_Count_2;
};

struct ConcurrentDictionary_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___StaticFields {
    bool s_isValueWriteAtomic;
};

struct ConcurrentDictionary_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ConcurrentDictionary_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ConcurrentDictionary_2_System_Int32_System_Threading_Tasks_ConcurrentExclusiveSchedulerPair_ProcessingMode___VTable vtable;
};

struct VoidTaskResult__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct VoidTaskResult__StaticFields {
};

struct VoidTaskResult__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct VoidTaskResult__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct VoidTaskResult__VTable vtable;
};

struct TaskCreationOptions__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct TaskCreationOptions__Enum__StaticFields {
};

struct TaskCreationOptions__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TaskCreationOptions__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TaskCreationOptions__Enum__VTable vtable;
};

struct TaskContinuationOptions__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct TaskContinuationOptions__Enum__StaticFields {
};

struct TaskContinuationOptions__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TaskContinuationOptions__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TaskContinuationOptions__Enum__VTable vtable;
};

struct TaskFactory_1_VoidTaskResult___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct TaskFactory_1_VoidTaskResult___StaticFields {
};

struct TaskFactory_1_VoidTaskResult___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TaskFactory_1_VoidTaskResult___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TaskFactory_1_VoidTaskResult___VTable vtable;
};

struct TaskFactory_1_Task___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct TaskFactory_1_Task___StaticFields {
};

struct TaskFactory_1_Task___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TaskFactory_1_Task___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TaskFactory_1_Task___VTable vtable;
};

struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__1__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__1__StaticFields {
};

struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__1__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__1__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__1__VTable vtable;
};

struct SystemException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct SystemException__StaticFields {
};

struct SystemException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SystemException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SystemException__VTable vtable;
};

struct ThreadAbortException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct ThreadAbortException__StaticFields {
};

struct ThreadAbortException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ThreadAbortException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ThreadAbortException__VTable vtable;
};

struct InternalTaskOptions__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct InternalTaskOptions__Enum__StaticFields {
};

struct InternalTaskOptions__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct InternalTaskOptions__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct InternalTaskOptions__Enum__VTable vtable;
};

struct Task_1_Task___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Threading_IThreadPoolWorkItem_ExecuteWorkItem;
    VirtualInvokeData System_Threading_IThreadPoolWorkItem_MarkAborted;
    VirtualInvokeData get_IsCompleted;
    VirtualInvokeData System_IAsyncResult_get_AsyncWaitHandle;
    VirtualInvokeData get_AsyncState;
    VirtualInvokeData System_IAsyncResult_get_CompletedSynchronously;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_ShouldNotifyDebuggerOfWaitCompletion;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData ShouldReplicate;
    VirtualInvokeData CreateReplicaTask;
    VirtualInvokeData get_SavedStateForNextReplica;
    VirtualInvokeData set_SavedStateForNextReplica;
    VirtualInvokeData get_SavedStateFromPreviousReplica;
    VirtualInvokeData set_SavedStateFromPreviousReplica;
    VirtualInvokeData get_HandedOverChildReplica;
    VirtualInvokeData set_HandedOverChildReplica;
    VirtualInvokeData InnerInvoke;
    VirtualInvokeData GetDelegateContinuationsForDebugger;
};

struct Task_1_Task___StaticFields {
    struct TaskFactory_1_Task_ *s_Factory;
    struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__1 *TaskWhenAnyCast;
};

struct Task_1_Task___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Task_1_Task___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Task_1_Task___VTable vtable;
};

struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1___StaticFields {
};

struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1___VTable vtable;
};

struct Task_1_VoidTaskResult___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Threading_IThreadPoolWorkItem_ExecuteWorkItem;
    VirtualInvokeData System_Threading_IThreadPoolWorkItem_MarkAborted;
    VirtualInvokeData get_IsCompleted;
    VirtualInvokeData System_IAsyncResult_get_AsyncWaitHandle;
    VirtualInvokeData get_AsyncState;
    VirtualInvokeData System_IAsyncResult_get_CompletedSynchronously;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_ShouldNotifyDebuggerOfWaitCompletion;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData ShouldReplicate;
    VirtualInvokeData CreateReplicaTask;
    VirtualInvokeData get_SavedStateForNextReplica;
    VirtualInvokeData set_SavedStateForNextReplica;
    VirtualInvokeData get_SavedStateFromPreviousReplica;
    VirtualInvokeData set_SavedStateFromPreviousReplica;
    VirtualInvokeData get_HandedOverChildReplica;
    VirtualInvokeData set_HandedOverChildReplica;
    VirtualInvokeData InnerInvoke;
    VirtualInvokeData GetDelegateContinuationsForDebugger;
};

struct Task_1_VoidTaskResult___StaticFields {
    struct TaskFactory_1_VoidTaskResult_ *s_Factory;
    struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1_ *TaskWhenAnyCast;
};

struct Task_1_VoidTaskResult___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Task_1_VoidTaskResult___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Task_1_VoidTaskResult___VTable vtable;
};

struct TaskCompletionSource_1_VoidTaskResult___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct TaskCompletionSource_1_VoidTaskResult___StaticFields {
};

struct TaskCompletionSource_1_VoidTaskResult___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TaskCompletionSource_1_VoidTaskResult___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TaskCompletionSource_1_VoidTaskResult___VTable vtable;
};

struct List_1_System_Exception___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData RemoveAt;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_T__get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_T__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IList_get_Item;
    VirtualInvokeData System_Collections_IList_set_Item;
    VirtualInvokeData System_Collections_IList_Add;
    VirtualInvokeData System_Collections_IList_Contains;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IList_get_IsReadOnly;
    VirtualInvokeData System_Collections_IList_get_IsFixedSize;
    VirtualInvokeData System_Collections_IList_IndexOf;
    VirtualInvokeData System_Collections_IList_Insert;
    VirtualInvokeData System_Collections_IList_Remove;
    VirtualInvokeData RemoveAt_1;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData get_Count_2;
};

struct List_1_System_Exception___StaticFields {
    struct Exception__Array *_emptyArray;
};

struct List_1_System_Exception___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct List_1_System_Exception___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct List_1_System_Exception___VTable vtable;
};

struct ConcurrentExclusiveSchedulerPair_CompletionState__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ConcurrentExclusiveSchedulerPair_CompletionState__StaticFields {
};

struct ConcurrentExclusiveSchedulerPair_CompletionState__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ConcurrentExclusiveSchedulerPair_CompletionState__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ConcurrentExclusiveSchedulerPair_CompletionState__VTable vtable;
};

struct ConcurrentExclusiveSchedulerPair__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ConcurrentExclusiveSchedulerPair__StaticFields {
};

struct ConcurrentExclusiveSchedulerPair__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ConcurrentExclusiveSchedulerPair__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ConcurrentExclusiveSchedulerPair__VTable vtable;
};

struct IProducerConsumerQueue_1_Task___VTable {
    VirtualInvokeData Enqueue;
    VirtualInvokeData TryDequeue;
    VirtualInvokeData get_IsEmpty;
    VirtualInvokeData get_Count;
    VirtualInvokeData GetCountSafe;
};

struct IProducerConsumerQueue_1_Task___StaticFields {
};

struct IProducerConsumerQueue_1_Task___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IProducerConsumerQueue_1_Task___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IProducerConsumerQueue_1_Task___VTable vtable;
};

struct IEnumerable_1_System_Threading_Tasks_Task___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_Threading_Tasks_Task___StaticFields {
};

struct IEnumerable_1_System_Threading_Tasks_Task___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_Threading_Tasks_Task___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_Threading_Tasks_Task___VTable vtable;
};

struct ConcurrentExclusiveSchedulerPair_ConcurrentExclusiveTaskScheduler__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData QueueTask;
    VirtualInvokeData TryExecuteTaskInline;
    VirtualInvokeData GetScheduledTasks;
    VirtualInvokeData get_MaximumConcurrencyLevel;
    VirtualInvokeData TryDequeue;
    VirtualInvokeData NotifyWorkItemProgress;
    VirtualInvokeData get_RequiresAtomicStartTransition;
};

struct ConcurrentExclusiveSchedulerPair_ConcurrentExclusiveTaskScheduler__StaticFields {
    struct Func_2_Object_Boolean_ *s_tryExecuteTaskShim;
};

struct ConcurrentExclusiveSchedulerPair_ConcurrentExclusiveTaskScheduler__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ConcurrentExclusiveSchedulerPair_ConcurrentExclusiveTaskScheduler__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ConcurrentExclusiveSchedulerPair_ConcurrentExclusiveTaskScheduler__VTable vtable;
};

struct TaskScheduler__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData get_MaximumConcurrencyLevel;
    VirtualInvokeData TryDequeue;
    VirtualInvokeData NotifyWorkItemProgress;
    VirtualInvokeData get_RequiresAtomicStartTransition;
};

struct TaskScheduler__StaticFields {
    struct ConditionalWeakTable_2_System_Threading_Tasks_TaskScheduler_System_Object_ *s_activeTaskSchedulers;
    struct TaskScheduler *s_defaultTaskScheduler;
    int32_t s_taskSchedulerIdCounter;
    struct EventHandler_1_System_Threading_Tasks_UnobservedTaskExceptionEventArgs_ *_unobservedTaskException;
    struct Object *_unobservedTaskExceptionLockObject;
};

struct TaskScheduler__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TaskScheduler__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TaskScheduler__VTable vtable;
};

struct TaskFactory__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct TaskFactory__StaticFields {
};

struct TaskFactory__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TaskFactory__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TaskFactory__VTable vtable;
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Threading_Tasks_Task___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Threading_Tasks_Task___StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Threading_Tasks_Task___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Threading_Tasks_Task___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Threading_Tasks_Task___VTable vtable;
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Threading_Tasks_Task___Array__VTable {
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Threading_Tasks_Task___Array__StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Threading_Tasks_Task___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Threading_Tasks_Task___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_Threading_Tasks_Task___Array__VTable vtable;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_Threading_Tasks_Task___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TKey__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_Threading_Tasks_Task___StaticFields {
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_Threading_Tasks_Task___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_Threading_Tasks_Task___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_Threading_Tasks_Task___VTable vtable;
};

struct Task__Array__VTable {
};

struct Task__Array__StaticFields {
};

struct Task__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Task__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Task__Array__VTable vtable;
};

struct IEnumerator_1_System_Threading_Tasks_Task___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_System_Threading_Tasks_Task___StaticFields {
};

struct IEnumerator_1_System_Threading_Tasks_Task___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_System_Threading_Tasks_Task___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_System_Threading_Tasks_Task___VTable vtable;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_Threading_Tasks_Task___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TValue__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_Threading_Tasks_Task___StaticFields {
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_Threading_Tasks_Task___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_Threading_Tasks_Task___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_Threading_Tasks_Task___VTable vtable;
};

struct ICollection_1_System_Threading_Tasks_Task___VTable {
    VirtualInvokeData get_Count;
    VirtualInvokeData get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
};

struct ICollection_1_System_Threading_Tasks_Task___StaticFields {
};

struct ICollection_1_System_Threading_Tasks_Task___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ICollection_1_System_Threading_Tasks_Task___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ICollection_1_System_Threading_Tasks_Task___VTable vtable;
};

struct Task___VTable {
};

struct Task___StaticFields {
};

struct Task___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Task___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Task___VTable vtable;
};

struct KeyValuePair_2_System_Int32_System_Threading_Tasks_Task___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct KeyValuePair_2_System_Int32_System_Threading_Tasks_Task___StaticFields {
};

struct KeyValuePair_2_System_Int32_System_Threading_Tasks_Task___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_Int32_System_Threading_Tasks_Task___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_Int32_System_Threading_Tasks_Task___VTable vtable;
};

struct KeyValuePair_2_System_Int32_System_Threading_Tasks_Task___Array__VTable {
};

struct KeyValuePair_2_System_Int32_System_Threading_Tasks_Task___Array__StaticFields {
};

struct KeyValuePair_2_System_Int32_System_Threading_Tasks_Task___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_Int32_System_Threading_Tasks_Task___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_Int32_System_Threading_Tasks_Task___Array__VTable vtable;
};

struct IEnumerator_1_KeyValuePair_2_System_Int32_System_Threading_Tasks_Task___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_KeyValuePair_2_System_Int32_System_Threading_Tasks_Task___StaticFields {
};

struct IEnumerator_1_KeyValuePair_2_System_Int32_System_Threading_Tasks_Task___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_KeyValuePair_2_System_Int32_System_Threading_Tasks_Task___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_KeyValuePair_2_System_Int32_System_Threading_Tasks_Task___VTable vtable;
};

struct Dictionary_2_System_Int32_System_Threading_Tasks_Task___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Values;
    VirtualInvokeData ContainsKey;
    VirtualInvokeData Add;
    VirtualInvokeData Remove;
    VirtualInvokeData TryGetValue;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Add;
    VirtualInvokeData Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Contains;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_System_Collections_Generic_KeyValuePair_TKey_TValue___GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_get_Item;
    VirtualInvokeData System_Collections_IDictionary_set_Item;
    VirtualInvokeData System_Collections_IDictionary_get_Keys;
    VirtualInvokeData System_Collections_IDictionary_get_Values;
    VirtualInvokeData System_Collections_IDictionary_Contains;
    VirtualInvokeData System_Collections_IDictionary_Add;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IDictionary_get_IsReadOnly;
    VirtualInvokeData System_Collections_IDictionary_get_IsFixedSize;
    VirtualInvokeData System_Collections_IDictionary_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_Remove;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData ContainsKey_1;
    VirtualInvokeData TryGetValue_1;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Values;
    VirtualInvokeData get_Count_2;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData OnDeserialization;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData OnDeserialization_1;
};

struct Dictionary_2_System_Int32_System_Threading_Tasks_Task___StaticFields {
};

struct Dictionary_2_System_Int32_System_Threading_Tasks_Task___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_System_Int32_System_Threading_Tasks_Task___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_System_Int32_System_Threading_Tasks_Task___VTable vtable;
};

struct ManualResetEventSlim__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData Dispose_1;
};

struct ManualResetEventSlim__StaticFields {
    struct Action_1_Object_ *s_cancellationTokenCallback;
};

struct ManualResetEventSlim__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ManualResetEventSlim__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ManualResetEventSlim__VTable vtable;
};

struct EventHandler__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct EventHandler__StaticFields {
};

struct EventHandler__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EventHandler__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EventHandler__VTable vtable;
};

struct ExceptionDispatchInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ExceptionDispatchInfo__StaticFields {
};

struct ExceptionDispatchInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ExceptionDispatchInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ExceptionDispatchInfo__VTable vtable;
};

struct ExceptionDispatchInfo__Array__VTable {
};

struct ExceptionDispatchInfo__Array__StaticFields {
};

struct ExceptionDispatchInfo__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ExceptionDispatchInfo__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ExceptionDispatchInfo__Array__VTable vtable;
};

struct IEnumerator_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo___StaticFields {
};

struct IEnumerator_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo___VTable vtable;
};

struct List_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData RemoveAt;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_T__get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_T__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IList_get_Item;
    VirtualInvokeData System_Collections_IList_set_Item;
    VirtualInvokeData System_Collections_IList_Add;
    VirtualInvokeData System_Collections_IList_Contains;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IList_get_IsReadOnly;
    VirtualInvokeData System_Collections_IList_get_IsFixedSize;
    VirtualInvokeData System_Collections_IList_IndexOf;
    VirtualInvokeData System_Collections_IList_Insert;
    VirtualInvokeData System_Collections_IList_Remove;
    VirtualInvokeData RemoveAt_1;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData get_Count_2;
};

struct List_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo___StaticFields {
    struct ExceptionDispatchInfo__Array *_emptyArray;
};

struct List_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct List_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct List_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo___VTable vtable;
};

struct TaskExceptionHolder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct TaskExceptionHolder__StaticFields {
    bool s_failFastOnUnobservedException;
    bool s_domainUnloadStarted;
    struct EventHandler *s_adUnloadEventHandler;
};

struct TaskExceptionHolder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TaskExceptionHolder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TaskExceptionHolder__VTable vtable;
};

struct Shared_1_System_Threading_CancellationTokenRegistration___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Shared_1_System_Threading_CancellationTokenRegistration___StaticFields {
};

struct Shared_1_System_Threading_CancellationTokenRegistration___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Shared_1_System_Threading_CancellationTokenRegistration___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Shared_1_System_Threading_CancellationTokenRegistration___VTable vtable;
};

struct List_1_System_Threading_Tasks_Task___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData RemoveAt;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_T__get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_T__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IList_get_Item;
    VirtualInvokeData System_Collections_IList_set_Item;
    VirtualInvokeData System_Collections_IList_Add;
    VirtualInvokeData System_Collections_IList_Contains;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IList_get_IsReadOnly;
    VirtualInvokeData System_Collections_IList_get_IsFixedSize;
    VirtualInvokeData System_Collections_IList_IndexOf;
    VirtualInvokeData System_Collections_IList_Insert;
    VirtualInvokeData System_Collections_IList_Remove;
    VirtualInvokeData RemoveAt_1;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData get_Count_2;
};

struct List_1_System_Threading_Tasks_Task___StaticFields {
    struct Task__Array *_emptyArray;
};

struct List_1_System_Threading_Tasks_Task___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct List_1_System_Threading_Tasks_Task___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct List_1_System_Threading_Tasks_Task___VTable vtable;
};

struct Task_ContingentProperties__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Task_ContingentProperties__StaticFields {
};

struct Task_ContingentProperties__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Task_ContingentProperties__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Task_ContingentProperties__VTable vtable;
};

struct Func_1_System_Threading_Tasks_Task_ContingentProperties___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Func_1_System_Threading_Tasks_Task_ContingentProperties___StaticFields {
};

struct Func_1_System_Threading_Tasks_Task_ContingentProperties___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Func_1_System_Threading_Tasks_Task_ContingentProperties___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Func_1_System_Threading_Tasks_Task_ContingentProperties___VTable vtable;
};

struct Predicate_1_System_Threading_Tasks_Task___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Predicate_1_System_Threading_Tasks_Task___StaticFields {
};

struct Predicate_1_System_Threading_Tasks_Task___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Predicate_1_System_Threading_Tasks_Task___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Predicate_1_System_Threading_Tasks_Task___VTable vtable;
};

struct Predicate_1_Object___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Predicate_1_Object___StaticFields {
};

struct Predicate_1_Object___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Predicate_1_Object___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Predicate_1_Object___VTable vtable;
};

struct Task__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Threading_IThreadPoolWorkItem_ExecuteWorkItem;
    VirtualInvokeData System_Threading_IThreadPoolWorkItem_MarkAborted;
    VirtualInvokeData get_IsCompleted;
    VirtualInvokeData System_IAsyncResult_get_AsyncWaitHandle;
    VirtualInvokeData get_AsyncState;
    VirtualInvokeData System_IAsyncResult_get_CompletedSynchronously;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_ShouldNotifyDebuggerOfWaitCompletion;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData ShouldReplicate;
    VirtualInvokeData CreateReplicaTask;
    VirtualInvokeData get_SavedStateForNextReplica;
    VirtualInvokeData set_SavedStateForNextReplica;
    VirtualInvokeData get_SavedStateFromPreviousReplica;
    VirtualInvokeData set_SavedStateFromPreviousReplica;
    VirtualInvokeData get_HandedOverChildReplica;
    VirtualInvokeData set_HandedOverChildReplica;
    VirtualInvokeData InnerInvoke;
    VirtualInvokeData GetDelegateContinuationsForDebugger;
};

struct Task__StaticFields {
    struct Task *t_currentTask;
    struct StackGuard *t_stackGuard;
    int32_t s_taskIdCounter;
    struct TaskFactory *s_factory;
    struct Object *s_taskCompletionSentinel;
    bool s_asyncDebuggingEnabled;
    struct Dictionary_2_System_Int32_System_Threading_Tasks_Task_ *s_currentActiveTasks;
    struct Object *s_activeTasksLock;
    struct Action_1_Object_ *s_taskCancelCallback;
    struct Func_1_System_Threading_Tasks_Task_ContingentProperties_ *s_createContingentProperties;
    struct Task *s_completedTask;
    struct Predicate_1_System_Threading_Tasks_Task_ *s_IsExceptionObservedByParentPredicate;
    struct ContextCallback *s_ecCallback;
    struct Predicate_1_Object_ *s_IsTaskContinuationNullPredicate;
};

struct Task__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Task__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Task__VTable vtable;
};

struct TaskFactory_1_System_Int32___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct TaskFactory_1_System_Int32___StaticFields {
};

struct TaskFactory_1_System_Int32___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TaskFactory_1_System_Int32___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TaskFactory_1_System_Int32___VTable vtable;
};

struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__2__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__2__StaticFields {
};

struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__2__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__2__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__2__VTable vtable;
};

struct Task_1_System_Int32___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Threading_IThreadPoolWorkItem_ExecuteWorkItem;
    VirtualInvokeData System_Threading_IThreadPoolWorkItem_MarkAborted;
    VirtualInvokeData get_IsCompleted;
    VirtualInvokeData System_IAsyncResult_get_AsyncWaitHandle;
    VirtualInvokeData get_AsyncState;
    VirtualInvokeData System_IAsyncResult_get_CompletedSynchronously;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_ShouldNotifyDebuggerOfWaitCompletion;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData ShouldReplicate;
    VirtualInvokeData CreateReplicaTask;
    VirtualInvokeData get_SavedStateForNextReplica;
    VirtualInvokeData set_SavedStateForNextReplica;
    VirtualInvokeData get_SavedStateFromPreviousReplica;
    VirtualInvokeData set_SavedStateFromPreviousReplica;
    VirtualInvokeData get_HandedOverChildReplica;
    VirtualInvokeData set_HandedOverChildReplica;
    VirtualInvokeData InnerInvoke;
    VirtualInvokeData GetDelegateContinuationsForDebugger;
};

struct Task_1_System_Int32___StaticFields {
    struct TaskFactory_1_System_Int32_ *s_Factory;
    struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__2 *TaskWhenAnyCast;
};

struct Task_1_System_Int32___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Task_1_System_Int32___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Task_1_System_Int32___VTable vtable;
};

struct Stream_ReadWriteTask__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Threading_IThreadPoolWorkItem_ExecuteWorkItem;
    VirtualInvokeData System_Threading_IThreadPoolWorkItem_MarkAborted;
    VirtualInvokeData get_IsCompleted;
    VirtualInvokeData System_IAsyncResult_get_AsyncWaitHandle;
    VirtualInvokeData get_AsyncState;
    VirtualInvokeData System_IAsyncResult_get_CompletedSynchronously;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_ShouldNotifyDebuggerOfWaitCompletion;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData ShouldReplicate;
    VirtualInvokeData CreateReplicaTask;
    VirtualInvokeData get_SavedStateForNextReplica;
    VirtualInvokeData set_SavedStateForNextReplica;
    VirtualInvokeData get_SavedStateFromPreviousReplica;
    VirtualInvokeData set_SavedStateFromPreviousReplica;
    VirtualInvokeData get_HandedOverChildReplica;
    VirtualInvokeData set_HandedOverChildReplica;
    VirtualInvokeData InnerInvoke;
    VirtualInvokeData GetDelegateContinuationsForDebugger;
    VirtualInvokeData System_Threading_Tasks_ITaskCompletionAction_Invoke;
};

struct Stream_ReadWriteTask__StaticFields {
    struct ContextCallback *s_invokeAsyncCallback;
};

struct Stream_ReadWriteTask__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Stream_ReadWriteTask__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Stream_ReadWriteTask__VTable vtable;
};

struct TaskFactory_1_System_Boolean___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct TaskFactory_1_System_Boolean___StaticFields {
};

struct TaskFactory_1_System_Boolean___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TaskFactory_1_System_Boolean___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TaskFactory_1_System_Boolean___VTable vtable;
};

struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__3__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__3__StaticFields {
};

struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__3__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__3__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__3__VTable vtable;
};

struct Task_1_System_Boolean___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Threading_IThreadPoolWorkItem_ExecuteWorkItem;
    VirtualInvokeData System_Threading_IThreadPoolWorkItem_MarkAborted;
    VirtualInvokeData get_IsCompleted;
    VirtualInvokeData System_IAsyncResult_get_AsyncWaitHandle;
    VirtualInvokeData get_AsyncState;
    VirtualInvokeData System_IAsyncResult_get_CompletedSynchronously;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_ShouldNotifyDebuggerOfWaitCompletion;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData ShouldReplicate;
    VirtualInvokeData CreateReplicaTask;
    VirtualInvokeData get_SavedStateForNextReplica;
    VirtualInvokeData set_SavedStateForNextReplica;
    VirtualInvokeData get_SavedStateFromPreviousReplica;
    VirtualInvokeData set_SavedStateFromPreviousReplica;
    VirtualInvokeData get_HandedOverChildReplica;
    VirtualInvokeData set_HandedOverChildReplica;
    VirtualInvokeData InnerInvoke;
    VirtualInvokeData GetDelegateContinuationsForDebugger;
};

struct Task_1_System_Boolean___StaticFields {
    struct TaskFactory_1_System_Boolean_ *s_Factory;
    struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__3 *TaskWhenAnyCast;
};

struct Task_1_System_Boolean___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Task_1_System_Boolean___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Task_1_System_Boolean___VTable vtable;
};

struct SemaphoreSlim_TaskNode__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Threading_IThreadPoolWorkItem_ExecuteWorkItem;
    VirtualInvokeData System_Threading_IThreadPoolWorkItem_MarkAborted;
    VirtualInvokeData get_IsCompleted;
    VirtualInvokeData System_IAsyncResult_get_AsyncWaitHandle;
    VirtualInvokeData get_AsyncState;
    VirtualInvokeData System_IAsyncResult_get_CompletedSynchronously;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_ShouldNotifyDebuggerOfWaitCompletion;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData ShouldReplicate;
    VirtualInvokeData CreateReplicaTask;
    VirtualInvokeData get_SavedStateForNextReplica;
    VirtualInvokeData set_SavedStateForNextReplica;
    VirtualInvokeData get_SavedStateFromPreviousReplica;
    VirtualInvokeData set_SavedStateFromPreviousReplica;
    VirtualInvokeData get_HandedOverChildReplica;
    VirtualInvokeData set_HandedOverChildReplica;
    VirtualInvokeData InnerInvoke;
    VirtualInvokeData GetDelegateContinuationsForDebugger;
};

struct SemaphoreSlim_TaskNode__StaticFields {
};

struct SemaphoreSlim_TaskNode__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SemaphoreSlim_TaskNode__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SemaphoreSlim_TaskNode__VTable vtable;
};

struct SemaphoreSlim__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData Dispose_1;
};

struct SemaphoreSlim__StaticFields {
    struct Task_1_System_Boolean_ *s_trueTask;
    struct Action_1_Object_ *s_cancellationTokenCanceledEventHandler;
};

struct SemaphoreSlim__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SemaphoreSlim__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SemaphoreSlim__VTable vtable;
};

struct SafeBuffer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_IsInvalid;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData __unknown;
};

struct SafeBuffer__StaticFields {
};

struct SafeBuffer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SafeBuffer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SafeBuffer__VTable vtable;
};

struct FileAccess__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct FileAccess__Enum__StaticFields {
};

struct FileAccess__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FileAccess__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FileAccess__Enum__VTable vtable;
};

struct SeekOrigin__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct SeekOrigin__Enum__StaticFields {
};

struct SeekOrigin__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SeekOrigin__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SeekOrigin__Enum__VTable vtable;
};

struct Pinnable_1_Byte___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Pinnable_1_Byte___StaticFields {
};

struct Pinnable_1_Byte___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Pinnable_1_Byte___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Pinnable_1_Byte___VTable vtable;
};

struct Span_1_Byte___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Span_1_Byte___StaticFields {
};

struct Span_1_Byte___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Span_1_Byte___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Span_1_Byte___VTable vtable;
};

struct ReadOnlySpan_1_Byte___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ReadOnlySpan_1_Byte___StaticFields {
};

struct ReadOnlySpan_1_Byte___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ReadOnlySpan_1_Byte___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ReadOnlySpan_1_Byte___VTable vtable;
};

struct ValueTask_1_System_Int32___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Equals_1;
};

struct ValueTask_1_System_Int32___StaticFields {
};

struct ValueTask_1_System_Int32___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ValueTask_1_System_Int32___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ValueTask_1_System_Int32___VTable vtable;
};

struct Memory_1_Byte___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Memory_1_Byte___StaticFields {
    struct Memory_1_Byte_ _Empty_k__BackingField;
};

struct Memory_1_Byte___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Memory_1_Byte___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Memory_1_Byte___VTable vtable;
};

struct ReadOnlyMemory_1_Byte___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ReadOnlyMemory_1_Byte___StaticFields {
    struct ReadOnlyMemory_1_Byte_ _Empty_k__BackingField;
};

struct ReadOnlyMemory_1_Byte___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ReadOnlyMemory_1_Byte___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ReadOnlyMemory_1_Byte___VTable vtable;
};

struct UnmanagedMemoryStream__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_CanRead;
    VirtualInvokeData get_CanSeek;
    VirtualInvokeData get_CanTimeout;
    VirtualInvokeData get_CanWrite;
    VirtualInvokeData get_Length;
    VirtualInvokeData get_Position;
    VirtualInvokeData set_Position;
    VirtualInvokeData get_ReadTimeout;
    VirtualInvokeData set_ReadTimeout;
    VirtualInvokeData get_WriteTimeout;
    VirtualInvokeData set_WriteTimeout;
    VirtualInvokeData CopyToAsync;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Close;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData Flush;
    VirtualInvokeData FlushAsync;
    VirtualInvokeData CreateWaitHandle;
    VirtualInvokeData BeginRead;
    VirtualInvokeData EndRead;
    VirtualInvokeData ReadAsync;
    VirtualInvokeData BeginWrite;
    VirtualInvokeData EndWrite;
    VirtualInvokeData WriteAsync;
    VirtualInvokeData Seek;
    VirtualInvokeData SetLength;
    VirtualInvokeData Read;
    VirtualInvokeData ReadByte;
    VirtualInvokeData Write;
    VirtualInvokeData WriteByte;
    VirtualInvokeData ObjectInvariant;
    VirtualInvokeData Read_1;
    VirtualInvokeData Write_1;
    VirtualInvokeData ReadAsync_1;
    VirtualInvokeData WriteAsync_1;
};

struct UnmanagedMemoryStream__StaticFields {
};

struct UnmanagedMemoryStream__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UnmanagedMemoryStream__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UnmanagedMemoryStream__VTable vtable;
};

struct Stream__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData Dispose;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData get_CanTimeout;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData __unknown_5;
    VirtualInvokeData get_ReadTimeout;
    VirtualInvokeData set_ReadTimeout;
    VirtualInvokeData get_WriteTimeout;
    VirtualInvokeData set_WriteTimeout;
    VirtualInvokeData CopyToAsync;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Close;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData __unknown_6;
    VirtualInvokeData FlushAsync;
    VirtualInvokeData CreateWaitHandle;
    VirtualInvokeData BeginRead;
    VirtualInvokeData EndRead;
    VirtualInvokeData ReadAsync;
    VirtualInvokeData BeginWrite;
    VirtualInvokeData EndWrite;
    VirtualInvokeData WriteAsync;
    VirtualInvokeData __unknown_7;
    VirtualInvokeData __unknown_8;
    VirtualInvokeData __unknown_9;
    VirtualInvokeData ReadByte;
    VirtualInvokeData __unknown_10;
    VirtualInvokeData WriteByte;
    VirtualInvokeData ObjectInvariant;
    VirtualInvokeData Read;
    VirtualInvokeData Write;
    VirtualInvokeData ReadAsync_1;
    VirtualInvokeData WriteAsync_1;
};

struct Stream__StaticFields {
    struct Stream *Null;
};

struct Stream__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Stream__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Stream__VTable vtable;
};

struct BigInteger__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct BigInteger__StaticFields {
    struct UInt32__Array *smallPrimes;
    struct RandomNumberGenerator *rng;
};

struct BigInteger__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct BigInteger__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct BigInteger__VTable vtable;
};

struct RSAManaged_KeyGeneratedEventHandler__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct RSAManaged_KeyGeneratedEventHandler__StaticFields {
};

struct RSAManaged_KeyGeneratedEventHandler__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RSAManaged_KeyGeneratedEventHandler__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RSAManaged_KeyGeneratedEventHandler__VTable vtable;
};

struct RSAParameters__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct RSAParameters__StaticFields {
};

struct RSAParameters__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RSAParameters__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RSAParameters__VTable vtable;
};

struct RSAManaged__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData get_KeySize;
    VirtualInvokeData set_KeySize;
    VirtualInvokeData get_LegalKeySizes;
    VirtualInvokeData get_SignatureAlgorithm;
    VirtualInvokeData get_KeyExchangeAlgorithm;
    VirtualInvokeData FromXmlString;
    VirtualInvokeData ToXmlString;
    VirtualInvokeData Encrypt;
    VirtualInvokeData Decrypt;
    VirtualInvokeData SignHash;
    VirtualInvokeData VerifyHash;
    VirtualInvokeData HashData;
    VirtualInvokeData HashData_1;
    VirtualInvokeData SignData;
    VirtualInvokeData SignData_1;
    VirtualInvokeData VerifyData;
    VirtualInvokeData DecryptValue;
    VirtualInvokeData EncryptValue;
    VirtualInvokeData ExportParameters;
    VirtualInvokeData ImportParameters;
};

struct RSAManaged__StaticFields {
};

struct RSAManaged__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RSAManaged__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RSAManaged__VTable vtable;
};

struct RSA__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData get_KeySize;
    VirtualInvokeData set_KeySize;
    VirtualInvokeData get_LegalKeySizes;
    VirtualInvokeData get_SignatureAlgorithm;
    VirtualInvokeData get_KeyExchangeAlgorithm;
    VirtualInvokeData FromXmlString;
    VirtualInvokeData ToXmlString;
    VirtualInvokeData Encrypt;
    VirtualInvokeData Decrypt;
    VirtualInvokeData SignHash;
    VirtualInvokeData VerifyHash;
    VirtualInvokeData HashData;
    VirtualInvokeData HashData_1;
    VirtualInvokeData SignData;
    VirtualInvokeData SignData_1;
    VirtualInvokeData VerifyData;
    VirtualInvokeData DecryptValue;
    VirtualInvokeData EncryptValue;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
};

struct RSA__StaticFields {
};

struct RSA__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RSA__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RSA__VTable vtable;
};

struct StrongNameKeyPair__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
    VirtualInvokeData System_Runtime_Serialization_IDeserializationCallback_OnDeserialization;
};

struct StrongNameKeyPair__StaticFields {
};

struct StrongNameKeyPair__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StrongNameKeyPair__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StrongNameKeyPair__VTable vtable;
};

struct AssemblyVersionCompatibility__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct AssemblyVersionCompatibility__Enum__StaticFields {
};

struct AssemblyVersionCompatibility__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyVersionCompatibility__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyVersionCompatibility__Enum__VTable vtable;
};

struct Version__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData CompareTo;
    VirtualInvokeData CompareTo_1;
    VirtualInvokeData Equals_1;
};

struct Version__StaticFields {
    struct Char__Array *SeparatorsArray;
};

struct Version__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Version__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Version__VTable vtable;
};

struct ProcessorArchitecture__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct ProcessorArchitecture__Enum__StaticFields {
};

struct ProcessorArchitecture__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ProcessorArchitecture__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ProcessorArchitecture__Enum__VTable vtable;
};

struct AssemblyContentType__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct AssemblyContentType__Enum__StaticFields {
};

struct AssemblyContentType__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyContentType__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyContentType__Enum__VTable vtable;
};

struct AssemblyName__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData OnDeserialization;
    VirtualInvokeData System_Runtime_InteropServices__AssemblyName_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__AssemblyName_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__AssemblyName_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__AssemblyName_Invoke;
};

struct AssemblyName__StaticFields {
};

struct AssemblyName__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyName__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyName__VTable vtable;
};

struct FileStream__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_CanRead;
    VirtualInvokeData get_CanSeek;
    VirtualInvokeData get_CanTimeout;
    VirtualInvokeData get_CanWrite;
    VirtualInvokeData get_Length;
    VirtualInvokeData get_Position;
    VirtualInvokeData set_Position;
    VirtualInvokeData get_ReadTimeout;
    VirtualInvokeData set_ReadTimeout;
    VirtualInvokeData get_WriteTimeout;
    VirtualInvokeData set_WriteTimeout;
    VirtualInvokeData CopyToAsync;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Close;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData Flush;
    VirtualInvokeData FlushAsync;
    VirtualInvokeData CreateWaitHandle;
    VirtualInvokeData BeginRead;
    VirtualInvokeData EndRead;
    VirtualInvokeData ReadAsync;
    VirtualInvokeData BeginWrite;
    VirtualInvokeData EndWrite;
    VirtualInvokeData WriteAsync;
    VirtualInvokeData Seek;
    VirtualInvokeData SetLength;
    VirtualInvokeData Read;
    VirtualInvokeData ReadByte;
    VirtualInvokeData Write;
    VirtualInvokeData WriteByte;
    VirtualInvokeData ObjectInvariant;
    VirtualInvokeData Read_1;
    VirtualInvokeData Write_1;
    VirtualInvokeData ReadAsync_1;
    VirtualInvokeData WriteAsync_1;
    VirtualInvokeData get_IsAsync;
    VirtualInvokeData get_Handle;
    VirtualInvokeData get_SafeFileHandle;
    VirtualInvokeData Flush_1;
    VirtualInvokeData Lock;
    VirtualInvokeData Unlock;
};

struct FileStream__StaticFields {
    struct Byte__Array *buf_recycle;
    struct Object *buf_recycle_lock;
};

struct FileStream__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FileStream__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FileStream__VTable vtable;
};

struct FileStream__Array__VTable {
};

struct FileStream__Array__StaticFields {
};

struct FileStream__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FileStream__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FileStream__Array__VTable vtable;
};

struct ResourceLocation__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct ResourceLocation__Enum__StaticFields {
};

struct ResourceLocation__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ResourceLocation__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ResourceLocation__Enum__VTable vtable;
};

struct ManifestResourceInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_ReferencedAssembly;
    VirtualInvokeData get_FileName;
    VirtualInvokeData get_ResourceLocation;
};

struct ManifestResourceInfo__StaticFields {
};

struct ManifestResourceInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ManifestResourceInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ManifestResourceInfo__VTable vtable;
};

struct Module__Array__VTable {
};

struct Module__Array__StaticFields {
};

struct Module__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Module__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Module__Array__VTable vtable;
};

struct AssemblyName__Array__VTable {
};

struct AssemblyName__Array__StaticFields {
};

struct AssemblyName__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyName__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyName__Array__VTable vtable;
};

struct ArrayList__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData Add;
    VirtualInvokeData Contains;
    VirtualInvokeData Clear;
    VirtualInvokeData get_IsReadOnly;
    VirtualInvokeData get_IsFixedSize;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData Remove;
    VirtualInvokeData RemoveAt;
    VirtualInvokeData CopyTo;
    VirtualInvokeData get_Count;
    VirtualInvokeData get_SyncRoot;
    VirtualInvokeData get_IsSynchronized;
    VirtualInvokeData GetEnumerator;
    VirtualInvokeData Clone;
    VirtualInvokeData get_Capacity;
    VirtualInvokeData set_Capacity;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData get_IsFixedSize_1;
    VirtualInvokeData get_IsReadOnly_1;
    VirtualInvokeData get_IsSynchronized_1;
    VirtualInvokeData get_SyncRoot_1;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData set_Item_1;
    VirtualInvokeData Add_1;
    VirtualInvokeData AddRange;
    VirtualInvokeData BinarySearch;
    VirtualInvokeData BinarySearch_1;
    VirtualInvokeData BinarySearch_2;
    VirtualInvokeData Clear_1;
    VirtualInvokeData Clone_1;
    VirtualInvokeData Contains_1;
    VirtualInvokeData CopyTo_1;
    VirtualInvokeData CopyTo_2;
    VirtualInvokeData CopyTo_3;
    VirtualInvokeData GetEnumerator_1;
    VirtualInvokeData GetEnumerator_2;
    VirtualInvokeData IndexOf_1;
    VirtualInvokeData IndexOf_2;
    VirtualInvokeData IndexOf_3;
    VirtualInvokeData Insert_1;
    VirtualInvokeData InsertRange;
    VirtualInvokeData LastIndexOf;
    VirtualInvokeData LastIndexOf_1;
    VirtualInvokeData LastIndexOf_2;
    VirtualInvokeData Remove_1;
    VirtualInvokeData RemoveAt_1;
    VirtualInvokeData RemoveRange;
    VirtualInvokeData Reverse;
    VirtualInvokeData Reverse_1;
    VirtualInvokeData SetRange;
    VirtualInvokeData GetRange;
    VirtualInvokeData Sort;
    VirtualInvokeData Sort_1;
    VirtualInvokeData Sort_2;
    VirtualInvokeData ToArray;
    VirtualInvokeData ToArray_1;
    VirtualInvokeData TrimToSize;
};

struct ArrayList__StaticFields {
    struct Object__Array *emptyArray;
};

struct ArrayList__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ArrayList__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ArrayList__VTable vtable;
};

struct Evidence__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CopyTo;
    VirtualInvokeData get_Count;
    VirtualInvokeData get_SyncRoot;
    VirtualInvokeData get_IsSynchronized;
    VirtualInvokeData GetEnumerator;
};

struct Evidence__StaticFields {
};

struct Evidence__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Evidence__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Evidence__VTable vtable;
};

struct SecurityRuleSet__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct SecurityRuleSet__Enum__StaticFields {
};

struct SecurityRuleSet__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SecurityRuleSet__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SecurityRuleSet__Enum__VTable vtable;
};

struct IEnumerable_1_System_Reflection_TypeInfo___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_Reflection_TypeInfo___StaticFields {
};

struct IEnumerable_1_System_Reflection_TypeInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_Reflection_TypeInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_Reflection_TypeInfo___VTable vtable;
};

struct IEnumerable_1_System_Type___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_Type___StaticFields {
};

struct IEnumerable_1_System_Type___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_Type___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_Type___VTable vtable;
};

struct IEnumerable_1_System_Reflection_Module___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_Reflection_Module___StaticFields {
};

struct IEnumerable_1_System_Reflection_Module___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_Reflection_Module___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_Reflection_Module___VTable vtable;
};

struct PermissionState__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct PermissionState__Enum__StaticFields {
};

struct PermissionState__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PermissionState__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PermissionState__Enum__VTable vtable;
};

struct PolicyStatementAttribute__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct PolicyStatementAttribute__Enum__StaticFields {
};

struct PolicyStatementAttribute__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PolicyStatementAttribute__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PolicyStatementAttribute__Enum__VTable vtable;
};

struct SecurityElement__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct SecurityElement__StaticFields {
    struct Char__Array *invalid_tag_chars;
    struct Char__Array *invalid_text_chars;
    struct Char__Array *invalid_attr_name_chars;
    struct Char__Array *invalid_attr_value_chars;
    struct Char__Array *invalid_chars;
};

struct SecurityElement__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SecurityElement__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SecurityElement__VTable vtable;
};

struct PolicyStatement__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData FromXml;
    VirtualInvokeData ToXml;
    VirtualInvokeData FromXml_1;
    VirtualInvokeData ToXml_1;
};

struct PolicyStatement__StaticFields {
};

struct PolicyStatement__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PolicyStatement__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PolicyStatement__VTable vtable;
};

struct IMembershipCondition__VTable {
    VirtualInvokeData Check;
    VirtualInvokeData Copy;
    VirtualInvokeData Equals;
    VirtualInvokeData ToString;
};

struct IMembershipCondition__StaticFields {
};

struct IMembershipCondition__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IMembershipCondition__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IMembershipCondition__VTable vtable;
};

struct FileIOPermissionAccess__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct FileIOPermissionAccess__Enum__StaticFields {
};

struct FileIOPermissionAccess__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FileIOPermissionAccess__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FileIOPermissionAccess__Enum__VTable vtable;
};

struct FileCodeGroup__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Copy;
    VirtualInvokeData get_MergeLogic;
    VirtualInvokeData Resolve;
    VirtualInvokeData ResolveMatchingCodeGroups;
    VirtualInvokeData get_AttributeString;
    VirtualInvokeData get_PermissionSetName;
    VirtualInvokeData ParseXml;
    VirtualInvokeData CreateXml;
};

struct FileCodeGroup__StaticFields {
};

struct FileCodeGroup__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FileCodeGroup__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FileCodeGroup__VTable vtable;
};

struct CodeGroup__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData get_AttributeString;
    VirtualInvokeData get_PermissionSetName;
    VirtualInvokeData ParseXml;
    VirtualInvokeData CreateXml;
};

struct CodeGroup__StaticFields {
};

struct CodeGroup__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CodeGroup__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CodeGroup__VTable vtable;
};

struct PolicyLevelType__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct PolicyLevelType__Enum__StaticFields {
};

struct PolicyLevelType__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PolicyLevelType__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PolicyLevelType__Enum__VTable vtable;
};

struct PolicyLevel__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct PolicyLevel__StaticFields {
};

struct PolicyLevel__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PolicyLevel__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PolicyLevel__VTable vtable;
};

struct IPermission__VTable {
    VirtualInvokeData Copy;
    VirtualInvokeData Demand;
    VirtualInvokeData Intersect;
    VirtualInvokeData IsSubsetOf;
    VirtualInvokeData Union;
};

struct IPermission__StaticFields {
};

struct IPermission__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IPermission__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IPermission__VTable vtable;
};

struct PermissionSet__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData FromXml;
    VirtualInvokeData ToXml;
    VirtualInvokeData CopyTo;
    VirtualInvokeData get_Count;
    VirtualInvokeData get_SyncRoot;
    VirtualInvokeData get_IsSynchronized;
    VirtualInvokeData GetEnumerator;
    VirtualInvokeData Assert;
    VirtualInvokeData Demand;
    VirtualInvokeData Deny;
    VirtualInvokeData PermitOnly;
    VirtualInvokeData System_Runtime_Serialization_IDeserializationCallback_OnDeserialization;
    VirtualInvokeData Copy;
    VirtualInvokeData CopyTo_1;
    VirtualInvokeData FromXml_1;
    VirtualInvokeData ToXml_1;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData get_IsSynchronized_1;
    VirtualInvokeData get_IsReadOnly;
    VirtualInvokeData get_SyncRoot_1;
    VirtualInvokeData AddPermissionImpl;
    VirtualInvokeData GetEnumeratorImpl;
    VirtualInvokeData GetPermissionImpl;
    VirtualInvokeData RemovePermissionImpl;
    VirtualInvokeData SetPermissionImpl;
};

struct PermissionSet__StaticFields {
    struct Object__Array *psUnrestricted;
    struct Object__Array *action;
};

struct PermissionSet__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PermissionSet__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PermissionSet__VTable vtable;
};

struct Assembly__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData ToString_1;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__Assembly_GetType;
    VirtualInvokeData get_CodeBase;
    VirtualInvokeData get_EscapedCodeBase;
    VirtualInvokeData GetName;
    VirtualInvokeData GetName_1;
    VirtualInvokeData get_FullName;
    VirtualInvokeData get_EntryPoint;
    VirtualInvokeData GetType;
    VirtualInvokeData GetType_1;
    VirtualInvokeData GetExportedTypes;
    VirtualInvokeData GetTypes;
    VirtualInvokeData GetManifestResourceStream;
    VirtualInvokeData GetManifestResourceStream_1;
    VirtualInvokeData GetFile;
    VirtualInvokeData GetFiles;
    VirtualInvokeData GetFiles_1;
    VirtualInvokeData GetManifestResourceNames;
    VirtualInvokeData GetManifestResourceInfo;
    VirtualInvokeData get_Location;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType_2;
    VirtualInvokeData GetSatelliteAssembly;
    VirtualInvokeData GetSatelliteAssembly_1;
    VirtualInvokeData LoadModule;
    VirtualInvokeData LoadModule_1;
    VirtualInvokeData CreateInstance;
    VirtualInvokeData CreateInstance_1;
    VirtualInvokeData CreateInstance_2;
    VirtualInvokeData GetLoadedModules;
    VirtualInvokeData GetLoadedModules_1;
    VirtualInvokeData GetModules;
    VirtualInvokeData GetModules_1;
    VirtualInvokeData GetModule;
    VirtualInvokeData GetReferencedAssemblies;
    VirtualInvokeData add_ModuleResolve;
    VirtualInvokeData remove_ModuleResolve;
    VirtualInvokeData get_Evidence;
    VirtualInvokeData get_GlobalAssemblyCache;
    VirtualInvokeData get_Evidence_1;
    VirtualInvokeData add_ModuleResolve_1;
    VirtualInvokeData remove_ModuleResolve_1;
    VirtualInvokeData get_CodeBase_1;
    VirtualInvokeData get_EscapedCodeBase_1;
    VirtualInvokeData get_FullName_1;
    VirtualInvokeData get_EntryPoint_1;
    VirtualInvokeData get_Evidence_2;
    VirtualInvokeData get_Location_1;
    VirtualInvokeData get_ImageRuntimeVersion;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData GetFiles_2;
    VirtualInvokeData GetFiles_3;
    VirtualInvokeData GetFile_1;
    VirtualInvokeData GetManifestResourceStream_2;
    VirtualInvokeData GetManifestResourceStream_3;
    VirtualInvokeData GetTypes_1;
    VirtualInvokeData GetTypes_2;
    VirtualInvokeData GetExportedTypes_1;
    VirtualInvokeData GetType_3;
    VirtualInvokeData GetType_4;
    VirtualInvokeData GetName_2;
    VirtualInvokeData GetName_3;
    VirtualInvokeData LoadModule_2;
    VirtualInvokeData CreateInstance_3;
    VirtualInvokeData GetModulesInternal;
    VirtualInvokeData GetManifestResourceNames_1;
    VirtualInvokeData GetManifestResourceInfo_1;
    VirtualInvokeData get_HostContext;
    VirtualInvokeData GetManifestModule;
    VirtualInvokeData get_ReflectionOnly;
    VirtualInvokeData get_SecurityRuleSet;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData GetType_5;
    VirtualInvokeData GetModule_1;
    VirtualInvokeData GetReferencedAssemblies_1;
    VirtualInvokeData GetModules_2;
    VirtualInvokeData GetLoadedModules_2;
    VirtualInvokeData GetSatelliteAssembly_2;
    VirtualInvokeData GetSatelliteAssembly_3;
    VirtualInvokeData get_ManifestModule;
    VirtualInvokeData get_GlobalAssemblyCache_1;
    VirtualInvokeData get_IsDynamic;
    VirtualInvokeData get_DefinedTypes;
    VirtualInvokeData get_ExportedTypes;
    VirtualInvokeData get_Modules;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData get_PermissionSet;
};

struct Assembly__StaticFields {
};

struct Assembly__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Assembly__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Assembly__VTable vtable;
};

struct PortableExecutableKinds__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct PortableExecutableKinds__Enum__StaticFields {
};

struct PortableExecutableKinds__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PortableExecutableKinds__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PortableExecutableKinds__Enum__VTable vtable;
};

struct PortableExecutableKinds___VTable {
};

struct PortableExecutableKinds___StaticFields {
};

struct PortableExecutableKinds___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PortableExecutableKinds___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PortableExecutableKinds___VTable vtable;
};

struct ImageFileMachine__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct ImageFileMachine__Enum__StaticFields {
};

struct ImageFileMachine__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ImageFileMachine__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ImageFileMachine__Enum__VTable vtable;
};

struct ImageFileMachine___VTable {
};

struct ImageFileMachine___StaticFields {
};

struct ImageFileMachine___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ImageFileMachine___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ImageFileMachine___VTable vtable;
};

struct ASN1__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetBytes;
};

struct ASN1__StaticFields {
};

struct ASN1__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ASN1__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ASN1__VTable vtable;
};

struct DSAManaged_KeyGeneratedEventHandler__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct DSAManaged_KeyGeneratedEventHandler__StaticFields {
};

struct DSAManaged_KeyGeneratedEventHandler__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DSAManaged_KeyGeneratedEventHandler__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DSAManaged_KeyGeneratedEventHandler__VTable vtable;
};

struct DSAParameters__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct DSAParameters__StaticFields {
};

struct DSAParameters__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DSAParameters__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DSAParameters__VTable vtable;
};

struct DSAManaged__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData get_KeySize;
    VirtualInvokeData set_KeySize;
    VirtualInvokeData get_LegalKeySizes;
    VirtualInvokeData get_SignatureAlgorithm;
    VirtualInvokeData get_KeyExchangeAlgorithm;
    VirtualInvokeData FromXmlString;
    VirtualInvokeData ToXmlString;
    VirtualInvokeData CreateSignature;
    VirtualInvokeData VerifySignature;
    VirtualInvokeData HashData;
    VirtualInvokeData HashData_1;
    VirtualInvokeData SignData;
    VirtualInvokeData SignData_1;
    VirtualInvokeData VerifyData;
    VirtualInvokeData VerifyData_1;
    VirtualInvokeData ExportParameters;
    VirtualInvokeData ImportParameters;
};

struct DSAManaged__StaticFields {
};

struct DSAManaged__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DSAManaged__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DSAManaged__VTable vtable;
};

struct DSA__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData get_KeySize;
    VirtualInvokeData set_KeySize;
    VirtualInvokeData get_LegalKeySizes;
    VirtualInvokeData get_SignatureAlgorithm;
    VirtualInvokeData get_KeyExchangeAlgorithm;
    VirtualInvokeData FromXmlString;
    VirtualInvokeData ToXmlString;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData HashData;
    VirtualInvokeData HashData_1;
    VirtualInvokeData SignData;
    VirtualInvokeData SignData_1;
    VirtualInvokeData VerifyData;
    VirtualInvokeData VerifyData_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData __unknown_3;
};

struct DSA__StaticFields {
};

struct DSA__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DSA__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DSA__VTable vtable;
};

struct CollectionBase__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Collections_IList_get_Item;
    VirtualInvokeData System_Collections_IList_set_Item;
    VirtualInvokeData System_Collections_IList_Add;
    VirtualInvokeData System_Collections_IList_Contains;
    VirtualInvokeData Clear;
    VirtualInvokeData System_Collections_IList_get_IsReadOnly;
    VirtualInvokeData System_Collections_IList_get_IsFixedSize;
    VirtualInvokeData System_Collections_IList_IndexOf;
    VirtualInvokeData System_Collections_IList_Insert;
    VirtualInvokeData System_Collections_IList_Remove;
    VirtualInvokeData RemoveAt;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData GetEnumerator;
    VirtualInvokeData OnSet;
    VirtualInvokeData OnInsert;
    VirtualInvokeData OnClear;
    VirtualInvokeData OnRemove;
    VirtualInvokeData OnValidate;
    VirtualInvokeData OnSetComplete;
    VirtualInvokeData OnInsertComplete;
    VirtualInvokeData OnClearComplete;
    VirtualInvokeData OnRemoveComplete;
};

struct CollectionBase__StaticFields {
};

struct CollectionBase__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CollectionBase__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CollectionBase__VTable vtable;
};

struct X509ExtensionCollection__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Collections_IList_get_Item;
    VirtualInvokeData System_Collections_IList_set_Item;
    VirtualInvokeData System_Collections_IList_Add;
    VirtualInvokeData System_Collections_IList_Contains;
    VirtualInvokeData Clear;
    VirtualInvokeData System_Collections_IList_get_IsReadOnly;
    VirtualInvokeData System_Collections_IList_get_IsFixedSize;
    VirtualInvokeData System_Collections_IList_IndexOf;
    VirtualInvokeData System_Collections_IList_Insert;
    VirtualInvokeData System_Collections_IList_Remove;
    VirtualInvokeData RemoveAt;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData OnSet;
    VirtualInvokeData OnInsert;
    VirtualInvokeData OnClear;
    VirtualInvokeData OnRemove;
    VirtualInvokeData OnValidate;
    VirtualInvokeData OnSetComplete;
    VirtualInvokeData OnInsertComplete;
    VirtualInvokeData OnClearComplete;
    VirtualInvokeData OnRemoveComplete;
};

struct X509ExtensionCollection__StaticFields {
};

struct X509ExtensionCollection__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X509ExtensionCollection__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X509ExtensionCollection__VTable vtable;
};

struct X509Certificate_1__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_IssuerName;
    VirtualInvokeData get_KeyAlgorithm;
    VirtualInvokeData get_KeyAlgorithmParameters;
    VirtualInvokeData set_KeyAlgorithmParameters;
    VirtualInvokeData get_PublicKey;
    VirtualInvokeData get_RSA;
    VirtualInvokeData set_RSA;
    VirtualInvokeData get_RawData;
    VirtualInvokeData get_SerialNumber;
    VirtualInvokeData get_Signature;
    VirtualInvokeData get_SignatureAlgorithm;
    VirtualInvokeData get_SignatureAlgorithmParameters;
    VirtualInvokeData get_SubjectName;
    VirtualInvokeData get_ValidFrom;
    VirtualInvokeData get_ValidUntil;
    VirtualInvokeData GetObjectData_1;
};

struct X509Certificate_1__StaticFields {
    struct String *encoding_error;
};

struct X509Certificate_1__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X509Certificate_1__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X509Certificate_1__VTable vtable;
};

struct Boolean___VTable {
};

struct Boolean___StaticFields {
};

struct Boolean___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Boolean___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Boolean___VTable vtable;
};

struct X509ContentType__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct X509ContentType__Enum__StaticFields {
};

struct X509ContentType__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X509ContentType__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X509ContentType__Enum__VTable vtable;
};

struct X509CertificateImplMono__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_IsValid;
    VirtualInvokeData get_Handle;
    VirtualInvokeData GetNativeAppleCertificate;
    VirtualInvokeData Clone;
    VirtualInvokeData GetIssuerName;
    VirtualInvokeData GetSubjectName;
    VirtualInvokeData GetRawCertData;
    VirtualInvokeData GetValidFrom;
    VirtualInvokeData GetValidUntil;
    VirtualInvokeData GetCertHash;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetKeyAlgorithm;
    VirtualInvokeData GetKeyAlgorithmParameters;
    VirtualInvokeData GetPublicKey;
    VirtualInvokeData GetSerialNumber;
    VirtualInvokeData Export;
    VirtualInvokeData ToString_1;
    VirtualInvokeData Dispose_1;
};

struct X509CertificateImplMono__StaticFields {
};

struct X509CertificateImplMono__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X509CertificateImplMono__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X509CertificateImplMono__VTable vtable;
};

struct X509CertificateImpl__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData __unknown_5;
    VirtualInvokeData __unknown_6;
    VirtualInvokeData __unknown_7;
    VirtualInvokeData __unknown_8;
    VirtualInvokeData __unknown_9;
    VirtualInvokeData __unknown_10;
    VirtualInvokeData __unknown_11;
    VirtualInvokeData __unknown_12;
    VirtualInvokeData __unknown_13;
    VirtualInvokeData __unknown_14;
    VirtualInvokeData __unknown_15;
    VirtualInvokeData __unknown_16;
    VirtualInvokeData Dispose_1;
};

struct X509CertificateImpl__StaticFields {
};

struct X509CertificateImpl__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X509CertificateImpl__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X509CertificateImpl__VTable vtable;
};

struct SecureString__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
};

struct SecureString__StaticFields {
};

struct SecureString__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SecureString__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SecureString__VTable vtable;
};

struct X509KeyStorageFlags__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct X509KeyStorageFlags__Enum__StaticFields {
};

struct X509KeyStorageFlags__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X509KeyStorageFlags__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X509KeyStorageFlags__Enum__VTable vtable;
};

struct X509Certificate__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_Serialization_IDeserializationCallback_OnDeserialization;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
    VirtualInvokeData Dispose;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCertHash;
    VirtualInvokeData GetCertHashString;
    VirtualInvokeData GetEffectiveDateString;
    VirtualInvokeData GetExpirationDateString;
    VirtualInvokeData GetFormat;
    VirtualInvokeData GetIssuerName;
    VirtualInvokeData GetKeyAlgorithm;
    VirtualInvokeData GetKeyAlgorithmParameters;
    VirtualInvokeData GetKeyAlgorithmParametersString;
    VirtualInvokeData GetName;
    VirtualInvokeData GetPublicKey;
    VirtualInvokeData GetPublicKeyString;
    VirtualInvokeData GetRawCertData;
    VirtualInvokeData GetRawCertDataString;
    VirtualInvokeData GetSerialNumber;
    VirtualInvokeData GetSerialNumberString;
    VirtualInvokeData ToString_1;
    VirtualInvokeData Export;
    VirtualInvokeData Export_1;
    VirtualInvokeData Export_2;
    VirtualInvokeData Import;
    VirtualInvokeData Import_1;
    VirtualInvokeData Import_2;
    VirtualInvokeData Import_3;
    VirtualInvokeData Import_4;
    VirtualInvokeData Import_5;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData Reset;
};

struct X509Certificate__StaticFields {
};

struct X509Certificate__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X509Certificate__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X509Certificate__VTable vtable;
};

struct Module__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData System_Runtime_InteropServices__Module_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Module_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Module_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Module_Invoke;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData GetType_1;
    VirtualInvokeData GetModuleVersionId;
    VirtualInvokeData get_Assembly;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ScopeName;
    VirtualInvokeData get_MDStreamVersion;
    VirtualInvokeData get_ModuleVersionId;
    VirtualInvokeData get_FullyQualifiedName;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData IsResource;
    VirtualInvokeData FindTypes;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData GetField;
    VirtualInvokeData GetFields;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetMethods;
    VirtualInvokeData GetPEKind;
    VirtualInvokeData GetType_2;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ResolveField;
    VirtualInvokeData ResolveMember;
    VirtualInvokeData ResolveMethod;
    VirtualInvokeData ResolveSignature;
    VirtualInvokeData ResolveString;
    VirtualInvokeData ResolveType;
    VirtualInvokeData GetSignerCertificate;
    VirtualInvokeData GetTypes;
    VirtualInvokeData get_CustomAttributes;
};

struct Module__StaticFields {
    struct TypeFilter *FilterTypeName;
    struct TypeFilter *FilterTypeNameIgnoreCase;
};

struct Module__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Module__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Module__VTable vtable;
};

struct MemberInfo_1__Array__VTable {
};

struct MemberInfo_1__Array__StaticFields {
};

struct MemberInfo_1__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MemberInfo_1__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MemberInfo_1__Array__VTable vtable;
};

struct MemberFilter__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct MemberFilter__StaticFields {
};

struct MemberFilter__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MemberFilter__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MemberFilter__VTable vtable;
};

struct RuntimeConstructorInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData __unknown_5;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData Equals_2;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData GetMethodImplementationFlags;
    VirtualInvokeData GetParameters;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_Invoke;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetType;
    VirtualInvokeData Invoke;
    VirtualInvokeData Invoke_1;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_CallingConvention;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsAbstract;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsAssembly;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsConstructor;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFamily;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFamilyAndAssembly;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFamilyOrAssembly;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFinal;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsHideBySig;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsPrivate;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsPublic;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsSpecialName;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsStatic;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsVirtual;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_MethodHandle;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData GetParametersNoCopy;
    VirtualInvokeData __unknown_6;
    VirtualInvokeData get_MethodImplementationFlags;
    VirtualInvokeData __unknown_7;
    VirtualInvokeData __unknown_8;
    VirtualInvokeData __unknown_9;
    VirtualInvokeData __unknown_10;
    VirtualInvokeData get_CallingConvention_1;
    VirtualInvokeData GetGenericArguments;
    VirtualInvokeData get_IsGenericMethodDefinition;
    VirtualInvokeData get_ContainsGenericParameters;
    VirtualInvokeData get_IsGenericMethod;
    VirtualInvokeData get_IsSecurityCritical;
    VirtualInvokeData get_IsSecuritySafeCritical;
    VirtualInvokeData get_IsSecurityTransparent;
    VirtualInvokeData get_IsPublic;
    VirtualInvokeData get_IsPrivate;
    VirtualInvokeData get_IsFamily;
    VirtualInvokeData get_IsAssembly;
    VirtualInvokeData get_IsFamilyAndAssembly;
    VirtualInvokeData get_IsFamilyOrAssembly;
    VirtualInvokeData get_IsStatic;
    VirtualInvokeData get_IsFinal;
    VirtualInvokeData get_IsVirtual;
    VirtualInvokeData get_IsHideBySig;
    VirtualInvokeData get_IsAbstract;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_IsConstructor;
    VirtualInvokeData GetMethodBody;
    VirtualInvokeData FormatNameAndSig;
    VirtualInvokeData GetParameterTypes;
    VirtualInvokeData GetParametersInternal;
    VirtualInvokeData GetParametersCount;
    VirtualInvokeData GetParameterType;
    VirtualInvokeData get_next_table_index;
    VirtualInvokeData Equals_3;
    VirtualInvokeData GetCustomAttributes_6;
    VirtualInvokeData GetCustomAttributes_7;
    VirtualInvokeData GetHashCode_3;
    VirtualInvokeData GetMethodImplementationFlags_1;
    VirtualInvokeData GetParameters_1;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_Invoke;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_GetType;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_Invoke_5;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_Invoke_3;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_Invoke_4;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_Invoke_2;
    VirtualInvokeData IsDefined_3;
    VirtualInvokeData ToString_3;
    VirtualInvokeData get_Attributes_1;
    VirtualInvokeData get_CallingConvention_2;
    VirtualInvokeData get_DeclaringType_2;
    VirtualInvokeData get_IsAbstract_1;
    VirtualInvokeData get_IsAssembly_1;
    VirtualInvokeData get_IsConstructor_1;
    VirtualInvokeData get_IsFamily_1;
    VirtualInvokeData get_IsFamilyAndAssembly_1;
    VirtualInvokeData get_IsFamilyOrAssembly_1;
    VirtualInvokeData get_IsFinal_1;
    VirtualInvokeData get_IsHideBySig_1;
    VirtualInvokeData get_IsPrivate_1;
    VirtualInvokeData get_IsPublic_1;
    VirtualInvokeData get_IsSpecialName_1;
    VirtualInvokeData get_IsStatic_1;
    VirtualInvokeData get_IsVirtual_1;
    VirtualInvokeData get_MemberType_3;
    VirtualInvokeData get_MethodHandle_1;
    VirtualInvokeData get_Name_2;
    VirtualInvokeData get_ReflectedType_2;
    VirtualInvokeData __unknown_11;
    VirtualInvokeData GetObjectData;
};

struct RuntimeConstructorInfo__StaticFields {
};

struct RuntimeConstructorInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeConstructorInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeConstructorInfo__VTable vtable;
};

struct MonoCMethod__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData Equals_2;
    VirtualInvokeData GetCustomAttributes_6;
    VirtualInvokeData GetCustomAttributes_7;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData GetMethodImplementationFlags;
    VirtualInvokeData GetParameters;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_Invoke;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetType;
    VirtualInvokeData Invoke;
    VirtualInvokeData Invoke_1;
    VirtualInvokeData IsDefined_3;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_CallingConvention;
    VirtualInvokeData get_DeclaringType_2;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsAbstract;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsAssembly;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsConstructor;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFamily;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFamilyAndAssembly;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFamilyOrAssembly;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFinal;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsHideBySig;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsPrivate;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsPublic;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsSpecialName;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsStatic;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsVirtual;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_MethodHandle;
    VirtualInvokeData get_Name_2;
    VirtualInvokeData get_ReflectedType_2;
    VirtualInvokeData GetParametersNoCopy;
    VirtualInvokeData GetParameters_1;
    VirtualInvokeData get_MethodImplementationFlags;
    VirtualInvokeData GetMethodImplementationFlags_1;
    VirtualInvokeData get_MethodHandle_1;
    VirtualInvokeData get_Attributes_1;
    VirtualInvokeData Invoke_2;
    VirtualInvokeData get_CallingConvention_1;
    VirtualInvokeData GetGenericArguments;
    VirtualInvokeData get_IsGenericMethodDefinition;
    VirtualInvokeData get_ContainsGenericParameters;
    VirtualInvokeData get_IsGenericMethod;
    VirtualInvokeData get_IsSecurityCritical;
    VirtualInvokeData get_IsSecuritySafeCritical;
    VirtualInvokeData get_IsSecurityTransparent;
    VirtualInvokeData get_IsPublic;
    VirtualInvokeData get_IsPrivate;
    VirtualInvokeData get_IsFamily;
    VirtualInvokeData get_IsAssembly;
    VirtualInvokeData get_IsFamilyAndAssembly;
    VirtualInvokeData get_IsFamilyOrAssembly;
    VirtualInvokeData get_IsStatic;
    VirtualInvokeData get_IsFinal;
    VirtualInvokeData get_IsVirtual;
    VirtualInvokeData get_IsHideBySig;
    VirtualInvokeData get_IsAbstract;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_IsConstructor;
    VirtualInvokeData GetMethodBody;
    VirtualInvokeData FormatNameAndSig;
    VirtualInvokeData GetParameterTypes;
    VirtualInvokeData GetParametersInternal;
    VirtualInvokeData GetParametersCount;
    VirtualInvokeData GetParameterType;
    VirtualInvokeData get_next_table_index;
    VirtualInvokeData Equals_3;
    VirtualInvokeData GetCustomAttributes_8;
    VirtualInvokeData GetCustomAttributes_9;
    VirtualInvokeData GetHashCode_3;
    VirtualInvokeData GetMethodImplementationFlags_2;
    VirtualInvokeData GetParameters_2;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_Invoke;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_GetType;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_Invoke_5;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_Invoke_3;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_Invoke_4;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_Invoke_2;
    VirtualInvokeData IsDefined_4;
    VirtualInvokeData ToString_3;
    VirtualInvokeData get_Attributes_2;
    VirtualInvokeData get_CallingConvention_2;
    VirtualInvokeData get_DeclaringType_3;
    VirtualInvokeData get_IsAbstract_1;
    VirtualInvokeData get_IsAssembly_1;
    VirtualInvokeData get_IsConstructor_1;
    VirtualInvokeData get_IsFamily_1;
    VirtualInvokeData get_IsFamilyAndAssembly_1;
    VirtualInvokeData get_IsFamilyOrAssembly_1;
    VirtualInvokeData get_IsFinal_1;
    VirtualInvokeData get_IsHideBySig_1;
    VirtualInvokeData get_IsPrivate_1;
    VirtualInvokeData get_IsPublic_1;
    VirtualInvokeData get_IsSpecialName_1;
    VirtualInvokeData get_IsStatic_1;
    VirtualInvokeData get_IsVirtual_1;
    VirtualInvokeData get_MemberType_3;
    VirtualInvokeData get_MethodHandle_2;
    VirtualInvokeData get_Name_3;
    VirtualInvokeData get_ReflectedType_3;
    VirtualInvokeData Invoke_3;
    VirtualInvokeData GetObjectData;
};

struct MonoCMethod__StaticFields {
};

struct MonoCMethod__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoCMethod__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoCMethod__VTable vtable;
};

struct ConstructorInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData __unknown_5;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData Equals_2;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData GetMethodImplementationFlags;
    VirtualInvokeData GetParameters;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_Invoke;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetType;
    VirtualInvokeData Invoke;
    VirtualInvokeData Invoke_1;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_CallingConvention;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsAbstract;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsAssembly;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsConstructor;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFamily;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFamilyAndAssembly;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFamilyOrAssembly;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFinal;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsHideBySig;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsPrivate;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsPublic;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsSpecialName;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsStatic;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsVirtual;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_MethodHandle;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData GetParametersNoCopy;
    VirtualInvokeData __unknown_6;
    VirtualInvokeData get_MethodImplementationFlags;
    VirtualInvokeData __unknown_7;
    VirtualInvokeData __unknown_8;
    VirtualInvokeData __unknown_9;
    VirtualInvokeData __unknown_10;
    VirtualInvokeData get_CallingConvention_1;
    VirtualInvokeData GetGenericArguments;
    VirtualInvokeData get_IsGenericMethodDefinition;
    VirtualInvokeData get_ContainsGenericParameters;
    VirtualInvokeData get_IsGenericMethod;
    VirtualInvokeData get_IsSecurityCritical;
    VirtualInvokeData get_IsSecuritySafeCritical;
    VirtualInvokeData get_IsSecurityTransparent;
    VirtualInvokeData get_IsPublic;
    VirtualInvokeData get_IsPrivate;
    VirtualInvokeData get_IsFamily;
    VirtualInvokeData get_IsAssembly;
    VirtualInvokeData get_IsFamilyAndAssembly;
    VirtualInvokeData get_IsFamilyOrAssembly;
    VirtualInvokeData get_IsStatic;
    VirtualInvokeData get_IsFinal;
    VirtualInvokeData get_IsVirtual;
    VirtualInvokeData get_IsHideBySig;
    VirtualInvokeData get_IsAbstract;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_IsConstructor;
    VirtualInvokeData GetMethodBody;
    VirtualInvokeData FormatNameAndSig;
    VirtualInvokeData GetParameterTypes;
    VirtualInvokeData GetParametersInternal;
    VirtualInvokeData GetParametersCount;
    VirtualInvokeData GetParameterType;
    VirtualInvokeData get_next_table_index;
    VirtualInvokeData Equals_3;
    VirtualInvokeData GetCustomAttributes_6;
    VirtualInvokeData GetCustomAttributes_7;
    VirtualInvokeData GetHashCode_3;
    VirtualInvokeData GetMethodImplementationFlags_1;
    VirtualInvokeData GetParameters_1;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_Invoke;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_GetType;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_Invoke_5;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_Invoke_3;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_Invoke_4;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_Invoke_2;
    VirtualInvokeData IsDefined_3;
    VirtualInvokeData ToString_3;
    VirtualInvokeData get_Attributes_1;
    VirtualInvokeData get_CallingConvention_2;
    VirtualInvokeData get_DeclaringType_2;
    VirtualInvokeData get_IsAbstract_1;
    VirtualInvokeData get_IsAssembly_1;
    VirtualInvokeData get_IsConstructor_1;
    VirtualInvokeData get_IsFamily_1;
    VirtualInvokeData get_IsFamilyAndAssembly_1;
    VirtualInvokeData get_IsFamilyOrAssembly_1;
    VirtualInvokeData get_IsFinal_1;
    VirtualInvokeData get_IsHideBySig_1;
    VirtualInvokeData get_IsPrivate_1;
    VirtualInvokeData get_IsPublic_1;
    VirtualInvokeData get_IsSpecialName_1;
    VirtualInvokeData get_IsStatic_1;
    VirtualInvokeData get_IsVirtual_1;
    VirtualInvokeData get_MemberType_3;
    VirtualInvokeData get_MethodHandle_1;
    VirtualInvokeData get_Name_2;
    VirtualInvokeData get_ReflectedType_2;
    VirtualInvokeData __unknown_11;
};

struct ConstructorInfo__StaticFields {
    struct String *ConstructorName;
    struct String *TypeConstructorName;
};

struct ConstructorInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ConstructorInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ConstructorInfo__VTable vtable;
};

struct ConstructorInfo__Array__VTable {
};

struct ConstructorInfo__Array__StaticFields {
};

struct ConstructorInfo__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ConstructorInfo__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ConstructorInfo__Array__VTable vtable;
};

struct EventInfo_AddEventAdapter__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct EventInfo_AddEventAdapter__StaticFields {
};

struct EventInfo_AddEventAdapter__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EventInfo_AddEventAdapter__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EventInfo_AddEventAdapter__VTable vtable;
};

struct EventAttributes__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct EventAttributes__Enum__StaticFields {
};

struct EventAttributes__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EventAttributes__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EventAttributes__Enum__VTable vtable;
};

struct RuntimeEventInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData __unknown_5;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData AddEventHandler;
    VirtualInvokeData Equals_2;
    VirtualInvokeData GetAddMethod;
    VirtualInvokeData GetAddMethod_1;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData System_Runtime_InteropServices__EventInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__EventInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__EventInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__EventInfo_Invoke;
    VirtualInvokeData GetRaiseMethod;
    VirtualInvokeData GetRaiseMethod_1;
    VirtualInvokeData GetRemoveMethod;
    VirtualInvokeData GetRemoveMethod_1;
    VirtualInvokeData System_Runtime_InteropServices__EventInfo_GetType;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData RemoveEventHandler;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData get_EventHandlerType;
    VirtualInvokeData get_IsMulticast;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData __unknown_6;
    VirtualInvokeData get_EventHandlerType_1;
    VirtualInvokeData get_IsMulticast_1;
    VirtualInvokeData AddEventHandler_1;
    VirtualInvokeData __unknown_7;
    VirtualInvokeData __unknown_8;
    VirtualInvokeData __unknown_9;
    VirtualInvokeData GetOtherMethods;
    VirtualInvokeData RemoveEventHandler_1;
    VirtualInvokeData get_AddMethod;
    VirtualInvokeData get_RaiseMethod;
    VirtualInvokeData get_RemoveMethod;
    VirtualInvokeData GetObjectData;
};

struct RuntimeEventInfo__StaticFields {
};

struct RuntimeEventInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeEventInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeEventInfo__VTable vtable;
};

struct MonoEvent__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData AddEventHandler;
    VirtualInvokeData Equals_2;
    VirtualInvokeData GetAddMethod;
    VirtualInvokeData GetAddMethod_1;
    VirtualInvokeData GetCustomAttributes_6;
    VirtualInvokeData GetCustomAttributes_7;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData System_Runtime_InteropServices__EventInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__EventInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__EventInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__EventInfo_Invoke;
    VirtualInvokeData GetRaiseMethod;
    VirtualInvokeData GetRaiseMethod_1;
    VirtualInvokeData GetRemoveMethod;
    VirtualInvokeData GetRemoveMethod_1;
    VirtualInvokeData System_Runtime_InteropServices__EventInfo_GetType;
    VirtualInvokeData IsDefined_3;
    VirtualInvokeData RemoveEventHandler;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_DeclaringType_2;
    VirtualInvokeData get_EventHandlerType;
    VirtualInvokeData get_IsMulticast;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_Name_2;
    VirtualInvokeData get_ReflectedType_2;
    VirtualInvokeData get_Attributes_1;
    VirtualInvokeData get_EventHandlerType_1;
    VirtualInvokeData get_IsMulticast_1;
    VirtualInvokeData AddEventHandler_1;
    VirtualInvokeData GetAddMethod_2;
    VirtualInvokeData GetRaiseMethod_2;
    VirtualInvokeData GetRemoveMethod_2;
    VirtualInvokeData GetOtherMethods;
    VirtualInvokeData RemoveEventHandler_1;
    VirtualInvokeData get_AddMethod;
    VirtualInvokeData get_RaiseMethod;
    VirtualInvokeData get_RemoveMethod;
    VirtualInvokeData GetObjectData;
};

struct MonoEvent__StaticFields {
};

struct MonoEvent__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoEvent__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoEvent__VTable vtable;
};

struct EventInfo_1__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData __unknown_5;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData AddEventHandler;
    VirtualInvokeData Equals_2;
    VirtualInvokeData GetAddMethod;
    VirtualInvokeData GetAddMethod_1;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData System_Runtime_InteropServices__EventInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__EventInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__EventInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__EventInfo_Invoke;
    VirtualInvokeData GetRaiseMethod;
    VirtualInvokeData GetRaiseMethod_1;
    VirtualInvokeData GetRemoveMethod;
    VirtualInvokeData GetRemoveMethod_1;
    VirtualInvokeData System_Runtime_InteropServices__EventInfo_GetType;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData RemoveEventHandler;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData get_EventHandlerType;
    VirtualInvokeData get_IsMulticast;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData __unknown_6;
    VirtualInvokeData get_EventHandlerType_1;
    VirtualInvokeData get_IsMulticast_1;
    VirtualInvokeData AddEventHandler_1;
    VirtualInvokeData __unknown_7;
    VirtualInvokeData __unknown_8;
    VirtualInvokeData __unknown_9;
    VirtualInvokeData GetOtherMethods;
    VirtualInvokeData RemoveEventHandler_1;
    VirtualInvokeData get_AddMethod;
    VirtualInvokeData get_RaiseMethod;
    VirtualInvokeData get_RemoveMethod;
};

struct EventInfo_1__StaticFields {
};

struct EventInfo_1__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EventInfo_1__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EventInfo_1__VTable vtable;
};

struct EventInfo_1__Array__VTable {
};

struct EventInfo_1__Array__StaticFields {
};

struct EventInfo_1__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EventInfo_1__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EventInfo_1__Array__VTable vtable;
};

struct InterfaceMapping__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct InterfaceMapping__StaticFields {
};

struct InterfaceMapping__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct InterfaceMapping__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct InterfaceMapping__VTable vtable;
};

struct TypeAttributes__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct TypeAttributes__Enum__StaticFields {
};

struct TypeAttributes__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeAttributes__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeAttributes__Enum__VTable vtable;
};

struct LayoutKind__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct LayoutKind__Enum__StaticFields {
};

struct LayoutKind__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct LayoutKind__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct LayoutKind__Enum__VTable vtable;
};

struct CharSet__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct CharSet__Enum__StaticFields {
};

struct CharSet__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CharSet__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CharSet__Enum__VTable vtable;
};

struct StructLayoutAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct StructLayoutAttribute__StaticFields {
};

struct StructLayoutAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StructLayoutAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StructLayoutAttribute__VTable vtable;
};

struct GenericParameterAttributes__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct GenericParameterAttributes__Enum__StaticFields {
};

struct GenericParameterAttributes__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct GenericParameterAttributes__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct GenericParameterAttributes__Enum__VTable vtable;
};

struct IEnumerable_1_System_Reflection_MethodInfo___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_Reflection_MethodInfo___StaticFields {
};

struct IEnumerable_1_System_Reflection_MethodInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_Reflection_MethodInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_Reflection_MethodInfo___VTable vtable;
};

struct IEnumerable_1_System_Reflection_ConstructorInfo___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_Reflection_ConstructorInfo___StaticFields {
};

struct IEnumerable_1_System_Reflection_ConstructorInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_Reflection_ConstructorInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_Reflection_ConstructorInfo___VTable vtable;
};

struct IEnumerable_1_System_Reflection_EventInfo___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_Reflection_EventInfo___StaticFields {
};

struct IEnumerable_1_System_Reflection_EventInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_Reflection_EventInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_Reflection_EventInfo___VTable vtable;
};

struct IEnumerable_1_System_Reflection_FieldInfo___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_Reflection_FieldInfo___StaticFields {
};

struct IEnumerable_1_System_Reflection_FieldInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_Reflection_FieldInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_Reflection_FieldInfo___VTable vtable;
};

struct IEnumerable_1_System_Reflection_MemberInfo___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_Reflection_MemberInfo___StaticFields {
};

struct IEnumerable_1_System_Reflection_MemberInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_Reflection_MemberInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_Reflection_MemberInfo___VTable vtable;
};

struct IEnumerable_1_System_Reflection_PropertyInfo___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_Reflection_PropertyInfo___StaticFields {
};

struct IEnumerable_1_System_Reflection_PropertyInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_Reflection_PropertyInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_Reflection_PropertyInfo___VTable vtable;
};

struct TypeInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData __unknown;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData Equals_2;
    VirtualInvokeData Equals_3;
    VirtualInvokeData FindInterfaces;
    VirtualInvokeData FindMembers;
    VirtualInvokeData GetArrayRank;
    VirtualInvokeData GetConstructor;
    VirtualInvokeData GetConstructor_1;
    VirtualInvokeData GetConstructor_2;
    VirtualInvokeData GetConstructors;
    VirtualInvokeData GetConstructors_1;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData GetDefaultMembers;
    VirtualInvokeData GetElementType;
    VirtualInvokeData GetEvent;
    VirtualInvokeData GetEvent_1;
    VirtualInvokeData GetEvents;
    VirtualInvokeData GetEvents_1;
    VirtualInvokeData GetField;
    VirtualInvokeData GetField_1;
    VirtualInvokeData GetFields;
    VirtualInvokeData GetFields_1;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Type_Invoke;
    VirtualInvokeData GetInterface;
    VirtualInvokeData GetInterface_1;
    VirtualInvokeData GetInterfaceMap;
    VirtualInvokeData GetInterfaces;
    VirtualInvokeData GetMember;
    VirtualInvokeData GetMember_1;
    VirtualInvokeData GetMember_2;
    VirtualInvokeData GetMembers;
    VirtualInvokeData GetMembers_1;
    VirtualInvokeData GetMethod;
    VirtualInvokeData GetMethod_1;
    VirtualInvokeData GetMethod_2;
    VirtualInvokeData GetMethod_3;
    VirtualInvokeData GetMethod_4;
    VirtualInvokeData GetMethod_5;
    VirtualInvokeData GetMethods;
    VirtualInvokeData GetMethods_1;
    VirtualInvokeData GetNestedType;
    VirtualInvokeData GetNestedType_1;
    VirtualInvokeData GetNestedTypes;
    VirtualInvokeData GetNestedTypes_1;
    VirtualInvokeData GetProperties;
    VirtualInvokeData GetProperties_1;
    VirtualInvokeData GetProperty;
    VirtualInvokeData GetProperty_1;
    VirtualInvokeData GetProperty_2;
    VirtualInvokeData GetProperty_3;
    VirtualInvokeData GetProperty_4;
    VirtualInvokeData GetProperty_5;
    VirtualInvokeData GetProperty_6;
    VirtualInvokeData GetType;
    VirtualInvokeData InvokeMember;
    VirtualInvokeData InvokeMember_1;
    VirtualInvokeData InvokeMember_2;
    VirtualInvokeData IsAssignableFrom;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData IsInstanceOfType;
    VirtualInvokeData IsSubclassOf;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Assembly;
    VirtualInvokeData get_AssemblyQualifiedName;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_BaseType;
    VirtualInvokeData get_DeclaringType_2;
    VirtualInvokeData get_FullName;
    VirtualInvokeData get_GUID;
    VirtualInvokeData get_HasElementType;
    VirtualInvokeData get_IsAbstract;
    VirtualInvokeData get_IsAnsiClass;
    VirtualInvokeData get_IsArray;
    VirtualInvokeData get_IsAutoClass;
    VirtualInvokeData get_IsAutoLayout;
    VirtualInvokeData get_IsByRef;
    VirtualInvokeData get_IsClass;
    VirtualInvokeData get_IsCOMObject;
    VirtualInvokeData get_IsContextful;
    VirtualInvokeData get_IsEnum;
    VirtualInvokeData get_IsExplicitLayout;
    VirtualInvokeData get_IsImport;
    VirtualInvokeData get_IsInterface;
    VirtualInvokeData get_IsLayoutSequential;
    VirtualInvokeData get_IsMarshalByRef;
    VirtualInvokeData get_IsNestedAssembly;
    VirtualInvokeData get_IsNestedFamANDAssem;
    VirtualInvokeData get_IsNestedFamily;
    VirtualInvokeData get_IsNestedFamORAssem;
    VirtualInvokeData get_IsNestedPrivate;
    VirtualInvokeData get_IsNestedPublic;
    VirtualInvokeData get_IsNotPublic;
    VirtualInvokeData get_IsPointer;
    VirtualInvokeData get_IsPrimitive;
    VirtualInvokeData get_IsPublic;
    VirtualInvokeData get_IsSealed;
    VirtualInvokeData get_IsSerializable;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_IsUnicodeClass;
    VirtualInvokeData get_IsValueType;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_Module;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_Namespace;
    VirtualInvokeData get_ReflectedType_2;
    VirtualInvokeData get_TypeHandle;
    VirtualInvokeData get_TypeInitializer;
    VirtualInvokeData get_UnderlyingSystemType;
    VirtualInvokeData GetMethod_6;
    VirtualInvokeData GetMethod_7;
    VirtualInvokeData GetMethods_2;
    VirtualInvokeData GetField_2;
    VirtualInvokeData GetFields_2;
    VirtualInvokeData GetProperty_7;
    VirtualInvokeData GetProperty_8;
    VirtualInvokeData GetProperties_2;
    VirtualInvokeData GetMember_3;
    VirtualInvokeData GetMembers_2;
    VirtualInvokeData InvokeMember_3;
    VirtualInvokeData get_UnderlyingSystemType_1;
    VirtualInvokeData get_DeclaringMethod;
    VirtualInvokeData MakePointerType;
    VirtualInvokeData get_StructLayoutAttribute;
    VirtualInvokeData MakeByRefType;
    VirtualInvokeData MakeArrayType;
    VirtualInvokeData MakeArrayType_1;
    VirtualInvokeData GetTypeCodeImpl;
    VirtualInvokeData __unknown_5;
    VirtualInvokeData __unknown_6;
    VirtualInvokeData __unknown_7;
    VirtualInvokeData get_TypeHandle_1;
    VirtualInvokeData GetTypeHandleInternal;
    VirtualInvokeData __unknown_8;
    VirtualInvokeData __unknown_9;
    VirtualInvokeData __unknown_10;
    VirtualInvokeData GetArrayRank_1;
    VirtualInvokeData __unknown_11;
    VirtualInvokeData __unknown_12;
    VirtualInvokeData __unknown_13;
    VirtualInvokeData __unknown_14;
    VirtualInvokeData __unknown_15;
    VirtualInvokeData __unknown_16;
    VirtualInvokeData __unknown_17;
    VirtualInvokeData __unknown_18;
    VirtualInvokeData __unknown_19;
    VirtualInvokeData FindInterfaces_1;
    VirtualInvokeData __unknown_20;
    VirtualInvokeData GetEvents_2;
    VirtualInvokeData __unknown_21;
    VirtualInvokeData __unknown_22;
    VirtualInvokeData __unknown_23;
    VirtualInvokeData __unknown_24;
    VirtualInvokeData __unknown_25;
    VirtualInvokeData GetMember_4;
    VirtualInvokeData GetMember_5;
    VirtualInvokeData __unknown_26;
    VirtualInvokeData GetDefaultMembers_1;
    VirtualInvokeData FindMembers_1;
    VirtualInvokeData get_GenericParameterAttributes;
    VirtualInvokeData get_IsEnum_1;
    VirtualInvokeData get_IsSerializable_1;
    VirtualInvokeData get_IsSzArray;
    VirtualInvokeData get_IsGenericType;
    VirtualInvokeData get_IsGenericTypeDefinition;
    VirtualInvokeData get_IsConstructedGenericType;
    VirtualInvokeData get_IsGenericParameter;
    VirtualInvokeData get_GenericParameterPosition;
    VirtualInvokeData get_ContainsGenericParameters;
    VirtualInvokeData GetGenericParameterConstraints;
    VirtualInvokeData IsValueTypeImpl;
    VirtualInvokeData __unknown_27;
    VirtualInvokeData __unknown_28;
    VirtualInvokeData __unknown_29;
    VirtualInvokeData __unknown_30;
    VirtualInvokeData __unknown_31;
    VirtualInvokeData __unknown_32;
    VirtualInvokeData IsWindowsRuntimeObjectImpl;
    VirtualInvokeData IsExportedToWindowsRuntimeImpl;
    VirtualInvokeData MakeGenericType;
    VirtualInvokeData IsContextfulImpl;
    VirtualInvokeData IsMarshalByRefImpl;
    VirtualInvokeData HasProxyAttributeImpl;
    VirtualInvokeData __unknown_33;
    VirtualInvokeData GetGenericArguments;
    VirtualInvokeData get_GenericTypeArguments;
    VirtualInvokeData GetGenericTypeDefinition;
    VirtualInvokeData __unknown_34;
    VirtualInvokeData GetEnumNames;
    VirtualInvokeData GetEnumValues;
    VirtualInvokeData GetEnumUnderlyingType;
    VirtualInvokeData IsEnumDefined;
    VirtualInvokeData GetEnumName;
    VirtualInvokeData get_IsSecurityCritical;
    VirtualInvokeData get_IsSecuritySafeCritical;
    VirtualInvokeData get_IsSecurityTransparent;
    VirtualInvokeData __unknown_35;
    VirtualInvokeData IsSubclassOf_1;
    VirtualInvokeData IsInstanceOfType_1;
    VirtualInvokeData IsAssignableFrom_1;
    VirtualInvokeData IsEquivalentTo;
    VirtualInvokeData FormatTypeName;
    VirtualInvokeData Equals_4;
    VirtualInvokeData GetInterfaceMap_1;
    VirtualInvokeData get_IsSZArray;
    VirtualInvokeData InternalResolve;
    VirtualInvokeData RuntimeResolve;
    VirtualInvokeData get_IsUserType;
    VirtualInvokeData GetMethod_8;
    VirtualInvokeData GetConstructor_3;
    VirtualInvokeData GetField_3;
    VirtualInvokeData System_Reflection_IReflectableType_GetTypeInfo;
    VirtualInvokeData AsType;
    VirtualInvokeData get_GenericTypeParameters;
    VirtualInvokeData IsAssignableFrom_2;
    VirtualInvokeData GetDeclaredEvent;
    VirtualInvokeData GetDeclaredField;
    VirtualInvokeData GetDeclaredMethod;
    VirtualInvokeData GetDeclaredMethods;
    VirtualInvokeData GetDeclaredNestedType;
    VirtualInvokeData GetDeclaredProperty;
    VirtualInvokeData get_DeclaredConstructors;
    VirtualInvokeData get_DeclaredEvents;
    VirtualInvokeData get_DeclaredFields;
    VirtualInvokeData get_DeclaredMembers;
    VirtualInvokeData get_DeclaredMethods;
    VirtualInvokeData get_DeclaredNestedTypes;
    VirtualInvokeData get_DeclaredProperties;
    VirtualInvokeData get_ImplementedInterfaces;
};

struct TypeInfo__StaticFields {
};

struct TypeInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeInfo__VTable vtable;
};

struct MonoTypeInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct MonoTypeInfo__StaticFields {
};

struct MonoTypeInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoTypeInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoTypeInfo__VTable vtable;
};

struct RuntimeType__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData Equals_2;
    VirtualInvokeData Equals_3;
    VirtualInvokeData FindInterfaces;
    VirtualInvokeData FindMembers;
    VirtualInvokeData GetArrayRank;
    VirtualInvokeData GetConstructor;
    VirtualInvokeData GetConstructor_1;
    VirtualInvokeData GetConstructor_2;
    VirtualInvokeData GetConstructors;
    VirtualInvokeData GetConstructors_1;
    VirtualInvokeData GetCustomAttributes_6;
    VirtualInvokeData GetCustomAttributes_7;
    VirtualInvokeData GetDefaultMembers;
    VirtualInvokeData GetElementType;
    VirtualInvokeData GetEvent;
    VirtualInvokeData GetEvent_1;
    VirtualInvokeData GetEvents;
    VirtualInvokeData GetEvents_1;
    VirtualInvokeData GetField;
    VirtualInvokeData GetField_1;
    VirtualInvokeData GetFields;
    VirtualInvokeData GetFields_1;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Type_Invoke;
    VirtualInvokeData GetInterface;
    VirtualInvokeData GetInterface_1;
    VirtualInvokeData GetInterfaceMap;
    VirtualInvokeData GetInterfaces;
    VirtualInvokeData GetMember;
    VirtualInvokeData GetMember_1;
    VirtualInvokeData GetMember_2;
    VirtualInvokeData GetMembers;
    VirtualInvokeData GetMembers_1;
    VirtualInvokeData GetMethod;
    VirtualInvokeData GetMethod_1;
    VirtualInvokeData GetMethod_2;
    VirtualInvokeData GetMethod_3;
    VirtualInvokeData GetMethod_4;
    VirtualInvokeData GetMethod_5;
    VirtualInvokeData GetMethods;
    VirtualInvokeData GetMethods_1;
    VirtualInvokeData GetNestedType;
    VirtualInvokeData GetNestedType_1;
    VirtualInvokeData GetNestedTypes;
    VirtualInvokeData GetNestedTypes_1;
    VirtualInvokeData GetProperties;
    VirtualInvokeData GetProperties_1;
    VirtualInvokeData GetProperty;
    VirtualInvokeData GetProperty_1;
    VirtualInvokeData GetProperty_2;
    VirtualInvokeData GetProperty_3;
    VirtualInvokeData GetProperty_4;
    VirtualInvokeData GetProperty_5;
    VirtualInvokeData GetProperty_6;
    VirtualInvokeData GetType;
    VirtualInvokeData InvokeMember;
    VirtualInvokeData InvokeMember_1;
    VirtualInvokeData InvokeMember_2;
    VirtualInvokeData IsAssignableFrom;
    VirtualInvokeData IsDefined_3;
    VirtualInvokeData IsInstanceOfType;
    VirtualInvokeData IsSubclassOf;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Assembly;
    VirtualInvokeData get_AssemblyQualifiedName;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_BaseType;
    VirtualInvokeData get_DeclaringType_2;
    VirtualInvokeData get_FullName;
    VirtualInvokeData get_GUID;
    VirtualInvokeData get_HasElementType;
    VirtualInvokeData get_IsAbstract;
    VirtualInvokeData get_IsAnsiClass;
    VirtualInvokeData get_IsArray;
    VirtualInvokeData get_IsAutoClass;
    VirtualInvokeData get_IsAutoLayout;
    VirtualInvokeData get_IsByRef;
    VirtualInvokeData get_IsClass;
    VirtualInvokeData get_IsCOMObject;
    VirtualInvokeData get_IsContextful;
    VirtualInvokeData get_IsEnum;
    VirtualInvokeData get_IsExplicitLayout;
    VirtualInvokeData get_IsImport;
    VirtualInvokeData get_IsInterface;
    VirtualInvokeData get_IsLayoutSequential;
    VirtualInvokeData get_IsMarshalByRef;
    VirtualInvokeData get_IsNestedAssembly;
    VirtualInvokeData get_IsNestedFamANDAssem;
    VirtualInvokeData get_IsNestedFamily;
    VirtualInvokeData get_IsNestedFamORAssem;
    VirtualInvokeData get_IsNestedPrivate;
    VirtualInvokeData get_IsNestedPublic;
    VirtualInvokeData get_IsNotPublic;
    VirtualInvokeData get_IsPointer;
    VirtualInvokeData get_IsPrimitive;
    VirtualInvokeData get_IsPublic;
    VirtualInvokeData get_IsSealed;
    VirtualInvokeData get_IsSerializable;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_IsUnicodeClass;
    VirtualInvokeData get_IsValueType;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_Module_1;
    VirtualInvokeData get_Name_2;
    VirtualInvokeData get_Namespace;
    VirtualInvokeData get_ReflectedType_2;
    VirtualInvokeData get_TypeHandle;
    VirtualInvokeData get_TypeInitializer;
    VirtualInvokeData get_UnderlyingSystemType;
    VirtualInvokeData GetMethod_6;
    VirtualInvokeData GetMethod_7;
    VirtualInvokeData GetMethods_2;
    VirtualInvokeData GetField_2;
    VirtualInvokeData GetFields_2;
    VirtualInvokeData GetProperty_7;
    VirtualInvokeData GetProperty_8;
    VirtualInvokeData GetProperties_2;
    VirtualInvokeData GetMember_3;
    VirtualInvokeData GetMembers_2;
    VirtualInvokeData InvokeMember_3;
    VirtualInvokeData get_UnderlyingSystemType_1;
    VirtualInvokeData get_DeclaringMethod;
    VirtualInvokeData MakePointerType;
    VirtualInvokeData get_StructLayoutAttribute;
    VirtualInvokeData MakeByRefType;
    VirtualInvokeData MakeArrayType;
    VirtualInvokeData MakeArrayType_1;
    VirtualInvokeData GetTypeCodeImpl;
    VirtualInvokeData get_GUID_1;
    VirtualInvokeData InvokeMember_4;
    VirtualInvokeData get_Assembly_1;
    VirtualInvokeData get_TypeHandle_1;
    VirtualInvokeData GetTypeHandleInternal;
    VirtualInvokeData get_FullName_1;
    VirtualInvokeData get_Namespace_1;
    VirtualInvokeData get_AssemblyQualifiedName_1;
    VirtualInvokeData GetArrayRank_1;
    VirtualInvokeData get_BaseType_1;
    VirtualInvokeData GetConstructorImpl;
    VirtualInvokeData GetConstructors_2;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetMethods_3;
    VirtualInvokeData GetField_3;
    VirtualInvokeData GetFields_3;
    VirtualInvokeData GetInterface_2;
    VirtualInvokeData GetInterfaces_1;
    VirtualInvokeData FindInterfaces_1;
    VirtualInvokeData GetEvent_2;
    VirtualInvokeData GetEvents_2;
    VirtualInvokeData GetEvents_3;
    VirtualInvokeData GetPropertyImpl;
    VirtualInvokeData GetProperties_3;
    VirtualInvokeData GetNestedTypes_2;
    VirtualInvokeData GetNestedType_2;
    VirtualInvokeData GetMember_4;
    VirtualInvokeData GetMember_5;
    VirtualInvokeData GetMembers_3;
    VirtualInvokeData GetDefaultMembers_1;
    VirtualInvokeData FindMembers_1;
    VirtualInvokeData get_GenericParameterAttributes;
    VirtualInvokeData get_IsEnum_1;
    VirtualInvokeData get_IsSerializable_1;
    VirtualInvokeData get_IsSzArray;
    VirtualInvokeData get_IsGenericType;
    VirtualInvokeData get_IsGenericTypeDefinition;
    VirtualInvokeData get_IsConstructedGenericType;
    VirtualInvokeData get_IsGenericParameter;
    VirtualInvokeData get_GenericParameterPosition;
    VirtualInvokeData get_ContainsGenericParameters;
    VirtualInvokeData GetGenericParameterConstraints;
    VirtualInvokeData IsValueTypeImpl;
    VirtualInvokeData GetAttributeFlagsImpl;
    VirtualInvokeData IsArrayImpl;
    VirtualInvokeData IsByRefImpl;
    VirtualInvokeData IsPointerImpl;
    VirtualInvokeData IsPrimitiveImpl;
    VirtualInvokeData IsCOMObjectImpl;
    VirtualInvokeData IsWindowsRuntimeObjectImpl;
    VirtualInvokeData IsExportedToWindowsRuntimeImpl;
    VirtualInvokeData MakeGenericType;
    VirtualInvokeData IsContextfulImpl;
    VirtualInvokeData IsMarshalByRefImpl;
    VirtualInvokeData HasProxyAttributeImpl;
    VirtualInvokeData GetElementType_1;
    VirtualInvokeData GetGenericArguments;
    VirtualInvokeData get_GenericTypeArguments;
    VirtualInvokeData GetGenericTypeDefinition;
    VirtualInvokeData HasElementTypeImpl;
    VirtualInvokeData GetEnumNames;
    VirtualInvokeData GetEnumValues;
    VirtualInvokeData GetEnumUnderlyingType;
    VirtualInvokeData IsEnumDefined;
    VirtualInvokeData GetEnumName;
    VirtualInvokeData get_IsSecurityCritical;
    VirtualInvokeData get_IsSecuritySafeCritical;
    VirtualInvokeData get_IsSecurityTransparent;
    VirtualInvokeData get_UnderlyingSystemType_2;
    VirtualInvokeData IsSubclassOf_1;
    VirtualInvokeData IsInstanceOfType_1;
    VirtualInvokeData IsAssignableFrom_1;
    VirtualInvokeData IsEquivalentTo;
    VirtualInvokeData FormatTypeName;
    VirtualInvokeData Equals_4;
    VirtualInvokeData GetInterfaceMap_1;
    VirtualInvokeData get_IsSZArray;
    VirtualInvokeData InternalResolve;
    VirtualInvokeData RuntimeResolve;
    VirtualInvokeData get_IsUserType;
    VirtualInvokeData GetMethod_8;
    VirtualInvokeData GetConstructor_3;
    VirtualInvokeData GetField_4;
    VirtualInvokeData System_Reflection_IReflectableType_GetTypeInfo;
    VirtualInvokeData AsType;
    VirtualInvokeData get_GenericTypeParameters;
    VirtualInvokeData IsAssignableFrom_2;
    VirtualInvokeData GetDeclaredEvent;
    VirtualInvokeData GetDeclaredField;
    VirtualInvokeData GetDeclaredMethod;
    VirtualInvokeData GetDeclaredMethods;
    VirtualInvokeData GetDeclaredNestedType;
    VirtualInvokeData GetDeclaredProperty;
    VirtualInvokeData get_DeclaredConstructors;
    VirtualInvokeData get_DeclaredEvents;
    VirtualInvokeData get_DeclaredFields;
    VirtualInvokeData get_DeclaredMembers;
    VirtualInvokeData get_DeclaredMethods;
    VirtualInvokeData get_DeclaredNestedTypes;
    VirtualInvokeData get_DeclaredProperties;
    VirtualInvokeData get_ImplementedInterfaces;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData Clone;
};

struct RuntimeType__StaticFields {
    struct RuntimeType *ValueType;
    struct RuntimeType *EnumType;
    struct RuntimeType *ObjectType;
    struct RuntimeType *StringType;
    struct RuntimeType *DelegateType;
    struct Type__Array *s_SICtorParamTypes;
    struct RuntimeType *s_typedRef;
};

struct RuntimeType__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeType__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeType__VTable vtable;
};

struct MemberInfo_1__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData __unknown_5;
    VirtualInvokeData __unknown_6;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
};

struct MemberInfo_1__StaticFields {
};

struct MemberInfo_1__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MemberInfo_1__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MemberInfo_1__VTable vtable;
};

struct Type__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData __unknown;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData Equals_2;
    VirtualInvokeData Equals_3;
    VirtualInvokeData FindInterfaces;
    VirtualInvokeData FindMembers;
    VirtualInvokeData GetArrayRank;
    VirtualInvokeData GetConstructor;
    VirtualInvokeData GetConstructor_1;
    VirtualInvokeData GetConstructor_2;
    VirtualInvokeData GetConstructors;
    VirtualInvokeData GetConstructors_1;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData GetDefaultMembers;
    VirtualInvokeData GetElementType;
    VirtualInvokeData GetEvent;
    VirtualInvokeData GetEvent_1;
    VirtualInvokeData GetEvents;
    VirtualInvokeData GetEvents_1;
    VirtualInvokeData GetField;
    VirtualInvokeData GetField_1;
    VirtualInvokeData GetFields;
    VirtualInvokeData GetFields_1;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Type_Invoke;
    VirtualInvokeData GetInterface;
    VirtualInvokeData GetInterface_1;
    VirtualInvokeData GetInterfaceMap;
    VirtualInvokeData GetInterfaces;
    VirtualInvokeData GetMember;
    VirtualInvokeData GetMember_1;
    VirtualInvokeData GetMember_2;
    VirtualInvokeData GetMembers;
    VirtualInvokeData GetMembers_1;
    VirtualInvokeData GetMethod;
    VirtualInvokeData GetMethod_1;
    VirtualInvokeData GetMethod_2;
    VirtualInvokeData GetMethod_3;
    VirtualInvokeData GetMethod_4;
    VirtualInvokeData GetMethod_5;
    VirtualInvokeData GetMethods;
    VirtualInvokeData GetMethods_1;
    VirtualInvokeData GetNestedType;
    VirtualInvokeData GetNestedType_1;
    VirtualInvokeData GetNestedTypes;
    VirtualInvokeData GetNestedTypes_1;
    VirtualInvokeData GetProperties;
    VirtualInvokeData GetProperties_1;
    VirtualInvokeData GetProperty;
    VirtualInvokeData GetProperty_1;
    VirtualInvokeData GetProperty_2;
    VirtualInvokeData GetProperty_3;
    VirtualInvokeData GetProperty_4;
    VirtualInvokeData GetProperty_5;
    VirtualInvokeData GetProperty_6;
    VirtualInvokeData GetType;
    VirtualInvokeData InvokeMember;
    VirtualInvokeData InvokeMember_1;
    VirtualInvokeData InvokeMember_2;
    VirtualInvokeData IsAssignableFrom;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData IsInstanceOfType;
    VirtualInvokeData IsSubclassOf;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Assembly;
    VirtualInvokeData get_AssemblyQualifiedName;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_BaseType;
    VirtualInvokeData get_DeclaringType_2;
    VirtualInvokeData get_FullName;
    VirtualInvokeData get_GUID;
    VirtualInvokeData get_HasElementType;
    VirtualInvokeData get_IsAbstract;
    VirtualInvokeData get_IsAnsiClass;
    VirtualInvokeData get_IsArray;
    VirtualInvokeData get_IsAutoClass;
    VirtualInvokeData get_IsAutoLayout;
    VirtualInvokeData get_IsByRef;
    VirtualInvokeData get_IsClass;
    VirtualInvokeData get_IsCOMObject;
    VirtualInvokeData get_IsContextful;
    VirtualInvokeData get_IsEnum;
    VirtualInvokeData get_IsExplicitLayout;
    VirtualInvokeData get_IsImport;
    VirtualInvokeData get_IsInterface;
    VirtualInvokeData get_IsLayoutSequential;
    VirtualInvokeData get_IsMarshalByRef;
    VirtualInvokeData get_IsNestedAssembly;
    VirtualInvokeData get_IsNestedFamANDAssem;
    VirtualInvokeData get_IsNestedFamily;
    VirtualInvokeData get_IsNestedFamORAssem;
    VirtualInvokeData get_IsNestedPrivate;
    VirtualInvokeData get_IsNestedPublic;
    VirtualInvokeData get_IsNotPublic;
    VirtualInvokeData get_IsPointer;
    VirtualInvokeData get_IsPrimitive;
    VirtualInvokeData get_IsPublic;
    VirtualInvokeData get_IsSealed;
    VirtualInvokeData get_IsSerializable;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_IsUnicodeClass;
    VirtualInvokeData get_IsValueType;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_Module;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_Namespace;
    VirtualInvokeData get_ReflectedType_2;
    VirtualInvokeData get_TypeHandle;
    VirtualInvokeData get_TypeInitializer;
    VirtualInvokeData get_UnderlyingSystemType;
    VirtualInvokeData GetMethod_6;
    VirtualInvokeData GetMethod_7;
    VirtualInvokeData GetMethods_2;
    VirtualInvokeData GetField_2;
    VirtualInvokeData GetFields_2;
    VirtualInvokeData GetProperty_7;
    VirtualInvokeData GetProperty_8;
    VirtualInvokeData GetProperties_2;
    VirtualInvokeData GetMember_3;
    VirtualInvokeData GetMembers_2;
    VirtualInvokeData InvokeMember_3;
    VirtualInvokeData get_UnderlyingSystemType_1;
    VirtualInvokeData get_DeclaringMethod;
    VirtualInvokeData MakePointerType;
    VirtualInvokeData get_StructLayoutAttribute;
    VirtualInvokeData MakeByRefType;
    VirtualInvokeData MakeArrayType;
    VirtualInvokeData MakeArrayType_1;
    VirtualInvokeData GetTypeCodeImpl;
    VirtualInvokeData __unknown_5;
    VirtualInvokeData __unknown_6;
    VirtualInvokeData __unknown_7;
    VirtualInvokeData get_TypeHandle_1;
    VirtualInvokeData GetTypeHandleInternal;
    VirtualInvokeData __unknown_8;
    VirtualInvokeData __unknown_9;
    VirtualInvokeData __unknown_10;
    VirtualInvokeData GetArrayRank_1;
    VirtualInvokeData __unknown_11;
    VirtualInvokeData __unknown_12;
    VirtualInvokeData __unknown_13;
    VirtualInvokeData __unknown_14;
    VirtualInvokeData __unknown_15;
    VirtualInvokeData __unknown_16;
    VirtualInvokeData __unknown_17;
    VirtualInvokeData __unknown_18;
    VirtualInvokeData __unknown_19;
    VirtualInvokeData FindInterfaces_1;
    VirtualInvokeData __unknown_20;
    VirtualInvokeData GetEvents_2;
    VirtualInvokeData __unknown_21;
    VirtualInvokeData __unknown_22;
    VirtualInvokeData __unknown_23;
    VirtualInvokeData __unknown_24;
    VirtualInvokeData __unknown_25;
    VirtualInvokeData GetMember_4;
    VirtualInvokeData GetMember_5;
    VirtualInvokeData __unknown_26;
    VirtualInvokeData GetDefaultMembers_1;
    VirtualInvokeData FindMembers_1;
    VirtualInvokeData get_GenericParameterAttributes;
    VirtualInvokeData get_IsEnum_1;
    VirtualInvokeData get_IsSerializable_1;
    VirtualInvokeData get_IsSzArray;
    VirtualInvokeData get_IsGenericType;
    VirtualInvokeData get_IsGenericTypeDefinition;
    VirtualInvokeData get_IsConstructedGenericType;
    VirtualInvokeData get_IsGenericParameter;
    VirtualInvokeData get_GenericParameterPosition;
    VirtualInvokeData get_ContainsGenericParameters;
    VirtualInvokeData GetGenericParameterConstraints;
    VirtualInvokeData IsValueTypeImpl;
    VirtualInvokeData __unknown_27;
    VirtualInvokeData __unknown_28;
    VirtualInvokeData __unknown_29;
    VirtualInvokeData __unknown_30;
    VirtualInvokeData __unknown_31;
    VirtualInvokeData __unknown_32;
    VirtualInvokeData IsWindowsRuntimeObjectImpl;
    VirtualInvokeData IsExportedToWindowsRuntimeImpl;
    VirtualInvokeData MakeGenericType;
    VirtualInvokeData IsContextfulImpl;
    VirtualInvokeData IsMarshalByRefImpl;
    VirtualInvokeData HasProxyAttributeImpl;
    VirtualInvokeData __unknown_33;
    VirtualInvokeData GetGenericArguments;
    VirtualInvokeData get_GenericTypeArguments;
    VirtualInvokeData GetGenericTypeDefinition;
    VirtualInvokeData __unknown_34;
    VirtualInvokeData GetEnumNames;
    VirtualInvokeData GetEnumValues;
    VirtualInvokeData GetEnumUnderlyingType;
    VirtualInvokeData IsEnumDefined;
    VirtualInvokeData GetEnumName;
    VirtualInvokeData get_IsSecurityCritical;
    VirtualInvokeData get_IsSecuritySafeCritical;
    VirtualInvokeData get_IsSecurityTransparent;
    VirtualInvokeData __unknown_35;
    VirtualInvokeData IsSubclassOf_1;
    VirtualInvokeData IsInstanceOfType_1;
    VirtualInvokeData IsAssignableFrom_1;
    VirtualInvokeData IsEquivalentTo;
    VirtualInvokeData FormatTypeName;
    VirtualInvokeData Equals_4;
    VirtualInvokeData GetInterfaceMap_1;
    VirtualInvokeData get_IsSZArray;
    VirtualInvokeData InternalResolve;
    VirtualInvokeData RuntimeResolve;
    VirtualInvokeData get_IsUserType;
    VirtualInvokeData GetMethod_8;
    VirtualInvokeData GetConstructor_3;
    VirtualInvokeData GetField_3;
};

struct Type__StaticFields {
    struct MemberFilter *FilterAttribute;
    struct MemberFilter *FilterName;
    struct MemberFilter *FilterNameIgnoreCase;
    struct Object *Missing;
    uint16_t Delimiter;
    struct Type__Array *EmptyTypes;
    struct Binder *defaultBinder;
};

struct Type__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Type__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Type__VTable vtable;
};

struct DateTime__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
    VirtualInvokeData CompareTo_1;
    VirtualInvokeData Equals_1;
};

struct DateTime__StaticFields {
    struct Int32__Array *DaysToMonth365;
    struct Int32__Array *DaysToMonth366;
    struct DateTime MinValue;
    struct DateTime MaxValue;
};

struct DateTime__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DateTime__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DateTime__VTable vtable;
};

struct Decimal__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData ToString_1;
    VirtualInvokeData CompareTo;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
    VirtualInvokeData System_Runtime_Serialization_IDeserializationCallback_OnDeserialization;
    VirtualInvokeData CompareTo_1;
    VirtualInvokeData Equals_1;
};

struct Decimal__StaticFields {
    struct UInt32__Array *Powers10;
    struct Decimal Zero;
    struct Decimal One;
    struct Decimal MinusOne;
    struct Decimal MaxValue;
    struct Decimal MinValue;
    struct Decimal NearNegativeZero;
    struct Decimal NearPositiveZero;
};

struct Decimal__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Decimal__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Decimal__VTable vtable;
};

struct Double__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
    VirtualInvokeData CompareTo_1;
    VirtualInvokeData Equals_1;
};

struct Double__StaticFields {
    double NegativeZero;
};

struct Double__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Double__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Double__VTable vtable;
};

struct Single__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
    VirtualInvokeData CompareTo_1;
    VirtualInvokeData Equals_1;
};

struct Single__StaticFields {
};

struct Single__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Single__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Single__VTable vtable;
};

struct UInt64__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
    VirtualInvokeData CompareTo_1;
    VirtualInvokeData Equals_1;
};

struct UInt64__StaticFields {
};

struct UInt64__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UInt64__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UInt64__VTable vtable;
};

struct Int64__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
    VirtualInvokeData CompareTo_1;
    VirtualInvokeData Equals_1;
};

struct Int64__StaticFields {
};

struct Int64__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Int64__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Int64__VTable vtable;
};

struct UInt32__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
    VirtualInvokeData CompareTo_1;
    VirtualInvokeData Equals_1;
};

struct UInt32__StaticFields {
};

struct UInt32__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UInt32__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UInt32__VTable vtable;
};

struct UInt16__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
    VirtualInvokeData CompareTo_1;
    VirtualInvokeData Equals_1;
};

struct UInt16__StaticFields {
};

struct UInt16__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UInt16__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UInt16__VTable vtable;
};

struct Int16__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
    VirtualInvokeData CompareTo_1;
    VirtualInvokeData Equals_1;
};

struct Int16__StaticFields {
};

struct Int16__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Int16__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Int16__VTable vtable;
};

struct SByte__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
    VirtualInvokeData CompareTo_1;
    VirtualInvokeData Equals_1;
};

struct SByte__StaticFields {
};

struct SByte__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SByte__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SByte__VTable vtable;
};

struct Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct Enum__StaticFields {
    struct Char__Array *enumSeperatorCharArray;
};

struct Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Enum__VTable vtable;
};

struct TypeCode__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct TypeCode__Enum__StaticFields {
};

struct TypeCode__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeCode__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeCode__Enum__VTable vtable;
};

struct Byte__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
    VirtualInvokeData CompareTo_1;
    VirtualInvokeData Equals_1;
};

struct Byte__StaticFields {
};

struct Byte__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Byte__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Byte__VTable vtable;
};

struct Byte__Array__VTable {
};

struct Byte__Array__StaticFields {
};

struct Byte__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Byte__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Byte__Array__VTable vtable;
};

struct Char__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_1;
    VirtualInvokeData System_IConvertible_ToType;
    VirtualInvokeData CompareTo_1;
    VirtualInvokeData Equals_1;
};

struct Char__StaticFields {
    struct Byte__Array *categoryForLatin1;
};

struct Char__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Char__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Char__VTable vtable;
};

struct IEnumerator_1_System_Char___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_System_Char___StaticFields {
};

struct IEnumerator_1_System_Char___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_System_Char___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_System_Char___VTable vtable;
};

struct String__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData Clone;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_1;
    VirtualInvokeData System_IConvertible_ToType;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData CompareTo_1;
    VirtualInvokeData System_Collections_Generic_IEnumerable_System_Char__GetEnumerator;
    VirtualInvokeData Equals_1;
};

struct String__StaticFields {
    struct String *Empty;
};

struct String__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct String__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct String__VTable vtable;
};

struct Int32__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
    VirtualInvokeData CompareTo_1;
    VirtualInvokeData Equals_1;
};

struct Int32__StaticFields {
};

struct Int32__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Int32__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Int32__VTable vtable;
};

struct Void__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Void__StaticFields {
};

struct Void__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Void__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Void__VTable vtable;
};

struct ValueType__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ValueType__StaticFields {
};

struct ValueType__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ValueType__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ValueType__VTable vtable;
};

struct Boolean__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_1;
    VirtualInvokeData System_IConvertible_ToType;
    VirtualInvokeData CompareTo_1;
    VirtualInvokeData Equals_1;
};

struct Boolean__StaticFields {
    struct String *TrueString;
    struct String *FalseString;
};

struct Boolean__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Boolean__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Boolean__VTable vtable;
};

struct Object__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Object__StaticFields {
};

struct Object__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Object__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Object__VTable vtable;
};

struct Locale__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Locale__StaticFields {
};

struct Locale__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Locale__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Locale__VTable vtable;
};

struct RelocatedTypeAttribute {
    struct RelocatedTypeAttribute__Class *klass;
    MonitorData *monitor;
};

struct RelocatedTypeAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct RelocatedTypeAttribute__StaticFields {
};

struct RelocatedTypeAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RelocatedTypeAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RelocatedTypeAttribute__VTable vtable;
};

struct RuntimeThread {
    struct RuntimeThread__Class *klass;
    MonitorData *monitor;
};

struct RuntimeThread__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct RuntimeThread__StaticFields {
};

struct RuntimeThread__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeThread__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeThread__VTable vtable;
};

struct DataConverter {
    struct DataConverter__Class *klass;
    MonitorData *monitor;
};

struct DataConverter_CopyConverter {
    struct DataConverter_CopyConverter__Class *klass;
    MonitorData *monitor;
};

struct DataConverter_CopyConverter__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetDouble;
    VirtualInvokeData GetFloat;
    VirtualInvokeData GetInt64;
    VirtualInvokeData GetInt32;
    VirtualInvokeData GetInt16;
    VirtualInvokeData GetUInt32;
    VirtualInvokeData GetUInt16;
    VirtualInvokeData GetUInt64;
    VirtualInvokeData PutBytes;
    VirtualInvokeData PutBytes_1;
    VirtualInvokeData PutBytes_2;
    VirtualInvokeData PutBytes_3;
    VirtualInvokeData PutBytes_4;
    VirtualInvokeData PutBytes_5;
    VirtualInvokeData PutBytes_6;
    VirtualInvokeData PutBytes_7;
};

struct DataConverter_CopyConverter__StaticFields {
};

struct DataConverter_CopyConverter__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DataConverter_CopyConverter__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DataConverter_CopyConverter__VTable vtable;
};

struct DataConverter__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData __unknown_5;
    VirtualInvokeData __unknown_6;
    VirtualInvokeData __unknown_7;
    VirtualInvokeData __unknown_8;
    VirtualInvokeData __unknown_9;
    VirtualInvokeData __unknown_10;
    VirtualInvokeData __unknown_11;
    VirtualInvokeData __unknown_12;
    VirtualInvokeData __unknown_13;
    VirtualInvokeData __unknown_14;
    VirtualInvokeData __unknown_15;
};

struct DataConverter__StaticFields {
    struct DataConverter *SwapConv;
    struct DataConverter *CopyConv;
    bool IsLittleEndian;
};

struct DataConverter__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DataConverter__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DataConverter__VTable vtable;
};

struct IEnumerable {
    struct IEnumerable__Class *klass;
    MonitorData *monitor;
};

struct IEnumerable__VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable__StaticFields {
};

struct IEnumerable__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable__VTable vtable;
};

struct __declspec(align(8)) DataConverter_PackContext__Fields {
    struct Byte__Array *buffer;
    int32_t next;
    struct String *description;
    int32_t i;
    struct DataConverter *conv;
    int32_t repeat;
    int32_t align;
};

struct DataConverter_PackContext {
    struct DataConverter_PackContext__Class *klass;
    MonitorData *monitor;
    struct DataConverter_PackContext__Fields fields;
};

struct DataConverter_PackContext__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct DataConverter_PackContext__StaticFields {
};

struct DataConverter_PackContext__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DataConverter_PackContext__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DataConverter_PackContext__VTable vtable;
};

struct DataConverter_SwapConverter {
    struct DataConverter_SwapConverter__Class *klass;
    MonitorData *monitor;
};

struct DataConverter_SwapConverter__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetDouble;
    VirtualInvokeData GetFloat;
    VirtualInvokeData GetInt64;
    VirtualInvokeData GetInt32;
    VirtualInvokeData GetInt16;
    VirtualInvokeData GetUInt32;
    VirtualInvokeData GetUInt16;
    VirtualInvokeData GetUInt64;
    VirtualInvokeData PutBytes;
    VirtualInvokeData PutBytes_1;
    VirtualInvokeData PutBytes_2;
    VirtualInvokeData PutBytes_3;
    VirtualInvokeData PutBytes_4;
    VirtualInvokeData PutBytes_5;
    VirtualInvokeData PutBytes_6;
    VirtualInvokeData PutBytes_7;
};

struct DataConverter_SwapConverter__StaticFields {
};

struct DataConverter_SwapConverter__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DataConverter_SwapConverter__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DataConverter_SwapConverter__VTable vtable;
};

struct RuntimeClassHandle {
    struct RuntimeStructs_MonoClass *value;
};

struct RuntimeClassHandle__Boxed {
    struct RuntimeClassHandle__Class *klass;
    MonitorData *monitor;
    struct RuntimeClassHandle fields;
};

struct RuntimeStructs_MonoClass {
};

struct RuntimeStructs_MonoClass__Boxed {
    struct RuntimeStructs_MonoClass__Class *klass;
    MonitorData *monitor;
    struct RuntimeStructs_MonoClass fields;
};

struct RuntimeStructs_MonoClassPtr {
    struct RuntimeStructs_MonoClassPtr__Class *klass;
    MonitorData *monitor;
};

struct RuntimeStructs_MonoClass__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct RuntimeStructs_MonoClass__StaticFields {
};

struct RuntimeStructs_MonoClass__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeStructs_MonoClass__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeStructs_MonoClass__VTable vtable;
};

struct RuntimeStructs_MonoClassPtr__VTable {
};

struct RuntimeStructs_MonoClassPtr__StaticFields {
};

struct RuntimeStructs_MonoClassPtr__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeStructs_MonoClassPtr__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeStructs_MonoClassPtr__VTable vtable;
};

struct RuntimeClassHandle__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct RuntimeClassHandle__StaticFields {
};

struct RuntimeClassHandle__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeClassHandle__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeClassHandle__VTable vtable;
};

struct RuntimeRemoteClassHandle {
    struct RuntimeStructs_RemoteClass *value;
};

struct RuntimeRemoteClassHandle__Boxed {
    struct RuntimeRemoteClassHandle__Class *klass;
    MonitorData *monitor;
    struct RuntimeRemoteClassHandle fields;
};

struct RuntimeStructs_RemoteClass {
    void *default_vtable;
    void *xdomain_vtable;
    struct RuntimeStructs_MonoClass *proxy_class;
    void *proxy_class_name;
    uint32_t interface_count;
};

struct RuntimeStructs_RemoteClass__Boxed {
    struct RuntimeStructs_RemoteClass__Class *klass;
    MonitorData *monitor;
    struct RuntimeStructs_RemoteClass fields;
};

struct RuntimeStructs_RemoteClassPtr {
    struct RuntimeStructs_RemoteClassPtr__Class *klass;
    MonitorData *monitor;
};

struct RuntimeStructs_RemoteClass__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct RuntimeStructs_RemoteClass__StaticFields {
};

struct RuntimeStructs_RemoteClass__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeStructs_RemoteClass__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeStructs_RemoteClass__VTable vtable;
};

struct RuntimeStructs_RemoteClassPtr__VTable {
};

struct RuntimeStructs_RemoteClassPtr__StaticFields {
};

struct RuntimeStructs_RemoteClassPtr__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeStructs_RemoteClassPtr__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeStructs_RemoteClassPtr__VTable vtable;
};

struct RuntimeRemoteClassHandle__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct RuntimeRemoteClassHandle__StaticFields {
};

struct RuntimeRemoteClassHandle__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeRemoteClassHandle__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeRemoteClassHandle__VTable vtable;
};

struct RuntimeGenericParamInfoHandle {
    struct RuntimeStructs_GenericParamInfo *value;
};

struct RuntimeGenericParamInfoHandle__Boxed {
    struct RuntimeGenericParamInfoHandle__Class *klass;
    MonitorData *monitor;
    struct RuntimeGenericParamInfoHandle fields;
};

struct RuntimeStructs_GenericParamInfo {
    struct RuntimeStructs_MonoClass *pklass;
    void *name;
    uint16_t flags;
    uint32_t token;
    struct RuntimeStructs_MonoClass **constraints;
};

struct RuntimeStructs_GenericParamInfo__Boxed {
    struct RuntimeStructs_GenericParamInfo__Class *klass;
    MonitorData *monitor;
    struct RuntimeStructs_GenericParamInfo fields;
};

struct RuntimeStructs_MonoClassPtrPtr {
    struct RuntimeStructs_MonoClassPtrPtr__Class *klass;
    MonitorData *monitor;
};

struct RuntimeStructs_GenericParamInfoPtr {
    struct RuntimeStructs_GenericParamInfoPtr__Class *klass;
    MonitorData *monitor;
};

struct RuntimeStructs_MonoClassPtrPtr__VTable {
};

struct RuntimeStructs_MonoClassPtrPtr__StaticFields {
};

struct RuntimeStructs_MonoClassPtrPtr__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeStructs_MonoClassPtrPtr__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeStructs_MonoClassPtrPtr__VTable vtable;
};

struct RuntimeStructs_GenericParamInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct RuntimeStructs_GenericParamInfo__StaticFields {
};

struct RuntimeStructs_GenericParamInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeStructs_GenericParamInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeStructs_GenericParamInfo__VTable vtable;
};

struct RuntimeStructs_GenericParamInfoPtr__VTable {
};

struct RuntimeStructs_GenericParamInfoPtr__StaticFields {
};

struct RuntimeStructs_GenericParamInfoPtr__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeStructs_GenericParamInfoPtr__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeStructs_GenericParamInfoPtr__VTable vtable;
};

struct RuntimeGenericParamInfoHandle__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct RuntimeGenericParamInfoHandle__StaticFields {
};

struct RuntimeGenericParamInfoHandle__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeGenericParamInfoHandle__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeGenericParamInfoHandle__VTable vtable;
};

struct RuntimeEventHandle {
    void *value;
};

struct RuntimeEventHandle__Boxed {
    struct RuntimeEventHandle__Class *klass;
    MonitorData *monitor;
    struct RuntimeEventHandle fields;
};

struct RuntimeEventHandle__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct RuntimeEventHandle__StaticFields {
};

struct RuntimeEventHandle__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeEventHandle__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeEventHandle__VTable vtable;
};

struct RuntimePropertyHandle {
    void *value;
};

struct RuntimePropertyHandle__Boxed {
    struct RuntimePropertyHandle__Class *klass;
    MonitorData *monitor;
    struct RuntimePropertyHandle fields;
};

struct RuntimePropertyHandle__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct RuntimePropertyHandle__StaticFields {
};

struct RuntimePropertyHandle__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimePropertyHandle__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimePropertyHandle__VTable vtable;
};

struct RuntimeGPtrArrayHandle {
    struct RuntimeStructs_GPtrArray *value;
};

struct RuntimeGPtrArrayHandle__Boxed {
    struct RuntimeGPtrArrayHandle__Class *klass;
    MonitorData *monitor;
    struct RuntimeGPtrArrayHandle fields;
};

struct RuntimeStructs_GPtrArray {
    void **data;
    int32_t len;
};

struct RuntimeStructs_GPtrArray__Boxed {
    struct RuntimeStructs_GPtrArray__Class *klass;
    MonitorData *monitor;
    struct RuntimeStructs_GPtrArray fields;
};

struct IntPtrPtr {
    struct IntPtrPtr__Class *klass;
    MonitorData *monitor;
};

struct RuntimeStructs_GPtrArrayPtr {
    struct RuntimeStructs_GPtrArrayPtr__Class *klass;
    MonitorData *monitor;
};

struct IntPtrPtr__VTable {
};

struct IntPtrPtr__StaticFields {
};

struct IntPtrPtr__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IntPtrPtr__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IntPtrPtr__VTable vtable;
};

struct RuntimeStructs_GPtrArray__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct RuntimeStructs_GPtrArray__StaticFields {
};

struct RuntimeStructs_GPtrArray__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeStructs_GPtrArray__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeStructs_GPtrArray__VTable vtable;
};

struct RuntimeStructs_GPtrArrayPtr__VTable {
};

struct RuntimeStructs_GPtrArrayPtr__StaticFields {
};

struct RuntimeStructs_GPtrArrayPtr__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeStructs_GPtrArrayPtr__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeStructs_GPtrArrayPtr__VTable vtable;
};

struct RuntimeGPtrArrayHandle__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct RuntimeGPtrArrayHandle__StaticFields {
};

struct RuntimeGPtrArrayHandle__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeGPtrArrayHandle__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeGPtrArrayHandle__VTable vtable;
};

struct RuntimeGPtrArrayHandle___VTable {
};

struct RuntimeGPtrArrayHandle___StaticFields {
};

struct RuntimeGPtrArrayHandle___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeGPtrArrayHandle___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeGPtrArrayHandle___VTable vtable;
};

struct SafeStringMarshal {
    struct String *str;
    void *marshaled_string;
};

struct SafeStringMarshal__Boxed {
    struct SafeStringMarshal__Class *klass;
    MonitorData *monitor;
    struct SafeStringMarshal fields;
};

struct SafeStringMarshal__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
};

struct SafeStringMarshal__StaticFields {
};

struct SafeStringMarshal__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SafeStringMarshal__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SafeStringMarshal__VTable vtable;
};

struct IntPtr___VTable {
};

struct IntPtr___StaticFields {
};

struct IntPtr___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IntPtr___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IntPtr___VTable vtable;
};

struct MonoAssemblyName_public_key_token_e_FixedBuffer {
    uint8_t FixedElementField;
};

struct MonoAssemblyName_public_key_token_e_FixedBuffer__Boxed {
    struct MonoAssemblyName_public_key_token_e_FixedBuffer__Class *klass;
    MonitorData *monitor;
    struct MonoAssemblyName_public_key_token_e_FixedBuffer fields;
};

struct MonoAssemblyName {
    void *name;
    void *culture;
    void *hash_value;
    void *public_key;
    struct MonoAssemblyName_public_key_token_e_FixedBuffer public_key_token;
    uint32_t hash_alg;
    uint32_t hash_len;
    uint32_t flags;
    uint16_t major;
    uint16_t minor;
    uint16_t build;
    uint16_t revision;
    uint16_t arch;
};

struct MonoAssemblyName__Boxed {
    struct MonoAssemblyName__Class *klass;
    MonitorData *monitor;
    struct MonoAssemblyName fields;
};

struct MonoAssemblyName_public_key_token_e_FixedBuffer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct MonoAssemblyName_public_key_token_e_FixedBuffer__StaticFields {
};

struct MonoAssemblyName_public_key_token_e_FixedBuffer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoAssemblyName_public_key_token_e_FixedBuffer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoAssemblyName_public_key_token_e_FixedBuffer__VTable vtable;
};

struct MonoAssemblyName__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct MonoAssemblyName__StaticFields {
};

struct MonoAssemblyName__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoAssemblyName__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoAssemblyName__VTable vtable;
};

struct MonoAssemblyName___VTable {
};

struct MonoAssemblyName___StaticFields {
};

struct MonoAssemblyName___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoAssemblyName___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoAssemblyName___VTable vtable;
};

struct SafeGPtrArrayHandle {
    struct RuntimeGPtrArrayHandle handle;
};

struct SafeGPtrArrayHandle__Boxed {
    struct SafeGPtrArrayHandle__Class *klass;
    MonitorData *monitor;
    struct SafeGPtrArrayHandle fields;
};

struct SafeGPtrArrayHandle__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
};

struct SafeGPtrArrayHandle__StaticFields {
};

struct SafeGPtrArrayHandle__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SafeGPtrArrayHandle__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SafeGPtrArrayHandle__VTable vtable;
};

struct __declspec(align(8)) SmallXmlParser__Fields {
    struct SmallXmlParser_IContentHandler *handler;
    struct TextReader *reader;
    struct Stack *elementNames;
    struct Stack *xmlSpaces;
    struct String *xmlSpace;
    struct StringBuilder *buffer;
    struct Char__Array *nameBuffer;
    bool isWhitespace;
    struct SmallXmlParser_AttrListImpl *attributes;
    int32_t line;
    int32_t column;
    bool resetColumn;
};

struct SmallXmlParser {
    struct SmallXmlParser__Class *klass;
    MonitorData *monitor;
    struct SmallXmlParser__Fields fields;
};

struct SecurityParser__Fields {
    struct SmallXmlParser__Fields _;
    struct SecurityElement *root;
    struct SecurityElement *current;
    struct Stack *stack;
};

struct SecurityParser {
    struct SecurityParser__Class *klass;
    MonitorData *monitor;
    struct SecurityParser__Fields fields;
};

struct SmallXmlParser_IContentHandler {
    struct SmallXmlParser_IContentHandler__Class *klass;
    MonitorData *monitor;
};

struct TextReader__Fields {
    struct MarshalByRefObject__Fields _;
};

struct TextReader {
    struct TextReader__Class *klass;
    MonitorData *monitor;
    struct TextReader__Fields fields;
};

struct Func_2_Object_String___Fields {
    struct MulticastDelegate__Fields _;
};

struct Func_2_Object_String_ {
    struct Func_2_Object_String___Class *klass;
    MonitorData *monitor;
    struct Func_2_Object_String___Fields fields;
};

struct Func_2_Object_Int32___Fields {
    struct MulticastDelegate__Fields _;
};

struct Func_2_Object_Int32_ {
    struct Func_2_Object_Int32___Class *klass;
    MonitorData *monitor;
    struct Func_2_Object_Int32___Fields fields;
};

struct Task_1_System_String___Fields {
    struct Task__Fields _;
    struct String *m_result;
};

struct Task_1_System_String_ {
    struct Task_1_System_String___Class *klass;
    MonitorData *monitor;
    struct Task_1_System_String___Fields fields;
};

struct __declspec(align(8)) TaskFactory_1_System_String___Fields {
    struct CancellationToken m_defaultCancellationToken;
    struct TaskScheduler *m_defaultScheduler;
    #if defined(_CPLUSPLUS_)
    enum TaskCreationOptions__Enum m_defaultCreationOptions;
    #else
    uint32_t m_defaultCreationOptions;
    #endif
    #if defined(_CPLUSPLUS_)
    enum TaskContinuationOptions__Enum m_defaultContinuationOptions;
    #else
    uint32_t m_defaultContinuationOptions;
    #endif
};

struct TaskFactory_1_System_String_ {
    struct TaskFactory_1_System_String___Class *klass;
    MonitorData *monitor;
    struct TaskFactory_1_System_String___Fields fields;
};

struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__4__Fields {
    struct MulticastDelegate__Fields _;
};

struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__4 {
    struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__4__Class *klass;
    MonitorData *monitor;
    struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__4__Fields fields;
};

struct __declspec(align(8)) Stack__Fields {
    struct Object__Array *_array;
    int32_t _size;
    int32_t _version;
    struct Object *_syncRoot;
};

struct Stack {
    struct Stack__Class *klass;
    MonitorData *monitor;
    struct Stack__Fields fields;
};

struct __declspec(align(8)) StringBuilder__Fields {
    struct Char__Array *m_ChunkChars;
    struct StringBuilder *m_ChunkPrevious;
    int32_t m_ChunkLength;
    int32_t m_ChunkOffset;
    int32_t m_MaxCapacity;
};

struct StringBuilder {
    struct StringBuilder__Class *klass;
    MonitorData *monitor;
    struct StringBuilder__Fields fields;
};

struct __declspec(align(8)) SmallXmlParser_AttrListImpl__Fields {
    struct List_1_System_String_ *attrNames;
    struct List_1_System_String_ *attrValues;
};

struct SmallXmlParser_AttrListImpl {
    struct SmallXmlParser_AttrListImpl__Class *klass;
    MonitorData *monitor;
    struct SmallXmlParser_AttrListImpl__Fields fields;
};

struct __declspec(align(8)) List_1_System_String___Fields {
    struct String__Array *_items;
    int32_t _size;
    int32_t _version;
    struct Object *_syncRoot;
};

struct List_1_System_String_ {
    struct List_1_System_String___Class *klass;
    MonitorData *monitor;
    struct List_1_System_String___Fields fields;
};

struct SmallXmlParser_IAttrList {
    struct SmallXmlParser_IAttrList__Class *klass;
    MonitorData *monitor;
};

struct SmallXmlParser_IContentHandler__VTable {
    VirtualInvokeData OnStartParsing;
    VirtualInvokeData OnEndParsing;
    VirtualInvokeData OnStartElement;
    VirtualInvokeData OnEndElement;
    VirtualInvokeData OnProcessingInstruction;
    VirtualInvokeData OnChars;
    VirtualInvokeData OnIgnorableWhitespace;
};

struct SmallXmlParser_IContentHandler__StaticFields {
};

struct SmallXmlParser_IContentHandler__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SmallXmlParser_IContentHandler__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SmallXmlParser_IContentHandler__VTable vtable;
};

struct Func_2_Object_String___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Func_2_Object_String___StaticFields {
};

struct Func_2_Object_String___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Func_2_Object_String___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Func_2_Object_String___VTable vtable;
};

struct Func_2_Object_Int32___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Func_2_Object_Int32___StaticFields {
};

struct Func_2_Object_Int32___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Func_2_Object_Int32___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Func_2_Object_Int32___VTable vtable;
};

struct TaskFactory_1_System_String___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct TaskFactory_1_System_String___StaticFields {
};

struct TaskFactory_1_System_String___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TaskFactory_1_System_String___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TaskFactory_1_System_String___VTable vtable;
};

struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__4__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__4__StaticFields {
};

struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__4__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__4__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__4__VTable vtable;
};

struct Task_1_System_String___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Threading_IThreadPoolWorkItem_ExecuteWorkItem;
    VirtualInvokeData System_Threading_IThreadPoolWorkItem_MarkAborted;
    VirtualInvokeData get_IsCompleted;
    VirtualInvokeData System_IAsyncResult_get_AsyncWaitHandle;
    VirtualInvokeData get_AsyncState;
    VirtualInvokeData System_IAsyncResult_get_CompletedSynchronously;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_ShouldNotifyDebuggerOfWaitCompletion;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData ShouldReplicate;
    VirtualInvokeData CreateReplicaTask;
    VirtualInvokeData get_SavedStateForNextReplica;
    VirtualInvokeData set_SavedStateForNextReplica;
    VirtualInvokeData get_SavedStateFromPreviousReplica;
    VirtualInvokeData set_SavedStateFromPreviousReplica;
    VirtualInvokeData get_HandedOverChildReplica;
    VirtualInvokeData set_HandedOverChildReplica;
    VirtualInvokeData InnerInvoke;
    VirtualInvokeData GetDelegateContinuationsForDebugger;
};

struct Task_1_System_String___StaticFields {
    struct TaskFactory_1_System_String_ *s_Factory;
    struct Func_2_System_Threading_Tasks_Task_1_System_Threading_Tasks_Task_1__4 *TaskWhenAnyCast;
};

struct Task_1_System_String___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Task_1_System_String___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Task_1_System_String___VTable vtable;
};

struct TextReader__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData Dispose;
    VirtualInvokeData Close;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData Peek;
    VirtualInvokeData Read;
    VirtualInvokeData Read_1;
    VirtualInvokeData ReadToEnd;
    VirtualInvokeData ReadBlock;
    VirtualInvokeData ReadLine;
    VirtualInvokeData ReadLineAsync;
    VirtualInvokeData ReadToEndAsync;
    VirtualInvokeData ReadAsync;
    VirtualInvokeData ReadAsyncInternal;
    VirtualInvokeData ReadBlockAsync;
};

struct TextReader__StaticFields {
    struct Func_2_Object_String_ *_ReadLineDelegate;
    struct Func_2_Object_Int32_ *_ReadDelegate;
    struct TextReader *Null;
};

struct TextReader__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TextReader__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TextReader__VTable vtable;
};

struct Stack__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CopyTo;
    VirtualInvokeData get_Count;
    VirtualInvokeData get_SyncRoot;
    VirtualInvokeData get_IsSynchronized;
    VirtualInvokeData GetEnumerator;
    VirtualInvokeData Clone;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData get_IsSynchronized_1;
    VirtualInvokeData get_SyncRoot_1;
    VirtualInvokeData Clear;
    VirtualInvokeData Clone_1;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo_1;
    VirtualInvokeData GetEnumerator_1;
    VirtualInvokeData Peek;
    VirtualInvokeData Pop;
    VirtualInvokeData Push;
    VirtualInvokeData ToArray;
};

struct Stack__StaticFields {
};

struct Stack__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Stack__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Stack__VTable vtable;
};

struct StringBuilder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
};

struct StringBuilder__StaticFields {
};

struct StringBuilder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StringBuilder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StringBuilder__VTable vtable;
};

struct List_1_System_String___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData RemoveAt;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_T__get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_T__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IList_get_Item;
    VirtualInvokeData System_Collections_IList_set_Item;
    VirtualInvokeData System_Collections_IList_Add;
    VirtualInvokeData System_Collections_IList_Contains;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IList_get_IsReadOnly;
    VirtualInvokeData System_Collections_IList_get_IsFixedSize;
    VirtualInvokeData System_Collections_IList_IndexOf;
    VirtualInvokeData System_Collections_IList_Insert;
    VirtualInvokeData System_Collections_IList_Remove;
    VirtualInvokeData RemoveAt_1;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData get_Count_2;
};

struct List_1_System_String___StaticFields {
    struct String__Array *_emptyArray;
};

struct List_1_System_String___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct List_1_System_String___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct List_1_System_String___VTable vtable;
};

struct SmallXmlParser_AttrListImpl__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Length;
    VirtualInvokeData get_IsEmpty;
    VirtualInvokeData GetName;
    VirtualInvokeData GetValue;
    VirtualInvokeData GetValue_1;
    VirtualInvokeData get_Names;
    VirtualInvokeData get_Values;
};

struct SmallXmlParser_AttrListImpl__StaticFields {
};

struct SmallXmlParser_AttrListImpl__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SmallXmlParser_AttrListImpl__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SmallXmlParser_AttrListImpl__VTable vtable;
};

struct SmallXmlParser__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct SmallXmlParser__StaticFields {
};

struct SmallXmlParser__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SmallXmlParser__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SmallXmlParser__VTable vtable;
};

struct SmallXmlParser_IAttrList__VTable {
    VirtualInvokeData get_Length;
    VirtualInvokeData get_IsEmpty;
    VirtualInvokeData GetName;
    VirtualInvokeData GetValue;
    VirtualInvokeData GetValue_1;
    VirtualInvokeData get_Names;
    VirtualInvokeData get_Values;
};

struct SmallXmlParser_IAttrList__StaticFields {
};

struct SmallXmlParser_IAttrList__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SmallXmlParser_IAttrList__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SmallXmlParser_IAttrList__VTable vtable;
};

struct SecurityParser__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData OnStartParsing;
    VirtualInvokeData OnEndParsing;
    VirtualInvokeData OnStartElement;
    VirtualInvokeData OnEndElement;
    VirtualInvokeData OnProcessingInstruction;
    VirtualInvokeData OnChars;
    VirtualInvokeData OnIgnorableWhitespace;
};

struct SecurityParser__StaticFields {
};

struct SecurityParser__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SecurityParser__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SecurityParser__VTable vtable;
};

struct DefaultHandler {
    struct DefaultHandler__Class *klass;
    MonitorData *monitor;
};

struct DefaultHandler__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData OnStartParsing;
    VirtualInvokeData OnEndParsing;
    VirtualInvokeData OnStartElement;
    VirtualInvokeData OnEndElement;
    VirtualInvokeData OnProcessingInstruction;
    VirtualInvokeData OnChars;
    VirtualInvokeData OnIgnorableWhitespace;
};

struct DefaultHandler__StaticFields {
};

struct DefaultHandler__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DefaultHandler__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DefaultHandler__VTable vtable;
};

struct SmallXmlParserException__Fields {
    struct SystemException__Fields _;
    int32_t line;
    int32_t column;
};

struct SmallXmlParserException {
    struct SmallXmlParserException__Class *klass;
    MonitorData *monitor;
    struct SmallXmlParserException__Fields fields;
};

struct SmallXmlParserException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct SmallXmlParserException__StaticFields {
};

struct SmallXmlParserException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SmallXmlParserException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SmallXmlParserException__VTable vtable;
};

struct __declspec(align(8)) TailoringInfo__Fields {
    int32_t LCID;
    int32_t TailoringIndex;
    int32_t TailoringCount;
    bool FrenchSort;
};

struct TailoringInfo {
    struct TailoringInfo__Class *klass;
    MonitorData *monitor;
    struct TailoringInfo__Fields fields;
};

struct TailoringInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct TailoringInfo__StaticFields {
};

struct TailoringInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TailoringInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TailoringInfo__VTable vtable;
};

struct ContractionComparer {
    struct ContractionComparer__Class *klass;
    MonitorData *monitor;
};

struct ContractionComparer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Compare;
};

struct ContractionComparer__StaticFields {
    struct ContractionComparer *Instance;
};

struct ContractionComparer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ContractionComparer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ContractionComparer__VTable vtable;
};

struct Contraction___VTable {
};

struct Contraction___StaticFields {
};

struct Contraction___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Contraction___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Contraction___VTable vtable;
};

struct Level2Map___VTable {
};

struct Level2Map___StaticFields {
};

struct Level2Map___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Level2Map___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Level2Map___VTable vtable;
};

struct CodePointIndexer___VTable {
};

struct CodePointIndexer___StaticFields {
};

struct CodePointIndexer___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CodePointIndexer___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CodePointIndexer___VTable vtable;
};

struct BytePtr___VTable {
};

struct BytePtr___StaticFields {
};

struct BytePtr___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct BytePtr___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct BytePtr___VTable vtable;
};

struct MSCompatUnicodeTable {
    struct MSCompatUnicodeTable__Class *klass;
    MonitorData *monitor;
};

struct TailoringInfo__Array {
    struct TailoringInfo__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct TailoringInfo *vector[32];
};

struct TailoringInfo__Array__VTable {
};

struct TailoringInfo__Array__StaticFields {
};

struct TailoringInfo__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TailoringInfo__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TailoringInfo__Array__VTable vtable;
};

struct MSCompatUnicodeTable__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct MSCompatUnicodeTable__StaticFields {
    int32_t MaxExpansionLength;
    uint8_t *ignorableFlags;
    uint8_t *categories;
    uint8_t *level1;
    uint8_t *level2;
    uint8_t *level3;
    uint8_t *cjkCHScategory;
    uint8_t *cjkCHTcategory;
    uint8_t *cjkJAcategory;
    uint8_t *cjkKOcategory;
    uint8_t *cjkCHSlv1;
    uint8_t *cjkCHTlv1;
    uint8_t *cjkJAlv1;
    uint8_t *cjkKOlv1;
    uint8_t *cjkKOlv2;
    struct Char__Array *tailoringArr;
    struct TailoringInfo__Array *tailoringInfos;
    struct Object *forLock;
    bool isReady;
};

struct MSCompatUnicodeTable__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MSCompatUnicodeTable__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MSCompatUnicodeTable__VTable vtable;
};

struct MSCompatUnicodeTable_c {
    struct MSCompatUnicodeTable_c__Class *klass;
    MonitorData *monitor;
};

struct Comparison_1_Mono_Globalization_Unicode_Level2Map___Fields {
    struct MulticastDelegate__Fields _;
};

struct Comparison_1_Mono_Globalization_Unicode_Level2Map_ {
    struct Comparison_1_Mono_Globalization_Unicode_Level2Map___Class *klass;
    MonitorData *monitor;
    struct Comparison_1_Mono_Globalization_Unicode_Level2Map___Fields fields;
};

struct Comparison_1_Mono_Globalization_Unicode_Level2Map___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Comparison_1_Mono_Globalization_Unicode_Level2Map___StaticFields {
};

struct Comparison_1_Mono_Globalization_Unicode_Level2Map___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Comparison_1_Mono_Globalization_Unicode_Level2Map___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Comparison_1_Mono_Globalization_Unicode_Level2Map___VTable vtable;
};

struct MSCompatUnicodeTable_c__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct MSCompatUnicodeTable_c__StaticFields {
    struct MSCompatUnicodeTable_c *__9;
    struct Comparison_1_Mono_Globalization_Unicode_Level2Map_ *__9__17_0;
};

struct MSCompatUnicodeTable_c__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MSCompatUnicodeTable_c__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MSCompatUnicodeTable_c__VTable vtable;
};

struct MSCompatUnicodeTableUtil {
    struct MSCompatUnicodeTableUtil__Class *klass;
    MonitorData *monitor;
};

struct MSCompatUnicodeTableUtil__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct MSCompatUnicodeTableUtil__StaticFields {
    struct CodePointIndexer *Ignorable;
    struct CodePointIndexer *Category;
    struct CodePointIndexer *Level1;
    struct CodePointIndexer *Level2;
    struct CodePointIndexer *Level3;
    struct CodePointIndexer *CjkCHS;
    struct CodePointIndexer *Cjk;
};

struct MSCompatUnicodeTableUtil__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MSCompatUnicodeTableUtil__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MSCompatUnicodeTableUtil__VTable vtable;
};

struct NormalizationTableUtil {
    struct NormalizationTableUtil__Class *klass;
    MonitorData *monitor;
};

struct NormalizationTableUtil__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct NormalizationTableUtil__StaticFields {
    struct CodePointIndexer *Prop;
    struct CodePointIndexer *Map;
    struct CodePointIndexer *Combining;
    struct CodePointIndexer *Composite;
    struct CodePointIndexer *Helper;
};

struct NormalizationTableUtil__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct NormalizationTableUtil__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct NormalizationTableUtil__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum SimpleCollator_ExtenderType__Enum : int32_t {
    SimpleCollator_ExtenderType__Enum_None = 0x00000000,
    SimpleCollator_ExtenderType__Enum_Simple = 0x00000001,
    SimpleCollator_ExtenderType__Enum_Voiced = 0x00000002,
    SimpleCollator_ExtenderType__Enum_Conditional = 0x00000003,
    SimpleCollator_ExtenderType__Enum_Buggy = 0x00000004,
};

#else
enum SimpleCollator_ExtenderType__Enum {
    SimpleCollator_ExtenderType__Enum_None = 0x00000000,
    SimpleCollator_ExtenderType__Enum_Simple = 0x00000001,
    SimpleCollator_ExtenderType__Enum_Voiced = 0x00000002,
    SimpleCollator_ExtenderType__Enum_Conditional = 0x00000003,
    SimpleCollator_ExtenderType__Enum_Buggy = 0x00000004,
};

#endif
struct SimpleCollator_ExtenderType__Enum__Boxed {
    struct SimpleCollator_ExtenderType__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum SimpleCollator_ExtenderType__Enum value;
    #else
    uint32_t value;
    #endif
};

struct SimpleCollator_ExtenderType__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct SimpleCollator_ExtenderType__Enum__StaticFields {
};

struct SimpleCollator_ExtenderType__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SimpleCollator_ExtenderType__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SimpleCollator_ExtenderType__Enum__VTable vtable;
};

struct __declspec(align(8)) SortKeyBuffer__Fields {
    struct Byte__Array *l1b;
    struct Byte__Array *l2b;
    struct Byte__Array *l3b;
    struct Byte__Array *l4sb;
    struct Byte__Array *l4tb;
    struct Byte__Array *l4kb;
    struct Byte__Array *l4wb;
    struct Byte__Array *l5b;
    struct String *source;
    int32_t l1;
    int32_t l2;
    int32_t l3;
    int32_t l4s;
    int32_t l4t;
    int32_t l4k;
    int32_t l4w;
    int32_t l5;
    int32_t lcid;
    #if defined(_CPLUSPLUS_)
    enum CompareOptions__Enum options;
    #else
    uint32_t options;
    #endif
    bool processLevel2;
    bool frenchSort;
    bool frenchSorted;
};

struct SortKeyBuffer {
    struct SortKeyBuffer__Class *klass;
    MonitorData *monitor;
    struct SortKeyBuffer__Fields fields;
};

struct SortKeyBuffer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct SortKeyBuffer__StaticFields {
};

struct SortKeyBuffer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SortKeyBuffer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SortKeyBuffer__VTable vtable;
};

struct SimpleCollator_Context {
    #if defined(_CPLUSPLUS_)
    enum CompareOptions__Enum Option;
    #else
    uint32_t Option;
    #endif
    uint8_t *NeverMatchFlags;
    uint8_t *AlwaysMatchFlags;
    uint8_t *Buffer1;
    uint8_t *Buffer2;
    int32_t PrevCode;
    uint8_t *PrevSortKey;
};

struct SimpleCollator_Context__Boxed {
    struct SimpleCollator_Context__Class *klass;
    MonitorData *monitor;
    struct SimpleCollator_Context fields;
};

struct SimpleCollator_Context__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct SimpleCollator_Context__StaticFields {
};

struct SimpleCollator_Context__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SimpleCollator_Context__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SimpleCollator_Context__VTable vtable;
};

struct SimpleCollator_Context___VTable {
};

struct SimpleCollator_Context___StaticFields {
};

struct SimpleCollator_Context___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SimpleCollator_Context___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SimpleCollator_Context___VTable vtable;
};

struct Contraction__1__VTable {
};

struct Contraction__1__StaticFields {
};

struct Contraction__1__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Contraction__1__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Contraction__1__VTable vtable;
};

struct SimpleCollator_PreviousInfo {
    int32_t Code;
    uint8_t *SortKey;
};

struct SimpleCollator_PreviousInfo__Boxed {
    struct SimpleCollator_PreviousInfo__Class *klass;
    MonitorData *monitor;
    struct SimpleCollator_PreviousInfo fields;
};

struct SimpleCollator_PreviousInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct SimpleCollator_PreviousInfo__StaticFields {
};

struct SimpleCollator_PreviousInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SimpleCollator_PreviousInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SimpleCollator_PreviousInfo__VTable vtable;
};

struct Byte___VTable {
};

struct Byte___StaticFields {
};

struct Byte___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Byte___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Byte___VTable vtable;
};

struct Byte__1__VTable {
};

struct Byte__1__StaticFields {
};

struct Byte__1__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Byte__1__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Byte__1__VTable vtable;
};

struct BitConverterLE {
    struct BitConverterLE__Class *klass;
    MonitorData *monitor;
};

struct BitConverterLE__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct BitConverterLE__StaticFields {
};

struct BitConverterLE__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct BitConverterLE__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct BitConverterLE__VTable vtable;
};

struct PKCS7 {
    struct PKCS7__Class *klass;
    MonitorData *monitor;
};

struct PKCS7__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct PKCS7__StaticFields {
};

struct PKCS7__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PKCS7__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PKCS7__VTable vtable;
};

struct PKCS7_Oid {
    struct PKCS7_Oid__Class *klass;
    MonitorData *monitor;
};

struct PKCS7_Oid__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct PKCS7_Oid__StaticFields {
};

struct PKCS7_Oid__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PKCS7_Oid__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PKCS7_Oid__VTable vtable;
};

struct __declspec(align(8)) PKCS7_ContentInfo__Fields {
    struct String *contentType;
    struct ASN1 *content;
};

struct PKCS7_ContentInfo {
    struct PKCS7_ContentInfo__Class *klass;
    MonitorData *monitor;
    struct PKCS7_ContentInfo__Fields fields;
};

struct PKCS7_ContentInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct PKCS7_ContentInfo__StaticFields {
};

struct PKCS7_ContentInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PKCS7_ContentInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PKCS7_ContentInfo__VTable vtable;
};

struct __declspec(align(8)) PKCS7_EncryptedData__Fields {
    uint8_t _version;
    struct PKCS7_ContentInfo *_content;
    struct PKCS7_ContentInfo *_encryptionAlgorithm;
    struct Byte__Array *_encrypted;
};

struct PKCS7_EncryptedData {
    struct PKCS7_EncryptedData__Class *klass;
    MonitorData *monitor;
    struct PKCS7_EncryptedData__Fields fields;
};

struct PKCS7_EncryptedData__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct PKCS7_EncryptedData__StaticFields {
};

struct PKCS7_EncryptedData__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PKCS7_EncryptedData__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PKCS7_EncryptedData__VTable vtable;
};

struct __declspec(align(8)) PKCS7_EnvelopedData__Fields {
    uint8_t _version;
    struct PKCS7_ContentInfo *_content;
    struct PKCS7_ContentInfo *_encryptionAlgorithm;
    struct ArrayList *_recipientInfos;
    struct Byte__Array *_encrypted;
};

struct PKCS7_EnvelopedData {
    struct PKCS7_EnvelopedData__Class *klass;
    MonitorData *monitor;
    struct PKCS7_EnvelopedData__Fields fields;
};

struct PKCS7_EnvelopedData__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct PKCS7_EnvelopedData__StaticFields {
};

struct PKCS7_EnvelopedData__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PKCS7_EnvelopedData__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PKCS7_EnvelopedData__VTable vtable;
};

struct __declspec(align(8)) PKCS7_RecipientInfo__Fields {
    int32_t _version;
    struct String *_oid;
    struct Byte__Array *_key;
    struct Byte__Array *_ski;
    struct String *_issuer;
    struct Byte__Array *_serial;
};

struct PKCS7_RecipientInfo {
    struct PKCS7_RecipientInfo__Class *klass;
    MonitorData *monitor;
    struct PKCS7_RecipientInfo__Fields fields;
};

struct PKCS7_RecipientInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct PKCS7_RecipientInfo__StaticFields {
};

struct PKCS7_RecipientInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PKCS7_RecipientInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PKCS7_RecipientInfo__VTable vtable;
};

struct __declspec(align(8)) PKCS7_SignedData__Fields {
    uint8_t version;
    struct String *hashAlgorithm;
    struct PKCS7_ContentInfo *contentInfo;
    struct X509CertificateCollection *certs;
    struct ArrayList *crls;
    struct PKCS7_SignerInfo *signerInfo;
    bool mda;
    bool signed_1;
};

struct PKCS7_SignedData {
    struct PKCS7_SignedData__Class *klass;
    MonitorData *monitor;
    struct PKCS7_SignedData__Fields fields;
};

struct X509CertificateCollection__Fields {
    struct CollectionBase__Fields _;
};

struct X509CertificateCollection {
    struct X509CertificateCollection__Class *klass;
    MonitorData *monitor;
    struct X509CertificateCollection__Fields fields;
};

struct __declspec(align(8)) PKCS7_SignerInfo__Fields {
    uint8_t version;
    struct X509Certificate_1 *x509;
    struct String *hashAlgorithm;
    struct AsymmetricAlgorithm *key;
    struct ArrayList *authenticatedAttributes;
    struct ArrayList *unauthenticatedAttributes;
    struct Byte__Array *signature;
    struct String *issuer;
    struct Byte__Array *serial;
    struct Byte__Array *ski;
};

struct PKCS7_SignerInfo {
    struct PKCS7_SignerInfo__Class *klass;
    MonitorData *monitor;
    struct PKCS7_SignerInfo__Fields fields;
};

struct X509CertificateCollection__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Collections_IList_get_Item;
    VirtualInvokeData System_Collections_IList_set_Item;
    VirtualInvokeData System_Collections_IList_Add;
    VirtualInvokeData System_Collections_IList_Contains;
    VirtualInvokeData Clear;
    VirtualInvokeData System_Collections_IList_get_IsReadOnly;
    VirtualInvokeData System_Collections_IList_get_IsFixedSize;
    VirtualInvokeData System_Collections_IList_IndexOf;
    VirtualInvokeData System_Collections_IList_Insert;
    VirtualInvokeData System_Collections_IList_Remove;
    VirtualInvokeData RemoveAt;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData OnSet;
    VirtualInvokeData OnInsert;
    VirtualInvokeData OnClear;
    VirtualInvokeData OnRemove;
    VirtualInvokeData OnValidate;
    VirtualInvokeData OnSetComplete;
    VirtualInvokeData OnInsertComplete;
    VirtualInvokeData OnClearComplete;
    VirtualInvokeData OnRemoveComplete;
};

struct X509CertificateCollection__StaticFields {
};

struct X509CertificateCollection__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X509CertificateCollection__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X509CertificateCollection__VTable vtable;
};

struct PKCS7_SignerInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct PKCS7_SignerInfo__StaticFields {
};

struct PKCS7_SignerInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PKCS7_SignerInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PKCS7_SignerInfo__VTable vtable;
};

struct PKCS7_SignedData__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct PKCS7_SignedData__StaticFields {
};

struct PKCS7_SignedData__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PKCS7_SignedData__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PKCS7_SignedData__VTable vtable;
};

struct PKCS7_SortedSet {
    struct PKCS7_SortedSet__Class *klass;
    MonitorData *monitor;
};

struct PKCS7_SortedSet__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Compare;
};

struct PKCS7_SortedSet__StaticFields {
};

struct PKCS7_SortedSet__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PKCS7_SortedSet__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PKCS7_SortedSet__VTable vtable;
};

struct __declspec(align(8)) StrongName__Fields {
    struct RSA *rsa;
    struct Byte__Array *publicKey;
    struct Byte__Array *keyToken;
    struct String *tokenAlgorithm;
};

struct StrongName {
    struct StrongName__Class *klass;
    MonitorData *monitor;
    struct StrongName__Fields fields;
};

struct StrongName__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct StrongName__StaticFields {
    struct Object *lockObject;
    bool initialized;
};

struct StrongName__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StrongName__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StrongName__VTable vtable;
};

struct __declspec(align(8)) StrongName_StrongNameSignature__Fields {
    struct Byte__Array *hash;
    struct Byte__Array *signature;
    uint32_t signaturePosition;
    uint32_t signatureLength;
    uint32_t metadataPosition;
    uint32_t metadataLength;
    uint8_t cliFlag;
    uint32_t cliFlagPosition;
};

struct StrongName_StrongNameSignature {
    struct StrongName_StrongNameSignature__Class *klass;
    MonitorData *monitor;
    struct StrongName_StrongNameSignature__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum StrongName_StrongNameOptions__Enum : int32_t {
    StrongName_StrongNameOptions__Enum_Metadata = 0x00000000,
    StrongName_StrongNameOptions__Enum_Signature = 0x00000001,
};

#else
enum StrongName_StrongNameOptions__Enum {
    StrongName_StrongNameOptions__Enum_Metadata = 0x00000000,
    StrongName_StrongNameOptions__Enum_Signature = 0x00000001,
};

#endif
struct StrongName_StrongNameOptions__Enum__Boxed {
    struct StrongName_StrongNameOptions__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum StrongName_StrongNameOptions__Enum value;
    #else
    uint32_t value;
    #endif
};

struct StrongName_StrongNameSignature__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct StrongName_StrongNameSignature__StaticFields {
};

struct StrongName_StrongNameSignature__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StrongName_StrongNameSignature__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StrongName_StrongNameSignature__VTable vtable;
};

struct StrongName_StrongNameOptions__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct StrongName_StrongNameOptions__Enum__StaticFields {
};

struct StrongName_StrongNameOptions__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StrongName_StrongNameOptions__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StrongName_StrongNameOptions__Enum__VTable vtable;
};

struct StrongNameManager {
    struct StrongNameManager__Class *klass;
    MonitorData *monitor;
};

struct StrongNameManager__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct StrongNameManager__StaticFields {
    struct Hashtable *mappings;
    struct Hashtable *tokens;
};

struct StrongNameManager__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StrongNameManager__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StrongNameManager__VTable vtable;
};

struct __declspec(align(8)) StrongNameManager_Element__Fields {
    struct Hashtable *assemblies;
};

struct StrongNameManager_Element {
    struct StrongNameManager_Element__Class *klass;
    MonitorData *monitor;
    struct StrongNameManager_Element__Fields fields;
};

struct StrongNameManager_Element__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct StrongNameManager_Element__StaticFields {
};

struct StrongNameManager_Element__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StrongNameManager_Element__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StrongNameManager_Element__VTable vtable;
};

struct __declspec(align(8)) Uri__Fields {
    bool isUnixFilePath;
    struct String *source;
    struct String *scheme;
    struct String *host;
    int32_t port;
    struct String *path;
    struct String *query;
    struct String *fragment;
    struct String *userinfo;
    bool isUnc;
    bool isOpaquePart;
    struct String__Array *segments;
    bool userEscaped;
    struct String *cachedAbsoluteUri;
    struct String *cachedToString;
    struct String *cachedLocalPath;
    int32_t cachedHashCode;
    bool reduce;
};

struct Uri {
    struct Uri__Class *klass;
    MonitorData *monitor;
    struct Uri__Fields fields;
};

struct Uri_UriScheme {
    struct String *scheme;
    struct String *delimiter;
    int32_t defaultPort;
};

struct Uri_UriScheme__Boxed {
    struct Uri_UriScheme__Class *klass;
    MonitorData *monitor;
    struct Uri_UriScheme fields;
};

struct Uri_UriScheme__Array {
    struct Uri_UriScheme__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Uri_UriScheme vector[32];
};

struct Uri_UriScheme__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Uri_UriScheme__StaticFields {
};

struct Uri_UriScheme__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Uri_UriScheme__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Uri_UriScheme__VTable vtable;
};

struct Uri_UriScheme__Array__VTable {
};

struct Uri_UriScheme__Array__StaticFields {
};

struct Uri_UriScheme__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Uri_UriScheme__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Uri_UriScheme__Array__VTable vtable;
};

struct Uri__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Uri__StaticFields {
    struct String *hexUpperChars;
    struct String *SchemeDelimiter;
    struct String *UriSchemeFile;
    struct String *UriSchemeFtp;
    struct String *UriSchemeGopher;
    struct String *UriSchemeHttp;
    struct String *UriSchemeHttps;
    struct String *UriSchemeMailto;
    struct String *UriSchemeNews;
    struct String *UriSchemeNntp;
    struct Uri_UriScheme__Array *schemes;
};

struct Uri__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Uri__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Uri__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum UriPartial__Enum : int32_t {
    UriPartial__Enum_Scheme = 0x00000000,
    UriPartial__Enum_Authority = 0x00000001,
    UriPartial__Enum_Path = 0x00000002,
};

#else
enum UriPartial__Enum {
    UriPartial__Enum_Scheme = 0x00000000,
    UriPartial__Enum_Authority = 0x00000001,
    UriPartial__Enum_Path = 0x00000002,
};

#endif
struct UriPartial__Enum__Boxed {
    struct UriPartial__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum UriPartial__Enum value;
    #else
    uint32_t value;
    #endif
};

struct UriPartial__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct UriPartial__Enum__StaticFields {
};

struct UriPartial__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UriPartial__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UriPartial__Enum__VTable vtable;
};

struct PKCS5 {
    struct PKCS5__Class *klass;
    MonitorData *monitor;
};

struct PKCS5__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct PKCS5__StaticFields {
};

struct PKCS5__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PKCS5__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PKCS5__VTable vtable;
};

struct PKCS9 {
    struct PKCS9__Class *klass;
    MonitorData *monitor;
};

struct PKCS9__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct PKCS9__StaticFields {
};

struct PKCS9__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PKCS9__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PKCS9__VTable vtable;
};

struct __declspec(align(8)) SafeBag__Fields {
    struct String *_bagOID;
    struct ASN1 *_asn1;
};

struct SafeBag {
    struct SafeBag__Class *klass;
    MonitorData *monitor;
    struct SafeBag__Fields fields;
};

struct SafeBag__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct SafeBag__StaticFields {
};

struct SafeBag__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SafeBag__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SafeBag__VTable vtable;
};

struct __declspec(align(8)) PKCS12__Fields {
    struct Byte__Array *_password;
    struct ArrayList *_keyBags;
    struct ArrayList *_secretBags;
    struct X509CertificateCollection *_certs;
    bool _keyBagsChanged;
    bool _secretBagsChanged;
    bool _certsChanged;
    int32_t _iterations;
    struct ArrayList *_safeBags;
    struct RandomNumberGenerator *_rng;
};

struct PKCS12 {
    struct PKCS12__Class *klass;
    MonitorData *monitor;
    struct PKCS12__Fields fields;
};

struct PKCS12__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
};

struct PKCS12__StaticFields {
    int32_t password_max_length;
};

struct PKCS12__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PKCS12__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PKCS12__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum CipherMode__Enum : int32_t {
    CipherMode__Enum_CBC = 0x00000001,
    CipherMode__Enum_ECB = 0x00000002,
    CipherMode__Enum_OFB = 0x00000003,
    CipherMode__Enum_CFB = 0x00000004,
    CipherMode__Enum_CTS = 0x00000005,
};

#else
enum CipherMode__Enum {
    CipherMode__Enum_CBC = 0x00000001,
    CipherMode__Enum_ECB = 0x00000002,
    CipherMode__Enum_OFB = 0x00000003,
    CipherMode__Enum_CFB = 0x00000004,
    CipherMode__Enum_CTS = 0x00000005,
};

#endif
struct CipherMode__Enum__Boxed {
    struct CipherMode__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum CipherMode__Enum value;
    #else
    uint32_t value;
    #endif
};

#if defined(_CPLUSPLUS_)
enum PaddingMode__Enum : int32_t {
    PaddingMode__Enum_None = 0x00000001,
    PaddingMode__Enum_PKCS7 = 0x00000002,
    PaddingMode__Enum_Zeros = 0x00000003,
    PaddingMode__Enum_ANSIX923 = 0x00000004,
    PaddingMode__Enum_ISO10126 = 0x00000005,
};

#else
enum PaddingMode__Enum {
    PaddingMode__Enum_None = 0x00000001,
    PaddingMode__Enum_PKCS7 = 0x00000002,
    PaddingMode__Enum_Zeros = 0x00000003,
    PaddingMode__Enum_ANSIX923 = 0x00000004,
    PaddingMode__Enum_ISO10126 = 0x00000005,
};

#endif
struct PaddingMode__Enum__Boxed {
    struct PaddingMode__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum PaddingMode__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) SymmetricAlgorithm__Fields {
    int32_t BlockSizeValue;
    int32_t FeedbackSizeValue;
    struct Byte__Array *IVValue;
    struct Byte__Array *KeyValue;
    struct KeySizes__Array *LegalBlockSizesValue;
    struct KeySizes__Array *LegalKeySizesValue;
    int32_t KeySizeValue;
    #if defined(_CPLUSPLUS_)
    enum CipherMode__Enum ModeValue;
    #else
    uint32_t ModeValue;
    #endif
    #if defined(_CPLUSPLUS_)
    enum PaddingMode__Enum PaddingValue;
    #else
    uint32_t PaddingValue;
    #endif
};

struct SymmetricAlgorithm {
    struct SymmetricAlgorithm__Class *klass;
    MonitorData *monitor;
    struct SymmetricAlgorithm__Fields fields;
};

struct ICryptoTransform {
    struct ICryptoTransform__Class *klass;
    MonitorData *monitor;
};

struct RC4__Fields {
    struct SymmetricAlgorithm__Fields _;
};

struct RC4 {
    struct RC4__Class *klass;
    MonitorData *monitor;
    struct RC4__Fields fields;
};

struct ARC4Managed__Fields {
    struct RC4__Fields _;
    struct Byte__Array *key;
    struct Byte__Array *state;
    uint8_t x;
    uint8_t y;
    bool m_disposed;
};

struct ARC4Managed {
    struct ARC4Managed__Class *klass;
    MonitorData *monitor;
    struct ARC4Managed__Fields fields;
};

struct CipherMode__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct CipherMode__Enum__StaticFields {
};

struct CipherMode__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CipherMode__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CipherMode__Enum__VTable vtable;
};

struct PaddingMode__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct PaddingMode__Enum__StaticFields {
};

struct PaddingMode__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PaddingMode__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PaddingMode__Enum__VTable vtable;
};

struct ICryptoTransform__VTable {
    VirtualInvokeData get_InputBlockSize;
    VirtualInvokeData get_OutputBlockSize;
    VirtualInvokeData get_CanTransformMultipleBlocks;
    VirtualInvokeData get_CanReuseTransform;
    VirtualInvokeData TransformBlock;
    VirtualInvokeData TransformFinalBlock;
};

struct ICryptoTransform__StaticFields {
};

struct ICryptoTransform__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ICryptoTransform__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ICryptoTransform__VTable vtable;
};

struct RC4__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData get_BlockSize;
    VirtualInvokeData set_BlockSize;
    VirtualInvokeData get_FeedbackSize;
    VirtualInvokeData set_FeedbackSize;
    VirtualInvokeData get_IV;
    VirtualInvokeData set_IV;
    VirtualInvokeData get_Key;
    VirtualInvokeData set_Key;
    VirtualInvokeData get_LegalBlockSizes;
    VirtualInvokeData get_LegalKeySizes;
    VirtualInvokeData get_KeySize;
    VirtualInvokeData set_KeySize;
    VirtualInvokeData get_Mode;
    VirtualInvokeData set_Mode;
    VirtualInvokeData get_Padding;
    VirtualInvokeData set_Padding;
    VirtualInvokeData CreateEncryptor;
    VirtualInvokeData __unknown;
    VirtualInvokeData CreateDecryptor;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData __unknown_3;
};

struct RC4__StaticFields {
    struct KeySizes__Array *s_legalBlockSizes;
    struct KeySizes__Array *s_legalKeySizes;
};

struct RC4__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RC4__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RC4__VTable vtable;
};

struct ARC4Managed__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData get_BlockSize;
    VirtualInvokeData set_BlockSize;
    VirtualInvokeData get_FeedbackSize;
    VirtualInvokeData set_FeedbackSize;
    VirtualInvokeData get_IV;
    VirtualInvokeData set_IV;
    VirtualInvokeData get_Key;
    VirtualInvokeData set_Key;
    VirtualInvokeData get_LegalBlockSizes;
    VirtualInvokeData get_LegalKeySizes;
    VirtualInvokeData get_KeySize;
    VirtualInvokeData set_KeySize;
    VirtualInvokeData get_Mode;
    VirtualInvokeData set_Mode;
    VirtualInvokeData get_Padding;
    VirtualInvokeData set_Padding;
    VirtualInvokeData CreateEncryptor;
    VirtualInvokeData CreateEncryptor_1;
    VirtualInvokeData CreateDecryptor;
    VirtualInvokeData CreateDecryptor_1;
    VirtualInvokeData GenerateKey;
    VirtualInvokeData GenerateIV;
    VirtualInvokeData get_InputBlockSize;
    VirtualInvokeData get_OutputBlockSize;
    VirtualInvokeData get_CanTransformMultipleBlocks;
    VirtualInvokeData get_CanReuseTransform;
    VirtualInvokeData TransformBlock;
    VirtualInvokeData TransformFinalBlock;
};

struct ARC4Managed__StaticFields {
};

struct ARC4Managed__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ARC4Managed__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ARC4Managed__VTable vtable;
};

struct SymmetricAlgorithm__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData get_BlockSize;
    VirtualInvokeData set_BlockSize;
    VirtualInvokeData get_FeedbackSize;
    VirtualInvokeData set_FeedbackSize;
    VirtualInvokeData get_IV;
    VirtualInvokeData set_IV;
    VirtualInvokeData get_Key;
    VirtualInvokeData set_Key;
    VirtualInvokeData get_LegalBlockSizes;
    VirtualInvokeData get_LegalKeySizes;
    VirtualInvokeData get_KeySize;
    VirtualInvokeData set_KeySize;
    VirtualInvokeData get_Mode;
    VirtualInvokeData set_Mode;
    VirtualInvokeData get_Padding;
    VirtualInvokeData set_Padding;
    VirtualInvokeData CreateEncryptor;
    VirtualInvokeData __unknown;
    VirtualInvokeData CreateDecryptor;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData __unknown_3;
};

struct SymmetricAlgorithm__StaticFields {
};

struct SymmetricAlgorithm__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SymmetricAlgorithm__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SymmetricAlgorithm__VTable vtable;
};

struct __declspec(align(8)) PKCS8_PrivateKeyInfo__Fields {
    int32_t _version;
    struct String *_algorithm;
    struct Byte__Array *_key;
    struct ArrayList *_list;
};

struct PKCS8_PrivateKeyInfo {
    struct PKCS8_PrivateKeyInfo__Class *klass;
    MonitorData *monitor;
    struct PKCS8_PrivateKeyInfo__Fields fields;
};

struct PKCS8_PrivateKeyInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct PKCS8_PrivateKeyInfo__StaticFields {
};

struct PKCS8_PrivateKeyInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PKCS8_PrivateKeyInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PKCS8_PrivateKeyInfo__VTable vtable;
};

struct __declspec(align(8)) PKCS12_DeriveBytes__Fields {
    struct String *_hashName;
    int32_t _iterations;
    struct Byte__Array *_password;
    struct Byte__Array *_salt;
};

struct PKCS12_DeriveBytes {
    struct PKCS12_DeriveBytes__Class *klass;
    MonitorData *monitor;
    struct PKCS12_DeriveBytes__Fields fields;
};

struct PKCS12_DeriveBytes__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct PKCS12_DeriveBytes__StaticFields {
    struct Byte__Array *keyDiversifier;
    struct Byte__Array *ivDiversifier;
    struct Byte__Array *macDiversifier;
};

struct PKCS12_DeriveBytes__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PKCS12_DeriveBytes__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PKCS12_DeriveBytes__VTable vtable;
};

struct X501 {
    struct X501__Class *klass;
    MonitorData *monitor;
};

struct X501__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct X501__StaticFields {
    struct Byte__Array *countryName;
    struct Byte__Array *organizationName;
    struct Byte__Array *organizationalUnitName;
    struct Byte__Array *commonName;
    struct Byte__Array *localityName;
    struct Byte__Array *stateOrProvinceName;
    struct Byte__Array *streetAddress;
    struct Byte__Array *domainComponent;
    struct Byte__Array *userid;
    struct Byte__Array *email;
    struct Byte__Array *dnQualifier;
    struct Byte__Array *title;
    struct Byte__Array *surname;
    struct Byte__Array *givenName;
    struct Byte__Array *initial;
};

struct X501__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X501__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X501__VTable vtable;
};

struct __declspec(align(8)) X520_AttributeTypeAndValue__Fields {
    struct String *oid;
    struct String *attrValue;
    int32_t upperBound;
    uint8_t encoding;
};

struct X520_AttributeTypeAndValue {
    struct X520_AttributeTypeAndValue__Class *klass;
    MonitorData *monitor;
    struct X520_AttributeTypeAndValue__Fields fields;
};

struct X520_AttributeTypeAndValue__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct X520_AttributeTypeAndValue__StaticFields {
};

struct X520_AttributeTypeAndValue__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X520_AttributeTypeAndValue__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X520_AttributeTypeAndValue__VTable vtable;
};

struct __declspec(align(8)) X509Crl__Fields {
    struct String *issuer;
    uint8_t version;
    struct DateTime thisUpdate;
    struct DateTime nextUpdate;
    struct ArrayList *entries;
    struct String *signatureOID;
    struct Byte__Array *signature;
    struct X509ExtensionCollection *extensions;
    struct Byte__Array *encoded;
    struct Byte__Array *hash_value;
};

struct X509Crl {
    struct X509Crl__Class *klass;
    MonitorData *monitor;
    struct X509Crl__Fields fields;
};

struct X509Crl__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct X509Crl__StaticFields {
};

struct X509Crl__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X509Crl__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X509Crl__VTable vtable;
};

struct __declspec(align(8)) X509Crl_X509CrlEntry__Fields {
    struct Byte__Array *sn;
    struct DateTime revocationDate;
    struct X509ExtensionCollection *extensions;
};

struct X509Crl_X509CrlEntry {
    struct X509Crl_X509CrlEntry__Class *klass;
    MonitorData *monitor;
    struct X509Crl_X509CrlEntry__Fields fields;
};

struct X509Crl_X509CrlEntry__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct X509Crl_X509CrlEntry__StaticFields {
};

struct X509Crl_X509CrlEntry__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X509Crl_X509CrlEntry__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X509Crl_X509CrlEntry__VTable vtable;
};

struct X509Certificate_1__Array {
    struct X509Certificate_1__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct X509Certificate_1 *vector[32];
};

struct X509Certificate_1__Array__VTable {
};

struct X509Certificate_1__Array__StaticFields {
};

struct X509Certificate_1__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X509Certificate_1__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X509Certificate_1__Array__VTable vtable;
};

struct __declspec(align(8)) X509CertificateCollection_X509CertificateEnumerator__Fields {
    struct IEnumerator *enumerator;
};

struct X509CertificateCollection_X509CertificateEnumerator {
    struct X509CertificateCollection_X509CertificateEnumerator__Class *klass;
    MonitorData *monitor;
    struct X509CertificateCollection_X509CertificateEnumerator__Fields fields;
};

struct X509CertificateCollection_X509CertificateEnumerator__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Collections_IEnumerator_MoveNext;
    VirtualInvokeData System_Collections_IEnumerator_get_Current;
    VirtualInvokeData System_Collections_IEnumerator_Reset;
};

struct X509CertificateCollection_X509CertificateEnumerator__StaticFields {
};

struct X509CertificateCollection_X509CertificateEnumerator__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X509CertificateCollection_X509CertificateEnumerator__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X509CertificateCollection_X509CertificateEnumerator__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum X509ChainStatusFlags__Enum : int32_t {
    X509ChainStatusFlags__Enum_InvalidBasicConstraints = 0x00000400,
    X509ChainStatusFlags__Enum_NoError = 0x00000000,
    X509ChainStatusFlags__Enum_NotSignatureValid = 0x00000008,
    X509ChainStatusFlags__Enum_NotTimeNested = 0x00000002,
    X509ChainStatusFlags__Enum_NotTimeValid = 0x00000001,
    X509ChainStatusFlags__Enum_PartialChain = 0x00010000,
    X509ChainStatusFlags__Enum_UntrustedRoot = 0x00000020,
};

#else
enum X509ChainStatusFlags__Enum {
    X509ChainStatusFlags__Enum_InvalidBasicConstraints = 0x00000400,
    X509ChainStatusFlags__Enum_NoError = 0x00000000,
    X509ChainStatusFlags__Enum_NotSignatureValid = 0x00000008,
    X509ChainStatusFlags__Enum_NotTimeNested = 0x00000002,
    X509ChainStatusFlags__Enum_NotTimeValid = 0x00000001,
    X509ChainStatusFlags__Enum_PartialChain = 0x00010000,
    X509ChainStatusFlags__Enum_UntrustedRoot = 0x00000020,
};

#endif
struct X509ChainStatusFlags__Enum__Boxed {
    struct X509ChainStatusFlags__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum X509ChainStatusFlags__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) X509Chain__Fields {
    struct X509CertificateCollection *roots;
    struct X509CertificateCollection *certs;
    struct X509Certificate_1 *_root;
    struct X509CertificateCollection *_chain;
    #if defined(_CPLUSPLUS_)
    enum X509ChainStatusFlags__Enum _status;
    #else
    uint32_t _status;
    #endif
};

struct X509Chain {
    struct X509Chain__Class *klass;
    MonitorData *monitor;
    struct X509Chain__Fields fields;
};

struct X509ChainStatusFlags__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct X509ChainStatusFlags__Enum__StaticFields {
};

struct X509ChainStatusFlags__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X509ChainStatusFlags__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X509ChainStatusFlags__Enum__VTable vtable;
};

struct X509Chain__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct X509Chain__StaticFields {
};

struct X509Chain__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X509Chain__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X509Chain__VTable vtable;
};

struct __declspec(align(8)) X509Extension__Fields {
    struct String *extnOid;
    bool extnCritical;
    struct ASN1 *extnValue;
};

struct X509Extension {
    struct X509Extension__Class *klass;
    MonitorData *monitor;
    struct X509Extension__Fields fields;
};

struct X509Extension__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Decode;
    VirtualInvokeData Encode;
    VirtualInvokeData get_Name;
};

struct X509Extension__StaticFields {
};

struct X509Extension__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X509Extension__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X509Extension__VTable vtable;
};

struct X509Extension__Array {
    struct X509Extension__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct X509Extension *vector[32];
};

struct X509Extension__Array__VTable {
};

struct X509Extension__Array__StaticFields {
};

struct X509Extension__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X509Extension__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X509Extension__Array__VTable vtable;
};

struct __declspec(align(8)) X509Store__Fields {
    struct String *_storePath;
    struct X509CertificateCollection *_certificates;
    struct ArrayList *_crls;
    bool _crl;
    bool _newFormat;
    struct String *_name;
};

struct X509Store {
    struct X509Store__Class *klass;
    MonitorData *monitor;
    struct X509Store__Fields fields;
};

struct X509Store__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct X509Store__StaticFields {
};

struct X509Store__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X509Store__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X509Store__VTable vtable;
};

struct X509StoreManager {
    struct X509StoreManager__Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) X509Stores__Fields {
    struct String *_storePath;
    bool _newFormat;
    struct X509Store *_personal;
    struct X509Store *_other;
    struct X509Store *_intermediate;
    struct X509Store *_trusted;
    struct X509Store *_untrusted;
};

struct X509Stores {
    struct X509Stores__Class *klass;
    MonitorData *monitor;
    struct X509Stores__Fields fields;
};

struct X509Stores__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct X509Stores__StaticFields {
};

struct X509Stores__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X509Stores__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X509Stores__VTable vtable;
};

struct X509StoreManager__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct X509StoreManager__StaticFields {
    struct String *_userPath;
    struct String *_localMachinePath;
    struct String *_newUserPath;
    struct String *_newLocalMachinePath;
    struct X509Stores *_userStore;
    struct X509Stores *_machineStore;
    struct X509Stores *_newUserStore;
    struct X509Stores *_newMachineStore;
};

struct X509StoreManager__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X509StoreManager__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X509StoreManager__VTable vtable;
};

struct X509Stores_Names {
    struct X509Stores_Names__Class *klass;
    MonitorData *monitor;
};

struct X509Stores_Names__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct X509Stores_Names__StaticFields {
};

struct X509Stores_Names__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X509Stores_Names__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X509Stores_Names__VTable vtable;
};

struct X520 {
    struct X520__Class *klass;
    MonitorData *monitor;
};

struct X520__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct X520__StaticFields {
};

struct X520__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X520__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X520__VTable vtable;
};

struct X520_Name__Fields {
    struct X520_AttributeTypeAndValue__Fields _;
};

struct X520_Name {
    struct X520_Name__Class *klass;
    MonitorData *monitor;
    struct X520_Name__Fields fields;
};

struct X520_Name__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct X520_Name__StaticFields {
};

struct X520_Name__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X520_Name__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X520_Name__VTable vtable;
};

struct X520_CommonName__Fields {
    struct X520_AttributeTypeAndValue__Fields _;
};

struct X520_CommonName {
    struct X520_CommonName__Class *klass;
    MonitorData *monitor;
    struct X520_CommonName__Fields fields;
};

struct X520_CommonName__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct X520_CommonName__StaticFields {
};

struct X520_CommonName__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X520_CommonName__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X520_CommonName__VTable vtable;
};

struct X520_SerialNumber__Fields {
    struct X520_AttributeTypeAndValue__Fields _;
};

struct X520_SerialNumber {
    struct X520_SerialNumber__Class *klass;
    MonitorData *monitor;
    struct X520_SerialNumber__Fields fields;
};

struct X520_SerialNumber__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct X520_SerialNumber__StaticFields {
};

struct X520_SerialNumber__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X520_SerialNumber__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X520_SerialNumber__VTable vtable;
};

struct X520_LocalityName__Fields {
    struct X520_AttributeTypeAndValue__Fields _;
};

struct X520_LocalityName {
    struct X520_LocalityName__Class *klass;
    MonitorData *monitor;
    struct X520_LocalityName__Fields fields;
};

struct X520_LocalityName__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct X520_LocalityName__StaticFields {
};

struct X520_LocalityName__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X520_LocalityName__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X520_LocalityName__VTable vtable;
};

struct X520_StateOrProvinceName__Fields {
    struct X520_AttributeTypeAndValue__Fields _;
};

struct X520_StateOrProvinceName {
    struct X520_StateOrProvinceName__Class *klass;
    MonitorData *monitor;
    struct X520_StateOrProvinceName__Fields fields;
};

struct X520_StateOrProvinceName__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct X520_StateOrProvinceName__StaticFields {
};

struct X520_StateOrProvinceName__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X520_StateOrProvinceName__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X520_StateOrProvinceName__VTable vtable;
};

struct X520_OrganizationName__Fields {
    struct X520_AttributeTypeAndValue__Fields _;
};

struct X520_OrganizationName {
    struct X520_OrganizationName__Class *klass;
    MonitorData *monitor;
    struct X520_OrganizationName__Fields fields;
};

struct X520_OrganizationName__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct X520_OrganizationName__StaticFields {
};

struct X520_OrganizationName__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X520_OrganizationName__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X520_OrganizationName__VTable vtable;
};

struct X520_OrganizationalUnitName__Fields {
    struct X520_AttributeTypeAndValue__Fields _;
};

struct X520_OrganizationalUnitName {
    struct X520_OrganizationalUnitName__Class *klass;
    MonitorData *monitor;
    struct X520_OrganizationalUnitName__Fields fields;
};

struct X520_OrganizationalUnitName__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct X520_OrganizationalUnitName__StaticFields {
};

struct X520_OrganizationalUnitName__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X520_OrganizationalUnitName__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X520_OrganizationalUnitName__VTable vtable;
};

struct X520_EmailAddress__Fields {
    struct X520_AttributeTypeAndValue__Fields _;
};

struct X520_EmailAddress {
    struct X520_EmailAddress__Class *klass;
    MonitorData *monitor;
    struct X520_EmailAddress__Fields fields;
};

struct X520_EmailAddress__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct X520_EmailAddress__StaticFields {
};

struct X520_EmailAddress__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X520_EmailAddress__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X520_EmailAddress__VTable vtable;
};

struct X520_DomainComponent__Fields {
    struct X520_AttributeTypeAndValue__Fields _;
};

struct X520_DomainComponent {
    struct X520_DomainComponent__Class *klass;
    MonitorData *monitor;
    struct X520_DomainComponent__Fields fields;
};

struct X520_DomainComponent__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct X520_DomainComponent__StaticFields {
};

struct X520_DomainComponent__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X520_DomainComponent__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X520_DomainComponent__VTable vtable;
};

struct X520_UserId__Fields {
    struct X520_AttributeTypeAndValue__Fields _;
};

struct X520_UserId {
    struct X520_UserId__Class *klass;
    MonitorData *monitor;
    struct X520_UserId__Fields fields;
};

struct X520_UserId__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct X520_UserId__StaticFields {
};

struct X520_UserId__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X520_UserId__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X520_UserId__VTable vtable;
};

struct X520_Oid__Fields {
    struct X520_AttributeTypeAndValue__Fields _;
};

struct X520_Oid {
    struct X520_Oid__Class *klass;
    MonitorData *monitor;
    struct X520_Oid__Fields fields;
};

struct X520_Oid__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct X520_Oid__StaticFields {
};

struct X520_Oid__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X520_Oid__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X520_Oid__VTable vtable;
};

struct X520_Title__Fields {
    struct X520_AttributeTypeAndValue__Fields _;
};

struct X520_Title {
    struct X520_Title__Class *klass;
    MonitorData *monitor;
    struct X520_Title__Fields fields;
};

struct X520_Title__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct X520_Title__StaticFields {
};

struct X520_Title__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X520_Title__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X520_Title__VTable vtable;
};

struct X520_CountryName__Fields {
    struct X520_AttributeTypeAndValue__Fields _;
};

struct X520_CountryName {
    struct X520_CountryName__Class *klass;
    MonitorData *monitor;
    struct X520_CountryName__Fields fields;
};

struct X520_CountryName__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct X520_CountryName__StaticFields {
};

struct X520_CountryName__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X520_CountryName__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X520_CountryName__VTable vtable;
};

struct X520_DnQualifier__Fields {
    struct X520_AttributeTypeAndValue__Fields _;
};

struct X520_DnQualifier {
    struct X520_DnQualifier__Class *klass;
    MonitorData *monitor;
    struct X520_DnQualifier__Fields fields;
};

struct X520_DnQualifier__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct X520_DnQualifier__StaticFields {
};

struct X520_DnQualifier__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X520_DnQualifier__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X520_DnQualifier__VTable vtable;
};

struct X520_Surname__Fields {
    struct X520_AttributeTypeAndValue__Fields _;
};

struct X520_Surname {
    struct X520_Surname__Class *klass;
    MonitorData *monitor;
    struct X520_Surname__Fields fields;
};

struct X520_Surname__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct X520_Surname__StaticFields {
};

struct X520_Surname__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X520_Surname__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X520_Surname__VTable vtable;
};

struct X520_GivenName__Fields {
    struct X520_AttributeTypeAndValue__Fields _;
};

struct X520_GivenName {
    struct X520_GivenName__Class *klass;
    MonitorData *monitor;
    struct X520_GivenName__Fields fields;
};

struct X520_GivenName__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct X520_GivenName__StaticFields {
};

struct X520_GivenName__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X520_GivenName__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X520_GivenName__VTable vtable;
};

struct X520_Initial__Fields {
    struct X520_AttributeTypeAndValue__Fields _;
};

struct X520_Initial {
    struct X520_Initial__Class *klass;
    MonitorData *monitor;
    struct X520_Initial__Fields fields;
};

struct X520_Initial__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct X520_Initial__StaticFields {
};

struct X520_Initial__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct X520_Initial__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct X520_Initial__VTable vtable;
};

struct BasicConstraintsExtension__Fields {
    struct X509Extension__Fields _;
    bool cA;
    int32_t pathLenConstraint;
};

struct BasicConstraintsExtension {
    struct BasicConstraintsExtension__Class *klass;
    MonitorData *monitor;
    struct BasicConstraintsExtension__Fields fields;
};

struct BasicConstraintsExtension__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Decode;
    VirtualInvokeData Encode;
    VirtualInvokeData get_Name;
};

struct BasicConstraintsExtension__StaticFields {
};

struct BasicConstraintsExtension__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct BasicConstraintsExtension__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct BasicConstraintsExtension__VTable vtable;
};

struct KeyUsageExtension__Fields {
    struct X509Extension__Fields _;
    int32_t kubits;
};

struct KeyUsageExtension {
    struct KeyUsageExtension__Class *klass;
    MonitorData *monitor;
    struct KeyUsageExtension__Fields fields;
};

struct KeyUsageExtension__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Decode;
    VirtualInvokeData Encode;
    VirtualInvokeData get_Name;
};

struct KeyUsageExtension__StaticFields {
};

struct KeyUsageExtension__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyUsageExtension__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyUsageExtension__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum KeyUsages__Enum : int32_t {
    KeyUsages__Enum_digitalSignature = 0x00000080,
    KeyUsages__Enum_nonRepudiation = 0x00000040,
    KeyUsages__Enum_keyEncipherment = 0x00000020,
    KeyUsages__Enum_dataEncipherment = 0x00000010,
    KeyUsages__Enum_keyAgreement = 0x00000008,
    KeyUsages__Enum_keyCertSign = 0x00000004,
    KeyUsages__Enum_cRLSign = 0x00000002,
    KeyUsages__Enum_encipherOnly = 0x00000001,
    KeyUsages__Enum_decipherOnly = 0x00000800,
    KeyUsages__Enum_none = 0x00000000,
};

#else
enum KeyUsages__Enum {
    KeyUsages__Enum_digitalSignature = 0x00000080,
    KeyUsages__Enum_nonRepudiation = 0x00000040,
    KeyUsages__Enum_keyEncipherment = 0x00000020,
    KeyUsages__Enum_dataEncipherment = 0x00000010,
    KeyUsages__Enum_keyAgreement = 0x00000008,
    KeyUsages__Enum_keyCertSign = 0x00000004,
    KeyUsages__Enum_cRLSign = 0x00000002,
    KeyUsages__Enum_encipherOnly = 0x00000001,
    KeyUsages__Enum_decipherOnly = 0x00000800,
    KeyUsages__Enum_none = 0x00000000,
};

#endif
struct KeyUsages__Enum__Boxed {
    struct KeyUsages__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum KeyUsages__Enum value;
    #else
    uint32_t value;
    #endif
};

struct KeyUsages__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct KeyUsages__Enum__StaticFields {
};

struct KeyUsages__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyUsages__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyUsages__Enum__VTable vtable;
};

struct SubjectKeyIdentifierExtension__Fields {
    struct X509Extension__Fields _;
    struct Byte__Array *ski;
};

struct SubjectKeyIdentifierExtension {
    struct SubjectKeyIdentifierExtension__Class *klass;
    MonitorData *monitor;
    struct SubjectKeyIdentifierExtension__Fields fields;
};

struct SubjectKeyIdentifierExtension__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Decode;
    VirtualInvokeData Encode;
    VirtualInvokeData get_Name;
};

struct SubjectKeyIdentifierExtension__StaticFields {
};

struct SubjectKeyIdentifierExtension__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SubjectKeyIdentifierExtension__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SubjectKeyIdentifierExtension__VTable vtable;
};

struct CryptoConvert {
    struct CryptoConvert__Class *klass;
    MonitorData *monitor;
};

struct CryptoConvert__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct CryptoConvert__StaticFields {
};

struct CryptoConvert__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CryptoConvert__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CryptoConvert__VTable vtable;
};

struct KeyBuilder {
    struct KeyBuilder__Class *klass;
    MonitorData *monitor;
};

struct KeyBuilder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct KeyBuilder__StaticFields {
    struct RandomNumberGenerator *rng;
};

struct KeyBuilder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyBuilder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyBuilder__VTable vtable;
};

struct __declspec(align(8)) BlockProcessor__Fields {
    struct ICryptoTransform *transform;
    struct Byte__Array *block;
    int32_t blockSize;
    int32_t blockCount;
};

struct BlockProcessor {
    struct BlockProcessor__Class *klass;
    MonitorData *monitor;
    struct BlockProcessor__Fields fields;
};

struct BlockProcessor__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct BlockProcessor__StaticFields {
};

struct BlockProcessor__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct BlockProcessor__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct BlockProcessor__VTable vtable;
};

struct __declspec(align(8)) KeyPairPersistence__Fields {
    struct CspParameters *_params;
    struct String *_keyvalue;
    struct String *_filename;
    struct String *_container;
};

struct KeyPairPersistence {
    struct KeyPairPersistence__Class *klass;
    MonitorData *monitor;
    struct KeyPairPersistence__Fields fields;
};

struct __declspec(align(8)) CspParameters__Fields {
    int32_t ProviderType;
    struct String *ProviderName;
    struct String *KeyContainerName;
    int32_t KeyNumber;
    int32_t m_flags;
    struct CryptoKeySecurity *m_cryptoKeySecurity;
    struct SecureString *m_keyPassword;
    void *m_parentWindowHandle;
};

struct CspParameters {
    struct CspParameters__Class *klass;
    MonitorData *monitor;
    struct CspParameters__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum AccessControlSections__Enum : int32_t {
    AccessControlSections__Enum_None = 0x00000000,
    AccessControlSections__Enum_Audit = 0x00000001,
    AccessControlSections__Enum_Access = 0x00000002,
    AccessControlSections__Enum_Owner = 0x00000004,
    AccessControlSections__Enum_Group = 0x00000008,
    AccessControlSections__Enum_All = 0x0000000f,
};

#else
enum AccessControlSections__Enum {
    AccessControlSections__Enum_None = 0x00000000,
    AccessControlSections__Enum_Audit = 0x00000001,
    AccessControlSections__Enum_Access = 0x00000002,
    AccessControlSections__Enum_Owner = 0x00000004,
    AccessControlSections__Enum_Group = 0x00000008,
    AccessControlSections__Enum_All = 0x0000000f,
};

#endif
struct AccessControlSections__Enum__Boxed {
    struct AccessControlSections__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum AccessControlSections__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) ObjectSecurity__Fields {
    struct CommonSecurityDescriptor *descriptor;
    #if defined(_CPLUSPLUS_)
    enum AccessControlSections__Enum sections_modified;
    #else
    uint32_t sections_modified;
    #endif
    struct ReaderWriterLock *rw_lock;
};

struct ObjectSecurity {
    struct ObjectSecurity__Class *klass;
    MonitorData *monitor;
    struct ObjectSecurity__Fields fields;
};

struct CommonObjectSecurity__Fields {
    struct ObjectSecurity__Fields _;
};

struct CommonObjectSecurity {
    struct CommonObjectSecurity__Class *klass;
    MonitorData *monitor;
    struct CommonObjectSecurity__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum ResourceType__Enum : int32_t {
    ResourceType__Enum_Unknown = 0x00000000,
    ResourceType__Enum_FileObject = 0x00000001,
    ResourceType__Enum_Service = 0x00000002,
    ResourceType__Enum_Printer = 0x00000003,
    ResourceType__Enum_RegistryKey = 0x00000004,
    ResourceType__Enum_LMShare = 0x00000005,
    ResourceType__Enum_KernelObject = 0x00000006,
    ResourceType__Enum_WindowObject = 0x00000007,
    ResourceType__Enum_DSObject = 0x00000008,
    ResourceType__Enum_DSObjectAll = 0x00000009,
    ResourceType__Enum_ProviderDefined = 0x0000000a,
    ResourceType__Enum_WmiGuidObject = 0x0000000b,
    ResourceType__Enum_RegistryWow6432Key = 0x0000000c,
};

#else
enum ResourceType__Enum {
    ResourceType__Enum_Unknown = 0x00000000,
    ResourceType__Enum_FileObject = 0x00000001,
    ResourceType__Enum_Service = 0x00000002,
    ResourceType__Enum_Printer = 0x00000003,
    ResourceType__Enum_RegistryKey = 0x00000004,
    ResourceType__Enum_LMShare = 0x00000005,
    ResourceType__Enum_KernelObject = 0x00000006,
    ResourceType__Enum_WindowObject = 0x00000007,
    ResourceType__Enum_DSObject = 0x00000008,
    ResourceType__Enum_DSObjectAll = 0x00000009,
    ResourceType__Enum_ProviderDefined = 0x0000000a,
    ResourceType__Enum_WmiGuidObject = 0x0000000b,
    ResourceType__Enum_RegistryWow6432Key = 0x0000000c,
};

#endif
struct ResourceType__Enum__Boxed {
    struct ResourceType__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum ResourceType__Enum value;
    #else
    uint32_t value;
    #endif
};

struct NativeObjectSecurity__Fields {
    struct CommonObjectSecurity__Fields _;
    struct NativeObjectSecurity_ExceptionFromErrorCode *exception_from_error_code;
    #if defined(_CPLUSPLUS_)
    enum ResourceType__Enum resource_type;
    #else
    uint32_t resource_type;
    #endif
};

struct NativeObjectSecurity {
    struct NativeObjectSecurity__Class *klass;
    MonitorData *monitor;
    struct NativeObjectSecurity__Fields fields;
};

struct CryptoKeySecurity__Fields {
    struct NativeObjectSecurity__Fields _;
};

struct CryptoKeySecurity {
    struct CryptoKeySecurity__Class *klass;
    MonitorData *monitor;
    struct CryptoKeySecurity__Fields fields;
};

struct GenericSecurityDescriptor {
    struct GenericSecurityDescriptor__Class *klass;
    MonitorData *monitor;
};

#if defined(_CPLUSPLUS_)
enum ControlFlags__Enum : int32_t {
    ControlFlags__Enum_None = 0x00000000,
    ControlFlags__Enum_OwnerDefaulted = 0x00000001,
    ControlFlags__Enum_GroupDefaulted = 0x00000002,
    ControlFlags__Enum_DiscretionaryAclPresent = 0x00000004,
    ControlFlags__Enum_DiscretionaryAclDefaulted = 0x00000008,
    ControlFlags__Enum_SystemAclPresent = 0x00000010,
    ControlFlags__Enum_SystemAclDefaulted = 0x00000020,
    ControlFlags__Enum_DiscretionaryAclUntrusted = 0x00000040,
    ControlFlags__Enum_ServerSecurity = 0x00000080,
    ControlFlags__Enum_DiscretionaryAclAutoInheritRequired = 0x00000100,
    ControlFlags__Enum_SystemAclAutoInheritRequired = 0x00000200,
    ControlFlags__Enum_DiscretionaryAclAutoInherited = 0x00000400,
    ControlFlags__Enum_SystemAclAutoInherited = 0x00000800,
    ControlFlags__Enum_DiscretionaryAclProtected = 0x00001000,
    ControlFlags__Enum_SystemAclProtected = 0x00002000,
    ControlFlags__Enum_RMControlValid = 0x00004000,
    ControlFlags__Enum_SelfRelative = 0x00008000,
};

#else
enum ControlFlags__Enum {
    ControlFlags__Enum_None = 0x00000000,
    ControlFlags__Enum_OwnerDefaulted = 0x00000001,
    ControlFlags__Enum_GroupDefaulted = 0x00000002,
    ControlFlags__Enum_DiscretionaryAclPresent = 0x00000004,
    ControlFlags__Enum_DiscretionaryAclDefaulted = 0x00000008,
    ControlFlags__Enum_SystemAclPresent = 0x00000010,
    ControlFlags__Enum_SystemAclDefaulted = 0x00000020,
    ControlFlags__Enum_DiscretionaryAclUntrusted = 0x00000040,
    ControlFlags__Enum_ServerSecurity = 0x00000080,
    ControlFlags__Enum_DiscretionaryAclAutoInheritRequired = 0x00000100,
    ControlFlags__Enum_SystemAclAutoInheritRequired = 0x00000200,
    ControlFlags__Enum_DiscretionaryAclAutoInherited = 0x00000400,
    ControlFlags__Enum_SystemAclAutoInherited = 0x00000800,
    ControlFlags__Enum_DiscretionaryAclProtected = 0x00001000,
    ControlFlags__Enum_SystemAclProtected = 0x00002000,
    ControlFlags__Enum_RMControlValid = 0x00004000,
    ControlFlags__Enum_SelfRelative = 0x00008000,
};

#endif
struct ControlFlags__Enum__Boxed {
    struct ControlFlags__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum ControlFlags__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) CommonSecurityDescriptor__Fields {
    bool is_container;
    bool is_ds;
    #if defined(_CPLUSPLUS_)
    enum ControlFlags__Enum flags;
    #else
    uint32_t flags;
    #endif
    struct SecurityIdentifier *owner;
    struct SecurityIdentifier *group;
    struct SystemAcl *system_acl;
    struct DiscretionaryAcl *discretionary_acl;
};

struct CommonSecurityDescriptor {
    struct CommonSecurityDescriptor__Class *klass;
    MonitorData *monitor;
    struct CommonSecurityDescriptor__Fields fields;
};

struct IdentityReference {
    struct IdentityReference__Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) SecurityIdentifier__Fields {
    struct Byte__Array *buffer;
};

struct SecurityIdentifier {
    struct SecurityIdentifier__Class *klass;
    MonitorData *monitor;
    struct SecurityIdentifier__Fields fields;
};

struct __declspec(align(8)) NTAccount__Fields {
    struct String *_value;
};

struct NTAccount {
    struct NTAccount__Class *klass;
    MonitorData *monitor;
    struct NTAccount__Fields fields;
};

struct GenericAcl {
    struct GenericAcl__Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) CommonAcl__Fields {
    bool is_aefa;
    bool is_canonical;
    bool is_container;
    bool is_ds;
    struct RawAcl *raw_acl;
};

struct CommonAcl {
    struct CommonAcl__Class *klass;
    MonitorData *monitor;
    struct CommonAcl__Fields fields;
};

struct __declspec(align(8)) RawAcl__Fields {
    uint8_t revision;
    struct List_1_System_Security_AccessControl_GenericAce_ *list;
};

struct RawAcl {
    struct RawAcl__Class *klass;
    MonitorData *monitor;
    struct RawAcl__Fields fields;
};

struct __declspec(align(8)) List_1_System_Security_AccessControl_GenericAce___Fields {
    struct GenericAce__Array *_items;
    int32_t _size;
    int32_t _version;
    struct Object *_syncRoot;
};

struct List_1_System_Security_AccessControl_GenericAce_ {
    struct List_1_System_Security_AccessControl_GenericAce___Class *klass;
    MonitorData *monitor;
    struct List_1_System_Security_AccessControl_GenericAce___Fields fields;
};

#if defined(_CPLUSPLUS_)
enum AceFlags__Enum : uint8_t {
    AceFlags__Enum_None = 0x00000000,
    AceFlags__Enum_ObjectInherit = 0x00000001,
    AceFlags__Enum_ContainerInherit = 0x00000002,
    AceFlags__Enum_NoPropagateInherit = 0x00000004,
    AceFlags__Enum_InheritOnly = 0x00000008,
    AceFlags__Enum_InheritanceFlags = 0x0000000f,
    AceFlags__Enum_Inherited = 0x00000010,
    AceFlags__Enum_SuccessfulAccess = 0x00000040,
    AceFlags__Enum_FailedAccess = 0x00000080,
    AceFlags__Enum_AuditFlags = 0x000000c0,
};

#else
enum AceFlags__Enum {
    AceFlags__Enum_None = 0x00000000,
    AceFlags__Enum_ObjectInherit = 0x00000001,
    AceFlags__Enum_ContainerInherit = 0x00000002,
    AceFlags__Enum_NoPropagateInherit = 0x00000004,
    AceFlags__Enum_InheritOnly = 0x00000008,
    AceFlags__Enum_InheritanceFlags = 0x0000000f,
    AceFlags__Enum_Inherited = 0x00000010,
    AceFlags__Enum_SuccessfulAccess = 0x00000040,
    AceFlags__Enum_FailedAccess = 0x00000080,
    AceFlags__Enum_AuditFlags = 0x000000c0,
};

#endif
struct AceFlags__Enum__Boxed {
    struct AceFlags__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum AceFlags__Enum value;
    #else
    uint8_t value;
    #endif
};

#if defined(_CPLUSPLUS_)
enum AceType__Enum : uint8_t {
    AceType__Enum_AccessAllowed = 0x00000000,
    AceType__Enum_AccessDenied = 0x00000001,
    AceType__Enum_SystemAudit = 0x00000002,
    AceType__Enum_SystemAlarm = 0x00000003,
    AceType__Enum_AccessAllowedCompound = 0x00000004,
    AceType__Enum_AccessAllowedObject = 0x00000005,
    AceType__Enum_AccessDeniedObject = 0x00000006,
    AceType__Enum_SystemAuditObject = 0x00000007,
    AceType__Enum_SystemAlarmObject = 0x00000008,
    AceType__Enum_AccessAllowedCallback = 0x00000009,
    AceType__Enum_AccessDeniedCallback = 0x0000000a,
    AceType__Enum_AccessAllowedCallbackObject = 0x0000000b,
    AceType__Enum_AccessDeniedCallbackObject = 0x0000000c,
    AceType__Enum_SystemAuditCallback = 0x0000000d,
    AceType__Enum_SystemAlarmCallback = 0x0000000e,
    AceType__Enum_SystemAuditCallbackObject = 0x0000000f,
    AceType__Enum_SystemAlarmCallbackObject = 0x00000010,
    AceType__Enum_MaxDefinedAceType = 0x00000010,
};

#else
enum AceType__Enum {
    AceType__Enum_AccessAllowed = 0x00000000,
    AceType__Enum_AccessDenied = 0x00000001,
    AceType__Enum_SystemAudit = 0x00000002,
    AceType__Enum_SystemAlarm = 0x00000003,
    AceType__Enum_AccessAllowedCompound = 0x00000004,
    AceType__Enum_AccessAllowedObject = 0x00000005,
    AceType__Enum_AccessDeniedObject = 0x00000006,
    AceType__Enum_SystemAuditObject = 0x00000007,
    AceType__Enum_SystemAlarmObject = 0x00000008,
    AceType__Enum_AccessAllowedCallback = 0x00000009,
    AceType__Enum_AccessDeniedCallback = 0x0000000a,
    AceType__Enum_AccessAllowedCallbackObject = 0x0000000b,
    AceType__Enum_AccessDeniedCallbackObject = 0x0000000c,
    AceType__Enum_SystemAuditCallback = 0x0000000d,
    AceType__Enum_SystemAlarmCallback = 0x0000000e,
    AceType__Enum_SystemAuditCallbackObject = 0x0000000f,
    AceType__Enum_SystemAlarmCallbackObject = 0x00000010,
    AceType__Enum_MaxDefinedAceType = 0x00000010,
};

#endif
struct AceType__Enum__Boxed {
    struct AceType__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum AceType__Enum value;
    #else
    uint8_t value;
    #endif
};

struct __declspec(align(8)) GenericAce__Fields {
    #if defined(_CPLUSPLUS_)
    enum AceFlags__Enum ace_flags;
    #else
    uint8_t ace_flags;
    #endif
    #if defined(_CPLUSPLUS_)
    enum AceType__Enum ace_type;
    #else
    uint8_t ace_type;
    #endif
};

struct GenericAce {
    struct GenericAce__Class *klass;
    MonitorData *monitor;
    struct GenericAce__Fields fields;
};

struct KnownAce__Fields {
    struct GenericAce__Fields _;
    int32_t access_mask;
    struct SecurityIdentifier *identifier;
};

struct KnownAce {
    struct KnownAce__Class *klass;
    MonitorData *monitor;
    struct KnownAce__Fields fields;
};

struct QualifiedAce__Fields {
    struct KnownAce__Fields _;
    struct Byte__Array *opaque;
};

struct QualifiedAce {
    struct QualifiedAce__Class *klass;
    MonitorData *monitor;
    struct QualifiedAce__Fields fields;
};

struct CommonAce__Fields {
    struct QualifiedAce__Fields _;
};

struct CommonAce {
    struct CommonAce__Class *klass;
    MonitorData *monitor;
    struct CommonAce__Fields fields;
};

struct GenericAce__Array {
    struct GenericAce__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct GenericAce *vector[32];
};

struct IEnumerator_1_System_Security_AccessControl_GenericAce_ {
    struct IEnumerator_1_System_Security_AccessControl_GenericAce___Class *klass;
    MonitorData *monitor;
};

struct DiscretionaryAcl__Fields {
    struct CommonAcl__Fields _;
};

struct DiscretionaryAcl {
    struct DiscretionaryAcl__Class *klass;
    MonitorData *monitor;
    struct DiscretionaryAcl__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum AceQualifier__Enum : int32_t {
    AceQualifier__Enum_AccessAllowed = 0x00000000,
    AceQualifier__Enum_AccessDenied = 0x00000001,
    AceQualifier__Enum_SystemAudit = 0x00000002,
    AceQualifier__Enum_SystemAlarm = 0x00000003,
};

#else
enum AceQualifier__Enum {
    AceQualifier__Enum_AccessAllowed = 0x00000000,
    AceQualifier__Enum_AccessDenied = 0x00000001,
    AceQualifier__Enum_SystemAudit = 0x00000002,
    AceQualifier__Enum_SystemAlarm = 0x00000003,
};

#endif
struct AceQualifier__Enum__Boxed {
    struct AceQualifier__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum AceQualifier__Enum value;
    #else
    uint32_t value;
    #endif
};

struct SystemAcl__Fields {
    struct CommonAcl__Fields _;
};

struct SystemAcl {
    struct SystemAcl__Class *klass;
    MonitorData *monitor;
    struct SystemAcl__Fields fields;
};

struct __declspec(align(8)) ReaderWriterLock__Fields {
    int32_t seq_num;
    int32_t state;
    int32_t readers;
    int32_t writer_lock_owner;
    struct LockQueue *writer_queue;
    struct Hashtable *reader_locks;
};

struct ReaderWriterLock {
    struct ReaderWriterLock__Class *klass;
    MonitorData *monitor;
    struct ReaderWriterLock__Fields fields;
};

struct __declspec(align(8)) LockQueue__Fields {
    struct ReaderWriterLock *rwlock;
    int32_t lockCount;
};

struct LockQueue {
    struct LockQueue__Class *klass;
    MonitorData *monitor;
    struct LockQueue__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum InheritanceFlags__Enum : int32_t {
    InheritanceFlags__Enum_None = 0x00000000,
    InheritanceFlags__Enum_ContainerInherit = 0x00000001,
    InheritanceFlags__Enum_ObjectInherit = 0x00000002,
};

#else
enum InheritanceFlags__Enum {
    InheritanceFlags__Enum_None = 0x00000000,
    InheritanceFlags__Enum_ContainerInherit = 0x00000001,
    InheritanceFlags__Enum_ObjectInherit = 0x00000002,
};

#endif
struct InheritanceFlags__Enum__Boxed {
    struct InheritanceFlags__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum InheritanceFlags__Enum value;
    #else
    uint32_t value;
    #endif
};

#if defined(_CPLUSPLUS_)
enum PropagationFlags__Enum : int32_t {
    PropagationFlags__Enum_None = 0x00000000,
    PropagationFlags__Enum_NoPropagateInherit = 0x00000001,
    PropagationFlags__Enum_InheritOnly = 0x00000002,
};

#else
enum PropagationFlags__Enum {
    PropagationFlags__Enum_None = 0x00000000,
    PropagationFlags__Enum_NoPropagateInherit = 0x00000001,
    PropagationFlags__Enum_InheritOnly = 0x00000002,
};

#endif
struct PropagationFlags__Enum__Boxed {
    struct PropagationFlags__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum PropagationFlags__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) AuthorizationRule__Fields {
    struct IdentityReference *identity;
    int32_t accessMask;
    bool isInherited;
    #if defined(_CPLUSPLUS_)
    enum InheritanceFlags__Enum inheritanceFlags;
    #else
    uint32_t inheritanceFlags;
    #endif
    #if defined(_CPLUSPLUS_)
    enum PropagationFlags__Enum propagationFlags;
    #else
    uint32_t propagationFlags;
    #endif
};

struct AuthorizationRule {
    struct AuthorizationRule__Class *klass;
    MonitorData *monitor;
    struct AuthorizationRule__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum AccessControlType__Enum : int32_t {
    AccessControlType__Enum_Allow = 0x00000000,
    AccessControlType__Enum_Deny = 0x00000001,
};

#else
enum AccessControlType__Enum {
    AccessControlType__Enum_Allow = 0x00000000,
    AccessControlType__Enum_Deny = 0x00000001,
};

#endif
struct AccessControlType__Enum__Boxed {
    struct AccessControlType__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum AccessControlType__Enum value;
    #else
    uint32_t value;
    #endif
};

struct AccessRule__Fields {
    struct AuthorizationRule__Fields _;
    #if defined(_CPLUSPLUS_)
    enum AccessControlType__Enum type;
    #else
    uint32_t type;
    #endif
};

struct AccessRule {
    struct AccessRule__Class *klass;
    MonitorData *monitor;
    struct AccessRule__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum AuditFlags__Enum : int32_t {
    AuditFlags__Enum_None = 0x00000000,
    AuditFlags__Enum_Success = 0x00000001,
    AuditFlags__Enum_Failure = 0x00000002,
};

#else
enum AuditFlags__Enum {
    AuditFlags__Enum_None = 0x00000000,
    AuditFlags__Enum_Success = 0x00000001,
    AuditFlags__Enum_Failure = 0x00000002,
};

#endif
struct AuditFlags__Enum__Boxed {
    struct AuditFlags__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum AuditFlags__Enum value;
    #else
    uint32_t value;
    #endif
};

struct AuditRule__Fields {
    struct AuthorizationRule__Fields _;
    #if defined(_CPLUSPLUS_)
    enum AuditFlags__Enum auditFlags;
    #else
    uint32_t auditFlags;
    #endif
};

struct AuditRule {
    struct AuditRule__Class *klass;
    MonitorData *monitor;
    struct AuditRule__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum AccessControlModification__Enum : int32_t {
    AccessControlModification__Enum_Add = 0x00000000,
    AccessControlModification__Enum_Set = 0x00000001,
    AccessControlModification__Enum_Reset = 0x00000002,
    AccessControlModification__Enum_Remove = 0x00000003,
    AccessControlModification__Enum_RemoveAll = 0x00000004,
    AccessControlModification__Enum_RemoveSpecific = 0x00000005,
};

#else
enum AccessControlModification__Enum {
    AccessControlModification__Enum_Add = 0x00000000,
    AccessControlModification__Enum_Set = 0x00000001,
    AccessControlModification__Enum_Reset = 0x00000002,
    AccessControlModification__Enum_Remove = 0x00000003,
    AccessControlModification__Enum_RemoveAll = 0x00000004,
    AccessControlModification__Enum_RemoveSpecific = 0x00000005,
};

#endif
struct AccessControlModification__Enum__Boxed {
    struct AccessControlModification__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum AccessControlModification__Enum value;
    #else
    uint32_t value;
    #endif
};

struct NativeObjectSecurity_ExceptionFromErrorCode__Fields {
    struct MulticastDelegate__Fields _;
};

struct NativeObjectSecurity_ExceptionFromErrorCode {
    struct NativeObjectSecurity_ExceptionFromErrorCode__Class *klass;
    MonitorData *monitor;
    struct NativeObjectSecurity_ExceptionFromErrorCode__Fields fields;
};

struct ControlFlags__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct ControlFlags__Enum__StaticFields {
};

struct ControlFlags__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ControlFlags__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ControlFlags__Enum__VTable vtable;
};

struct NTAccount__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Value;
    VirtualInvokeData IsValidTargetType;
    VirtualInvokeData Translate;
};

struct NTAccount__StaticFields {
};

struct NTAccount__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct NTAccount__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct NTAccount__VTable vtable;
};

struct IdentityReference__VTable {
    VirtualInvokeData __unknown;
    VirtualInvokeData Finalize;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData __unknown_5;
};

struct IdentityReference__StaticFields {
};

struct IdentityReference__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IdentityReference__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IdentityReference__VTable vtable;
};

struct SecurityIdentifier__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Value;
    VirtualInvokeData IsValidTargetType;
    VirtualInvokeData Translate;
    VirtualInvokeData CompareTo;
};

struct SecurityIdentifier__StaticFields {
    int32_t MaxBinaryLength;
    int32_t MinBinaryLength;
};

struct SecurityIdentifier__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SecurityIdentifier__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SecurityIdentifier__VTable vtable;
};

struct AceFlags__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct AceFlags__Enum__StaticFields {
};

struct AceFlags__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AceFlags__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AceFlags__Enum__VTable vtable;
};

struct AceType__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct AceType__Enum__StaticFields {
};

struct AceType__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AceType__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AceType__Enum__VTable vtable;
};

struct KnownAce__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
};

struct KnownAce__StaticFields {
};

struct KnownAce__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KnownAce__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KnownAce__VTable vtable;
};

struct QualifiedAce__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
};

struct QualifiedAce__StaticFields {
};

struct QualifiedAce__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct QualifiedAce__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct QualifiedAce__VTable vtable;
};

struct CommonAce__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_BinaryLength;
    VirtualInvokeData GetBinaryForm;
    VirtualInvokeData GetSddlForm;
};

struct CommonAce__StaticFields {
};

struct CommonAce__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CommonAce__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CommonAce__VTable vtable;
};

struct GenericAce__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
};

struct GenericAce__StaticFields {
};

struct GenericAce__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct GenericAce__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct GenericAce__VTable vtable;
};

struct GenericAce__Array__VTable {
};

struct GenericAce__Array__StaticFields {
};

struct GenericAce__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct GenericAce__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct GenericAce__Array__VTable vtable;
};

struct IEnumerator_1_System_Security_AccessControl_GenericAce___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_System_Security_AccessControl_GenericAce___StaticFields {
};

struct IEnumerator_1_System_Security_AccessControl_GenericAce___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_System_Security_AccessControl_GenericAce___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_System_Security_AccessControl_GenericAce___VTable vtable;
};

struct List_1_System_Security_AccessControl_GenericAce___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData RemoveAt;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_T__get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_T__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IList_get_Item;
    VirtualInvokeData System_Collections_IList_set_Item;
    VirtualInvokeData System_Collections_IList_Add;
    VirtualInvokeData System_Collections_IList_Contains;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IList_get_IsReadOnly;
    VirtualInvokeData System_Collections_IList_get_IsFixedSize;
    VirtualInvokeData System_Collections_IList_IndexOf;
    VirtualInvokeData System_Collections_IList_Insert;
    VirtualInvokeData System_Collections_IList_Remove;
    VirtualInvokeData RemoveAt_1;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData get_Count_2;
};

struct List_1_System_Security_AccessControl_GenericAce___StaticFields {
    struct GenericAce__Array *_emptyArray;
};

struct List_1_System_Security_AccessControl_GenericAce___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct List_1_System_Security_AccessControl_GenericAce___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct List_1_System_Security_AccessControl_GenericAce___VTable vtable;
};

struct RawAcl__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count;
    VirtualInvokeData get_SyncRoot;
    VirtualInvokeData get_IsSynchronized;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData get_BinaryLength;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData get_Revision;
    VirtualInvokeData get_SyncRoot_1;
    VirtualInvokeData GetBinaryForm;
    VirtualInvokeData GetSddlForm;
};

struct RawAcl__StaticFields {
};

struct RawAcl__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RawAcl__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RawAcl__VTable vtable;
};

struct AceQualifier__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct AceQualifier__Enum__StaticFields {
};

struct AceQualifier__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AceQualifier__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AceQualifier__Enum__VTable vtable;
};

struct DiscretionaryAcl__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count;
    VirtualInvokeData get_SyncRoot;
    VirtualInvokeData get_IsSynchronized;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData get_BinaryLength;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData get_Revision;
    VirtualInvokeData get_SyncRoot_1;
    VirtualInvokeData GetBinaryForm;
    VirtualInvokeData GetSddlForm;
    VirtualInvokeData IsAceMeaningless;
    VirtualInvokeData ApplyCanonicalSortToExplicitAces;
    VirtualInvokeData GetAceInsertPosition;
};

struct DiscretionaryAcl__StaticFields {
};

struct DiscretionaryAcl__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DiscretionaryAcl__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DiscretionaryAcl__VTable vtable;
};

struct CommonAcl__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count;
    VirtualInvokeData get_SyncRoot;
    VirtualInvokeData get_IsSynchronized;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData get_BinaryLength;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData get_Revision;
    VirtualInvokeData get_SyncRoot_1;
    VirtualInvokeData GetBinaryForm;
    VirtualInvokeData GetSddlForm;
    VirtualInvokeData IsAceMeaningless;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
};

struct CommonAcl__StaticFields {
};

struct CommonAcl__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CommonAcl__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CommonAcl__VTable vtable;
};

struct GenericAcl__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count;
    VirtualInvokeData get_SyncRoot;
    VirtualInvokeData get_IsSynchronized;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData get_SyncRoot_1;
    VirtualInvokeData __unknown_5;
    VirtualInvokeData __unknown_6;
};

struct GenericAcl__StaticFields {
    uint8_t AclRevision;
    uint8_t AclRevisionDS;
    int32_t MaxBinaryLength;
};

struct GenericAcl__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct GenericAcl__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct GenericAcl__VTable vtable;
};

struct GenericSecurityDescriptor__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData get_InternalDacl;
    VirtualInvokeData get_InternalSacl;
    VirtualInvokeData get_InternalReservedField;
    VirtualInvokeData get_DaclIsUnmodifiedAefa;
};

struct GenericSecurityDescriptor__StaticFields {
};

struct GenericSecurityDescriptor__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct GenericSecurityDescriptor__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct GenericSecurityDescriptor__VTable vtable;
};

struct SystemAcl__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count;
    VirtualInvokeData get_SyncRoot;
    VirtualInvokeData get_IsSynchronized;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData get_BinaryLength;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData get_Revision;
    VirtualInvokeData get_SyncRoot_1;
    VirtualInvokeData GetBinaryForm;
    VirtualInvokeData GetSddlForm;
    VirtualInvokeData IsAceMeaningless;
    VirtualInvokeData ApplyCanonicalSortToExplicitAces;
    VirtualInvokeData GetAceInsertPosition;
};

struct SystemAcl__StaticFields {
};

struct SystemAcl__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SystemAcl__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SystemAcl__VTable vtable;
};

struct CommonSecurityDescriptor__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_ControlFlags;
    VirtualInvokeData get_Group;
    VirtualInvokeData set_Group;
    VirtualInvokeData get_Owner;
    VirtualInvokeData set_Owner;
    VirtualInvokeData get_InternalDacl;
    VirtualInvokeData get_InternalSacl;
    VirtualInvokeData get_InternalReservedField;
    VirtualInvokeData get_DaclIsUnmodifiedAefa;
};

struct CommonSecurityDescriptor__StaticFields {
};

struct CommonSecurityDescriptor__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CommonSecurityDescriptor__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CommonSecurityDescriptor__VTable vtable;
};

struct AccessControlSections__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct AccessControlSections__Enum__StaticFields {
};

struct AccessControlSections__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AccessControlSections__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AccessControlSections__Enum__VTable vtable;
};

struct LockQueue__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct LockQueue__StaticFields {
};

struct LockQueue__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct LockQueue__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct LockQueue__VTable vtable;
};

struct ReaderWriterLock__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ReaderWriterLock__StaticFields {
};

struct ReaderWriterLock__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ReaderWriterLock__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ReaderWriterLock__VTable vtable;
};

struct InheritanceFlags__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct InheritanceFlags__Enum__StaticFields {
};

struct InheritanceFlags__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct InheritanceFlags__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct InheritanceFlags__Enum__VTable vtable;
};

struct PropagationFlags__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct PropagationFlags__Enum__StaticFields {
};

struct PropagationFlags__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PropagationFlags__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PropagationFlags__Enum__VTable vtable;
};

struct AuthorizationRule__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct AuthorizationRule__StaticFields {
};

struct AuthorizationRule__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AuthorizationRule__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AuthorizationRule__VTable vtable;
};

struct AccessControlType__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct AccessControlType__Enum__StaticFields {
};

struct AccessControlType__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AccessControlType__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AccessControlType__Enum__VTable vtable;
};

struct AccessRule__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct AccessRule__StaticFields {
};

struct AccessRule__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AccessRule__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AccessRule__VTable vtable;
};

struct AuditFlags__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct AuditFlags__Enum__StaticFields {
};

struct AuditFlags__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AuditFlags__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AuditFlags__Enum__VTable vtable;
};

struct AuditRule__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct AuditRule__StaticFields {
};

struct AuditRule__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AuditRule__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AuditRule__VTable vtable;
};

struct AccessControlModification__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct AccessControlModification__Enum__StaticFields {
};

struct AccessControlModification__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AccessControlModification__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AccessControlModification__Enum__VTable vtable;
};

struct ObjectSecurity__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData ModifyAccessRule;
    VirtualInvokeData ModifyAuditRule;
    VirtualInvokeData PurgeAccessRules;
    VirtualInvokeData PurgeAuditRules;
    VirtualInvokeData __unknown_5;
    VirtualInvokeData __unknown_6;
    VirtualInvokeData Persist;
    VirtualInvokeData Persist_1;
    VirtualInvokeData Persist_2;
    VirtualInvokeData InternalAccessRuleFactory;
    VirtualInvokeData InternalAuditRuleFactory;
};

struct ObjectSecurity__StaticFields {
};

struct ObjectSecurity__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ObjectSecurity__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ObjectSecurity__VTable vtable;
};

struct CommonObjectSecurity__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData ModifyAccessRule;
    VirtualInvokeData ModifyAuditRule;
    VirtualInvokeData PurgeAccessRules;
    VirtualInvokeData PurgeAuditRules;
    VirtualInvokeData ModifyAccess;
    VirtualInvokeData ModifyAudit;
    VirtualInvokeData Persist;
    VirtualInvokeData Persist_1;
    VirtualInvokeData Persist_2;
    VirtualInvokeData InternalAccessRuleFactory;
    VirtualInvokeData InternalAuditRuleFactory;
};

struct CommonObjectSecurity__StaticFields {
};

struct CommonObjectSecurity__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CommonObjectSecurity__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CommonObjectSecurity__VTable vtable;
};

struct NativeObjectSecurity_ExceptionFromErrorCode__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct NativeObjectSecurity_ExceptionFromErrorCode__StaticFields {
};

struct NativeObjectSecurity_ExceptionFromErrorCode__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct NativeObjectSecurity_ExceptionFromErrorCode__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct NativeObjectSecurity_ExceptionFromErrorCode__VTable vtable;
};

struct ResourceType__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct ResourceType__Enum__StaticFields {
};

struct ResourceType__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ResourceType__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ResourceType__Enum__VTable vtable;
};

struct NativeObjectSecurity__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData ModifyAccessRule;
    VirtualInvokeData ModifyAuditRule;
    VirtualInvokeData PurgeAccessRules;
    VirtualInvokeData PurgeAuditRules;
    VirtualInvokeData ModifyAccess;
    VirtualInvokeData ModifyAudit;
    VirtualInvokeData Persist;
    VirtualInvokeData Persist_1;
    VirtualInvokeData Persist_2;
    VirtualInvokeData InternalAccessRuleFactory;
    VirtualInvokeData InternalAuditRuleFactory;
    VirtualInvokeData InternalGet;
    VirtualInvokeData InternalGet_1;
    VirtualInvokeData InternalSet;
    VirtualInvokeData InternalSet_1;
};

struct NativeObjectSecurity__StaticFields {
};

struct NativeObjectSecurity__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct NativeObjectSecurity__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct NativeObjectSecurity__VTable vtable;
};

struct CryptoKeySecurity__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_AccessRightType;
    VirtualInvokeData get_AccessRuleType;
    VirtualInvokeData get_AuditRuleType;
    VirtualInvokeData AccessRuleFactory;
    VirtualInvokeData AuditRuleFactory;
    VirtualInvokeData ModifyAccessRule;
    VirtualInvokeData ModifyAuditRule;
    VirtualInvokeData PurgeAccessRules;
    VirtualInvokeData PurgeAuditRules;
    VirtualInvokeData ModifyAccess;
    VirtualInvokeData ModifyAudit;
    VirtualInvokeData Persist;
    VirtualInvokeData Persist_1;
    VirtualInvokeData Persist_2;
    VirtualInvokeData InternalAccessRuleFactory;
    VirtualInvokeData InternalAuditRuleFactory;
    VirtualInvokeData InternalGet;
    VirtualInvokeData InternalGet_1;
    VirtualInvokeData InternalSet;
    VirtualInvokeData InternalSet_1;
};

struct CryptoKeySecurity__StaticFields {
};

struct CryptoKeySecurity__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CryptoKeySecurity__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CryptoKeySecurity__VTable vtable;
};

struct CspParameters__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct CspParameters__StaticFields {
};

struct CspParameters__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CspParameters__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CspParameters__VTable vtable;
};

struct KeyPairPersistence__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct KeyPairPersistence__StaticFields {
    bool _userPathExists;
    struct String *_userPath;
    bool _machinePathExists;
    struct String *_machinePath;
    struct Object *lockobj;
};

struct KeyPairPersistence__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyPairPersistence__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyPairPersistence__VTable vtable;
};

struct __declspec(align(8)) HashAlgorithm__Fields {
    int32_t HashSizeValue;
    struct Byte__Array *HashValue;
    int32_t State;
    bool m_bDisposed;
};

struct HashAlgorithm {
    struct HashAlgorithm__Class *klass;
    MonitorData *monitor;
    struct HashAlgorithm__Fields fields;
};

struct MD2__Fields {
    struct HashAlgorithm__Fields _;
};

struct MD2 {
    struct MD2__Class *klass;
    MonitorData *monitor;
    struct MD2__Fields fields;
};

struct MD2Managed__Fields {
    struct MD2__Fields _;
    struct Byte__Array *state;
    struct Byte__Array *checksum;
    struct Byte__Array *buffer;
    int32_t count;
    struct Byte__Array *x;
};

struct MD2Managed {
    struct MD2Managed__Class *klass;
    MonitorData *monitor;
    struct MD2Managed__Fields fields;
};

struct MD2Managed__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_InputBlockSize;
    VirtualInvokeData get_OutputBlockSize;
    VirtualInvokeData get_CanTransformMultipleBlocks;
    VirtualInvokeData get_CanReuseTransform;
    VirtualInvokeData TransformBlock;
    VirtualInvokeData TransformFinalBlock;
    VirtualInvokeData get_HashSize;
    VirtualInvokeData get_Hash;
    VirtualInvokeData get_InputBlockSize_1;
    VirtualInvokeData get_OutputBlockSize_1;
    VirtualInvokeData get_CanTransformMultipleBlocks_1;
    VirtualInvokeData get_CanReuseTransform_1;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData Initialize;
    VirtualInvokeData HashCore;
    VirtualInvokeData HashFinal;
};

struct MD2Managed__StaticFields {
    struct Byte__Array *PI_SUBST;
};

struct MD2Managed__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MD2Managed__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MD2Managed__VTable vtable;
};

struct HashAlgorithm__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_InputBlockSize;
    VirtualInvokeData get_OutputBlockSize;
    VirtualInvokeData get_CanTransformMultipleBlocks;
    VirtualInvokeData get_CanReuseTransform;
    VirtualInvokeData TransformBlock;
    VirtualInvokeData TransformFinalBlock;
    VirtualInvokeData get_HashSize;
    VirtualInvokeData get_Hash;
    VirtualInvokeData get_InputBlockSize_1;
    VirtualInvokeData get_OutputBlockSize_1;
    VirtualInvokeData get_CanTransformMultipleBlocks_1;
    VirtualInvokeData get_CanReuseTransform_1;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
};

struct HashAlgorithm__StaticFields {
};

struct HashAlgorithm__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct HashAlgorithm__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct HashAlgorithm__VTable vtable;
};

struct MD2__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_InputBlockSize;
    VirtualInvokeData get_OutputBlockSize;
    VirtualInvokeData get_CanTransformMultipleBlocks;
    VirtualInvokeData get_CanReuseTransform;
    VirtualInvokeData TransformBlock;
    VirtualInvokeData TransformFinalBlock;
    VirtualInvokeData get_HashSize;
    VirtualInvokeData get_Hash;
    VirtualInvokeData get_InputBlockSize_1;
    VirtualInvokeData get_OutputBlockSize_1;
    VirtualInvokeData get_CanTransformMultipleBlocks_1;
    VirtualInvokeData get_CanReuseTransform_1;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
};

struct MD2__StaticFields {
};

struct MD2__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MD2__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MD2__VTable vtable;
};

struct MD4__Fields {
    struct HashAlgorithm__Fields _;
};

struct MD4 {
    struct MD4__Class *klass;
    MonitorData *monitor;
    struct MD4__Fields fields;
};

struct MD4Managed__Fields {
    struct MD4__Fields _;
    struct UInt32__Array *state;
    struct Byte__Array *buffer;
    struct UInt32__Array *count;
    struct UInt32__Array *x;
    struct Byte__Array *digest;
};

struct MD4Managed {
    struct MD4Managed__Class *klass;
    MonitorData *monitor;
    struct MD4Managed__Fields fields;
};

struct MD4Managed__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_InputBlockSize;
    VirtualInvokeData get_OutputBlockSize;
    VirtualInvokeData get_CanTransformMultipleBlocks;
    VirtualInvokeData get_CanReuseTransform;
    VirtualInvokeData TransformBlock;
    VirtualInvokeData TransformFinalBlock;
    VirtualInvokeData get_HashSize;
    VirtualInvokeData get_Hash;
    VirtualInvokeData get_InputBlockSize_1;
    VirtualInvokeData get_OutputBlockSize_1;
    VirtualInvokeData get_CanTransformMultipleBlocks_1;
    VirtualInvokeData get_CanReuseTransform_1;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData Initialize;
    VirtualInvokeData HashCore;
    VirtualInvokeData HashFinal;
};

struct MD4Managed__StaticFields {
};

struct MD4Managed__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MD4Managed__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MD4Managed__VTable vtable;
};

struct MD4__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_InputBlockSize;
    VirtualInvokeData get_OutputBlockSize;
    VirtualInvokeData get_CanTransformMultipleBlocks;
    VirtualInvokeData get_CanReuseTransform;
    VirtualInvokeData TransformBlock;
    VirtualInvokeData TransformFinalBlock;
    VirtualInvokeData get_HashSize;
    VirtualInvokeData get_Hash;
    VirtualInvokeData get_InputBlockSize_1;
    VirtualInvokeData get_OutputBlockSize_1;
    VirtualInvokeData get_CanTransformMultipleBlocks_1;
    VirtualInvokeData get_CanReuseTransform_1;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
};

struct MD4__StaticFields {
};

struct MD4__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MD4__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MD4__VTable vtable;
};

struct PKCS1 {
    struct PKCS1__Class *klass;
    MonitorData *monitor;
};

struct PKCS1__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct PKCS1__StaticFields {
    struct Byte__Array *emptySHA1;
    struct Byte__Array *emptySHA256;
    struct Byte__Array *emptySHA384;
    struct Byte__Array *emptySHA512;
};

struct PKCS1__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PKCS1__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PKCS1__VTable vtable;
};

struct PKCS8 {
    struct PKCS8__Class *klass;
    MonitorData *monitor;
};

struct PKCS8__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct PKCS8__StaticFields {
};

struct PKCS8__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PKCS8__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PKCS8__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum PKCS8_KeyInfo__Enum : int32_t {
    PKCS8_KeyInfo__Enum_PrivateKey = 0x00000000,
    PKCS8_KeyInfo__Enum_EncryptedPrivateKey = 0x00000001,
    PKCS8_KeyInfo__Enum_Unknown = 0x00000002,
};

#else
enum PKCS8_KeyInfo__Enum {
    PKCS8_KeyInfo__Enum_PrivateKey = 0x00000000,
    PKCS8_KeyInfo__Enum_EncryptedPrivateKey = 0x00000001,
    PKCS8_KeyInfo__Enum_Unknown = 0x00000002,
};

#endif
struct PKCS8_KeyInfo__Enum__Boxed {
    struct PKCS8_KeyInfo__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum PKCS8_KeyInfo__Enum value;
    #else
    uint32_t value;
    #endif
};

struct PKCS8_KeyInfo__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct PKCS8_KeyInfo__Enum__StaticFields {
};

struct PKCS8_KeyInfo__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PKCS8_KeyInfo__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PKCS8_KeyInfo__Enum__VTable vtable;
};

struct __declspec(align(8)) PKCS8_EncryptedPrivateKeyInfo__Fields {
    struct String *_algorithm;
    struct Byte__Array *_salt;
    int32_t _iterations;
    struct Byte__Array *_data;
};

struct PKCS8_EncryptedPrivateKeyInfo {
    struct PKCS8_EncryptedPrivateKeyInfo__Class *klass;
    MonitorData *monitor;
    struct PKCS8_EncryptedPrivateKeyInfo__Fields fields;
};

struct PKCS8_EncryptedPrivateKeyInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct PKCS8_EncryptedPrivateKeyInfo__StaticFields {
};

struct PKCS8_EncryptedPrivateKeyInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PKCS8_EncryptedPrivateKeyInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PKCS8_EncryptedPrivateKeyInfo__VTable vtable;
};

struct __declspec(align(8)) SymmetricTransform__Fields {
    struct SymmetricAlgorithm *algo;
    bool encrypt;
    int32_t BlockSizeByte;
    struct Byte__Array *temp;
    struct Byte__Array *temp2;
    struct Byte__Array *workBuff;
    struct Byte__Array *workout;
    #if defined(_CPLUSPLUS_)
    enum PaddingMode__Enum padmode;
    #else
    uint32_t padmode;
    #endif
    int32_t FeedBackByte;
    bool m_disposed;
    bool lastBlock;
    struct RandomNumberGenerator *_rng;
};

struct SymmetricTransform {
    struct SymmetricTransform__Class *klass;
    MonitorData *monitor;
    struct SymmetricTransform__Fields fields;
};

struct DESTransform__Fields {
    struct SymmetricTransform__Fields _;
    struct Byte__Array *keySchedule;
    struct Byte__Array *byteBuff;
    struct UInt32__Array *dwordBuff;
};

struct DESTransform {
    struct DESTransform__Class *klass;
    MonitorData *monitor;
    struct DESTransform__Fields fields;
};

struct DESTransform__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_InputBlockSize;
    VirtualInvokeData get_OutputBlockSize;
    VirtualInvokeData get_CanTransformMultipleBlocks;
    VirtualInvokeData get_CanReuseTransform;
    VirtualInvokeData TransformBlock;
    VirtualInvokeData TransformFinalBlock;
    VirtualInvokeData System_IDisposable_Dispose;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_CanTransformMultipleBlocks_1;
    VirtualInvokeData get_CanReuseTransform_1;
    VirtualInvokeData get_InputBlockSize_1;
    VirtualInvokeData get_OutputBlockSize_1;
    VirtualInvokeData Transform;
    VirtualInvokeData ECB;
    VirtualInvokeData CBC;
    VirtualInvokeData CFB;
    VirtualInvokeData OFB;
    VirtualInvokeData CTS;
    VirtualInvokeData TransformBlock_1;
    VirtualInvokeData FinalEncrypt;
    VirtualInvokeData FinalDecrypt;
    VirtualInvokeData TransformFinalBlock_1;
};

struct DESTransform__StaticFields {
    int32_t KEY_BIT_SIZE;
    int32_t KEY_BYTE_SIZE;
    int32_t BLOCK_BIT_SIZE;
    int32_t BLOCK_BYTE_SIZE;
    struct UInt32__Array *spBoxes;
    struct Byte__Array *PC1;
    struct Byte__Array *leftRotTotal;
    struct Byte__Array *PC2;
    struct UInt32__Array *ipTab;
    struct UInt32__Array *fpTab;
};

struct DESTransform__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DESTransform__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DESTransform__VTable vtable;
};

struct SymmetricTransform__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_InputBlockSize;
    VirtualInvokeData get_OutputBlockSize;
    VirtualInvokeData get_CanTransformMultipleBlocks;
    VirtualInvokeData get_CanReuseTransform;
    VirtualInvokeData TransformBlock;
    VirtualInvokeData TransformFinalBlock;
    VirtualInvokeData System_IDisposable_Dispose;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_CanTransformMultipleBlocks_1;
    VirtualInvokeData get_CanReuseTransform_1;
    VirtualInvokeData get_InputBlockSize_1;
    VirtualInvokeData get_OutputBlockSize_1;
    VirtualInvokeData Transform;
    VirtualInvokeData __unknown;
    VirtualInvokeData CBC;
    VirtualInvokeData CFB;
    VirtualInvokeData OFB;
    VirtualInvokeData CTS;
    VirtualInvokeData TransformBlock_1;
    VirtualInvokeData FinalEncrypt;
    VirtualInvokeData FinalDecrypt;
    VirtualInvokeData TransformFinalBlock_1;
};

struct SymmetricTransform__StaticFields {
};

struct SymmetricTransform__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SymmetricTransform__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SymmetricTransform__VTable vtable;
};

struct __declspec(align(8)) HMACAlgorithm__Fields {
    struct Byte__Array *key;
    struct Byte__Array *hash;
    struct HashAlgorithm *algo;
    struct String *hashName;
    struct BlockProcessor *block;
};

struct HMACAlgorithm {
    struct HMACAlgorithm__Class *klass;
    MonitorData *monitor;
    struct HMACAlgorithm__Fields fields;
};

struct HMACAlgorithm__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct HMACAlgorithm__StaticFields {
};

struct HMACAlgorithm__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct HMACAlgorithm__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct HMACAlgorithm__VTable vtable;
};

struct __declspec(align(8)) MACAlgorithm__Fields {
    struct SymmetricAlgorithm *algo;
    struct ICryptoTransform *enc;
    struct Byte__Array *block;
    int32_t blockSize;
    int32_t blockCount;
};

struct MACAlgorithm {
    struct MACAlgorithm__Class *klass;
    MonitorData *monitor;
    struct MACAlgorithm__Fields fields;
};

struct MACAlgorithm__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct MACAlgorithm__StaticFields {
};

struct MACAlgorithm__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MACAlgorithm__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MACAlgorithm__VTable vtable;
};

struct __declspec(align(8)) AuthenticodeBase__Fields {
    struct Byte__Array *fileblock;
    struct FileStream *fs;
    int32_t blockNo;
    int32_t blockLength;
    int32_t peOffset;
    int32_t dirSecurityOffset;
    int32_t dirSecuritySize;
    int32_t coffSymbolTableOffset;
};

struct AuthenticodeBase {
    struct AuthenticodeBase__Class *klass;
    MonitorData *monitor;
    struct AuthenticodeBase__Fields fields;
};

struct AuthenticodeBase__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct AuthenticodeBase__StaticFields {
};

struct AuthenticodeBase__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AuthenticodeBase__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AuthenticodeBase__VTable vtable;
};

struct AuthenticodeDeformatter__Fields {
    struct AuthenticodeBase__Fields _;
    struct String *filename;
    struct Byte__Array *hash;
    struct X509CertificateCollection *coll;
    struct ASN1 *signedHash;
    struct DateTime timestamp;
    struct X509Certificate_1 *signingCertificate;
    int32_t reason;
    bool trustedRoot;
    bool trustedTimestampRoot;
    struct Byte__Array *entry;
    struct X509Chain *signerChain;
    struct X509Chain *timestampChain;
};

struct AuthenticodeDeformatter {
    struct AuthenticodeDeformatter__Class *klass;
    MonitorData *monitor;
    struct AuthenticodeDeformatter__Fields fields;
};

struct AuthenticodeDeformatter__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct AuthenticodeDeformatter__StaticFields {
};

struct AuthenticodeDeformatter__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AuthenticodeDeformatter__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AuthenticodeDeformatter__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum BigInteger_Sign__Enum : int32_t {
    BigInteger_Sign__Enum_Negative = 0xffffffff,
    BigInteger_Sign__Enum_Zero = 0x00000000,
    BigInteger_Sign__Enum_Positive = 0x00000001,
};

#else
enum BigInteger_Sign__Enum {
    BigInteger_Sign__Enum_Negative = 0xffffffff,
    BigInteger_Sign__Enum_Zero = 0x00000000,
    BigInteger_Sign__Enum_Positive = 0x00000001,
};

#endif
struct BigInteger_Sign__Enum__Boxed {
    struct BigInteger_Sign__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum BigInteger_Sign__Enum value;
    #else
    uint32_t value;
    #endif
};

struct BigInteger_Sign__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct BigInteger_Sign__Enum__StaticFields {
};

struct BigInteger_Sign__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct BigInteger_Sign__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct BigInteger_Sign__Enum__VTable vtable;
};

struct __declspec(align(8)) BigInteger_ModulusRing__Fields {
    struct BigInteger *mod;
    struct BigInteger *constant;
};

struct BigInteger_ModulusRing {
    struct BigInteger_ModulusRing__Class *klass;
    MonitorData *monitor;
    struct BigInteger_ModulusRing__Fields fields;
};

struct BigInteger_ModulusRing__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct BigInteger_ModulusRing__StaticFields {
};

struct BigInteger_ModulusRing__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct BigInteger_ModulusRing__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct BigInteger_ModulusRing__VTable vtable;
};

struct BigInteger__Array {
    struct BigInteger__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct BigInteger *vector[32];
};

struct BigInteger__Array__VTable {
};

struct BigInteger__Array__StaticFields {
};

struct BigInteger__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct BigInteger__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct BigInteger__Array__VTable vtable;
};

struct UInt32__1__VTable {
};

struct UInt32__1__StaticFields {
};

struct UInt32__1__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UInt32__1__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UInt32__1__VTable vtable;
};

struct BigInteger_Kernel {
    struct BigInteger_Kernel__Class *klass;
    MonitorData *monitor;
};

struct BigInteger_Kernel__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct BigInteger_Kernel__StaticFields {
};

struct BigInteger_Kernel__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct BigInteger_Kernel__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct BigInteger_Kernel__VTable vtable;
};

struct PrimalityTest__Fields {
    struct MulticastDelegate__Fields _;
};

struct PrimalityTest {
    struct PrimalityTest__Class *klass;
    MonitorData *monitor;
    struct PrimalityTest__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum ConfidenceFactor__Enum : int32_t {
    ConfidenceFactor__Enum_ExtraLow = 0x00000000,
    ConfidenceFactor__Enum_Low = 0x00000001,
    ConfidenceFactor__Enum_Medium = 0x00000002,
    ConfidenceFactor__Enum_High = 0x00000003,
    ConfidenceFactor__Enum_ExtraHigh = 0x00000004,
    ConfidenceFactor__Enum_Provable = 0x00000005,
};

#else
enum ConfidenceFactor__Enum {
    ConfidenceFactor__Enum_ExtraLow = 0x00000000,
    ConfidenceFactor__Enum_Low = 0x00000001,
    ConfidenceFactor__Enum_Medium = 0x00000002,
    ConfidenceFactor__Enum_High = 0x00000003,
    ConfidenceFactor__Enum_ExtraHigh = 0x00000004,
    ConfidenceFactor__Enum_Provable = 0x00000005,
};

#endif
struct ConfidenceFactor__Enum__Boxed {
    struct ConfidenceFactor__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum ConfidenceFactor__Enum value;
    #else
    uint32_t value;
    #endif
};

struct ConfidenceFactor__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct ConfidenceFactor__Enum__StaticFields {
};

struct ConfidenceFactor__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ConfidenceFactor__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ConfidenceFactor__Enum__VTable vtable;
};

struct PrimalityTest__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct PrimalityTest__StaticFields {
};

struct PrimalityTest__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PrimalityTest__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PrimalityTest__VTable vtable;
};

struct PrimalityTests {
    struct PrimalityTests__Class *klass;
    MonitorData *monitor;
};

struct PrimalityTests__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct PrimalityTests__StaticFields {
};

struct PrimalityTests__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PrimalityTests__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PrimalityTests__VTable vtable;
};

struct PrimeGeneratorBase {
    struct PrimeGeneratorBase__Class *klass;
    MonitorData *monitor;
};

struct SequentialSearchPrimeGeneratorBase {
    struct SequentialSearchPrimeGeneratorBase__Class *klass;
    MonitorData *monitor;
};

struct NextPrimeFinder {
    struct NextPrimeFinder__Class *klass;
    MonitorData *monitor;
};

struct PrimeGeneratorBase__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Confidence;
    VirtualInvokeData get_PrimalityTest;
    VirtualInvokeData get_TrialDivisionBounds;
    VirtualInvokeData __unknown;
};

struct PrimeGeneratorBase__StaticFields {
};

struct PrimeGeneratorBase__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PrimeGeneratorBase__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PrimeGeneratorBase__VTable vtable;
};

struct SequentialSearchPrimeGeneratorBase__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Confidence;
    VirtualInvokeData get_PrimalityTest;
    VirtualInvokeData get_TrialDivisionBounds;
    VirtualInvokeData GenerateNewPrime;
    VirtualInvokeData GenerateSearchBase;
    VirtualInvokeData GenerateNewPrime_1;
    VirtualInvokeData IsPrimeAcceptable;
};

struct SequentialSearchPrimeGeneratorBase__StaticFields {
};

struct SequentialSearchPrimeGeneratorBase__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SequentialSearchPrimeGeneratorBase__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SequentialSearchPrimeGeneratorBase__VTable vtable;
};

struct NextPrimeFinder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Confidence;
    VirtualInvokeData get_PrimalityTest;
    VirtualInvokeData get_TrialDivisionBounds;
    VirtualInvokeData GenerateNewPrime;
    VirtualInvokeData GenerateSearchBase;
    VirtualInvokeData GenerateNewPrime_1;
    VirtualInvokeData IsPrimeAcceptable;
};

struct NextPrimeFinder__StaticFields {
};

struct NextPrimeFinder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct NextPrimeFinder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct NextPrimeFinder__VTable vtable;
};

struct UnsafeNativeMethods_ManifestEtw_EtwEnableCallback__Fields {
    struct MulticastDelegate__Fields _;
};

struct UnsafeNativeMethods_ManifestEtw_EtwEnableCallback {
    struct UnsafeNativeMethods_ManifestEtw_EtwEnableCallback__Class *klass;
    MonitorData *monitor;
    struct UnsafeNativeMethods_ManifestEtw_EtwEnableCallback__Fields fields;
};

struct UnsafeNativeMethods_ManifestEtw_EVENT_FILTER_DESCRIPTOR {
    int64_t Ptr;
    int32_t Size;
    int32_t Type;
};

struct UnsafeNativeMethods_ManifestEtw_EVENT_FILTER_DESCRIPTOR__Boxed {
    struct UnsafeNativeMethods_ManifestEtw_EVENT_FILTER_DESCRIPTOR__Class *klass;
    MonitorData *monitor;
    struct UnsafeNativeMethods_ManifestEtw_EVENT_FILTER_DESCRIPTOR fields;
};

struct UnsafeNativeMethods_ManifestEtw_EVENT_FILTER_DESCRIPTORPtr {
    struct UnsafeNativeMethods_ManifestEtw_EVENT_FILTER_DESCRIPTORPtr__Class *klass;
    MonitorData *monitor;
};

struct UnsafeNativeMethods_ManifestEtw_EVENT_FILTER_DESCRIPTOR__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct UnsafeNativeMethods_ManifestEtw_EVENT_FILTER_DESCRIPTOR__StaticFields {
};

struct UnsafeNativeMethods_ManifestEtw_EVENT_FILTER_DESCRIPTOR__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UnsafeNativeMethods_ManifestEtw_EVENT_FILTER_DESCRIPTOR__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UnsafeNativeMethods_ManifestEtw_EVENT_FILTER_DESCRIPTOR__VTable vtable;
};

struct UnsafeNativeMethods_ManifestEtw_EVENT_FILTER_DESCRIPTORPtr__VTable {
};

struct UnsafeNativeMethods_ManifestEtw_EVENT_FILTER_DESCRIPTORPtr__StaticFields {
};

struct UnsafeNativeMethods_ManifestEtw_EVENT_FILTER_DESCRIPTORPtr__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UnsafeNativeMethods_ManifestEtw_EVENT_FILTER_DESCRIPTORPtr__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UnsafeNativeMethods_ManifestEtw_EVENT_FILTER_DESCRIPTORPtr__VTable vtable;
};

struct UnsafeNativeMethods_ManifestEtw_EtwEnableCallback__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct UnsafeNativeMethods_ManifestEtw_EtwEnableCallback__StaticFields {
};

struct UnsafeNativeMethods_ManifestEtw_EtwEnableCallback__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UnsafeNativeMethods_ManifestEtw_EtwEnableCallback__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UnsafeNativeMethods_ManifestEtw_EtwEnableCallback__VTable vtable;
};

struct Int64___VTable {
};

struct Int64___StaticFields {
};

struct Int64___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Int64___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Int64___VTable vtable;
};

struct EventDescriptor {
    int32_t m_traceloggingId;
    uint16_t m_id;
    uint8_t m_version;
    uint8_t m_channel;
    uint8_t m_level;
    uint8_t m_opcode;
    uint16_t m_task;
    int64_t m_keywords;
};

struct EventDescriptor__Boxed {
    struct EventDescriptor__Class *klass;
    MonitorData *monitor;
    struct EventDescriptor fields;
};

struct EventProvider_EventData {
    uint64_t Ptr;
    uint32_t Size;
    uint32_t Reserved;
};

struct EventProvider_EventData__Boxed {
    struct EventProvider_EventData__Class *klass;
    MonitorData *monitor;
    struct EventProvider_EventData fields;
};

struct EventProvider_EventDataPtr {
    struct EventProvider_EventDataPtr__Class *klass;
    MonitorData *monitor;
};

struct EventDescriptor__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct EventDescriptor__StaticFields {
};

struct EventDescriptor__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EventDescriptor__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EventDescriptor__VTable vtable;
};

struct EventDescriptor___VTable {
};

struct EventDescriptor___StaticFields {
};

struct EventDescriptor___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EventDescriptor___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EventDescriptor___VTable vtable;
};

struct EventProvider_EventData__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct EventProvider_EventData__StaticFields {
};

struct EventProvider_EventData__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EventProvider_EventData__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EventProvider_EventData__VTable vtable;
};

struct EventProvider_EventDataPtr__VTable {
};

struct EventProvider_EventDataPtr__StaticFields {
};

struct EventProvider_EventDataPtr__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EventProvider_EventDataPtr__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EventProvider_EventDataPtr__VTable vtable;
};

struct GuidPtr {
    struct GuidPtr__Class *klass;
    MonitorData *monitor;
};

struct GuidPtr__VTable {
};

struct GuidPtr__StaticFields {
};

struct GuidPtr__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct GuidPtr__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct GuidPtr__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum UnsafeNativeMethods_ManifestEtw_ActivityControl__Enum : uint32_t {
    UnsafeNativeMethods_ManifestEtw_ActivityControl__Enum_EVENT_ACTIVITY_CTRL_GET_ID = 0x00000001,
    UnsafeNativeMethods_ManifestEtw_ActivityControl__Enum_EVENT_ACTIVITY_CTRL_SET_ID = 0x00000002,
    UnsafeNativeMethods_ManifestEtw_ActivityControl__Enum_EVENT_ACTIVITY_CTRL_CREATE_ID = 0x00000003,
    UnsafeNativeMethods_ManifestEtw_ActivityControl__Enum_EVENT_ACTIVITY_CTRL_GET_SET_ID = 0x00000004,
    UnsafeNativeMethods_ManifestEtw_ActivityControl__Enum_EVENT_ACTIVITY_CTRL_CREATE_SET_ID = 0x00000005,
};

#else
enum UnsafeNativeMethods_ManifestEtw_ActivityControl__Enum {
    UnsafeNativeMethods_ManifestEtw_ActivityControl__Enum_EVENT_ACTIVITY_CTRL_GET_ID = 0x00000001,
    UnsafeNativeMethods_ManifestEtw_ActivityControl__Enum_EVENT_ACTIVITY_CTRL_SET_ID = 0x00000002,
    UnsafeNativeMethods_ManifestEtw_ActivityControl__Enum_EVENT_ACTIVITY_CTRL_CREATE_ID = 0x00000003,
    UnsafeNativeMethods_ManifestEtw_ActivityControl__Enum_EVENT_ACTIVITY_CTRL_GET_SET_ID = 0x00000004,
    UnsafeNativeMethods_ManifestEtw_ActivityControl__Enum_EVENT_ACTIVITY_CTRL_CREATE_SET_ID = 0x00000005,
};

#endif
struct UnsafeNativeMethods_ManifestEtw_ActivityControl__Enum__Boxed {
    struct UnsafeNativeMethods_ManifestEtw_ActivityControl__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum UnsafeNativeMethods_ManifestEtw_ActivityControl__Enum value;
    #else
    uint32_t value;
    #endif
};

struct UnsafeNativeMethods_ManifestEtw_ActivityControl__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct UnsafeNativeMethods_ManifestEtw_ActivityControl__Enum__StaticFields {
};

struct UnsafeNativeMethods_ManifestEtw_ActivityControl__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UnsafeNativeMethods_ManifestEtw_ActivityControl__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UnsafeNativeMethods_ManifestEtw_ActivityControl__Enum__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum UnsafeNativeMethods_ManifestEtw_EVENT_INFO_CLASS__Enum : int32_t {
    UnsafeNativeMethods_ManifestEtw_EVENT_INFO_CLASS__Enum_BinaryTrackInfo = 0x00000000,
    UnsafeNativeMethods_ManifestEtw_EVENT_INFO_CLASS__Enum_SetEnableAllKeywords = 0x00000001,
    UnsafeNativeMethods_ManifestEtw_EVENT_INFO_CLASS__Enum_SetTraits = 0x00000002,
};

#else
enum UnsafeNativeMethods_ManifestEtw_EVENT_INFO_CLASS__Enum {
    UnsafeNativeMethods_ManifestEtw_EVENT_INFO_CLASS__Enum_BinaryTrackInfo = 0x00000000,
    UnsafeNativeMethods_ManifestEtw_EVENT_INFO_CLASS__Enum_SetEnableAllKeywords = 0x00000001,
    UnsafeNativeMethods_ManifestEtw_EVENT_INFO_CLASS__Enum_SetTraits = 0x00000002,
};

#endif
struct UnsafeNativeMethods_ManifestEtw_EVENT_INFO_CLASS__Enum__Boxed {
    struct UnsafeNativeMethods_ManifestEtw_EVENT_INFO_CLASS__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum UnsafeNativeMethods_ManifestEtw_EVENT_INFO_CLASS__Enum value;
    #else
    uint32_t value;
    #endif
};

struct UnsafeNativeMethods_ManifestEtw_EVENT_INFO_CLASS__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct UnsafeNativeMethods_ManifestEtw_EVENT_INFO_CLASS__Enum__StaticFields {
};

struct UnsafeNativeMethods_ManifestEtw_EVENT_INFO_CLASS__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UnsafeNativeMethods_ManifestEtw_EVENT_INFO_CLASS__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UnsafeNativeMethods_ManifestEtw_EVENT_INFO_CLASS__Enum__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum UnsafeNativeMethods_ManifestEtw_TRACE_QUERY_INFO_CLASS__Enum : int32_t {
    UnsafeNativeMethods_ManifestEtw_TRACE_QUERY_INFO_CLASS__Enum_TraceGuidQueryList = 0x00000000,
    UnsafeNativeMethods_ManifestEtw_TRACE_QUERY_INFO_CLASS__Enum_TraceGuidQueryInfo = 0x00000001,
    UnsafeNativeMethods_ManifestEtw_TRACE_QUERY_INFO_CLASS__Enum_TraceGuidQueryProcess = 0x00000002,
    UnsafeNativeMethods_ManifestEtw_TRACE_QUERY_INFO_CLASS__Enum_TraceStackTracingInfo = 0x00000003,
    UnsafeNativeMethods_ManifestEtw_TRACE_QUERY_INFO_CLASS__Enum_MaxTraceSetInfoClass = 0x00000004,
};

#else
enum UnsafeNativeMethods_ManifestEtw_TRACE_QUERY_INFO_CLASS__Enum {
    UnsafeNativeMethods_ManifestEtw_TRACE_QUERY_INFO_CLASS__Enum_TraceGuidQueryList = 0x00000000,
    UnsafeNativeMethods_ManifestEtw_TRACE_QUERY_INFO_CLASS__Enum_TraceGuidQueryInfo = 0x00000001,
    UnsafeNativeMethods_ManifestEtw_TRACE_QUERY_INFO_CLASS__Enum_TraceGuidQueryProcess = 0x00000002,
    UnsafeNativeMethods_ManifestEtw_TRACE_QUERY_INFO_CLASS__Enum_TraceStackTracingInfo = 0x00000003,
    UnsafeNativeMethods_ManifestEtw_TRACE_QUERY_INFO_CLASS__Enum_MaxTraceSetInfoClass = 0x00000004,
};

#endif
struct UnsafeNativeMethods_ManifestEtw_TRACE_QUERY_INFO_CLASS__Enum__Boxed {
    struct UnsafeNativeMethods_ManifestEtw_TRACE_QUERY_INFO_CLASS__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum UnsafeNativeMethods_ManifestEtw_TRACE_QUERY_INFO_CLASS__Enum value;
    #else
    uint32_t value;
    #endif
};

struct UnsafeNativeMethods_ManifestEtw_TRACE_QUERY_INFO_CLASS__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct UnsafeNativeMethods_ManifestEtw_TRACE_QUERY_INFO_CLASS__Enum__StaticFields {
};

struct UnsafeNativeMethods_ManifestEtw_TRACE_QUERY_INFO_CLASS__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UnsafeNativeMethods_ManifestEtw_TRACE_QUERY_INFO_CLASS__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UnsafeNativeMethods_ManifestEtw_TRACE_QUERY_INFO_CLASS__Enum__VTable vtable;
};

struct RegistryKey__Fields {
    struct MarshalByRefObject__Fields _;
    struct Object *handle;
    struct SafeRegistryHandle *safe_handle;
    struct Object *hive;
    struct String *qname;
    bool isRemoteRoot;
    bool isWritable;
};

struct RegistryKey {
    struct RegistryKey__Class *klass;
    MonitorData *monitor;
    struct RegistryKey__Fields fields;
};

struct SafeRegistryHandle__Fields {
    struct SafeHandleZeroOrMinusOneIsInvalid__Fields _;
};

struct SafeRegistryHandle {
    struct SafeRegistryHandle__Class *klass;
    MonitorData *monitor;
    struct SafeRegistryHandle__Fields fields;
};

struct IRegistryApi {
    struct IRegistryApi__Class *klass;
    MonitorData *monitor;
};

struct SafeRegistryHandle__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_IsInvalid;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData ReleaseHandle;
};

struct SafeRegistryHandle__StaticFields {
};

struct SafeRegistryHandle__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SafeRegistryHandle__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SafeRegistryHandle__VTable vtable;
};

struct IRegistryApi__VTable {
    VirtualInvokeData CreateSubKey;
    VirtualInvokeData OpenRemoteBaseKey;
    VirtualInvokeData OpenSubKey;
    VirtualInvokeData Flush;
    VirtualInvokeData Close;
    VirtualInvokeData GetValue;
    VirtualInvokeData GetValueKind;
    VirtualInvokeData SetValue;
    VirtualInvokeData SubKeyCount;
    VirtualInvokeData ValueCount;
    VirtualInvokeData DeleteValue;
    VirtualInvokeData DeleteKey;
    VirtualInvokeData GetSubKeyNames;
    VirtualInvokeData GetValueNames;
    VirtualInvokeData ToString;
    VirtualInvokeData SetValue_1;
    VirtualInvokeData CreateSubKey_1;
    VirtualInvokeData FromHandle;
    VirtualInvokeData GetHandle;
};

struct IRegistryApi__StaticFields {
};

struct IRegistryApi__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IRegistryApi__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IRegistryApi__VTable vtable;
};

struct RegistryKey__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData Dispose;
};

struct RegistryKey__StaticFields {
    struct IRegistryApi *RegistryApi;
};

struct RegistryKey__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RegistryKey__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RegistryKey__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum RegistryValueKind__Enum : int32_t {
    RegistryValueKind__Enum_Unknown = 0x00000000,
    RegistryValueKind__Enum_String = 0x00000001,
    RegistryValueKind__Enum_ExpandString = 0x00000002,
    RegistryValueKind__Enum_Binary = 0x00000003,
    RegistryValueKind__Enum_DWord = 0x00000004,
    RegistryValueKind__Enum_MultiString = 0x00000007,
    RegistryValueKind__Enum_QWord = 0x0000000b,
    RegistryValueKind__Enum_None = 0xffffffff,
};

#else
enum RegistryValueKind__Enum {
    RegistryValueKind__Enum_Unknown = 0x00000000,
    RegistryValueKind__Enum_String = 0x00000001,
    RegistryValueKind__Enum_ExpandString = 0x00000002,
    RegistryValueKind__Enum_Binary = 0x00000003,
    RegistryValueKind__Enum_DWord = 0x00000004,
    RegistryValueKind__Enum_MultiString = 0x00000007,
    RegistryValueKind__Enum_QWord = 0x0000000b,
    RegistryValueKind__Enum_None = 0xffffffff,
};

#endif
struct RegistryValueKind__Enum__Boxed {
    struct RegistryValueKind__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum RegistryValueKind__Enum value;
    #else
    uint32_t value;
    #endif
};

struct RegistryValueKind__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct RegistryValueKind__Enum__StaticFields {
};

struct RegistryValueKind__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RegistryValueKind__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RegistryValueKind__Enum__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum RegistryHive__Enum : int32_t {
    RegistryHive__Enum_ClassesRoot = 0x80000000,
    RegistryHive__Enum_CurrentConfig = 0x80000005,
    RegistryHive__Enum_CurrentUser = 0x80000001,
    RegistryHive__Enum_DynData = 0x80000006,
    RegistryHive__Enum_LocalMachine = 0x80000002,
    RegistryHive__Enum_PerformanceData = 0x80000004,
    RegistryHive__Enum_Users = 0x80000003,
};

#else
enum RegistryHive__Enum {
    RegistryHive__Enum_ClassesRoot = 0x80000000,
    RegistryHive__Enum_CurrentConfig = 0x80000005,
    RegistryHive__Enum_CurrentUser = 0x80000001,
    RegistryHive__Enum_DynData = 0x80000006,
    RegistryHive__Enum_LocalMachine = 0x80000002,
    RegistryHive__Enum_PerformanceData = 0x80000004,
    RegistryHive__Enum_Users = 0x80000003,
};

#endif
struct RegistryHive__Enum__Boxed {
    struct RegistryHive__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum RegistryHive__Enum value;
    #else
    uint32_t value;
    #endif
};

struct RegistryHive__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct RegistryHive__Enum__StaticFields {
};

struct RegistryHive__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RegistryHive__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RegistryHive__Enum__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum RegistryView__Enum : int32_t {
    RegistryView__Enum_Default = 0x00000000,
    RegistryView__Enum_Registry64 = 0x00000100,
    RegistryView__Enum_Registry32 = 0x00000200,
};

#else
enum RegistryView__Enum {
    RegistryView__Enum_Default = 0x00000000,
    RegistryView__Enum_Registry64 = 0x00000100,
    RegistryView__Enum_Registry32 = 0x00000200,
};

#endif
struct RegistryView__Enum__Boxed {
    struct RegistryView__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum RegistryView__Enum value;
    #else
    uint32_t value;
    #endif
};

struct RegistryView__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct RegistryView__Enum__StaticFields {
};

struct RegistryView__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RegistryView__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RegistryView__Enum__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum RegistryValueOptions__Enum : int32_t {
    RegistryValueOptions__Enum_None = 0x00000000,
    RegistryValueOptions__Enum_DoNotExpandEnvironmentNames = 0x00000001,
};

#else
enum RegistryValueOptions__Enum {
    RegistryValueOptions__Enum_None = 0x00000000,
    RegistryValueOptions__Enum_DoNotExpandEnvironmentNames = 0x00000001,
};

#endif
struct RegistryValueOptions__Enum__Boxed {
    struct RegistryValueOptions__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum RegistryValueOptions__Enum value;
    #else
    uint32_t value;
    #endif
};

struct RegistryValueOptions__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct RegistryValueOptions__Enum__StaticFields {
};

struct RegistryValueOptions__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RegistryValueOptions__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RegistryValueOptions__Enum__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum RegistryKeyPermissionCheck__Enum : int32_t {
    RegistryKeyPermissionCheck__Enum_Default = 0x00000000,
    RegistryKeyPermissionCheck__Enum_ReadSubTree = 0x00000001,
    RegistryKeyPermissionCheck__Enum_ReadWriteSubTree = 0x00000002,
};

#else
enum RegistryKeyPermissionCheck__Enum {
    RegistryKeyPermissionCheck__Enum_Default = 0x00000000,
    RegistryKeyPermissionCheck__Enum_ReadSubTree = 0x00000001,
    RegistryKeyPermissionCheck__Enum_ReadWriteSubTree = 0x00000002,
};

#endif
struct RegistryKeyPermissionCheck__Enum__Boxed {
    struct RegistryKeyPermissionCheck__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum RegistryKeyPermissionCheck__Enum value;
    #else
    uint32_t value;
    #endif
};

struct RegistryKeyPermissionCheck__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct RegistryKeyPermissionCheck__Enum__StaticFields {
};

struct RegistryKeyPermissionCheck__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RegistryKeyPermissionCheck__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RegistryKeyPermissionCheck__Enum__VTable vtable;
};

struct RegistrySecurity__Fields {
    struct NativeObjectSecurity__Fields _;
};

struct RegistrySecurity {
    struct RegistrySecurity__Class *klass;
    MonitorData *monitor;
    struct RegistrySecurity__Fields fields;
};

struct RegistrySecurity__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_AccessRightType;
    VirtualInvokeData get_AccessRuleType;
    VirtualInvokeData get_AuditRuleType;
    VirtualInvokeData AccessRuleFactory;
    VirtualInvokeData AuditRuleFactory;
    VirtualInvokeData ModifyAccessRule;
    VirtualInvokeData ModifyAuditRule;
    VirtualInvokeData PurgeAccessRules;
    VirtualInvokeData PurgeAuditRules;
    VirtualInvokeData ModifyAccess;
    VirtualInvokeData ModifyAudit;
    VirtualInvokeData Persist;
    VirtualInvokeData Persist_1;
    VirtualInvokeData Persist_2;
    VirtualInvokeData InternalAccessRuleFactory;
    VirtualInvokeData InternalAuditRuleFactory;
    VirtualInvokeData InternalGet;
    VirtualInvokeData InternalGet_1;
    VirtualInvokeData InternalSet;
    VirtualInvokeData InternalSet_1;
};

struct RegistrySecurity__StaticFields {
};

struct RegistrySecurity__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RegistrySecurity__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RegistrySecurity__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum RegistryOptions__Enum : int32_t {
    RegistryOptions__Enum_None = 0x00000000,
    RegistryOptions__Enum_Volatile = 0x00000001,
};

#else
enum RegistryOptions__Enum {
    RegistryOptions__Enum_None = 0x00000000,
    RegistryOptions__Enum_Volatile = 0x00000001,
};

#endif
struct RegistryOptions__Enum__Boxed {
    struct RegistryOptions__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum RegistryOptions__Enum value;
    #else
    uint32_t value;
    #endif
};

struct RegistryOptions__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct RegistryOptions__Enum__StaticFields {
};

struct RegistryOptions__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RegistryOptions__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RegistryOptions__Enum__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum RegistryRights__Enum : int32_t {
    RegistryRights__Enum_QueryValues = 0x00000001,
    RegistryRights__Enum_SetValue = 0x00000002,
    RegistryRights__Enum_CreateSubKey = 0x00000004,
    RegistryRights__Enum_EnumerateSubKeys = 0x00000008,
    RegistryRights__Enum_Notify = 0x00000010,
    RegistryRights__Enum_CreateLink = 0x00000020,
    RegistryRights__Enum_Delete = 0x00010000,
    RegistryRights__Enum_ReadPermissions = 0x00020000,
    RegistryRights__Enum_WriteKey = 0x00020006,
    RegistryRights__Enum_ReadKey = 0x00020019,
    RegistryRights__Enum_ExecuteKey = 0x00020019,
    RegistryRights__Enum_ChangePermissions = 0x00040000,
    RegistryRights__Enum_TakeOwnership = 0x00080000,
    RegistryRights__Enum_FullControl = 0x000f003f,
};

#else
enum RegistryRights__Enum {
    RegistryRights__Enum_QueryValues = 0x00000001,
    RegistryRights__Enum_SetValue = 0x00000002,
    RegistryRights__Enum_CreateSubKey = 0x00000004,
    RegistryRights__Enum_EnumerateSubKeys = 0x00000008,
    RegistryRights__Enum_Notify = 0x00000010,
    RegistryRights__Enum_CreateLink = 0x00000020,
    RegistryRights__Enum_Delete = 0x00010000,
    RegistryRights__Enum_ReadPermissions = 0x00020000,
    RegistryRights__Enum_WriteKey = 0x00020006,
    RegistryRights__Enum_ReadKey = 0x00020019,
    RegistryRights__Enum_ExecuteKey = 0x00020019,
    RegistryRights__Enum_ChangePermissions = 0x00040000,
    RegistryRights__Enum_TakeOwnership = 0x00080000,
    RegistryRights__Enum_FullControl = 0x000f003f,
};

#endif
struct RegistryRights__Enum__Boxed {
    struct RegistryRights__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum RegistryRights__Enum value;
    #else
    uint32_t value;
    #endif
};

struct RegistryRights__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct RegistryRights__Enum__StaticFields {
};

struct RegistryRights__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RegistryRights__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RegistryRights__Enum__VTable vtable;
};

struct IOException__Fields {
    struct SystemException__Fields _;
    struct String *_maybeFullPath;
};

struct IOException {
    struct IOException__Class *klass;
    MonitorData *monitor;
    struct IOException__Fields fields;
};

struct IOException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct IOException__StaticFields {
};

struct IOException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IOException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IOException__VTable vtable;
};

struct __declspec(align(8)) ExpandString__Fields {
    struct String *value;
};

struct ExpandString {
    struct ExpandString__Class *klass;
    MonitorData *monitor;
    struct ExpandString__Fields fields;
};

struct ExpandString__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ExpandString__StaticFields {
};

struct ExpandString__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ExpandString__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ExpandString__VTable vtable;
};

struct RegistryKeyComparer {
    struct RegistryKeyComparer__Class *klass;
    MonitorData *monitor;
};

struct RegistryKeyComparer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetHashCode_1;
};

struct RegistryKeyComparer__StaticFields {
};

struct RegistryKeyComparer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RegistryKeyComparer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RegistryKeyComparer__VTable vtable;
};

struct __declspec(align(8)) KeyHandler__Fields {
    struct String *Dir;
    struct String *ActualDir;
    bool IsVolatile;
    struct Hashtable *values;
    struct String *file;
    bool dirty;
};

struct KeyHandler {
    struct KeyHandler__Class *klass;
    MonitorData *monitor;
    struct KeyHandler__Fields fields;
};

struct KeyHandler__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct KeyHandler__StaticFields {
    struct Hashtable *key_to_handler;
    struct Hashtable *dir_to_handler;
    struct String *user_store;
    struct String *machine_store;
};

struct KeyHandler__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyHandler__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyHandler__VTable vtable;
};

struct UnixRegistryApi {
    struct UnixRegistryApi__Class *klass;
    MonitorData *monitor;
};

struct UnixRegistryApi__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateSubKey;
    VirtualInvokeData OpenRemoteBaseKey;
    VirtualInvokeData OpenSubKey;
    VirtualInvokeData Flush;
    VirtualInvokeData Close;
    VirtualInvokeData GetValue;
    VirtualInvokeData GetValueKind;
    VirtualInvokeData SetValue;
    VirtualInvokeData SubKeyCount;
    VirtualInvokeData ValueCount;
    VirtualInvokeData DeleteValue;
    VirtualInvokeData DeleteKey;
    VirtualInvokeData GetSubKeyNames;
    VirtualInvokeData GetValueNames;
    VirtualInvokeData ToString_1;
    VirtualInvokeData SetValue_1;
    VirtualInvokeData CreateSubKey_1;
    VirtualInvokeData FromHandle;
    VirtualInvokeData GetHandle;
};

struct UnixRegistryApi__StaticFields {
};

struct UnixRegistryApi__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UnixRegistryApi__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UnixRegistryApi__VTable vtable;
};

struct CharPtr {
    struct CharPtr__Class *klass;
    MonitorData *monitor;
};

struct Int64__Array {
    struct Int64__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    int64_t vector[32];
};

struct CharPtr__VTable {
};

struct CharPtr__StaticFields {
};

struct CharPtr__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CharPtr__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CharPtr__VTable vtable;
};

struct Int64__Array__VTable {
};

struct Int64__Array__StaticFields {
};

struct Int64__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Int64__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Int64__Array__VTable vtable;
};

struct RegistryValueKind___VTable {
};

struct RegistryValueKind___StaticFields {
};

struct RegistryValueKind___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RegistryValueKind___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RegistryValueKind___VTable vtable;
};

struct __declspec(align(8)) Win32RegistryApi__Fields {
    int32_t NativeBytesPerCharacter;
};

struct Win32RegistryApi {
    struct Win32RegistryApi__Class *klass;
    MonitorData *monitor;
    struct Win32RegistryApi__Fields fields;
};

struct Win32RegistryApi__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateSubKey;
    VirtualInvokeData OpenRemoteBaseKey;
    VirtualInvokeData OpenSubKey;
    VirtualInvokeData Flush;
    VirtualInvokeData Close;
    VirtualInvokeData GetValue;
    VirtualInvokeData GetValueKind;
    VirtualInvokeData SetValue;
    VirtualInvokeData SubKeyCount;
    VirtualInvokeData ValueCount;
    VirtualInvokeData DeleteValue;
    VirtualInvokeData DeleteKey;
    VirtualInvokeData GetSubKeyNames;
    VirtualInvokeData GetValueNames;
    VirtualInvokeData ToString_1;
    VirtualInvokeData SetValue_1;
    VirtualInvokeData CreateSubKey_1;
    VirtualInvokeData FromHandle;
    VirtualInvokeData GetHandle;
};

struct Win32RegistryApi__StaticFields {
};

struct Win32RegistryApi__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Win32RegistryApi__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Win32RegistryApi__VTable vtable;
};

struct Win32ResultCode {
    struct Win32ResultCode__Class *klass;
    MonitorData *monitor;
};

struct Win32ResultCode__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Win32ResultCode__StaticFields {
};

struct Win32ResultCode__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Win32ResultCode__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Win32ResultCode__VTable vtable;
};

struct Win32Native_SECURITY_ATTRIBUTES {
    struct Win32Native_SECURITY_ATTRIBUTES__Class *klass;
    MonitorData *monitor;
};

struct Win32Native_SECURITY_ATTRIBUTES__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Win32Native_SECURITY_ATTRIBUTES__StaticFields {
};

struct Win32Native_SECURITY_ATTRIBUTES__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Win32Native_SECURITY_ATTRIBUTES__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Win32Native_SECURITY_ATTRIBUTES__VTable vtable;
};

struct __declspec(align(8)) Win32Native_WIN32_FIND_DATA__Fields {
    int32_t dwFileAttributes;
    struct String *cFileName;
};

struct Win32Native_WIN32_FIND_DATA {
    struct Win32Native_WIN32_FIND_DATA__Class *klass;
    MonitorData *monitor;
    struct Win32Native_WIN32_FIND_DATA__Fields fields;
};

struct Win32Native_WIN32_FIND_DATA__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Win32Native_WIN32_FIND_DATA__StaticFields {
};

struct Win32Native_WIN32_FIND_DATA__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Win32Native_WIN32_FIND_DATA__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Win32Native_WIN32_FIND_DATA__VTable vtable;
};

struct SafeFindHandle__Fields {
    struct SafeHandleZeroOrMinusOneIsInvalid__Fields _;
};

struct SafeFindHandle {
    struct SafeFindHandle__Class *klass;
    MonitorData *monitor;
    struct SafeFindHandle__Fields fields;
};

struct SafeFindHandle__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_IsInvalid;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData ReleaseHandle;
};

struct SafeFindHandle__StaticFields {
};

struct SafeFindHandle__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SafeFindHandle__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SafeFindHandle__VTable vtable;
};

struct SafeHandleMinusOneIsInvalid__Fields {
    struct SafeHandle__Fields _;
};

struct SafeHandleMinusOneIsInvalid {
    struct SafeHandleMinusOneIsInvalid__Class *klass;
    MonitorData *monitor;
    struct SafeHandleMinusOneIsInvalid__Fields fields;
};

struct SafeHandleMinusOneIsInvalid__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_IsInvalid;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData __unknown;
};

struct SafeHandleMinusOneIsInvalid__StaticFields {
};

struct SafeHandleMinusOneIsInvalid__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SafeHandleMinusOneIsInvalid__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SafeHandleMinusOneIsInvalid__VTable vtable;
};

struct __declspec(align(8)) CriticalHandle__Fields {
    void *handle;
    bool _isClosed;
};

struct CriticalHandle {
    struct CriticalHandle__Class *klass;
    MonitorData *monitor;
    struct CriticalHandle__Fields fields;
};

struct CriticalHandleZeroOrMinusOneIsInvalid__Fields {
    struct CriticalHandle__Fields _;
};

struct CriticalHandleZeroOrMinusOneIsInvalid {
    struct CriticalHandleZeroOrMinusOneIsInvalid__Class *klass;
    MonitorData *monitor;
    struct CriticalHandleZeroOrMinusOneIsInvalid__Fields fields;
};

struct CriticalHandle__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData __unknown;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData __unknown_1;
};

struct CriticalHandle__StaticFields {
};

struct CriticalHandle__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CriticalHandle__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CriticalHandle__VTable vtable;
};

struct CriticalHandleZeroOrMinusOneIsInvalid__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_IsInvalid;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData __unknown;
};

struct CriticalHandleZeroOrMinusOneIsInvalid__StaticFields {
};

struct CriticalHandleZeroOrMinusOneIsInvalid__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CriticalHandleZeroOrMinusOneIsInvalid__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CriticalHandleZeroOrMinusOneIsInvalid__VTable vtable;
};

struct CriticalHandleMinusOneIsInvalid__Fields {
    struct CriticalHandle__Fields _;
};

struct CriticalHandleMinusOneIsInvalid {
    struct CriticalHandleMinusOneIsInvalid__Class *klass;
    MonitorData *monitor;
    struct CriticalHandleMinusOneIsInvalid__Fields fields;
};

struct CriticalHandleMinusOneIsInvalid__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_IsInvalid;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData __unknown;
};

struct CriticalHandleMinusOneIsInvalid__StaticFields {
};

struct CriticalHandleMinusOneIsInvalid__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CriticalHandleMinusOneIsInvalid__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CriticalHandleMinusOneIsInvalid__VTable vtable;
};

struct SafeAccessTokenHandle__Fields {
    struct SafeHandle__Fields _;
};

struct SafeAccessTokenHandle {
    struct SafeAccessTokenHandle__Class *klass;
    MonitorData *monitor;
    struct SafeAccessTokenHandle__Fields fields;
};

struct SafeAccessTokenHandle__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_IsInvalid;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData ReleaseHandle;
};

struct SafeAccessTokenHandle__StaticFields {
};

struct SafeAccessTokenHandle__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SafeAccessTokenHandle__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SafeAccessTokenHandle__VTable vtable;
};

struct ReadOnlySpan_1_Char_ {
    struct Pinnable_1_Char_ *_pinnable;
    void *_byteOffset;
    int32_t _length;
};

struct ReadOnlySpan_1_Char___Boxed {
    struct ReadOnlySpan_1_Char___Class *klass;
    MonitorData *monitor;
    struct ReadOnlySpan_1_Char_ fields;
};

struct __declspec(align(8)) Pinnable_1_Char___Fields {
    uint16_t Data;
};

struct Pinnable_1_Char_ {
    struct Pinnable_1_Char___Class *klass;
    MonitorData *monitor;
    struct Pinnable_1_Char___Fields fields;
};

struct Pinnable_1_Char___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Pinnable_1_Char___StaticFields {
};

struct Pinnable_1_Char___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Pinnable_1_Char___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Pinnable_1_Char___VTable vtable;
};

struct ReadOnlySpan_1_Char___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ReadOnlySpan_1_Char___StaticFields {
};

struct ReadOnlySpan_1_Char___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ReadOnlySpan_1_Char___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ReadOnlySpan_1_Char___VTable vtable;
};

struct UIntPtr {
    struct Void *_pointer;
};

struct UIntPtr__Boxed {
    struct UIntPtr__Class *klass;
    MonitorData *monitor;
    void *fields;
};

struct UIntPtr__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
};

struct UIntPtr__StaticFields {
    void *Zero;
};

struct UIntPtr__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UIntPtr__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UIntPtr__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum ExceptionArgument__Enum : int32_t {
    ExceptionArgument__Enum_obj = 0x00000000,
    ExceptionArgument__Enum_dictionary = 0x00000001,
    ExceptionArgument__Enum_dictionaryCreationThreshold = 0x00000002,
    ExceptionArgument__Enum_array = 0x00000003,
    ExceptionArgument__Enum_info = 0x00000004,
    ExceptionArgument__Enum_key = 0x00000005,
    ExceptionArgument__Enum_collection = 0x00000006,
    ExceptionArgument__Enum_list = 0x00000007,
    ExceptionArgument__Enum_match = 0x00000008,
    ExceptionArgument__Enum_converter = 0x00000009,
    ExceptionArgument__Enum_queue = 0x0000000a,
    ExceptionArgument__Enum_stack = 0x0000000b,
    ExceptionArgument__Enum_capacity = 0x0000000c,
    ExceptionArgument__Enum_index = 0x0000000d,
    ExceptionArgument__Enum_startIndex = 0x0000000e,
    ExceptionArgument__Enum_value = 0x0000000f,
    ExceptionArgument__Enum_count = 0x00000010,
    ExceptionArgument__Enum_arrayIndex = 0x00000011,
    ExceptionArgument__Enum_name = 0x00000012,
    ExceptionArgument__Enum_mode = 0x00000013,
    ExceptionArgument__Enum_item = 0x00000014,
    ExceptionArgument__Enum_options = 0x00000015,
    ExceptionArgument__Enum_view = 0x00000016,
    ExceptionArgument__Enum_sourceBytesToCopy = 0x00000017,
    ExceptionArgument__Enum_start = 0x00000018,
    ExceptionArgument__Enum_pointer = 0x00000019,
    ExceptionArgument__Enum_ownedMemory = 0x0000001a,
    ExceptionArgument__Enum_text = 0x0000001b,
};

#else
enum ExceptionArgument__Enum {
    ExceptionArgument__Enum_obj = 0x00000000,
    ExceptionArgument__Enum_dictionary = 0x00000001,
    ExceptionArgument__Enum_dictionaryCreationThreshold = 0x00000002,
    ExceptionArgument__Enum_array = 0x00000003,
    ExceptionArgument__Enum_info = 0x00000004,
    ExceptionArgument__Enum_key = 0x00000005,
    ExceptionArgument__Enum_collection = 0x00000006,
    ExceptionArgument__Enum_list = 0x00000007,
    ExceptionArgument__Enum_match = 0x00000008,
    ExceptionArgument__Enum_converter = 0x00000009,
    ExceptionArgument__Enum_queue = 0x0000000a,
    ExceptionArgument__Enum_stack = 0x0000000b,
    ExceptionArgument__Enum_capacity = 0x0000000c,
    ExceptionArgument__Enum_index = 0x0000000d,
    ExceptionArgument__Enum_startIndex = 0x0000000e,
    ExceptionArgument__Enum_value = 0x0000000f,
    ExceptionArgument__Enum_count = 0x00000010,
    ExceptionArgument__Enum_arrayIndex = 0x00000011,
    ExceptionArgument__Enum_name = 0x00000012,
    ExceptionArgument__Enum_mode = 0x00000013,
    ExceptionArgument__Enum_item = 0x00000014,
    ExceptionArgument__Enum_options = 0x00000015,
    ExceptionArgument__Enum_view = 0x00000016,
    ExceptionArgument__Enum_sourceBytesToCopy = 0x00000017,
    ExceptionArgument__Enum_start = 0x00000018,
    ExceptionArgument__Enum_pointer = 0x00000019,
    ExceptionArgument__Enum_ownedMemory = 0x0000001a,
    ExceptionArgument__Enum_text = 0x0000001b,
};

#endif
struct ExceptionArgument__Enum__Boxed {
    struct ExceptionArgument__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum ExceptionArgument__Enum value;
    #else
    uint32_t value;
    #endif
};

struct ExceptionArgument__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct ExceptionArgument__Enum__StaticFields {
};

struct ExceptionArgument__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ExceptionArgument__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ExceptionArgument__Enum__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum ExceptionResource__Enum : int32_t {
    ExceptionResource__Enum_Argument_ImplementIComparable = 0x00000000,
    ExceptionResource__Enum_Argument_InvalidType = 0x00000001,
    ExceptionResource__Enum_Argument_InvalidArgumentForComparison = 0x00000002,
    ExceptionResource__Enum_Argument_InvalidRegistryKeyPermissionCheck = 0x00000003,
    ExceptionResource__Enum_ArgumentOutOfRange_NeedNonNegNum = 0x00000004,
    ExceptionResource__Enum_Arg_ArrayPlusOffTooSmall = 0x00000005,
    ExceptionResource__Enum_Arg_NonZeroLowerBound = 0x00000006,
    ExceptionResource__Enum_Arg_RankMultiDimNotSupported = 0x00000007,
    ExceptionResource__Enum_Arg_RegKeyDelHive = 0x00000008,
    ExceptionResource__Enum_Arg_RegKeyStrLenBug = 0x00000009,
    ExceptionResource__Enum_Arg_RegSetStrArrNull = 0x0000000a,
    ExceptionResource__Enum_Arg_RegSetMismatchedKind = 0x0000000b,
    ExceptionResource__Enum_Arg_RegSubKeyAbsent = 0x0000000c,
    ExceptionResource__Enum_Arg_RegSubKeyValueAbsent = 0x0000000d,
    ExceptionResource__Enum_Argument_AddingDuplicate = 0x0000000e,
    ExceptionResource__Enum_Serialization_InvalidOnDeser = 0x0000000f,
    ExceptionResource__Enum_Serialization_MissingKeys = 0x00000010,
    ExceptionResource__Enum_Serialization_NullKey = 0x00000011,
    ExceptionResource__Enum_Argument_InvalidArrayType = 0x00000012,
    ExceptionResource__Enum_NotSupported_KeyCollectionSet = 0x00000013,
    ExceptionResource__Enum_NotSupported_ValueCollectionSet = 0x00000014,
    ExceptionResource__Enum_ArgumentOutOfRange_SmallCapacity = 0x00000015,
    ExceptionResource__Enum_ArgumentOutOfRange_Index = 0x00000016,
    ExceptionResource__Enum_Argument_InvalidOffLen = 0x00000017,
    ExceptionResource__Enum_Argument_ItemNotExist = 0x00000018,
    ExceptionResource__Enum_ArgumentOutOfRange_Count = 0x00000019,
    ExceptionResource__Enum_ArgumentOutOfRange_InvalidThreshold = 0x0000001a,
    ExceptionResource__Enum_ArgumentOutOfRange_ListInsert = 0x0000001b,
    ExceptionResource__Enum_NotSupported_ReadOnlyCollection = 0x0000001c,
    ExceptionResource__Enum_InvalidOperation_CannotRemoveFromStackOrQueue = 0x0000001d,
    ExceptionResource__Enum_InvalidOperation_EmptyQueue = 0x0000001e,
    ExceptionResource__Enum_InvalidOperation_EnumOpCantHappen = 0x0000001f,
    ExceptionResource__Enum_InvalidOperation_EnumFailedVersion = 0x00000020,
    ExceptionResource__Enum_InvalidOperation_EmptyStack = 0x00000021,
    ExceptionResource__Enum_ArgumentOutOfRange_BiggerThanCollection = 0x00000022,
    ExceptionResource__Enum_InvalidOperation_EnumNotStarted = 0x00000023,
    ExceptionResource__Enum_InvalidOperation_EnumEnded = 0x00000024,
    ExceptionResource__Enum_NotSupported_SortedListNestedWrite = 0x00000025,
    ExceptionResource__Enum_InvalidOperation_NoValue = 0x00000026,
    ExceptionResource__Enum_InvalidOperation_RegRemoveSubKey = 0x00000027,
    ExceptionResource__Enum_Security_RegistryPermission = 0x00000028,
    ExceptionResource__Enum_UnauthorizedAccess_RegistryNoWrite = 0x00000029,
    ExceptionResource__Enum_ObjectDisposed_RegKeyClosed = 0x0000002a,
    ExceptionResource__Enum_NotSupported_InComparableType = 0x0000002b,
    ExceptionResource__Enum_Argument_InvalidRegistryOptionsCheck = 0x0000002c,
    ExceptionResource__Enum_Argument_InvalidRegistryViewCheck = 0x0000002d,
};

#else
enum ExceptionResource__Enum {
    ExceptionResource__Enum_Argument_ImplementIComparable = 0x00000000,
    ExceptionResource__Enum_Argument_InvalidType = 0x00000001,
    ExceptionResource__Enum_Argument_InvalidArgumentForComparison = 0x00000002,
    ExceptionResource__Enum_Argument_InvalidRegistryKeyPermissionCheck = 0x00000003,
    ExceptionResource__Enum_ArgumentOutOfRange_NeedNonNegNum = 0x00000004,
    ExceptionResource__Enum_Arg_ArrayPlusOffTooSmall = 0x00000005,
    ExceptionResource__Enum_Arg_NonZeroLowerBound = 0x00000006,
    ExceptionResource__Enum_Arg_RankMultiDimNotSupported = 0x00000007,
    ExceptionResource__Enum_Arg_RegKeyDelHive = 0x00000008,
    ExceptionResource__Enum_Arg_RegKeyStrLenBug = 0x00000009,
    ExceptionResource__Enum_Arg_RegSetStrArrNull = 0x0000000a,
    ExceptionResource__Enum_Arg_RegSetMismatchedKind = 0x0000000b,
    ExceptionResource__Enum_Arg_RegSubKeyAbsent = 0x0000000c,
    ExceptionResource__Enum_Arg_RegSubKeyValueAbsent = 0x0000000d,
    ExceptionResource__Enum_Argument_AddingDuplicate = 0x0000000e,
    ExceptionResource__Enum_Serialization_InvalidOnDeser = 0x0000000f,
    ExceptionResource__Enum_Serialization_MissingKeys = 0x00000010,
    ExceptionResource__Enum_Serialization_NullKey = 0x00000011,
    ExceptionResource__Enum_Argument_InvalidArrayType = 0x00000012,
    ExceptionResource__Enum_NotSupported_KeyCollectionSet = 0x00000013,
    ExceptionResource__Enum_NotSupported_ValueCollectionSet = 0x00000014,
    ExceptionResource__Enum_ArgumentOutOfRange_SmallCapacity = 0x00000015,
    ExceptionResource__Enum_ArgumentOutOfRange_Index = 0x00000016,
    ExceptionResource__Enum_Argument_InvalidOffLen = 0x00000017,
    ExceptionResource__Enum_Argument_ItemNotExist = 0x00000018,
    ExceptionResource__Enum_ArgumentOutOfRange_Count = 0x00000019,
    ExceptionResource__Enum_ArgumentOutOfRange_InvalidThreshold = 0x0000001a,
    ExceptionResource__Enum_ArgumentOutOfRange_ListInsert = 0x0000001b,
    ExceptionResource__Enum_NotSupported_ReadOnlyCollection = 0x0000001c,
    ExceptionResource__Enum_InvalidOperation_CannotRemoveFromStackOrQueue = 0x0000001d,
    ExceptionResource__Enum_InvalidOperation_EmptyQueue = 0x0000001e,
    ExceptionResource__Enum_InvalidOperation_EnumOpCantHappen = 0x0000001f,
    ExceptionResource__Enum_InvalidOperation_EnumFailedVersion = 0x00000020,
    ExceptionResource__Enum_InvalidOperation_EmptyStack = 0x00000021,
    ExceptionResource__Enum_ArgumentOutOfRange_BiggerThanCollection = 0x00000022,
    ExceptionResource__Enum_InvalidOperation_EnumNotStarted = 0x00000023,
    ExceptionResource__Enum_InvalidOperation_EnumEnded = 0x00000024,
    ExceptionResource__Enum_NotSupported_SortedListNestedWrite = 0x00000025,
    ExceptionResource__Enum_InvalidOperation_NoValue = 0x00000026,
    ExceptionResource__Enum_InvalidOperation_RegRemoveSubKey = 0x00000027,
    ExceptionResource__Enum_Security_RegistryPermission = 0x00000028,
    ExceptionResource__Enum_UnauthorizedAccess_RegistryNoWrite = 0x00000029,
    ExceptionResource__Enum_ObjectDisposed_RegKeyClosed = 0x0000002a,
    ExceptionResource__Enum_NotSupported_InComparableType = 0x0000002b,
    ExceptionResource__Enum_Argument_InvalidRegistryOptionsCheck = 0x0000002c,
    ExceptionResource__Enum_Argument_InvalidRegistryViewCheck = 0x0000002d,
};

#endif
struct ExceptionResource__Enum__Boxed {
    struct ExceptionResource__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum ExceptionResource__Enum value;
    #else
    uint32_t value;
    #endif
};

struct ExceptionResource__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct ExceptionResource__Enum__StaticFields {
};

struct ExceptionResource__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ExceptionResource__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ExceptionResource__Enum__VTable vtable;
};

struct ValueTuple {
};

struct ValueTuple__Boxed {
    struct ValueTuple__Class *klass;
    MonitorData *monitor;
    struct ValueTuple fields;
};

struct ValueTuple__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Equals_1;
    VirtualInvokeData System_Collections_IStructuralEquatable_Equals;
    VirtualInvokeData System_Collections_IStructuralEquatable_GetHashCode;
    VirtualInvokeData System_Collections_IStructuralComparable_CompareTo;
    VirtualInvokeData System_IComparable_CompareTo;
    VirtualInvokeData CompareTo;
    VirtualInvokeData System_IValueTupleInternal_GetHashCode;
    VirtualInvokeData System_IValueTupleInternal_ToStringEnd;
    VirtualInvokeData System_Runtime_CompilerServices_ITuple_get_Length;
    VirtualInvokeData System_Runtime_CompilerServices_ITuple_get_Item;
};

struct ValueTuple__StaticFields {
};

struct ValueTuple__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ValueTuple__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ValueTuple__VTable vtable;
};

struct __declspec(align(8)) Array_ArrayEnumerator__Fields {
    struct Array *_array;
    int32_t _index;
    int32_t _endIndex;
};

struct Array_ArrayEnumerator {
    struct Array_ArrayEnumerator__Class *klass;
    MonitorData *monitor;
    struct Array_ArrayEnumerator__Fields fields;
};

struct Array_ArrayEnumerator__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData MoveNext;
    VirtualInvokeData get_Current;
    VirtualInvokeData Reset;
    VirtualInvokeData Clone;
};

struct Array_ArrayEnumerator__StaticFields {
};

struct Array_ArrayEnumerator__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Array_ArrayEnumerator__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Array_ArrayEnumerator__VTable vtable;
};

struct Array_SorterObjectArray {
    struct Object__Array *keys;
    struct Object__Array *items;
    struct IComparer *comparer;
};

struct Array_SorterObjectArray__Boxed {
    struct Array_SorterObjectArray__Class *klass;
    MonitorData *monitor;
    struct Array_SorterObjectArray fields;
};

struct Array_SorterObjectArray__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Array_SorterObjectArray__StaticFields {
};

struct Array_SorterObjectArray__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Array_SorterObjectArray__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Array_SorterObjectArray__VTable vtable;
};

struct Array_SorterGenericArray {
    struct Array *keys;
    struct Array *items;
    struct IComparer *comparer;
};

struct Array_SorterGenericArray__Boxed {
    struct Array_SorterGenericArray__Class *klass;
    MonitorData *monitor;
    struct Array_SorterGenericArray fields;
};

struct Array_SorterGenericArray__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Array_SorterGenericArray__StaticFields {
};

struct Array_SorterGenericArray__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Array_SorterGenericArray__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Array_SorterGenericArray__VTable vtable;
};

struct __declspec(align(8)) MonoTODOAttribute__Fields {
    struct String *comment;
};

struct MonoTODOAttribute {
    struct MonoTODOAttribute__Class *klass;
    MonitorData *monitor;
    struct MonoTODOAttribute__Fields fields;
};

struct MonoTODOAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct MonoTODOAttribute__StaticFields {
};

struct MonoTODOAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoTODOAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoTODOAttribute__VTable vtable;
};

struct MonoDocumentationNoteAttribute__Fields {
    struct MonoTODOAttribute__Fields _;
};

struct MonoDocumentationNoteAttribute {
    struct MonoDocumentationNoteAttribute__Class *klass;
    MonitorData *monitor;
    struct MonoDocumentationNoteAttribute__Fields fields;
};

struct MonoDocumentationNoteAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct MonoDocumentationNoteAttribute__StaticFields {
};

struct MonoDocumentationNoteAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoDocumentationNoteAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoDocumentationNoteAttribute__VTable vtable;
};

struct MonoExtensionAttribute__Fields {
    struct MonoTODOAttribute__Fields _;
};

struct MonoExtensionAttribute {
    struct MonoExtensionAttribute__Class *klass;
    MonitorData *monitor;
    struct MonoExtensionAttribute__Fields fields;
};

struct MonoExtensionAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct MonoExtensionAttribute__StaticFields {
};

struct MonoExtensionAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoExtensionAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoExtensionAttribute__VTable vtable;
};

struct MonoInternalNoteAttribute__Fields {
    struct MonoTODOAttribute__Fields _;
};

struct MonoInternalNoteAttribute {
    struct MonoInternalNoteAttribute__Class *klass;
    MonitorData *monitor;
    struct MonoInternalNoteAttribute__Fields fields;
};

struct MonoInternalNoteAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct MonoInternalNoteAttribute__StaticFields {
};

struct MonoInternalNoteAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoInternalNoteAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoInternalNoteAttribute__VTable vtable;
};

struct MonoLimitationAttribute__Fields {
    struct MonoTODOAttribute__Fields _;
};

struct MonoLimitationAttribute {
    struct MonoLimitationAttribute__Class *klass;
    MonitorData *monitor;
    struct MonoLimitationAttribute__Fields fields;
};

struct MonoLimitationAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct MonoLimitationAttribute__StaticFields {
};

struct MonoLimitationAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoLimitationAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoLimitationAttribute__VTable vtable;
};

struct MonoNotSupportedAttribute__Fields {
    struct MonoTODOAttribute__Fields _;
};

struct MonoNotSupportedAttribute {
    struct MonoNotSupportedAttribute__Class *klass;
    MonitorData *monitor;
    struct MonoNotSupportedAttribute__Fields fields;
};

struct MonoNotSupportedAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct MonoNotSupportedAttribute__StaticFields {
};

struct MonoNotSupportedAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoNotSupportedAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoNotSupportedAttribute__VTable vtable;
};

struct IEnumerable_1_System_Exception_ {
    struct IEnumerable_1_System_Exception___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_Exception___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_Exception___StaticFields {
};

struct IEnumerable_1_System_Exception___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_Exception___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_Exception___VTable vtable;
};

struct IEnumerable_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo_ {
    struct IEnumerable_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo___StaticFields {
};

struct IEnumerable_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo___VTable vtable;
};

struct IList_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo_ {
    struct IList_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo___Class *klass;
    MonitorData *monitor;
};

struct IList_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo___VTable {
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData RemoveAt;
};

struct IList_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo___StaticFields {
};

struct IList_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IList_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IList_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo___VTable vtable;
};

struct Func_2_Exception_Boolean___Fields {
    struct MulticastDelegate__Fields _;
};

struct Func_2_Exception_Boolean_ {
    struct Func_2_Exception_Boolean___Class *klass;
    MonitorData *monitor;
    struct Func_2_Exception_Boolean___Fields fields;
};

struct Func_2_Exception_Boolean___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Func_2_Exception_Boolean___StaticFields {
};

struct Func_2_Exception_Boolean___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Func_2_Exception_Boolean___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Func_2_Exception_Boolean___VTable vtable;
};

struct FormattableString {
    struct FormattableString__Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) FormattableStringFactory_ConcreteFormattableString__Fields {
    struct String *_format;
    struct Object__Array *_arguments;
};

struct FormattableStringFactory_ConcreteFormattableString {
    struct FormattableStringFactory_ConcreteFormattableString__Class *klass;
    MonitorData *monitor;
    struct FormattableStringFactory_ConcreteFormattableString__Fields fields;
};

struct FormattableStringFactory_ConcreteFormattableString__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_IFormattable_ToString;
    VirtualInvokeData get_Format;
    VirtualInvokeData GetArguments;
    VirtualInvokeData get_ArgumentCount;
    VirtualInvokeData GetArgument;
    VirtualInvokeData ToString_1;
};

struct FormattableStringFactory_ConcreteFormattableString__StaticFields {
};

struct FormattableStringFactory_ConcreteFormattableString__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FormattableStringFactory_ConcreteFormattableString__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FormattableStringFactory_ConcreteFormattableString__VTable vtable;
};

struct FormattableString__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_IFormattable_ToString;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData __unknown_4;
};

struct FormattableString__StaticFields {
};

struct FormattableString__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FormattableString__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FormattableString__VTable vtable;
};

struct _Filters {
    struct _Filters__Class *klass;
    MonitorData *monitor;
};

struct _Filters__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData FilterAttribute;
    VirtualInvokeData FilterName;
    VirtualInvokeData FilterIgnoreCase;
};

struct _Filters__StaticFields {
    struct _Filters *Instance;
};

struct _Filters__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct _Filters__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct _Filters__VTable vtable;
};

struct __declspec(align(8)) LocalDataStoreHolder__Fields {
    struct LocalDataStore *m_Store;
};

struct LocalDataStoreHolder {
    struct LocalDataStoreHolder__Class *klass;
    MonitorData *monitor;
    struct LocalDataStoreHolder__Fields fields;
};

struct __declspec(align(8)) LocalDataStore__Fields {
    struct LocalDataStoreElement__Array *m_DataTable;
    struct LocalDataStoreMgr *m_Manager;
};

struct LocalDataStore {
    struct LocalDataStore__Class *klass;
    MonitorData *monitor;
    struct LocalDataStore__Fields fields;
};

struct __declspec(align(8)) LocalDataStoreElement__Fields {
    struct Object *m_value;
    int64_t m_cookie;
};

struct LocalDataStoreElement {
    struct LocalDataStoreElement__Class *klass;
    MonitorData *monitor;
    struct LocalDataStoreElement__Fields fields;
};

struct LocalDataStoreElement__Array {
    struct LocalDataStoreElement__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct LocalDataStoreElement *vector[32];
};

struct __declspec(align(8)) LocalDataStoreMgr__Fields {
    struct Boolean__Array *m_SlotInfoTable;
    int32_t m_FirstAvailableSlot;
    struct List_1_System_LocalDataStore_ *m_ManagedLocalDataStores;
    struct Dictionary_2_System_String_System_LocalDataStoreSlot_ *m_KeyToSlotMap;
    int64_t m_CookieGenerator;
};

struct LocalDataStoreMgr {
    struct LocalDataStoreMgr__Class *klass;
    MonitorData *monitor;
    struct LocalDataStoreMgr__Fields fields;
};

struct __declspec(align(8)) List_1_System_LocalDataStore___Fields {
    struct LocalDataStore__Array *_items;
    int32_t _size;
    int32_t _version;
    struct Object *_syncRoot;
};

struct List_1_System_LocalDataStore_ {
    struct List_1_System_LocalDataStore___Class *klass;
    MonitorData *monitor;
    struct List_1_System_LocalDataStore___Fields fields;
};

struct LocalDataStore__Array {
    struct LocalDataStore__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct LocalDataStore *vector[32];
};

struct IEnumerator_1_System_LocalDataStore_ {
    struct IEnumerator_1_System_LocalDataStore___Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) Dictionary_2_System_String_System_LocalDataStoreSlot___Fields {
    struct Int32__Array *buckets;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_LocalDataStoreSlot___Array *entries;
    int32_t count;
    int32_t version;
    int32_t freeList;
    int32_t freeCount;
    struct IEqualityComparer_1_System_String_ *comparer;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_LocalDataStoreSlot_ *keys;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_LocalDataStoreSlot_ *values;
    struct Object *_syncRoot;
};

struct Dictionary_2_System_String_System_LocalDataStoreSlot_ {
    struct Dictionary_2_System_String_System_LocalDataStoreSlot___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_System_String_System_LocalDataStoreSlot___Fields fields;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_LocalDataStoreSlot_ {
    int32_t hashCode;
    int32_t next;
    struct String *key;
    struct LocalDataStoreSlot *value;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_LocalDataStoreSlot___Boxed {
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_LocalDataStoreSlot___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_LocalDataStoreSlot_ fields;
};

struct __declspec(align(8)) LocalDataStoreSlot__Fields {
    struct LocalDataStoreMgr *m_mgr;
    int32_t m_slot;
    int64_t m_cookie;
};

struct LocalDataStoreSlot {
    struct LocalDataStoreSlot__Class *klass;
    MonitorData *monitor;
    struct LocalDataStoreSlot__Fields fields;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_LocalDataStoreSlot___Array {
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_LocalDataStoreSlot___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_LocalDataStoreSlot_ vector[32];
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_KeyCollection_System_String_System_LocalDataStoreSlot___Fields {
    struct Dictionary_2_System_String_System_LocalDataStoreSlot_ *dictionary;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_LocalDataStoreSlot_ {
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_LocalDataStoreSlot___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_LocalDataStoreSlot___Fields fields;
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_ValueCollection_System_String_System_LocalDataStoreSlot___Fields {
    struct Dictionary_2_System_String_System_LocalDataStoreSlot_ *dictionary;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_LocalDataStoreSlot_ {
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_LocalDataStoreSlot___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_LocalDataStoreSlot___Fields fields;
};

struct LocalDataStoreSlot__Array {
    struct LocalDataStoreSlot__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct LocalDataStoreSlot *vector[32];
};

struct IEnumerator_1_System_LocalDataStoreSlot_ {
    struct IEnumerator_1_System_LocalDataStoreSlot___Class *klass;
    MonitorData *monitor;
};

struct ICollection_1_System_LocalDataStoreSlot_ {
    struct ICollection_1_System_LocalDataStoreSlot___Class *klass;
    MonitorData *monitor;
};

struct KeyValuePair_2_System_String_System_LocalDataStoreSlot_ {
    struct String *key;
    struct LocalDataStoreSlot *value;
};

struct KeyValuePair_2_System_String_System_LocalDataStoreSlot___Boxed {
    struct KeyValuePair_2_System_String_System_LocalDataStoreSlot___Class *klass;
    MonitorData *monitor;
    struct KeyValuePair_2_System_String_System_LocalDataStoreSlot_ fields;
};

struct KeyValuePair_2_System_String_System_LocalDataStoreSlot___Array {
    struct KeyValuePair_2_System_String_System_LocalDataStoreSlot___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct KeyValuePair_2_System_String_System_LocalDataStoreSlot_ vector[32];
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_LocalDataStoreSlot_ {
    struct IEnumerator_1_KeyValuePair_2_System_String_System_LocalDataStoreSlot___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_LocalDataStoreSlot_ {
    struct IEnumerable_1_System_LocalDataStoreSlot___Class *klass;
    MonitorData *monitor;
};

struct LocalDataStoreElement__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct LocalDataStoreElement__StaticFields {
};

struct LocalDataStoreElement__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct LocalDataStoreElement__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct LocalDataStoreElement__VTable vtable;
};

struct LocalDataStoreElement__Array__VTable {
};

struct LocalDataStoreElement__Array__StaticFields {
};

struct LocalDataStoreElement__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct LocalDataStoreElement__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct LocalDataStoreElement__Array__VTable vtable;
};

struct LocalDataStore__Array__VTable {
};

struct LocalDataStore__Array__StaticFields {
};

struct LocalDataStore__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct LocalDataStore__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct LocalDataStore__Array__VTable vtable;
};

struct IEnumerator_1_System_LocalDataStore___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_System_LocalDataStore___StaticFields {
};

struct IEnumerator_1_System_LocalDataStore___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_System_LocalDataStore___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_System_LocalDataStore___VTable vtable;
};

struct List_1_System_LocalDataStore___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData RemoveAt;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_T__get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_T__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IList_get_Item;
    VirtualInvokeData System_Collections_IList_set_Item;
    VirtualInvokeData System_Collections_IList_Add;
    VirtualInvokeData System_Collections_IList_Contains;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IList_get_IsReadOnly;
    VirtualInvokeData System_Collections_IList_get_IsFixedSize;
    VirtualInvokeData System_Collections_IList_IndexOf;
    VirtualInvokeData System_Collections_IList_Insert;
    VirtualInvokeData System_Collections_IList_Remove;
    VirtualInvokeData RemoveAt_1;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData get_Count_2;
};

struct List_1_System_LocalDataStore___StaticFields {
    struct LocalDataStore__Array *_emptyArray;
};

struct List_1_System_LocalDataStore___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct List_1_System_LocalDataStore___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct List_1_System_LocalDataStore___VTable vtable;
};

struct LocalDataStoreSlot__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct LocalDataStoreSlot__StaticFields {
};

struct LocalDataStoreSlot__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct LocalDataStoreSlot__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct LocalDataStoreSlot__VTable vtable;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_LocalDataStoreSlot___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_LocalDataStoreSlot___StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_LocalDataStoreSlot___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_LocalDataStoreSlot___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_LocalDataStoreSlot___VTable vtable;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_LocalDataStoreSlot___Array__VTable {
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_LocalDataStoreSlot___Array__StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_LocalDataStoreSlot___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_LocalDataStoreSlot___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_LocalDataStoreSlot___Array__VTable vtable;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_LocalDataStoreSlot___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TKey__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_LocalDataStoreSlot___StaticFields {
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_LocalDataStoreSlot___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_LocalDataStoreSlot___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_LocalDataStoreSlot___VTable vtable;
};

struct LocalDataStoreSlot__Array__VTable {
};

struct LocalDataStoreSlot__Array__StaticFields {
};

struct LocalDataStoreSlot__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct LocalDataStoreSlot__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct LocalDataStoreSlot__Array__VTable vtable;
};

struct IEnumerator_1_System_LocalDataStoreSlot___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_System_LocalDataStoreSlot___StaticFields {
};

struct IEnumerator_1_System_LocalDataStoreSlot___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_System_LocalDataStoreSlot___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_System_LocalDataStoreSlot___VTable vtable;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_LocalDataStoreSlot___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TValue__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_LocalDataStoreSlot___StaticFields {
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_LocalDataStoreSlot___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_LocalDataStoreSlot___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_LocalDataStoreSlot___VTable vtable;
};

struct ICollection_1_System_LocalDataStoreSlot___VTable {
    VirtualInvokeData get_Count;
    VirtualInvokeData get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
};

struct ICollection_1_System_LocalDataStoreSlot___StaticFields {
};

struct ICollection_1_System_LocalDataStoreSlot___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ICollection_1_System_LocalDataStoreSlot___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ICollection_1_System_LocalDataStoreSlot___VTable vtable;
};

struct LocalDataStoreSlot___VTable {
};

struct LocalDataStoreSlot___StaticFields {
};

struct LocalDataStoreSlot___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct LocalDataStoreSlot___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct LocalDataStoreSlot___VTable vtable;
};

struct KeyValuePair_2_System_String_System_LocalDataStoreSlot___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct KeyValuePair_2_System_String_System_LocalDataStoreSlot___StaticFields {
};

struct KeyValuePair_2_System_String_System_LocalDataStoreSlot___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_String_System_LocalDataStoreSlot___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_String_System_LocalDataStoreSlot___VTable vtable;
};

struct KeyValuePair_2_System_String_System_LocalDataStoreSlot___Array__VTable {
};

struct KeyValuePair_2_System_String_System_LocalDataStoreSlot___Array__StaticFields {
};

struct KeyValuePair_2_System_String_System_LocalDataStoreSlot___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_String_System_LocalDataStoreSlot___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_String_System_LocalDataStoreSlot___Array__VTable vtable;
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_LocalDataStoreSlot___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_LocalDataStoreSlot___StaticFields {
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_LocalDataStoreSlot___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_KeyValuePair_2_System_String_System_LocalDataStoreSlot___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_KeyValuePair_2_System_String_System_LocalDataStoreSlot___VTable vtable;
};

struct IEnumerable_1_System_LocalDataStoreSlot___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_LocalDataStoreSlot___StaticFields {
};

struct IEnumerable_1_System_LocalDataStoreSlot___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_LocalDataStoreSlot___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_LocalDataStoreSlot___VTable vtable;
};

struct Dictionary_2_System_String_System_LocalDataStoreSlot___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Values;
    VirtualInvokeData ContainsKey;
    VirtualInvokeData Add;
    VirtualInvokeData Remove;
    VirtualInvokeData TryGetValue;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Add;
    VirtualInvokeData Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Contains;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_System_Collections_Generic_KeyValuePair_TKey_TValue___GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_get_Item;
    VirtualInvokeData System_Collections_IDictionary_set_Item;
    VirtualInvokeData System_Collections_IDictionary_get_Keys;
    VirtualInvokeData System_Collections_IDictionary_get_Values;
    VirtualInvokeData System_Collections_IDictionary_Contains;
    VirtualInvokeData System_Collections_IDictionary_Add;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IDictionary_get_IsReadOnly;
    VirtualInvokeData System_Collections_IDictionary_get_IsFixedSize;
    VirtualInvokeData System_Collections_IDictionary_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_Remove;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData ContainsKey_1;
    VirtualInvokeData TryGetValue_1;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Values;
    VirtualInvokeData get_Count_2;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData OnDeserialization;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData OnDeserialization_1;
};

struct Dictionary_2_System_String_System_LocalDataStoreSlot___StaticFields {
};

struct Dictionary_2_System_String_System_LocalDataStoreSlot___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_System_String_System_LocalDataStoreSlot___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_System_String_System_LocalDataStoreSlot___VTable vtable;
};

struct LocalDataStoreMgr__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct LocalDataStoreMgr__StaticFields {
};

struct LocalDataStoreMgr__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct LocalDataStoreMgr__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct LocalDataStoreMgr__VTable vtable;
};

struct LocalDataStore__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct LocalDataStore__StaticFields {
};

struct LocalDataStore__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct LocalDataStore__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct LocalDataStore__VTable vtable;
};

struct LocalDataStoreHolder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct LocalDataStoreHolder__StaticFields {
};

struct LocalDataStoreHolder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct LocalDataStoreHolder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct LocalDataStoreHolder__VTable vtable;
};

struct AccessViolationException__Fields {
    struct SystemException__Fields _;
    void *_ip;
    void *_target;
    int32_t _accessType;
};

struct AccessViolationException {
    struct AccessViolationException__Class *klass;
    MonitorData *monitor;
    struct AccessViolationException__Fields fields;
};

struct AccessViolationException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct AccessViolationException__StaticFields {
};

struct AccessViolationException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AccessViolationException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AccessViolationException__VTable vtable;
};

struct Action__Fields {
    struct MulticastDelegate__Fields _;
};

struct Action {
    struct Action__Class *klass;
    MonitorData *monitor;
    struct Action__Fields fields;
};

struct Action__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Action__StaticFields {
};

struct Action__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Action__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Action__VTable vtable;
};

struct Activator {
    struct Activator__Class *klass;
    MonitorData *monitor;
};

struct Activator__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Activator_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Activator_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Activator_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Activator_Invoke;
};

struct Activator__StaticFields {
};

struct Activator__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Activator__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Activator__VTable vtable;
};

struct ObjectHandle__Fields {
    struct MarshalByRefObject__Fields _;
    struct Object *_wrapped;
};

struct ObjectHandle {
    struct ObjectHandle__Class *klass;
    MonitorData *monitor;
    struct ObjectHandle__Fields fields;
};

struct ObjectHandle__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData Unwrap;
};

struct ObjectHandle__StaticFields {
};

struct ObjectHandle__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ObjectHandle__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ObjectHandle__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum StackCrawlMark__Enum : int32_t {
    StackCrawlMark__Enum_LookForMe = 0x00000000,
    StackCrawlMark__Enum_LookForMyCaller = 0x00000001,
    StackCrawlMark__Enum_LookForMyCallersCaller = 0x00000002,
    StackCrawlMark__Enum_LookForThread = 0x00000003,
};

#else
enum StackCrawlMark__Enum {
    StackCrawlMark__Enum_LookForMe = 0x00000000,
    StackCrawlMark__Enum_LookForMyCaller = 0x00000001,
    StackCrawlMark__Enum_LookForMyCallersCaller = 0x00000002,
    StackCrawlMark__Enum_LookForThread = 0x00000003,
};

#endif
struct StackCrawlMark__Enum__Boxed {
    struct StackCrawlMark__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum StackCrawlMark__Enum value;
    #else
    uint32_t value;
    #endif
};

struct StackCrawlMark__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct StackCrawlMark__Enum__StaticFields {
};

struct StackCrawlMark__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StackCrawlMark__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StackCrawlMark__Enum__VTable vtable;
};

struct StackCrawlMark___VTable {
};

struct StackCrawlMark___StaticFields {
};

struct StackCrawlMark___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StackCrawlMark___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StackCrawlMark___VTable vtable;
};

struct AppDomain__Fields {
    struct MarshalByRefObject__Fields _;
    void *_mono_app_domain;
    struct Object *_evidence;
    struct Object *_granted;
    int32_t _principalPolicy;
    struct AssemblyLoadEventHandler *AssemblyLoad;
    struct ResolveEventHandler *AssemblyResolve;
    struct EventHandler *DomainUnload;
    struct EventHandler *ProcessExit;
    struct ResolveEventHandler *ResourceResolve;
    struct ResolveEventHandler *TypeResolve;
    struct UnhandledExceptionEventHandler *UnhandledException;
    struct EventHandler_1_System_Runtime_ExceptionServices_FirstChanceExceptionEventArgs_ *FirstChanceException;
    struct Object *_domain_manager;
    struct ResolveEventHandler *ReflectionOnlyAssemblyResolve;
    struct Object *_activation;
    struct Object *_applicationIdentity;
    struct List_1_System_String_ *compatibility_switch;
};

struct AppDomain {
    struct AppDomain__Class *klass;
    MonitorData *monitor;
    struct AppDomain__Fields fields;
};

struct __declspec(align(8)) Dictionary_2_System_String_System_Object___Fields {
    struct Int32__Array *buckets;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Object___Array *entries;
    int32_t count;
    int32_t version;
    int32_t freeList;
    int32_t freeCount;
    struct IEqualityComparer_1_System_String_ *comparer;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Object_ *keys;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Object_ *values;
    struct Object *_syncRoot;
};

struct Dictionary_2_System_String_System_Object_ {
    struct Dictionary_2_System_String_System_Object___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_System_String_System_Object___Fields fields;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Object_ {
    int32_t hashCode;
    int32_t next;
    struct String *key;
    struct Object *value;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Object___Boxed {
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Object___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Object_ fields;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Object___Array {
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Object___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Object_ vector[32];
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Object___Fields {
    struct Dictionary_2_System_String_System_Object_ *dictionary;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Object_ {
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Object___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Object___Fields fields;
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Object___Fields {
    struct Dictionary_2_System_String_System_Object_ *dictionary;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Object_ {
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Object___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Object___Fields fields;
};

struct KeyValuePair_2_System_String_System_Object_ {
    struct String *key;
    struct Object *value;
};

struct KeyValuePair_2_System_String_System_Object___Boxed {
    struct KeyValuePair_2_System_String_System_Object___Class *klass;
    MonitorData *monitor;
    struct KeyValuePair_2_System_String_System_Object_ fields;
};

struct KeyValuePair_2_System_String_System_Object___Array {
    struct KeyValuePair_2_System_String_System_Object___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct KeyValuePair_2_System_String_System_Object_ vector[32];
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_Object_ {
    struct IEnumerator_1_KeyValuePair_2_System_String_System_Object___Class *klass;
    MonitorData *monitor;
};

struct AssemblyLoadEventHandler__Fields {
    struct MulticastDelegate__Fields _;
};

struct AssemblyLoadEventHandler {
    struct AssemblyLoadEventHandler__Class *klass;
    MonitorData *monitor;
    struct AssemblyLoadEventHandler__Fields fields;
};

struct __declspec(align(8)) AssemblyLoadEventArgs__Fields {
    struct Assembly *m_loadedAssembly;
};

struct AssemblyLoadEventArgs {
    struct AssemblyLoadEventArgs__Class *klass;
    MonitorData *monitor;
    struct AssemblyLoadEventArgs__Fields fields;
};

struct ResolveEventHandler__Fields {
    struct MulticastDelegate__Fields _;
};

struct ResolveEventHandler {
    struct ResolveEventHandler__Class *klass;
    MonitorData *monitor;
    struct ResolveEventHandler__Fields fields;
};

struct UnhandledExceptionEventHandler__Fields {
    struct MulticastDelegate__Fields _;
};

struct UnhandledExceptionEventHandler {
    struct UnhandledExceptionEventHandler__Class *klass;
    MonitorData *monitor;
    struct UnhandledExceptionEventHandler__Fields fields;
};

struct __declspec(align(8)) UnhandledExceptionEventArgs__Fields {
    struct Object *_Exception;
    bool _IsTerminating;
};

struct UnhandledExceptionEventArgs {
    struct UnhandledExceptionEventArgs__Class *klass;
    MonitorData *monitor;
    struct UnhandledExceptionEventArgs__Fields fields;
};

struct EventHandler_1_System_Runtime_ExceptionServices_FirstChanceExceptionEventArgs___Fields {
    struct MulticastDelegate__Fields _;
};

struct EventHandler_1_System_Runtime_ExceptionServices_FirstChanceExceptionEventArgs_ {
    struct EventHandler_1_System_Runtime_ExceptionServices_FirstChanceExceptionEventArgs___Class *klass;
    MonitorData *monitor;
    struct EventHandler_1_System_Runtime_ExceptionServices_FirstChanceExceptionEventArgs___Fields fields;
};

struct __declspec(align(8)) FirstChanceExceptionEventArgs__Fields {
    struct Exception *m_Exception;
};

struct FirstChanceExceptionEventArgs {
    struct FirstChanceExceptionEventArgs__Class *klass;
    MonitorData *monitor;
    struct FirstChanceExceptionEventArgs__Fields fields;
};

struct Assembly__Array {
    struct Assembly__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Assembly *vector[32];
};

#if defined(_CPLUSPLUS_)
enum PrincipalPolicy__Enum : int32_t {
    PrincipalPolicy__Enum_UnauthenticatedPrincipal = 0x00000000,
    PrincipalPolicy__Enum_NoPrincipal = 0x00000001,
    PrincipalPolicy__Enum_WindowsPrincipal = 0x00000002,
};

#else
enum PrincipalPolicy__Enum {
    PrincipalPolicy__Enum_UnauthenticatedPrincipal = 0x00000000,
    PrincipalPolicy__Enum_NoPrincipal = 0x00000001,
    PrincipalPolicy__Enum_WindowsPrincipal = 0x00000002,
};

#endif
struct PrincipalPolicy__Enum__Boxed {
    struct PrincipalPolicy__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum PrincipalPolicy__Enum value;
    #else
    uint32_t value;
    #endif
};

struct CrossAppDomainDelegate__Fields {
    struct MulticastDelegate__Fields _;
};

struct CrossAppDomainDelegate {
    struct CrossAppDomainDelegate__Class *klass;
    MonitorData *monitor;
    struct CrossAppDomainDelegate__Fields fields;
};

struct AssemblyBuilder__Fields {
    struct Assembly__Fields _;
};

struct AssemblyBuilder {
    struct AssemblyBuilder__Class *klass;
    MonitorData *monitor;
    struct AssemblyBuilder__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum AssemblyBuilderAccess__Enum : int32_t {
    AssemblyBuilderAccess__Enum_Run = 0x00000001,
    AssemblyBuilderAccess__Enum_Save = 0x00000002,
    AssemblyBuilderAccess__Enum_RunAndSave = 0x00000003,
    AssemblyBuilderAccess__Enum_ReflectionOnly = 0x00000006,
    AssemblyBuilderAccess__Enum_RunAndCollect = 0x00000009,
};

#else
enum AssemblyBuilderAccess__Enum {
    AssemblyBuilderAccess__Enum_Run = 0x00000001,
    AssemblyBuilderAccess__Enum_Save = 0x00000002,
    AssemblyBuilderAccess__Enum_RunAndSave = 0x00000003,
    AssemblyBuilderAccess__Enum_ReflectionOnly = 0x00000006,
    AssemblyBuilderAccess__Enum_RunAndCollect = 0x00000009,
};

#endif
struct AssemblyBuilderAccess__Enum__Boxed {
    struct AssemblyBuilderAccess__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum AssemblyBuilderAccess__Enum value;
    #else
    uint32_t value;
    #endif
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Object___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Object___StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Object___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Object___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Object___VTable vtable;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Object___Array__VTable {
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Object___Array__StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Object___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Object___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Object___Array__VTable vtable;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Object___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TKey__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Object___StaticFields {
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Object___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Object___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Object___VTable vtable;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Object___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TValue__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Object___StaticFields {
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Object___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Object___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Object___VTable vtable;
};

struct KeyValuePair_2_System_String_System_Object___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct KeyValuePair_2_System_String_System_Object___StaticFields {
};

struct KeyValuePair_2_System_String_System_Object___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_String_System_Object___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_String_System_Object___VTable vtable;
};

struct KeyValuePair_2_System_String_System_Object___Array__VTable {
};

struct KeyValuePair_2_System_String_System_Object___Array__StaticFields {
};

struct KeyValuePair_2_System_String_System_Object___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_String_System_Object___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_String_System_Object___Array__VTable vtable;
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_Object___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_Object___StaticFields {
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_Object___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_KeyValuePair_2_System_String_System_Object___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_KeyValuePair_2_System_String_System_Object___VTable vtable;
};

struct Dictionary_2_System_String_System_Object___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Values;
    VirtualInvokeData ContainsKey;
    VirtualInvokeData Add;
    VirtualInvokeData Remove;
    VirtualInvokeData TryGetValue;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Add;
    VirtualInvokeData Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Contains;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_System_Collections_Generic_KeyValuePair_TKey_TValue___GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_get_Item;
    VirtualInvokeData System_Collections_IDictionary_set_Item;
    VirtualInvokeData System_Collections_IDictionary_get_Keys;
    VirtualInvokeData System_Collections_IDictionary_get_Values;
    VirtualInvokeData System_Collections_IDictionary_Contains;
    VirtualInvokeData System_Collections_IDictionary_Add;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IDictionary_get_IsReadOnly;
    VirtualInvokeData System_Collections_IDictionary_get_IsFixedSize;
    VirtualInvokeData System_Collections_IDictionary_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_Remove;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData ContainsKey_1;
    VirtualInvokeData TryGetValue_1;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Values;
    VirtualInvokeData get_Count_2;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData OnDeserialization;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData OnDeserialization_1;
};

struct Dictionary_2_System_String_System_Object___StaticFields {
};

struct Dictionary_2_System_String_System_Object___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_System_String_System_Object___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_System_String_System_Object___VTable vtable;
};

struct AssemblyLoadEventArgs__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct AssemblyLoadEventArgs__StaticFields {
};

struct AssemblyLoadEventArgs__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyLoadEventArgs__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyLoadEventArgs__VTable vtable;
};

struct AssemblyLoadEventHandler__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct AssemblyLoadEventHandler__StaticFields {
};

struct AssemblyLoadEventHandler__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyLoadEventHandler__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyLoadEventHandler__VTable vtable;
};

struct ResolveEventHandler__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct ResolveEventHandler__StaticFields {
};

struct ResolveEventHandler__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ResolveEventHandler__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ResolveEventHandler__VTable vtable;
};

struct UnhandledExceptionEventArgs__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct UnhandledExceptionEventArgs__StaticFields {
};

struct UnhandledExceptionEventArgs__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UnhandledExceptionEventArgs__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UnhandledExceptionEventArgs__VTable vtable;
};

struct UnhandledExceptionEventHandler__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct UnhandledExceptionEventHandler__StaticFields {
};

struct UnhandledExceptionEventHandler__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UnhandledExceptionEventHandler__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UnhandledExceptionEventHandler__VTable vtable;
};

struct FirstChanceExceptionEventArgs__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct FirstChanceExceptionEventArgs__StaticFields {
};

struct FirstChanceExceptionEventArgs__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FirstChanceExceptionEventArgs__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FirstChanceExceptionEventArgs__VTable vtable;
};

struct EventHandler_1_System_Runtime_ExceptionServices_FirstChanceExceptionEventArgs___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct EventHandler_1_System_Runtime_ExceptionServices_FirstChanceExceptionEventArgs___StaticFields {
};

struct EventHandler_1_System_Runtime_ExceptionServices_FirstChanceExceptionEventArgs___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EventHandler_1_System_Runtime_ExceptionServices_FirstChanceExceptionEventArgs___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EventHandler_1_System_Runtime_ExceptionServices_FirstChanceExceptionEventArgs___VTable vtable;
};

struct Assembly__Array__VTable {
};

struct Assembly__Array__StaticFields {
};

struct Assembly__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Assembly__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Assembly__Array__VTable vtable;
};

struct PrincipalPolicy__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct PrincipalPolicy__Enum__StaticFields {
};

struct PrincipalPolicy__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PrincipalPolicy__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PrincipalPolicy__Enum__VTable vtable;
};

struct CrossAppDomainDelegate__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct CrossAppDomainDelegate__StaticFields {
};

struct CrossAppDomainDelegate__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CrossAppDomainDelegate__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CrossAppDomainDelegate__VTable vtable;
};

struct AssemblyBuilder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData ToString_1;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__Assembly_GetType;
    VirtualInvokeData get_CodeBase;
    VirtualInvokeData get_EscapedCodeBase;
    VirtualInvokeData GetName;
    VirtualInvokeData GetName_1;
    VirtualInvokeData get_FullName;
    VirtualInvokeData get_EntryPoint;
    VirtualInvokeData GetType;
    VirtualInvokeData GetType_1;
    VirtualInvokeData GetExportedTypes;
    VirtualInvokeData GetTypes;
    VirtualInvokeData GetManifestResourceStream;
    VirtualInvokeData GetManifestResourceStream_1;
    VirtualInvokeData GetFile;
    VirtualInvokeData GetFiles;
    VirtualInvokeData GetFiles_1;
    VirtualInvokeData GetManifestResourceNames;
    VirtualInvokeData GetManifestResourceInfo;
    VirtualInvokeData get_Location;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType_2;
    VirtualInvokeData GetSatelliteAssembly;
    VirtualInvokeData GetSatelliteAssembly_1;
    VirtualInvokeData LoadModule;
    VirtualInvokeData LoadModule_1;
    VirtualInvokeData CreateInstance;
    VirtualInvokeData CreateInstance_1;
    VirtualInvokeData CreateInstance_2;
    VirtualInvokeData GetLoadedModules;
    VirtualInvokeData GetLoadedModules_1;
    VirtualInvokeData GetModules;
    VirtualInvokeData GetModules_1;
    VirtualInvokeData GetModule;
    VirtualInvokeData GetReferencedAssemblies;
    VirtualInvokeData add_ModuleResolve;
    VirtualInvokeData remove_ModuleResolve;
    VirtualInvokeData get_Evidence;
    VirtualInvokeData get_GlobalAssemblyCache;
    VirtualInvokeData get_Evidence_1;
    VirtualInvokeData add_ModuleResolve_1;
    VirtualInvokeData remove_ModuleResolve_1;
    VirtualInvokeData get_CodeBase_1;
    VirtualInvokeData get_EscapedCodeBase_1;
    VirtualInvokeData get_FullName_1;
    VirtualInvokeData get_EntryPoint_1;
    VirtualInvokeData get_Evidence_2;
    VirtualInvokeData get_Location_1;
    VirtualInvokeData get_ImageRuntimeVersion;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData GetFiles_2;
    VirtualInvokeData GetFiles_3;
    VirtualInvokeData GetFile_1;
    VirtualInvokeData GetManifestResourceStream_2;
    VirtualInvokeData GetManifestResourceStream_3;
    VirtualInvokeData GetTypes_1;
    VirtualInvokeData GetTypes_2;
    VirtualInvokeData GetExportedTypes_1;
    VirtualInvokeData GetType_3;
    VirtualInvokeData GetType_4;
    VirtualInvokeData GetName_2;
    VirtualInvokeData GetName_3;
    VirtualInvokeData LoadModule_2;
    VirtualInvokeData CreateInstance_3;
    VirtualInvokeData GetModulesInternal;
    VirtualInvokeData GetManifestResourceNames_1;
    VirtualInvokeData GetManifestResourceInfo_1;
    VirtualInvokeData get_HostContext;
    VirtualInvokeData GetManifestModule;
    VirtualInvokeData get_ReflectionOnly;
    VirtualInvokeData get_SecurityRuleSet;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData GetType_5;
    VirtualInvokeData GetModule_1;
    VirtualInvokeData GetReferencedAssemblies_1;
    VirtualInvokeData GetModules_2;
    VirtualInvokeData GetLoadedModules_2;
    VirtualInvokeData GetSatelliteAssembly_2;
    VirtualInvokeData GetSatelliteAssembly_3;
    VirtualInvokeData get_ManifestModule;
    VirtualInvokeData get_GlobalAssemblyCache_1;
    VirtualInvokeData get_IsDynamic;
    VirtualInvokeData get_DefinedTypes;
    VirtualInvokeData get_ExportedTypes;
    VirtualInvokeData get_Modules;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData get_PermissionSet;
    VirtualInvokeData System_Runtime_InteropServices__AssemblyBuilder_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__AssemblyBuilder_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__AssemblyBuilder_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__AssemblyBuilder_Invoke;
};

struct AssemblyBuilder__StaticFields {
};

struct AssemblyBuilder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyBuilder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyBuilder__VTable vtable;
};

struct AssemblyBuilderAccess__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct AssemblyBuilderAccess__Enum__StaticFields {
};

struct AssemblyBuilderAccess__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyBuilderAccess__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyBuilderAccess__Enum__VTable vtable;
};

struct AppDomain__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData get_Evidence;
    VirtualInvokeData System__AppDomain_GetTypeInfoCount;
    VirtualInvokeData System__AppDomain_GetTypeInfo;
    VirtualInvokeData System__AppDomain_GetIDsOfNames;
    VirtualInvokeData System__AppDomain_Invoke;
    VirtualInvokeData ToString_1;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetType;
    VirtualInvokeData InitializeLifetimeService_1;
    VirtualInvokeData GetLifetimeService_1;
    VirtualInvokeData get_Evidence_1;
    VirtualInvokeData add_DomainUnload;
    VirtualInvokeData remove_DomainUnload;
    VirtualInvokeData add_AssemblyLoad;
    VirtualInvokeData remove_AssemblyLoad;
    VirtualInvokeData add_ProcessExit;
    VirtualInvokeData remove_ProcessExit;
    VirtualInvokeData add_TypeResolve;
    VirtualInvokeData remove_TypeResolve;
    VirtualInvokeData add_ResourceResolve;
    VirtualInvokeData remove_ResourceResolve;
    VirtualInvokeData add_AssemblyResolve;
    VirtualInvokeData remove_AssemblyResolve;
    VirtualInvokeData add_UnhandledException;
    VirtualInvokeData remove_UnhandledException;
    VirtualInvokeData CreateInstance;
    VirtualInvokeData CreateInstanceFrom;
    VirtualInvokeData CreateInstance_1;
    VirtualInvokeData CreateInstanceFrom_1;
    VirtualInvokeData CreateInstance_2;
    VirtualInvokeData CreateInstanceFrom_2;
    VirtualInvokeData Load;
    VirtualInvokeData Load_1;
    VirtualInvokeData Load_2;
    VirtualInvokeData Load_3;
    VirtualInvokeData Load_4;
    VirtualInvokeData Load_5;
    VirtualInvokeData Load_6;
    VirtualInvokeData ExecuteAssembly;
    VirtualInvokeData ExecuteAssembly_1;
    VirtualInvokeData ExecuteAssembly_2;
    VirtualInvokeData get_FriendlyName;
    VirtualInvokeData get_BaseDirectory;
    VirtualInvokeData get_RelativeSearchPath;
    VirtualInvokeData get_ShadowCopyFiles;
    VirtualInvokeData GetAssemblies;
    VirtualInvokeData AppendPrivatePath;
    VirtualInvokeData ClearPrivatePath;
    VirtualInvokeData SetShadowCopyPath;
    VirtualInvokeData ClearShadowCopyPath;
    VirtualInvokeData SetCachePath;
    VirtualInvokeData SetData;
    VirtualInvokeData GetData;
    VirtualInvokeData SetAppDomainPolicy;
    VirtualInvokeData SetThreadPrincipal;
    VirtualInvokeData SetPrincipalPolicy;
    VirtualInvokeData DoCallBack;
    VirtualInvokeData get_DynamicDirectory;
    VirtualInvokeData DefineDynamicAssembly;
    VirtualInvokeData DefineDynamicAssembly_1;
    VirtualInvokeData DefineDynamicAssembly_2;
    VirtualInvokeData DefineDynamicAssembly_3;
    VirtualInvokeData DefineDynamicAssembly_4;
    VirtualInvokeData DefineDynamicAssembly_5;
    VirtualInvokeData DefineDynamicAssembly_6;
    VirtualInvokeData DefineDynamicAssembly_7;
    VirtualInvokeData DefineDynamicAssembly_8;
};

struct AppDomain__StaticFields {
    struct String *_process_guid;
    struct Dictionary_2_System_String_System_Object_ *type_resolve_in_progress;
    struct Dictionary_2_System_String_System_Object_ *assembly_resolve_in_progress;
    struct Dictionary_2_System_String_System_Object_ *assembly_resolve_in_progress_refonly;
    struct Object *_principal;
    struct AppDomain *default_domain;
};

struct AppDomain__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AppDomain__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AppDomain__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum ActivationContext_ContextForm__Enum : int32_t {
    ActivationContext_ContextForm__Enum_Loose = 0x00000000,
    ActivationContext_ContextForm__Enum_StoreBounded = 0x00000001,
};

#else
enum ActivationContext_ContextForm__Enum {
    ActivationContext_ContextForm__Enum_Loose = 0x00000000,
    ActivationContext_ContextForm__Enum_StoreBounded = 0x00000001,
};

#endif
struct ActivationContext_ContextForm__Enum__Boxed {
    struct ActivationContext_ContextForm__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum ActivationContext_ContextForm__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) ActivationContext__Fields {
    struct ApplicationIdentity *_appid;
    #if defined(_CPLUSPLUS_)
    enum ActivationContext_ContextForm__Enum _form;
    #else
    uint32_t _form;
    #endif
    bool _disposed;
};

struct ActivationContext {
    struct ActivationContext__Class *klass;
    MonitorData *monitor;
    struct ActivationContext__Fields fields;
};

struct __declspec(align(8)) ApplicationIdentity__Fields {
    struct String *_fullName;
    struct String *_codeBase;
};

struct ApplicationIdentity {
    struct ApplicationIdentity__Class *klass;
    MonitorData *monitor;
    struct ApplicationIdentity__Fields fields;
};

struct ApplicationIdentity__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
};

struct ApplicationIdentity__StaticFields {
};

struct ApplicationIdentity__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ApplicationIdentity__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ApplicationIdentity__VTable vtable;
};

struct ActivationContext_ContextForm__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct ActivationContext_ContextForm__Enum__StaticFields {
};

struct ActivationContext_ContextForm__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ActivationContext_ContextForm__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ActivationContext_ContextForm__Enum__VTable vtable;
};

struct ActivationContext__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
};

struct ActivationContext__StaticFields {
};

struct ActivationContext__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ActivationContext__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ActivationContext__VTable vtable;
};

struct __declspec(align(8)) LoaderOptimizationAttribute__Fields {
    uint8_t _val;
};

struct LoaderOptimizationAttribute {
    struct LoaderOptimizationAttribute__Class *klass;
    MonitorData *monitor;
    struct LoaderOptimizationAttribute__Fields fields;
};

struct LoaderOptimizationAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct LoaderOptimizationAttribute__StaticFields {
};

struct LoaderOptimizationAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct LoaderOptimizationAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct LoaderOptimizationAttribute__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum LoaderOptimization__Enum : int32_t {
    LoaderOptimization__Enum_NotSpecified = 0x00000000,
    LoaderOptimization__Enum_SingleDomain = 0x00000001,
    LoaderOptimization__Enum_MultiDomain = 0x00000002,
    LoaderOptimization__Enum_MultiDomainHost = 0x00000003,
    LoaderOptimization__Enum_DomainMask = 0x00000003,
    LoaderOptimization__Enum_DisallowBindings = 0x00000004,
};

#else
enum LoaderOptimization__Enum {
    LoaderOptimization__Enum_NotSpecified = 0x00000000,
    LoaderOptimization__Enum_SingleDomain = 0x00000001,
    LoaderOptimization__Enum_MultiDomain = 0x00000002,
    LoaderOptimization__Enum_MultiDomainHost = 0x00000003,
    LoaderOptimization__Enum_DomainMask = 0x00000003,
    LoaderOptimization__Enum_DisallowBindings = 0x00000004,
};

#endif
struct LoaderOptimization__Enum__Boxed {
    struct LoaderOptimization__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum LoaderOptimization__Enum value;
    #else
    uint32_t value;
    #endif
};

struct LoaderOptimization__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct LoaderOptimization__Enum__StaticFields {
};

struct LoaderOptimization__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct LoaderOptimization__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct LoaderOptimization__Enum__VTable vtable;
};

struct AppDomainUnloadedException__Fields {
    struct SystemException__Fields _;
};

struct AppDomainUnloadedException {
    struct AppDomainUnloadedException__Class *klass;
    MonitorData *monitor;
    struct AppDomainUnloadedException__Fields fields;
};

struct AppDomainUnloadedException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct AppDomainUnloadedException__StaticFields {
};

struct AppDomainUnloadedException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AppDomainUnloadedException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AppDomainUnloadedException__VTable vtable;
};

struct ApplicationException__Fields {
    struct Exception__Fields _;
};

struct ApplicationException {
    struct ApplicationException__Class *klass;
    MonitorData *monitor;
    struct ApplicationException__Fields fields;
};

struct ApplicationException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct ApplicationException__StaticFields {
};

struct ApplicationException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ApplicationException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ApplicationException__VTable vtable;
};

struct __declspec(align(8)) ApplicationId__Fields {
    struct String *m_name;
    struct Version *m_version;
    struct String *m_processorArchitecture;
    struct String *m_culture;
    struct Byte__Array *m_publicKeyToken;
};

struct ApplicationId {
    struct ApplicationId__Class *klass;
    MonitorData *monitor;
    struct ApplicationId__Fields fields;
};

struct ApplicationId__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ApplicationId__StaticFields {
};

struct ApplicationId__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ApplicationId__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ApplicationId__VTable vtable;
};

struct ArgumentException__Fields {
    struct SystemException__Fields _;
    struct String *m_paramName;
};

struct ArgumentException {
    struct ArgumentException__Class *klass;
    MonitorData *monitor;
    struct ArgumentException__Fields fields;
};

struct ArgumentException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
    VirtualInvokeData get_ParamName;
};

struct ArgumentException__StaticFields {
};

struct ArgumentException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ArgumentException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ArgumentException__VTable vtable;
};

struct ArgumentNullException__Fields {
    struct ArgumentException__Fields _;
};

struct ArgumentNullException {
    struct ArgumentNullException__Class *klass;
    MonitorData *monitor;
    struct ArgumentNullException__Fields fields;
};

struct ArgumentNullException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
    VirtualInvokeData get_ParamName;
};

struct ArgumentNullException__StaticFields {
};

struct ArgumentNullException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ArgumentNullException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ArgumentNullException__VTable vtable;
};

struct ArgumentOutOfRangeException__Fields {
    struct ArgumentException__Fields _;
    struct Object *m_actualValue;
};

struct ArgumentOutOfRangeException {
    struct ArgumentOutOfRangeException__Class *klass;
    MonitorData *monitor;
    struct ArgumentOutOfRangeException__Fields fields;
};

struct ArgumentOutOfRangeException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
    VirtualInvokeData get_ParamName;
    VirtualInvokeData get_ActualValue;
};

struct ArgumentOutOfRangeException__StaticFields {
    struct String *_rangeMessage;
};

struct ArgumentOutOfRangeException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ArgumentOutOfRangeException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ArgumentOutOfRangeException__VTable vtable;
};

struct ArithmeticException__Fields {
    struct SystemException__Fields _;
};

struct ArithmeticException {
    struct ArithmeticException__Class *klass;
    MonitorData *monitor;
    struct ArithmeticException__Fields fields;
};

struct ArithmeticException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct ArithmeticException__StaticFields {
};

struct ArithmeticException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ArithmeticException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ArithmeticException__VTable vtable;
};

struct ArrayTypeMismatchException__Fields {
    struct SystemException__Fields _;
};

struct ArrayTypeMismatchException {
    struct ArrayTypeMismatchException__Class *klass;
    MonitorData *monitor;
    struct ArrayTypeMismatchException__Fields fields;
};

struct ArrayTypeMismatchException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct ArrayTypeMismatchException__StaticFields {
};

struct ArrayTypeMismatchException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ArrayTypeMismatchException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ArrayTypeMismatchException__VTable vtable;
};

struct Attribute__Array {
    struct Attribute__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Attribute *vector[32];
};

struct Attribute__Array__VTable {
};

struct Attribute__Array__StaticFields {
};

struct Attribute__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Attribute__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Attribute__Array__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum AttributeTargets__Enum : int32_t {
    AttributeTargets__Enum_Assembly = 0x00000001,
    AttributeTargets__Enum_Module = 0x00000002,
    AttributeTargets__Enum_Class = 0x00000004,
    AttributeTargets__Enum_Struct = 0x00000008,
    AttributeTargets__Enum_Enum = 0x00000010,
    AttributeTargets__Enum_Constructor = 0x00000020,
    AttributeTargets__Enum_Method = 0x00000040,
    AttributeTargets__Enum_Property = 0x00000080,
    AttributeTargets__Enum_Field = 0x00000100,
    AttributeTargets__Enum_Event = 0x00000200,
    AttributeTargets__Enum_Interface = 0x00000400,
    AttributeTargets__Enum_Parameter = 0x00000800,
    AttributeTargets__Enum_Delegate = 0x00001000,
    AttributeTargets__Enum_ReturnValue = 0x00002000,
    AttributeTargets__Enum_GenericParameter = 0x00004000,
    AttributeTargets__Enum_All = 0x00007fff,
};

#else
enum AttributeTargets__Enum {
    AttributeTargets__Enum_Assembly = 0x00000001,
    AttributeTargets__Enum_Module = 0x00000002,
    AttributeTargets__Enum_Class = 0x00000004,
    AttributeTargets__Enum_Struct = 0x00000008,
    AttributeTargets__Enum_Enum = 0x00000010,
    AttributeTargets__Enum_Constructor = 0x00000020,
    AttributeTargets__Enum_Method = 0x00000040,
    AttributeTargets__Enum_Property = 0x00000080,
    AttributeTargets__Enum_Field = 0x00000100,
    AttributeTargets__Enum_Event = 0x00000200,
    AttributeTargets__Enum_Interface = 0x00000400,
    AttributeTargets__Enum_Parameter = 0x00000800,
    AttributeTargets__Enum_Delegate = 0x00001000,
    AttributeTargets__Enum_ReturnValue = 0x00002000,
    AttributeTargets__Enum_GenericParameter = 0x00004000,
    AttributeTargets__Enum_All = 0x00007fff,
};

#endif
struct AttributeTargets__Enum__Boxed {
    struct AttributeTargets__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum AttributeTargets__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) AttributeUsageAttribute__Fields {
    #if defined(_CPLUSPLUS_)
    enum AttributeTargets__Enum m_attributeTarget;
    #else
    uint32_t m_attributeTarget;
    #endif
    bool m_allowMultiple;
    bool m_inherited;
};

struct AttributeUsageAttribute {
    struct AttributeUsageAttribute__Class *klass;
    MonitorData *monitor;
    struct AttributeUsageAttribute__Fields fields;
};

struct AttributeTargets__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct AttributeTargets__Enum__StaticFields {
};

struct AttributeTargets__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AttributeTargets__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AttributeTargets__Enum__VTable vtable;
};

struct AttributeUsageAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct AttributeUsageAttribute__StaticFields {
    struct AttributeUsageAttribute *Default;
};

struct AttributeUsageAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AttributeUsageAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AttributeUsageAttribute__VTable vtable;
};

struct BadImageFormatException__Fields {
    struct SystemException__Fields _;
    struct String *_fileName;
    struct String *_fusionLog;
};

struct BadImageFormatException {
    struct BadImageFormatException__Class *klass;
    MonitorData *monitor;
    struct BadImageFormatException__Fields fields;
};

struct BadImageFormatException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct BadImageFormatException__StaticFields {
};

struct BadImageFormatException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct BadImageFormatException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct BadImageFormatException__VTable vtable;
};

struct CannotUnloadAppDomainException__Fields {
    struct SystemException__Fields _;
};

struct CannotUnloadAppDomainException {
    struct CannotUnloadAppDomainException__Class *klass;
    MonitorData *monitor;
    struct CannotUnloadAppDomainException__Fields fields;
};

struct CannotUnloadAppDomainException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct CannotUnloadAppDomainException__StaticFields {
};

struct CannotUnloadAppDomainException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CannotUnloadAppDomainException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CannotUnloadAppDomainException__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum UnicodeCategory__Enum : int32_t {
    UnicodeCategory__Enum_UppercaseLetter = 0x00000000,
    UnicodeCategory__Enum_LowercaseLetter = 0x00000001,
    UnicodeCategory__Enum_TitlecaseLetter = 0x00000002,
    UnicodeCategory__Enum_ModifierLetter = 0x00000003,
    UnicodeCategory__Enum_OtherLetter = 0x00000004,
    UnicodeCategory__Enum_NonSpacingMark = 0x00000005,
    UnicodeCategory__Enum_SpacingCombiningMark = 0x00000006,
    UnicodeCategory__Enum_EnclosingMark = 0x00000007,
    UnicodeCategory__Enum_DecimalDigitNumber = 0x00000008,
    UnicodeCategory__Enum_LetterNumber = 0x00000009,
    UnicodeCategory__Enum_OtherNumber = 0x0000000a,
    UnicodeCategory__Enum_SpaceSeparator = 0x0000000b,
    UnicodeCategory__Enum_LineSeparator = 0x0000000c,
    UnicodeCategory__Enum_ParagraphSeparator = 0x0000000d,
    UnicodeCategory__Enum_Control = 0x0000000e,
    UnicodeCategory__Enum_Format = 0x0000000f,
    UnicodeCategory__Enum_Surrogate = 0x00000010,
    UnicodeCategory__Enum_PrivateUse = 0x00000011,
    UnicodeCategory__Enum_ConnectorPunctuation = 0x00000012,
    UnicodeCategory__Enum_DashPunctuation = 0x00000013,
    UnicodeCategory__Enum_OpenPunctuation = 0x00000014,
    UnicodeCategory__Enum_ClosePunctuation = 0x00000015,
    UnicodeCategory__Enum_InitialQuotePunctuation = 0x00000016,
    UnicodeCategory__Enum_FinalQuotePunctuation = 0x00000017,
    UnicodeCategory__Enum_OtherPunctuation = 0x00000018,
    UnicodeCategory__Enum_MathSymbol = 0x00000019,
    UnicodeCategory__Enum_CurrencySymbol = 0x0000001a,
    UnicodeCategory__Enum_ModifierSymbol = 0x0000001b,
    UnicodeCategory__Enum_OtherSymbol = 0x0000001c,
    UnicodeCategory__Enum_OtherNotAssigned = 0x0000001d,
};

#else
enum UnicodeCategory__Enum {
    UnicodeCategory__Enum_UppercaseLetter = 0x00000000,
    UnicodeCategory__Enum_LowercaseLetter = 0x00000001,
    UnicodeCategory__Enum_TitlecaseLetter = 0x00000002,
    UnicodeCategory__Enum_ModifierLetter = 0x00000003,
    UnicodeCategory__Enum_OtherLetter = 0x00000004,
    UnicodeCategory__Enum_NonSpacingMark = 0x00000005,
    UnicodeCategory__Enum_SpacingCombiningMark = 0x00000006,
    UnicodeCategory__Enum_EnclosingMark = 0x00000007,
    UnicodeCategory__Enum_DecimalDigitNumber = 0x00000008,
    UnicodeCategory__Enum_LetterNumber = 0x00000009,
    UnicodeCategory__Enum_OtherNumber = 0x0000000a,
    UnicodeCategory__Enum_SpaceSeparator = 0x0000000b,
    UnicodeCategory__Enum_LineSeparator = 0x0000000c,
    UnicodeCategory__Enum_ParagraphSeparator = 0x0000000d,
    UnicodeCategory__Enum_Control = 0x0000000e,
    UnicodeCategory__Enum_Format = 0x0000000f,
    UnicodeCategory__Enum_Surrogate = 0x00000010,
    UnicodeCategory__Enum_PrivateUse = 0x00000011,
    UnicodeCategory__Enum_ConnectorPunctuation = 0x00000012,
    UnicodeCategory__Enum_DashPunctuation = 0x00000013,
    UnicodeCategory__Enum_OpenPunctuation = 0x00000014,
    UnicodeCategory__Enum_ClosePunctuation = 0x00000015,
    UnicodeCategory__Enum_InitialQuotePunctuation = 0x00000016,
    UnicodeCategory__Enum_FinalQuotePunctuation = 0x00000017,
    UnicodeCategory__Enum_OtherPunctuation = 0x00000018,
    UnicodeCategory__Enum_MathSymbol = 0x00000019,
    UnicodeCategory__Enum_CurrencySymbol = 0x0000001a,
    UnicodeCategory__Enum_ModifierSymbol = 0x0000001b,
    UnicodeCategory__Enum_OtherSymbol = 0x0000001c,
    UnicodeCategory__Enum_OtherNotAssigned = 0x0000001d,
};

#endif
struct UnicodeCategory__Enum__Boxed {
    struct UnicodeCategory__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum UnicodeCategory__Enum value;
    #else
    uint32_t value;
    #endif
};

struct UnicodeCategory__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct UnicodeCategory__Enum__StaticFields {
};

struct UnicodeCategory__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UnicodeCategory__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UnicodeCategory__Enum__VTable vtable;
};

struct Char___VTable {
};

struct Char___StaticFields {
};

struct Char___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Char___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Char___VTable vtable;
};

struct __declspec(align(8)) CharEnumerator__Fields {
    struct String *str;
    int32_t index;
    uint16_t currentElement;
};

struct CharEnumerator {
    struct CharEnumerator__Class *klass;
    MonitorData *monitor;
    struct CharEnumerator__Fields fields;
};

struct CharEnumerator__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData MoveNext;
    VirtualInvokeData System_Collections_IEnumerator_get_Current;
    VirtualInvokeData Reset;
    VirtualInvokeData Clone;
    VirtualInvokeData get_Current;
    VirtualInvokeData Dispose;
};

struct CharEnumerator__StaticFields {
};

struct CharEnumerator__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CharEnumerator__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CharEnumerator__VTable vtable;
};

struct __declspec(align(8)) CLSCompliantAttribute__Fields {
    bool m_compliant;
};

struct CLSCompliantAttribute {
    struct CLSCompliantAttribute__Class *klass;
    MonitorData *monitor;
    struct CLSCompliantAttribute__Fields fields;
};

struct CLSCompliantAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct CLSCompliantAttribute__StaticFields {
};

struct CLSCompliantAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CLSCompliantAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CLSCompliantAttribute__VTable vtable;
};

struct ConsoleCancelEventHandler__Fields {
    struct MulticastDelegate__Fields _;
};

struct ConsoleCancelEventHandler {
    struct ConsoleCancelEventHandler__Class *klass;
    MonitorData *monitor;
    struct ConsoleCancelEventHandler__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum ConsoleSpecialKey__Enum : int32_t {
    ConsoleSpecialKey__Enum_ControlC = 0x00000000,
    ConsoleSpecialKey__Enum_ControlBreak = 0x00000001,
};

#else
enum ConsoleSpecialKey__Enum {
    ConsoleSpecialKey__Enum_ControlC = 0x00000000,
    ConsoleSpecialKey__Enum_ControlBreak = 0x00000001,
};

#endif
struct ConsoleSpecialKey__Enum__Boxed {
    struct ConsoleSpecialKey__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum ConsoleSpecialKey__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) ConsoleCancelEventArgs__Fields {
    #if defined(_CPLUSPLUS_)
    enum ConsoleSpecialKey__Enum _type;
    #else
    uint32_t _type;
    #endif
    bool _cancel;
};

struct ConsoleCancelEventArgs {
    struct ConsoleCancelEventArgs__Class *klass;
    MonitorData *monitor;
    struct ConsoleCancelEventArgs__Fields fields;
};

struct ConsoleSpecialKey__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct ConsoleSpecialKey__Enum__StaticFields {
};

struct ConsoleSpecialKey__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ConsoleSpecialKey__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ConsoleSpecialKey__Enum__VTable vtable;
};

struct ConsoleCancelEventArgs__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ConsoleCancelEventArgs__StaticFields {
};

struct ConsoleCancelEventArgs__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ConsoleCancelEventArgs__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ConsoleCancelEventArgs__VTable vtable;
};

struct ConsoleCancelEventHandler__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct ConsoleCancelEventHandler__StaticFields {
};

struct ConsoleCancelEventHandler__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ConsoleCancelEventHandler__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ConsoleCancelEventHandler__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum ConsoleKey__Enum : int32_t {
    ConsoleKey__Enum_Backspace = 0x00000008,
    ConsoleKey__Enum_Tab = 0x00000009,
    ConsoleKey__Enum_Clear = 0x0000000c,
    ConsoleKey__Enum_Enter = 0x0000000d,
    ConsoleKey__Enum_Pause = 0x00000013,
    ConsoleKey__Enum_Escape = 0x0000001b,
    ConsoleKey__Enum_Spacebar = 0x00000020,
    ConsoleKey__Enum_PageUp = 0x00000021,
    ConsoleKey__Enum_PageDown = 0x00000022,
    ConsoleKey__Enum_End = 0x00000023,
    ConsoleKey__Enum_Home = 0x00000024,
    ConsoleKey__Enum_LeftArrow = 0x00000025,
    ConsoleKey__Enum_UpArrow = 0x00000026,
    ConsoleKey__Enum_RightArrow = 0x00000027,
    ConsoleKey__Enum_DownArrow = 0x00000028,
    ConsoleKey__Enum_Select = 0x00000029,
    ConsoleKey__Enum_Print = 0x0000002a,
    ConsoleKey__Enum_Execute = 0x0000002b,
    ConsoleKey__Enum_PrintScreen = 0x0000002c,
    ConsoleKey__Enum_Insert = 0x0000002d,
    ConsoleKey__Enum_Delete = 0x0000002e,
    ConsoleKey__Enum_Help = 0x0000002f,
    ConsoleKey__Enum_D0 = 0x00000030,
    ConsoleKey__Enum_D1 = 0x00000031,
    ConsoleKey__Enum_D2 = 0x00000032,
    ConsoleKey__Enum_D3 = 0x00000033,
    ConsoleKey__Enum_D4 = 0x00000034,
    ConsoleKey__Enum_D5 = 0x00000035,
    ConsoleKey__Enum_D6 = 0x00000036,
    ConsoleKey__Enum_D7 = 0x00000037,
    ConsoleKey__Enum_D8 = 0x00000038,
    ConsoleKey__Enum_D9 = 0x00000039,
    ConsoleKey__Enum_A = 0x00000041,
    ConsoleKey__Enum_B = 0x00000042,
    ConsoleKey__Enum_C = 0x00000043,
    ConsoleKey__Enum_D = 0x00000044,
    ConsoleKey__Enum_E = 0x00000045,
    ConsoleKey__Enum_F = 0x00000046,
    ConsoleKey__Enum_G = 0x00000047,
    ConsoleKey__Enum_H = 0x00000048,
    ConsoleKey__Enum_I = 0x00000049,
    ConsoleKey__Enum_J = 0x0000004a,
    ConsoleKey__Enum_K = 0x0000004b,
    ConsoleKey__Enum_L = 0x0000004c,
    ConsoleKey__Enum_M = 0x0000004d,
    ConsoleKey__Enum_N = 0x0000004e,
    ConsoleKey__Enum_O = 0x0000004f,
    ConsoleKey__Enum_P = 0x00000050,
    ConsoleKey__Enum_Q = 0x00000051,
    ConsoleKey__Enum_R = 0x00000052,
    ConsoleKey__Enum_S = 0x00000053,
    ConsoleKey__Enum_T = 0x00000054,
    ConsoleKey__Enum_U = 0x00000055,
    ConsoleKey__Enum_V = 0x00000056,
    ConsoleKey__Enum_W = 0x00000057,
    ConsoleKey__Enum_X = 0x00000058,
    ConsoleKey__Enum_Y = 0x00000059,
    ConsoleKey__Enum_Z = 0x0000005a,
    ConsoleKey__Enum_LeftWindows = 0x0000005b,
    ConsoleKey__Enum_RightWindows = 0x0000005c,
    ConsoleKey__Enum_Applications = 0x0000005d,
    ConsoleKey__Enum_Sleep = 0x0000005f,
    ConsoleKey__Enum_NumPad0 = 0x00000060,
    ConsoleKey__Enum_NumPad1 = 0x00000061,
    ConsoleKey__Enum_NumPad2 = 0x00000062,
    ConsoleKey__Enum_NumPad3 = 0x00000063,
    ConsoleKey__Enum_NumPad4 = 0x00000064,
    ConsoleKey__Enum_NumPad5 = 0x00000065,
    ConsoleKey__Enum_NumPad6 = 0x00000066,
    ConsoleKey__Enum_NumPad7 = 0x00000067,
    ConsoleKey__Enum_NumPad8 = 0x00000068,
    ConsoleKey__Enum_NumPad9 = 0x00000069,
    ConsoleKey__Enum_Multiply = 0x0000006a,
    ConsoleKey__Enum_Add = 0x0000006b,
    ConsoleKey__Enum_Separator = 0x0000006c,
    ConsoleKey__Enum_Subtract = 0x0000006d,
    ConsoleKey__Enum_Decimal = 0x0000006e,
    ConsoleKey__Enum_Divide = 0x0000006f,
    ConsoleKey__Enum_F1 = 0x00000070,
    ConsoleKey__Enum_F2 = 0x00000071,
    ConsoleKey__Enum_F3 = 0x00000072,
    ConsoleKey__Enum_F4 = 0x00000073,
    ConsoleKey__Enum_F5 = 0x00000074,
    ConsoleKey__Enum_F6 = 0x00000075,
    ConsoleKey__Enum_F7 = 0x00000076,
    ConsoleKey__Enum_F8 = 0x00000077,
    ConsoleKey__Enum_F9 = 0x00000078,
    ConsoleKey__Enum_F10 = 0x00000079,
    ConsoleKey__Enum_F11 = 0x0000007a,
    ConsoleKey__Enum_F12 = 0x0000007b,
    ConsoleKey__Enum_F13 = 0x0000007c,
    ConsoleKey__Enum_F14 = 0x0000007d,
    ConsoleKey__Enum_F15 = 0x0000007e,
    ConsoleKey__Enum_F16 = 0x0000007f,
    ConsoleKey__Enum_F17 = 0x00000080,
    ConsoleKey__Enum_F18 = 0x00000081,
    ConsoleKey__Enum_F19 = 0x00000082,
    ConsoleKey__Enum_F20 = 0x00000083,
    ConsoleKey__Enum_F21 = 0x00000084,
    ConsoleKey__Enum_F22 = 0x00000085,
    ConsoleKey__Enum_F23 = 0x00000086,
    ConsoleKey__Enum_F24 = 0x00000087,
    ConsoleKey__Enum_BrowserBack = 0x000000a6,
    ConsoleKey__Enum_BrowserForward = 0x000000a7,
    ConsoleKey__Enum_BrowserRefresh = 0x000000a8,
    ConsoleKey__Enum_BrowserStop = 0x000000a9,
    ConsoleKey__Enum_BrowserSearch = 0x000000aa,
    ConsoleKey__Enum_BrowserFavorites = 0x000000ab,
    ConsoleKey__Enum_BrowserHome = 0x000000ac,
    ConsoleKey__Enum_VolumeMute = 0x000000ad,
    ConsoleKey__Enum_VolumeDown = 0x000000ae,
    ConsoleKey__Enum_VolumeUp = 0x000000af,
    ConsoleKey__Enum_MediaNext = 0x000000b0,
    ConsoleKey__Enum_MediaPrevious = 0x000000b1,
    ConsoleKey__Enum_MediaStop = 0x000000b2,
    ConsoleKey__Enum_MediaPlay = 0x000000b3,
    ConsoleKey__Enum_LaunchMail = 0x000000b4,
    ConsoleKey__Enum_LaunchMediaSelect = 0x000000b5,
    ConsoleKey__Enum_LaunchApp1 = 0x000000b6,
    ConsoleKey__Enum_LaunchApp2 = 0x000000b7,
    ConsoleKey__Enum_Oem1 = 0x000000ba,
    ConsoleKey__Enum_OemPlus = 0x000000bb,
    ConsoleKey__Enum_OemComma = 0x000000bc,
    ConsoleKey__Enum_OemMinus = 0x000000bd,
    ConsoleKey__Enum_OemPeriod = 0x000000be,
    ConsoleKey__Enum_Oem2 = 0x000000bf,
    ConsoleKey__Enum_Oem3 = 0x000000c0,
    ConsoleKey__Enum_Oem4 = 0x000000db,
    ConsoleKey__Enum_Oem5 = 0x000000dc,
    ConsoleKey__Enum_Oem6 = 0x000000dd,
    ConsoleKey__Enum_Oem7 = 0x000000de,
    ConsoleKey__Enum_Oem8 = 0x000000df,
    ConsoleKey__Enum_Oem102 = 0x000000e2,
    ConsoleKey__Enum_Process = 0x000000e5,
    ConsoleKey__Enum_Packet = 0x000000e7,
    ConsoleKey__Enum_Attention = 0x000000f6,
    ConsoleKey__Enum_CrSel = 0x000000f7,
    ConsoleKey__Enum_ExSel = 0x000000f8,
    ConsoleKey__Enum_EraseEndOfFile = 0x000000f9,
    ConsoleKey__Enum_Play = 0x000000fa,
    ConsoleKey__Enum_Zoom = 0x000000fb,
    ConsoleKey__Enum_NoName = 0x000000fc,
    ConsoleKey__Enum_Pa1 = 0x000000fd,
    ConsoleKey__Enum_OemClear = 0x000000fe,
};

#else
enum ConsoleKey__Enum {
    ConsoleKey__Enum_Backspace = 0x00000008,
    ConsoleKey__Enum_Tab = 0x00000009,
    ConsoleKey__Enum_Clear = 0x0000000c,
    ConsoleKey__Enum_Enter = 0x0000000d,
    ConsoleKey__Enum_Pause = 0x00000013,
    ConsoleKey__Enum_Escape = 0x0000001b,
    ConsoleKey__Enum_Spacebar = 0x00000020,
    ConsoleKey__Enum_PageUp = 0x00000021,
    ConsoleKey__Enum_PageDown = 0x00000022,
    ConsoleKey__Enum_End = 0x00000023,
    ConsoleKey__Enum_Home = 0x00000024,
    ConsoleKey__Enum_LeftArrow = 0x00000025,
    ConsoleKey__Enum_UpArrow = 0x00000026,
    ConsoleKey__Enum_RightArrow = 0x00000027,
    ConsoleKey__Enum_DownArrow = 0x00000028,
    ConsoleKey__Enum_Select = 0x00000029,
    ConsoleKey__Enum_Print = 0x0000002a,
    ConsoleKey__Enum_Execute = 0x0000002b,
    ConsoleKey__Enum_PrintScreen = 0x0000002c,
    ConsoleKey__Enum_Insert = 0x0000002d,
    ConsoleKey__Enum_Delete = 0x0000002e,
    ConsoleKey__Enum_Help = 0x0000002f,
    ConsoleKey__Enum_D0 = 0x00000030,
    ConsoleKey__Enum_D1 = 0x00000031,
    ConsoleKey__Enum_D2 = 0x00000032,
    ConsoleKey__Enum_D3 = 0x00000033,
    ConsoleKey__Enum_D4 = 0x00000034,
    ConsoleKey__Enum_D5 = 0x00000035,
    ConsoleKey__Enum_D6 = 0x00000036,
    ConsoleKey__Enum_D7 = 0x00000037,
    ConsoleKey__Enum_D8 = 0x00000038,
    ConsoleKey__Enum_D9 = 0x00000039,
    ConsoleKey__Enum_A = 0x00000041,
    ConsoleKey__Enum_B = 0x00000042,
    ConsoleKey__Enum_C = 0x00000043,
    ConsoleKey__Enum_D = 0x00000044,
    ConsoleKey__Enum_E = 0x00000045,
    ConsoleKey__Enum_F = 0x00000046,
    ConsoleKey__Enum_G = 0x00000047,
    ConsoleKey__Enum_H = 0x00000048,
    ConsoleKey__Enum_I = 0x00000049,
    ConsoleKey__Enum_J = 0x0000004a,
    ConsoleKey__Enum_K = 0x0000004b,
    ConsoleKey__Enum_L = 0x0000004c,
    ConsoleKey__Enum_M = 0x0000004d,
    ConsoleKey__Enum_N = 0x0000004e,
    ConsoleKey__Enum_O = 0x0000004f,
    ConsoleKey__Enum_P = 0x00000050,
    ConsoleKey__Enum_Q = 0x00000051,
    ConsoleKey__Enum_R = 0x00000052,
    ConsoleKey__Enum_S = 0x00000053,
    ConsoleKey__Enum_T = 0x00000054,
    ConsoleKey__Enum_U = 0x00000055,
    ConsoleKey__Enum_V = 0x00000056,
    ConsoleKey__Enum_W = 0x00000057,
    ConsoleKey__Enum_X = 0x00000058,
    ConsoleKey__Enum_Y = 0x00000059,
    ConsoleKey__Enum_Z = 0x0000005a,
    ConsoleKey__Enum_LeftWindows = 0x0000005b,
    ConsoleKey__Enum_RightWindows = 0x0000005c,
    ConsoleKey__Enum_Applications = 0x0000005d,
    ConsoleKey__Enum_Sleep = 0x0000005f,
    ConsoleKey__Enum_NumPad0 = 0x00000060,
    ConsoleKey__Enum_NumPad1 = 0x00000061,
    ConsoleKey__Enum_NumPad2 = 0x00000062,
    ConsoleKey__Enum_NumPad3 = 0x00000063,
    ConsoleKey__Enum_NumPad4 = 0x00000064,
    ConsoleKey__Enum_NumPad5 = 0x00000065,
    ConsoleKey__Enum_NumPad6 = 0x00000066,
    ConsoleKey__Enum_NumPad7 = 0x00000067,
    ConsoleKey__Enum_NumPad8 = 0x00000068,
    ConsoleKey__Enum_NumPad9 = 0x00000069,
    ConsoleKey__Enum_Multiply = 0x0000006a,
    ConsoleKey__Enum_Add = 0x0000006b,
    ConsoleKey__Enum_Separator = 0x0000006c,
    ConsoleKey__Enum_Subtract = 0x0000006d,
    ConsoleKey__Enum_Decimal = 0x0000006e,
    ConsoleKey__Enum_Divide = 0x0000006f,
    ConsoleKey__Enum_F1 = 0x00000070,
    ConsoleKey__Enum_F2 = 0x00000071,
    ConsoleKey__Enum_F3 = 0x00000072,
    ConsoleKey__Enum_F4 = 0x00000073,
    ConsoleKey__Enum_F5 = 0x00000074,
    ConsoleKey__Enum_F6 = 0x00000075,
    ConsoleKey__Enum_F7 = 0x00000076,
    ConsoleKey__Enum_F8 = 0x00000077,
    ConsoleKey__Enum_F9 = 0x00000078,
    ConsoleKey__Enum_F10 = 0x00000079,
    ConsoleKey__Enum_F11 = 0x0000007a,
    ConsoleKey__Enum_F12 = 0x0000007b,
    ConsoleKey__Enum_F13 = 0x0000007c,
    ConsoleKey__Enum_F14 = 0x0000007d,
    ConsoleKey__Enum_F15 = 0x0000007e,
    ConsoleKey__Enum_F16 = 0x0000007f,
    ConsoleKey__Enum_F17 = 0x00000080,
    ConsoleKey__Enum_F18 = 0x00000081,
    ConsoleKey__Enum_F19 = 0x00000082,
    ConsoleKey__Enum_F20 = 0x00000083,
    ConsoleKey__Enum_F21 = 0x00000084,
    ConsoleKey__Enum_F22 = 0x00000085,
    ConsoleKey__Enum_F23 = 0x00000086,
    ConsoleKey__Enum_F24 = 0x00000087,
    ConsoleKey__Enum_BrowserBack = 0x000000a6,
    ConsoleKey__Enum_BrowserForward = 0x000000a7,
    ConsoleKey__Enum_BrowserRefresh = 0x000000a8,
    ConsoleKey__Enum_BrowserStop = 0x000000a9,
    ConsoleKey__Enum_BrowserSearch = 0x000000aa,
    ConsoleKey__Enum_BrowserFavorites = 0x000000ab,
    ConsoleKey__Enum_BrowserHome = 0x000000ac,
    ConsoleKey__Enum_VolumeMute = 0x000000ad,
    ConsoleKey__Enum_VolumeDown = 0x000000ae,
    ConsoleKey__Enum_VolumeUp = 0x000000af,
    ConsoleKey__Enum_MediaNext = 0x000000b0,
    ConsoleKey__Enum_MediaPrevious = 0x000000b1,
    ConsoleKey__Enum_MediaStop = 0x000000b2,
    ConsoleKey__Enum_MediaPlay = 0x000000b3,
    ConsoleKey__Enum_LaunchMail = 0x000000b4,
    ConsoleKey__Enum_LaunchMediaSelect = 0x000000b5,
    ConsoleKey__Enum_LaunchApp1 = 0x000000b6,
    ConsoleKey__Enum_LaunchApp2 = 0x000000b7,
    ConsoleKey__Enum_Oem1 = 0x000000ba,
    ConsoleKey__Enum_OemPlus = 0x000000bb,
    ConsoleKey__Enum_OemComma = 0x000000bc,
    ConsoleKey__Enum_OemMinus = 0x000000bd,
    ConsoleKey__Enum_OemPeriod = 0x000000be,
    ConsoleKey__Enum_Oem2 = 0x000000bf,
    ConsoleKey__Enum_Oem3 = 0x000000c0,
    ConsoleKey__Enum_Oem4 = 0x000000db,
    ConsoleKey__Enum_Oem5 = 0x000000dc,
    ConsoleKey__Enum_Oem6 = 0x000000dd,
    ConsoleKey__Enum_Oem7 = 0x000000de,
    ConsoleKey__Enum_Oem8 = 0x000000df,
    ConsoleKey__Enum_Oem102 = 0x000000e2,
    ConsoleKey__Enum_Process = 0x000000e5,
    ConsoleKey__Enum_Packet = 0x000000e7,
    ConsoleKey__Enum_Attention = 0x000000f6,
    ConsoleKey__Enum_CrSel = 0x000000f7,
    ConsoleKey__Enum_ExSel = 0x000000f8,
    ConsoleKey__Enum_EraseEndOfFile = 0x000000f9,
    ConsoleKey__Enum_Play = 0x000000fa,
    ConsoleKey__Enum_Zoom = 0x000000fb,
    ConsoleKey__Enum_NoName = 0x000000fc,
    ConsoleKey__Enum_Pa1 = 0x000000fd,
    ConsoleKey__Enum_OemClear = 0x000000fe,
};

#endif
struct ConsoleKey__Enum__Boxed {
    struct ConsoleKey__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum ConsoleKey__Enum value;
    #else
    uint32_t value;
    #endif
};

#if defined(_CPLUSPLUS_)
enum ConsoleModifiers__Enum : int32_t {
    ConsoleModifiers__Enum_Alt = 0x00000001,
    ConsoleModifiers__Enum_Shift = 0x00000002,
    ConsoleModifiers__Enum_Control = 0x00000004,
};

#else
enum ConsoleModifiers__Enum {
    ConsoleModifiers__Enum_Alt = 0x00000001,
    ConsoleModifiers__Enum_Shift = 0x00000002,
    ConsoleModifiers__Enum_Control = 0x00000004,
};

#endif
struct ConsoleModifiers__Enum__Boxed {
    struct ConsoleModifiers__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum ConsoleModifiers__Enum value;
    #else
    uint32_t value;
    #endif
};

struct ConsoleKeyInfo {
    uint16_t _keyChar;
    #if defined(_CPLUSPLUS_)
    enum ConsoleKey__Enum _key;
    #else
    uint32_t _key;
    #endif
    #if defined(_CPLUSPLUS_)
    enum ConsoleModifiers__Enum _mods;
    #else
    uint32_t _mods;
    #endif
};

struct ConsoleKeyInfo__Boxed {
    struct ConsoleKeyInfo__Class *klass;
    MonitorData *monitor;
    struct ConsoleKeyInfo fields;
};

struct ConsoleKey__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct ConsoleKey__Enum__StaticFields {
};

struct ConsoleKey__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ConsoleKey__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ConsoleKey__Enum__VTable vtable;
};

struct ConsoleModifiers__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct ConsoleModifiers__Enum__StaticFields {
};

struct ConsoleModifiers__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ConsoleModifiers__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ConsoleModifiers__Enum__VTable vtable;
};

struct ConsoleKeyInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ConsoleKeyInfo__StaticFields {
};

struct ConsoleKeyInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ConsoleKeyInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ConsoleKeyInfo__VTable vtable;
};

struct ContextBoundObject__Fields {
    struct MarshalByRefObject__Fields _;
};

struct ContextBoundObject {
    struct ContextBoundObject__Class *klass;
    MonitorData *monitor;
    struct ContextBoundObject__Fields fields;
};

struct ContextBoundObject__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
};

struct ContextBoundObject__StaticFields {
};

struct ContextBoundObject__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ContextBoundObject__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ContextBoundObject__VTable vtable;
};

struct ContextMarshalException__Fields {
    struct SystemException__Fields _;
};

struct ContextMarshalException {
    struct ContextMarshalException__Class *klass;
    MonitorData *monitor;
    struct ContextMarshalException__Fields fields;
};

struct ContextMarshalException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct ContextMarshalException__StaticFields {
};

struct ContextMarshalException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ContextMarshalException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ContextMarshalException__VTable vtable;
};

struct ContextStaticAttribute {
    struct ContextStaticAttribute__Class *klass;
    MonitorData *monitor;
};

struct ContextStaticAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct ContextStaticAttribute__StaticFields {
};

struct ContextStaticAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ContextStaticAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ContextStaticAttribute__VTable vtable;
};

struct IConvertible {
    struct IConvertible__Class *klass;
    MonitorData *monitor;
};

struct IConvertible__VTable {
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData ToBoolean;
    VirtualInvokeData ToChar;
    VirtualInvokeData ToSByte;
    VirtualInvokeData ToByte;
    VirtualInvokeData ToInt16;
    VirtualInvokeData ToUInt16;
    VirtualInvokeData ToInt32;
    VirtualInvokeData ToUInt32;
    VirtualInvokeData ToInt64;
    VirtualInvokeData ToUInt64;
    VirtualInvokeData ToSingle;
    VirtualInvokeData ToDouble;
    VirtualInvokeData ToDecimal;
    VirtualInvokeData ToDateTime;
    VirtualInvokeData ToString;
    VirtualInvokeData ToType;
};

struct IConvertible__StaticFields {
};

struct IConvertible__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IConvertible__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IConvertible__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum Base64FormattingOptions__Enum : int32_t {
    Base64FormattingOptions__Enum_None = 0x00000000,
    Base64FormattingOptions__Enum_InsertLineBreaks = 0x00000001,
};

#else
enum Base64FormattingOptions__Enum {
    Base64FormattingOptions__Enum_None = 0x00000000,
    Base64FormattingOptions__Enum_InsertLineBreaks = 0x00000001,
};

#endif
struct Base64FormattingOptions__Enum__Boxed {
    struct Base64FormattingOptions__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum Base64FormattingOptions__Enum value;
    #else
    uint32_t value;
    #endif
};

struct Base64FormattingOptions__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct Base64FormattingOptions__Enum__StaticFields {
};

struct Base64FormattingOptions__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Base64FormattingOptions__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Base64FormattingOptions__Enum__VTable vtable;
};

struct DataMisalignedException__Fields {
    struct SystemException__Fields _;
};

struct DataMisalignedException {
    struct DataMisalignedException__Class *klass;
    MonitorData *monitor;
    struct DataMisalignedException__Fields fields;
};

struct DataMisalignedException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct DataMisalignedException__StaticFields {
};

struct DataMisalignedException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DataMisalignedException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DataMisalignedException__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum DateTimeKind__Enum : int32_t {
    DateTimeKind__Enum_Unspecified = 0x00000000,
    DateTimeKind__Enum_Utc = 0x00000001,
    DateTimeKind__Enum_Local = 0x00000002,
};

#else
enum DateTimeKind__Enum {
    DateTimeKind__Enum_Unspecified = 0x00000000,
    DateTimeKind__Enum_Utc = 0x00000001,
    DateTimeKind__Enum_Local = 0x00000002,
};

#endif
struct DateTimeKind__Enum__Boxed {
    struct DateTimeKind__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum DateTimeKind__Enum value;
    #else
    uint32_t value;
    #endif
};

struct DateTimeKind__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct DateTimeKind__Enum__StaticFields {
};

struct DateTimeKind__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DateTimeKind__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DateTimeKind__Enum__VTable vtable;
};

struct DateTimeOffset {
    struct DateTime m_dateTime;
    int16_t m_offsetMinutes;
};

struct DateTimeOffset__Boxed {
    struct DateTimeOffset__Class *klass;
    MonitorData *monitor;
    struct DateTimeOffset fields;
};

struct DateTimeOffset__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_IComparable_CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
    VirtualInvokeData System_Runtime_Serialization_IDeserializationCallback_OnDeserialization;
    VirtualInvokeData CompareTo;
    VirtualInvokeData Equals_1;
};

struct DateTimeOffset__StaticFields {
    struct DateTimeOffset MinValue;
    struct DateTimeOffset MaxValue;
};

struct DateTimeOffset__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DateTimeOffset__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DateTimeOffset__VTable vtable;
};

struct DateTimeOffset___VTable {
};

struct DateTimeOffset___StaticFields {
};

struct DateTimeOffset___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DateTimeOffset___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DateTimeOffset___VTable vtable;
};

struct DBNull {
    struct DBNull__Class *klass;
    MonitorData *monitor;
};

struct DBNull__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_1;
    VirtualInvokeData System_IConvertible_ToType;
};

struct DBNull__StaticFields {
    struct DBNull *Value;
};

struct DBNull__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DBNull__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DBNull__VTable vtable;
};

struct Decimal___VTable {
};

struct Decimal___StaticFields {
};

struct Decimal___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Decimal___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Decimal___VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum MidpointRounding__Enum : int32_t {
    MidpointRounding__Enum_ToEven = 0x00000000,
    MidpointRounding__Enum_AwayFromZero = 0x00000001,
};

#else
enum MidpointRounding__Enum {
    MidpointRounding__Enum_ToEven = 0x00000000,
    MidpointRounding__Enum_AwayFromZero = 0x00000001,
};

#endif
struct MidpointRounding__Enum__Boxed {
    struct MidpointRounding__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum MidpointRounding__Enum value;
    #else
    uint32_t value;
    #endif
};

struct MidpointRounding__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct MidpointRounding__Enum__StaticFields {
};

struct MidpointRounding__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MidpointRounding__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MidpointRounding__Enum__VTable vtable;
};

struct __declspec(align(8)) DefaultBinder_BinderState__Fields {
    struct Int32__Array *m_argsMap;
    int32_t m_originalSize;
    bool m_isParamArray;
};

struct DefaultBinder_BinderState {
    struct DefaultBinder_BinderState__Class *klass;
    MonitorData *monitor;
    struct DefaultBinder_BinderState__Fields fields;
};

struct DefaultBinder_BinderState__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct DefaultBinder_BinderState__StaticFields {
};

struct DefaultBinder_BinderState__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DefaultBinder_BinderState__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DefaultBinder_BinderState__VTable vtable;
};

struct DefaultBinder_c {
    struct DefaultBinder_c__Class *klass;
    MonitorData *monitor;
};

struct Predicate_1_Type___Fields {
    struct MulticastDelegate__Fields _;
};

struct Predicate_1_Type_ {
    struct Predicate_1_Type___Class *klass;
    MonitorData *monitor;
    struct Predicate_1_Type___Fields fields;
};

struct Predicate_1_Type___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Predicate_1_Type___StaticFields {
};

struct Predicate_1_Type___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Predicate_1_Type___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Predicate_1_Type___VTable vtable;
};

struct DefaultBinder_c__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct DefaultBinder_c__StaticFields {
    struct DefaultBinder_c *__9;
    struct Predicate_1_Type_ *__9__3_0;
};

struct DefaultBinder_c__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DefaultBinder_c__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DefaultBinder_c__VTable vtable;
};

struct DivideByZeroException__Fields {
    struct ArithmeticException__Fields _;
};

struct DivideByZeroException {
    struct DivideByZeroException__Class *klass;
    MonitorData *monitor;
    struct DivideByZeroException__Fields fields;
};

struct DivideByZeroException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct DivideByZeroException__StaticFields {
};

struct DivideByZeroException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DivideByZeroException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DivideByZeroException__VTable vtable;
};

struct TypeLoadException__Fields {
    struct SystemException__Fields _;
    struct String *ClassName;
    struct String *AssemblyName;
    struct String *MessageArg;
    int32_t ResourceId;
};

struct TypeLoadException {
    struct TypeLoadException__Class *klass;
    MonitorData *monitor;
    struct TypeLoadException__Fields fields;
};

struct DllNotFoundException__Fields {
    struct TypeLoadException__Fields _;
};

struct DllNotFoundException {
    struct DllNotFoundException__Class *klass;
    MonitorData *monitor;
    struct DllNotFoundException__Fields fields;
};

struct TypeLoadException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct TypeLoadException__StaticFields {
};

struct TypeLoadException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeLoadException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeLoadException__VTable vtable;
};

struct DllNotFoundException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct DllNotFoundException__StaticFields {
};

struct DllNotFoundException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DllNotFoundException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DllNotFoundException__VTable vtable;
};

struct Double___VTable {
};

struct Double___StaticFields {
};

struct Double___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Double___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Double___VTable vtable;
};

struct DuplicateWaitObjectException__Fields {
    struct ArgumentException__Fields _;
};

struct DuplicateWaitObjectException {
    struct DuplicateWaitObjectException__Class *klass;
    MonitorData *monitor;
    struct DuplicateWaitObjectException__Fields fields;
};

struct DuplicateWaitObjectException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
    VirtualInvokeData get_ParamName;
};

struct DuplicateWaitObjectException__StaticFields {
    struct String *_duplicateWaitObjectMessage;
};

struct DuplicateWaitObjectException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DuplicateWaitObjectException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DuplicateWaitObjectException__VTable vtable;
};

struct Empty {
    struct Empty__Class *klass;
    MonitorData *monitor;
};

struct Empty__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
};

struct Empty__StaticFields {
    struct Empty *Value;
};

struct Empty__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Empty__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Empty__VTable vtable;
};

struct EntryPointNotFoundException__Fields {
    struct TypeLoadException__Fields _;
};

struct EntryPointNotFoundException {
    struct EntryPointNotFoundException__Class *klass;
    MonitorData *monitor;
    struct EntryPointNotFoundException__Fields fields;
};

struct EntryPointNotFoundException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct EntryPointNotFoundException__StaticFields {
};

struct EntryPointNotFoundException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EntryPointNotFoundException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EntryPointNotFoundException__VTable vtable;
};

struct __declspec(align(8)) Enum_ValuesAndNames__Fields {
    struct UInt64__Array *Values;
    struct String__Array *Names;
};

struct Enum_ValuesAndNames {
    struct Enum_ValuesAndNames__Class *klass;
    MonitorData *monitor;
    struct Enum_ValuesAndNames__Fields fields;
};

struct UInt64__Array {
    struct UInt64__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    uint64_t vector[32];
};

struct UInt64__Array__VTable {
};

struct UInt64__Array__StaticFields {
};

struct UInt64__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UInt64__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UInt64__Array__VTable vtable;
};

struct Enum_ValuesAndNames__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Enum_ValuesAndNames__StaticFields {
};

struct Enum_ValuesAndNames__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Enum_ValuesAndNames__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Enum_ValuesAndNames__VTable vtable;
};

struct UInt64___VTable {
};

struct UInt64___StaticFields {
};

struct UInt64___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UInt64___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UInt64___VTable vtable;
};

struct String___VTable {
};

struct String___StaticFields {
};

struct String___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct String___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct String___VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum Enum_ParseFailureKind__Enum : int32_t {
    Enum_ParseFailureKind__Enum_None = 0x00000000,
    Enum_ParseFailureKind__Enum_Argument = 0x00000001,
    Enum_ParseFailureKind__Enum_ArgumentNull = 0x00000002,
    Enum_ParseFailureKind__Enum_ArgumentWithParameter = 0x00000003,
    Enum_ParseFailureKind__Enum_UnhandledException = 0x00000004,
};

#else
enum Enum_ParseFailureKind__Enum {
    Enum_ParseFailureKind__Enum_None = 0x00000000,
    Enum_ParseFailureKind__Enum_Argument = 0x00000001,
    Enum_ParseFailureKind__Enum_ArgumentNull = 0x00000002,
    Enum_ParseFailureKind__Enum_ArgumentWithParameter = 0x00000003,
    Enum_ParseFailureKind__Enum_UnhandledException = 0x00000004,
};

#endif
struct Enum_ParseFailureKind__Enum__Boxed {
    struct Enum_ParseFailureKind__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum Enum_ParseFailureKind__Enum value;
    #else
    uint32_t value;
    #endif
};

struct Enum_EnumResult {
    struct Object *parsedEnum;
    bool canThrow;
    #if defined(_CPLUSPLUS_)
    enum Enum_ParseFailureKind__Enum m_failure;
    #else
    uint32_t m_failure;
    #endif
    struct String *m_failureMessageID;
    struct String *m_failureParameter;
    struct Object *m_failureMessageFormatArgument;
    struct Exception *m_innerException;
};

struct Enum_EnumResult__Boxed {
    struct Enum_EnumResult__Class *klass;
    MonitorData *monitor;
    struct Enum_EnumResult fields;
};

struct Enum_ParseFailureKind__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct Enum_ParseFailureKind__Enum__StaticFields {
};

struct Enum_ParseFailureKind__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Enum_ParseFailureKind__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Enum_ParseFailureKind__Enum__VTable vtable;
};

struct Enum_EnumResult__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Enum_EnumResult__StaticFields {
};

struct Enum_EnumResult__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Enum_EnumResult__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Enum_EnumResult__VTable vtable;
};

struct Enum_EnumResult___VTable {
};

struct Enum_EnumResult___StaticFields {
};

struct Enum_EnumResult___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Enum_EnumResult___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Enum_EnumResult___VTable vtable;
};

struct IRuntimeMethodInfo {
    struct IRuntimeMethodInfo__Class *klass;
    MonitorData *monitor;
};

struct IRuntimeMethodInfo__VTable {
    VirtualInvokeData get_Value;
};

struct IRuntimeMethodInfo__StaticFields {
};

struct IRuntimeMethodInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IRuntimeMethodInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IRuntimeMethodInfo__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum Exception_ExceptionMessageKind__Enum : int32_t {
    Exception_ExceptionMessageKind__Enum_ThreadAbort = 0x00000001,
    Exception_ExceptionMessageKind__Enum_ThreadInterrupted = 0x00000002,
    Exception_ExceptionMessageKind__Enum_OutOfMemory = 0x00000003,
};

#else
enum Exception_ExceptionMessageKind__Enum {
    Exception_ExceptionMessageKind__Enum_ThreadAbort = 0x00000001,
    Exception_ExceptionMessageKind__Enum_ThreadInterrupted = 0x00000002,
    Exception_ExceptionMessageKind__Enum_OutOfMemory = 0x00000003,
};

#endif
struct Exception_ExceptionMessageKind__Enum__Boxed {
    struct Exception_ExceptionMessageKind__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum Exception_ExceptionMessageKind__Enum value;
    #else
    uint32_t value;
    #endif
};

struct Exception_ExceptionMessageKind__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct Exception_ExceptionMessageKind__Enum__StaticFields {
};

struct Exception_ExceptionMessageKind__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Exception_ExceptionMessageKind__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Exception_ExceptionMessageKind__Enum__VTable vtable;
};

struct ExecutionEngineException__Fields {
    struct SystemException__Fields _;
};

struct ExecutionEngineException {
    struct ExecutionEngineException__Class *klass;
    MonitorData *monitor;
    struct ExecutionEngineException__Fields fields;
};

struct ExecutionEngineException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct ExecutionEngineException__StaticFields {
};

struct ExecutionEngineException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ExecutionEngineException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ExecutionEngineException__VTable vtable;
};

struct MemberAccessException__Fields {
    struct SystemException__Fields _;
};

struct MemberAccessException {
    struct MemberAccessException__Class *klass;
    MonitorData *monitor;
    struct MemberAccessException__Fields fields;
};

struct FieldAccessException__Fields {
    struct MemberAccessException__Fields _;
};

struct FieldAccessException {
    struct FieldAccessException__Class *klass;
    MonitorData *monitor;
    struct FieldAccessException__Fields fields;
};

struct MemberAccessException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct MemberAccessException__StaticFields {
};

struct MemberAccessException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MemberAccessException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MemberAccessException__VTable vtable;
};

struct FieldAccessException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct FieldAccessException__StaticFields {
};

struct FieldAccessException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FieldAccessException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FieldAccessException__VTable vtable;
};

struct FlagsAttribute {
    struct FlagsAttribute__Class *klass;
    MonitorData *monitor;
};

struct FlagsAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct FlagsAttribute__StaticFields {
};

struct FlagsAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FlagsAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FlagsAttribute__VTable vtable;
};

struct FormatException__Fields {
    struct SystemException__Fields _;
};

struct FormatException {
    struct FormatException__Class *klass;
    MonitorData *monitor;
    struct FormatException__Fields fields;
};

struct FormatException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct FormatException__StaticFields {
};

struct FormatException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FormatException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FormatException__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum GCCollectionMode__Enum : int32_t {
    GCCollectionMode__Enum_Default = 0x00000000,
    GCCollectionMode__Enum_Forced = 0x00000001,
    GCCollectionMode__Enum_Optimized = 0x00000002,
};

#else
enum GCCollectionMode__Enum {
    GCCollectionMode__Enum_Default = 0x00000000,
    GCCollectionMode__Enum_Forced = 0x00000001,
    GCCollectionMode__Enum_Optimized = 0x00000002,
};

#endif
struct GCCollectionMode__Enum__Boxed {
    struct GCCollectionMode__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum GCCollectionMode__Enum value;
    #else
    uint32_t value;
    #endif
};

struct GCCollectionMode__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct GCCollectionMode__Enum__StaticFields {
};

struct GCCollectionMode__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct GCCollectionMode__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct GCCollectionMode__Enum__VTable vtable;
};

struct GCHandle {
    int32_t handle;
};

struct GCHandle__Boxed {
    struct GCHandle__Class *klass;
    MonitorData *monitor;
    struct GCHandle fields;
};

struct __declspec(align(8)) WeakReference__Fields {
    bool isLongReference;
    struct GCHandle gcHandle;
};

struct WeakReference {
    struct WeakReference__Class *klass;
    MonitorData *monitor;
    struct WeakReference__Fields fields;
};

struct GCHandle__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct GCHandle__StaticFields {
};

struct GCHandle__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct GCHandle__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct GCHandle__VTable vtable;
};

struct WeakReference__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_IsAlive;
    VirtualInvokeData get_Target;
    VirtualInvokeData set_Target;
    VirtualInvokeData get_TrackResurrection;
    VirtualInvokeData GetObjectData_1;
};

struct WeakReference__StaticFields {
};

struct WeakReference__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct WeakReference__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct WeakReference__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum GCNotificationStatus__Enum : int32_t {
    GCNotificationStatus__Enum_Succeeded = 0x00000000,
    GCNotificationStatus__Enum_Failed = 0x00000001,
    GCNotificationStatus__Enum_Canceled = 0x00000002,
    GCNotificationStatus__Enum_Timeout = 0x00000003,
    GCNotificationStatus__Enum_NotApplicable = 0x00000004,
};

#else
enum GCNotificationStatus__Enum {
    GCNotificationStatus__Enum_Succeeded = 0x00000000,
    GCNotificationStatus__Enum_Failed = 0x00000001,
    GCNotificationStatus__Enum_Canceled = 0x00000002,
    GCNotificationStatus__Enum_Timeout = 0x00000003,
    GCNotificationStatus__Enum_NotApplicable = 0x00000004,
};

#endif
struct GCNotificationStatus__Enum__Boxed {
    struct GCNotificationStatus__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum GCNotificationStatus__Enum value;
    #else
    uint32_t value;
    #endif
};

struct GCNotificationStatus__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct GCNotificationStatus__Enum__StaticFields {
};

struct GCNotificationStatus__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct GCNotificationStatus__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct GCNotificationStatus__Enum__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum GC_EndNoGCRegionStatus__Enum : int32_t {
    GC_EndNoGCRegionStatus__Enum_Succeeded = 0x00000000,
    GC_EndNoGCRegionStatus__Enum_NotInProgress = 0x00000001,
    GC_EndNoGCRegionStatus__Enum_GCInduced = 0x00000002,
    GC_EndNoGCRegionStatus__Enum_AllocationExceeded = 0x00000003,
};

#else
enum GC_EndNoGCRegionStatus__Enum {
    GC_EndNoGCRegionStatus__Enum_Succeeded = 0x00000000,
    GC_EndNoGCRegionStatus__Enum_NotInProgress = 0x00000001,
    GC_EndNoGCRegionStatus__Enum_GCInduced = 0x00000002,
    GC_EndNoGCRegionStatus__Enum_AllocationExceeded = 0x00000003,
};

#endif
struct GC_EndNoGCRegionStatus__Enum__Boxed {
    struct GC_EndNoGCRegionStatus__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum GC_EndNoGCRegionStatus__Enum value;
    #else
    uint32_t value;
    #endif
};

struct GC_EndNoGCRegionStatus__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct GC_EndNoGCRegionStatus__Enum__StaticFields {
};

struct GC_EndNoGCRegionStatus__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct GC_EndNoGCRegionStatus__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct GC_EndNoGCRegionStatus__Enum__VTable vtable;
};

struct __declspec(align(8)) SizedReference__Fields {
    void *_handle;
};

struct SizedReference {
    struct SizedReference__Class *klass;
    MonitorData *monitor;
    struct SizedReference__Fields fields;
};

struct SizedReference__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
};

struct SizedReference__StaticFields {
};

struct SizedReference__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SizedReference__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SizedReference__VTable vtable;
};

struct DateTimeFormatInfo___VTable {
};

struct DateTimeFormatInfo___StaticFields {
};

struct DateTimeFormatInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DateTimeFormatInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DateTimeFormatInfo___VTable vtable;
};

struct TimeSpan___VTable {
};

struct TimeSpan___StaticFields {
};

struct TimeSpan___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TimeSpan___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TimeSpan___VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum ParseFlags__Enum : int32_t {
    ParseFlags__Enum_HaveYear = 0x00000001,
    ParseFlags__Enum_HaveMonth = 0x00000002,
    ParseFlags__Enum_HaveDay = 0x00000004,
    ParseFlags__Enum_HaveHour = 0x00000008,
    ParseFlags__Enum_HaveMinute = 0x00000010,
    ParseFlags__Enum_HaveSecond = 0x00000020,
    ParseFlags__Enum_HaveTime = 0x00000040,
    ParseFlags__Enum_HaveDate = 0x00000080,
    ParseFlags__Enum_TimeZoneUsed = 0x00000100,
    ParseFlags__Enum_TimeZoneUtc = 0x00000200,
    ParseFlags__Enum_ParsedMonthName = 0x00000400,
    ParseFlags__Enum_CaptureOffset = 0x00000800,
    ParseFlags__Enum_YearDefault = 0x00001000,
    ParseFlags__Enum_Rfc1123Pattern = 0x00002000,
    ParseFlags__Enum_UtcSortPattern = 0x00004000,
};

#else
enum ParseFlags__Enum {
    ParseFlags__Enum_HaveYear = 0x00000001,
    ParseFlags__Enum_HaveMonth = 0x00000002,
    ParseFlags__Enum_HaveDay = 0x00000004,
    ParseFlags__Enum_HaveHour = 0x00000008,
    ParseFlags__Enum_HaveMinute = 0x00000010,
    ParseFlags__Enum_HaveSecond = 0x00000020,
    ParseFlags__Enum_HaveTime = 0x00000040,
    ParseFlags__Enum_HaveDate = 0x00000080,
    ParseFlags__Enum_TimeZoneUsed = 0x00000100,
    ParseFlags__Enum_TimeZoneUtc = 0x00000200,
    ParseFlags__Enum_ParsedMonthName = 0x00000400,
    ParseFlags__Enum_CaptureOffset = 0x00000800,
    ParseFlags__Enum_YearDefault = 0x00001000,
    ParseFlags__Enum_Rfc1123Pattern = 0x00002000,
    ParseFlags__Enum_UtcSortPattern = 0x00004000,
};

#endif
struct ParseFlags__Enum__Boxed {
    struct ParseFlags__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum ParseFlags__Enum value;
    #else
    uint32_t value;
    #endif
};

#if defined(_CPLUSPLUS_)
enum ParseFailureKind__Enum : int32_t {
    ParseFailureKind__Enum_None = 0x00000000,
    ParseFailureKind__Enum_ArgumentNull = 0x00000001,
    ParseFailureKind__Enum_Format = 0x00000002,
    ParseFailureKind__Enum_FormatWithParameter = 0x00000003,
    ParseFailureKind__Enum_FormatBadDateTimeCalendar = 0x00000004,
};

#else
enum ParseFailureKind__Enum {
    ParseFailureKind__Enum_None = 0x00000000,
    ParseFailureKind__Enum_ArgumentNull = 0x00000001,
    ParseFailureKind__Enum_Format = 0x00000002,
    ParseFailureKind__Enum_FormatWithParameter = 0x00000003,
    ParseFailureKind__Enum_FormatBadDateTimeCalendar = 0x00000004,
};

#endif
struct ParseFailureKind__Enum__Boxed {
    struct ParseFailureKind__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum ParseFailureKind__Enum value;
    #else
    uint32_t value;
    #endif
};

struct DateTimeResult {
    int32_t Year;
    int32_t Month;
    int32_t Day;
    int32_t Hour;
    int32_t Minute;
    int32_t Second;
    double fraction;
    int32_t era;
    #if defined(_CPLUSPLUS_)
    enum ParseFlags__Enum flags;
    #else
    uint32_t flags;
    #endif
    struct TimeSpan timeZoneOffset;
    struct Calendar *calendar;
    struct DateTime parsedDate;
    #if defined(_CPLUSPLUS_)
    enum ParseFailureKind__Enum failure;
    #else
    uint32_t failure;
    #endif
    struct String *failureMessageID;
    struct Object *failureMessageFormatArgument;
    struct String *failureArgumentName;
};

struct DateTimeResult__Boxed {
    struct DateTimeResult__Class *klass;
    MonitorData *monitor;
    struct DateTimeResult fields;
};

struct ParseFlags__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct ParseFlags__Enum__StaticFields {
};

struct ParseFlags__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ParseFlags__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ParseFlags__Enum__VTable vtable;
};

struct ParseFailureKind__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct ParseFailureKind__Enum__StaticFields {
};

struct ParseFailureKind__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ParseFailureKind__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ParseFailureKind__Enum__VTable vtable;
};

struct DateTimeResult__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct DateTimeResult__StaticFields {
};

struct DateTimeResult__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DateTimeResult__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DateTimeResult__VTable vtable;
};

struct DateTimeResult___VTable {
};

struct DateTimeResult___StaticFields {
};

struct DateTimeResult___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DateTimeResult___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DateTimeResult___VTable vtable;
};

struct _DTString {
    struct String *Value;
    int32_t Index;
    int32_t len;
    uint16_t m_current;
    struct CompareInfo *m_info;
    bool m_checkDigitToken;
};

struct _DTString__Boxed {
    struct _DTString__Class *klass;
    MonitorData *monitor;
    struct _DTString fields;
};

struct _DTString__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct _DTString__StaticFields {
    struct Char__Array *WhiteSpaceChecks;
};

struct _DTString__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct _DTString__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct _DTString__VTable vtable;
};

struct _DTString___VTable {
};

struct _DTString___StaticFields {
};

struct _DTString___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct _DTString___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct _DTString___VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum DateTimeParse_DS__Enum : int32_t {
    DateTimeParse_DS__Enum_BEGIN = 0x00000000,
    DateTimeParse_DS__Enum_N = 0x00000001,
    DateTimeParse_DS__Enum_NN = 0x00000002,
    DateTimeParse_DS__Enum_D_Nd = 0x00000003,
    DateTimeParse_DS__Enum_D_NN = 0x00000004,
    DateTimeParse_DS__Enum_D_NNd = 0x00000005,
    DateTimeParse_DS__Enum_D_M = 0x00000006,
    DateTimeParse_DS__Enum_D_MN = 0x00000007,
    DateTimeParse_DS__Enum_D_NM = 0x00000008,
    DateTimeParse_DS__Enum_D_MNd = 0x00000009,
    DateTimeParse_DS__Enum_D_NDS = 0x0000000a,
    DateTimeParse_DS__Enum_D_Y = 0x0000000b,
    DateTimeParse_DS__Enum_D_YN = 0x0000000c,
    DateTimeParse_DS__Enum_D_YNd = 0x0000000d,
    DateTimeParse_DS__Enum_D_YM = 0x0000000e,
    DateTimeParse_DS__Enum_D_YMd = 0x0000000f,
    DateTimeParse_DS__Enum_D_S = 0x00000010,
    DateTimeParse_DS__Enum_T_S = 0x00000011,
    DateTimeParse_DS__Enum_T_Nt = 0x00000012,
    DateTimeParse_DS__Enum_T_NNt = 0x00000013,
    DateTimeParse_DS__Enum_ERROR = 0x00000014,
    DateTimeParse_DS__Enum_DX_NN = 0x00000015,
    DateTimeParse_DS__Enum_DX_NNN = 0x00000016,
    DateTimeParse_DS__Enum_DX_MN = 0x00000017,
    DateTimeParse_DS__Enum_DX_NM = 0x00000018,
    DateTimeParse_DS__Enum_DX_MNN = 0x00000019,
    DateTimeParse_DS__Enum_DX_DS = 0x0000001a,
    DateTimeParse_DS__Enum_DX_DSN = 0x0000001b,
    DateTimeParse_DS__Enum_DX_NDS = 0x0000001c,
    DateTimeParse_DS__Enum_DX_NNDS = 0x0000001d,
    DateTimeParse_DS__Enum_DX_YNN = 0x0000001e,
    DateTimeParse_DS__Enum_DX_YMN = 0x0000001f,
    DateTimeParse_DS__Enum_DX_YN = 0x00000020,
    DateTimeParse_DS__Enum_DX_YM = 0x00000021,
    DateTimeParse_DS__Enum_TX_N = 0x00000022,
    DateTimeParse_DS__Enum_TX_NN = 0x00000023,
    DateTimeParse_DS__Enum_TX_NNN = 0x00000024,
    DateTimeParse_DS__Enum_TX_TS = 0x00000025,
    DateTimeParse_DS__Enum_DX_NNY = 0x00000026,
};

#else
enum DateTimeParse_DS__Enum {
    DateTimeParse_DS__Enum_BEGIN = 0x00000000,
    DateTimeParse_DS__Enum_N = 0x00000001,
    DateTimeParse_DS__Enum_NN = 0x00000002,
    DateTimeParse_DS__Enum_D_Nd = 0x00000003,
    DateTimeParse_DS__Enum_D_NN = 0x00000004,
    DateTimeParse_DS__Enum_D_NNd = 0x00000005,
    DateTimeParse_DS__Enum_D_M = 0x00000006,
    DateTimeParse_DS__Enum_D_MN = 0x00000007,
    DateTimeParse_DS__Enum_D_NM = 0x00000008,
    DateTimeParse_DS__Enum_D_MNd = 0x00000009,
    DateTimeParse_DS__Enum_D_NDS = 0x0000000a,
    DateTimeParse_DS__Enum_D_Y = 0x0000000b,
    DateTimeParse_DS__Enum_D_YN = 0x0000000c,
    DateTimeParse_DS__Enum_D_YNd = 0x0000000d,
    DateTimeParse_DS__Enum_D_YM = 0x0000000e,
    DateTimeParse_DS__Enum_D_YMd = 0x0000000f,
    DateTimeParse_DS__Enum_D_S = 0x00000010,
    DateTimeParse_DS__Enum_T_S = 0x00000011,
    DateTimeParse_DS__Enum_T_Nt = 0x00000012,
    DateTimeParse_DS__Enum_T_NNt = 0x00000013,
    DateTimeParse_DS__Enum_ERROR = 0x00000014,
    DateTimeParse_DS__Enum_DX_NN = 0x00000015,
    DateTimeParse_DS__Enum_DX_NNN = 0x00000016,
    DateTimeParse_DS__Enum_DX_MN = 0x00000017,
    DateTimeParse_DS__Enum_DX_NM = 0x00000018,
    DateTimeParse_DS__Enum_DX_MNN = 0x00000019,
    DateTimeParse_DS__Enum_DX_DS = 0x0000001a,
    DateTimeParse_DS__Enum_DX_DSN = 0x0000001b,
    DateTimeParse_DS__Enum_DX_NDS = 0x0000001c,
    DateTimeParse_DS__Enum_DX_NNDS = 0x0000001d,
    DateTimeParse_DS__Enum_DX_YNN = 0x0000001e,
    DateTimeParse_DS__Enum_DX_YMN = 0x0000001f,
    DateTimeParse_DS__Enum_DX_YN = 0x00000020,
    DateTimeParse_DS__Enum_DX_YM = 0x00000021,
    DateTimeParse_DS__Enum_TX_N = 0x00000022,
    DateTimeParse_DS__Enum_TX_NN = 0x00000023,
    DateTimeParse_DS__Enum_TX_NNN = 0x00000024,
    DateTimeParse_DS__Enum_TX_TS = 0x00000025,
    DateTimeParse_DS__Enum_DX_NNY = 0x00000026,
};

#endif
struct DateTimeParse_DS__Enum__Boxed {
    struct DateTimeParse_DS__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum DateTimeParse_DS__Enum value;
    #else
    uint32_t value;
    #endif
};

#if defined(_CPLUSPLUS_)
enum DateTimeParse_DTT__Enum : int32_t {
    DateTimeParse_DTT__Enum_End = 0x00000000,
    DateTimeParse_DTT__Enum_NumEnd = 0x00000001,
    DateTimeParse_DTT__Enum_NumAmpm = 0x00000002,
    DateTimeParse_DTT__Enum_NumSpace = 0x00000003,
    DateTimeParse_DTT__Enum_NumDatesep = 0x00000004,
    DateTimeParse_DTT__Enum_NumTimesep = 0x00000005,
    DateTimeParse_DTT__Enum_MonthEnd = 0x00000006,
    DateTimeParse_DTT__Enum_MonthSpace = 0x00000007,
    DateTimeParse_DTT__Enum_MonthDatesep = 0x00000008,
    DateTimeParse_DTT__Enum_NumDatesuff = 0x00000009,
    DateTimeParse_DTT__Enum_NumTimesuff = 0x0000000a,
    DateTimeParse_DTT__Enum_DayOfWeek = 0x0000000b,
    DateTimeParse_DTT__Enum_YearSpace = 0x0000000c,
    DateTimeParse_DTT__Enum_YearDateSep = 0x0000000d,
    DateTimeParse_DTT__Enum_YearEnd = 0x0000000e,
    DateTimeParse_DTT__Enum_TimeZone = 0x0000000f,
    DateTimeParse_DTT__Enum_Era = 0x00000010,
    DateTimeParse_DTT__Enum_NumUTCTimeMark = 0x00000011,
    DateTimeParse_DTT__Enum_Unk = 0x00000012,
    DateTimeParse_DTT__Enum_NumLocalTimeMark = 0x00000013,
    DateTimeParse_DTT__Enum_Max = 0x00000014,
};

#else
enum DateTimeParse_DTT__Enum {
    DateTimeParse_DTT__Enum_End = 0x00000000,
    DateTimeParse_DTT__Enum_NumEnd = 0x00000001,
    DateTimeParse_DTT__Enum_NumAmpm = 0x00000002,
    DateTimeParse_DTT__Enum_NumSpace = 0x00000003,
    DateTimeParse_DTT__Enum_NumDatesep = 0x00000004,
    DateTimeParse_DTT__Enum_NumTimesep = 0x00000005,
    DateTimeParse_DTT__Enum_MonthEnd = 0x00000006,
    DateTimeParse_DTT__Enum_MonthSpace = 0x00000007,
    DateTimeParse_DTT__Enum_MonthDatesep = 0x00000008,
    DateTimeParse_DTT__Enum_NumDatesuff = 0x00000009,
    DateTimeParse_DTT__Enum_NumTimesuff = 0x0000000a,
    DateTimeParse_DTT__Enum_DayOfWeek = 0x0000000b,
    DateTimeParse_DTT__Enum_YearSpace = 0x0000000c,
    DateTimeParse_DTT__Enum_YearDateSep = 0x0000000d,
    DateTimeParse_DTT__Enum_YearEnd = 0x0000000e,
    DateTimeParse_DTT__Enum_TimeZone = 0x0000000f,
    DateTimeParse_DTT__Enum_Era = 0x00000010,
    DateTimeParse_DTT__Enum_NumUTCTimeMark = 0x00000011,
    DateTimeParse_DTT__Enum_Unk = 0x00000012,
    DateTimeParse_DTT__Enum_NumLocalTimeMark = 0x00000013,
    DateTimeParse_DTT__Enum_Max = 0x00000014,
};

#endif
struct DateTimeParse_DTT__Enum__Boxed {
    struct DateTimeParse_DTT__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum DateTimeParse_DTT__Enum value;
    #else
    uint32_t value;
    #endif
};

struct DateTimeToken {
    #if defined(_CPLUSPLUS_)
    enum DateTimeParse_DTT__Enum dtt;
    #else
    uint32_t dtt;
    #endif
    #if defined(_CPLUSPLUS_)
    enum TokenType__Enum suffix;
    #else
    uint32_t suffix;
    #endif
    int32_t num;
};

struct DateTimeToken__Boxed {
    struct DateTimeToken__Class *klass;
    MonitorData *monitor;
    struct DateTimeToken fields;
};

#if defined(_CPLUSPLUS_)
enum DateTimeParse_TM__Enum : int32_t {
    DateTimeParse_TM__Enum_NotSet = 0xffffffff,
    DateTimeParse_TM__Enum_AM = 0x00000000,
    DateTimeParse_TM__Enum_PM = 0x00000001,
};

#else
enum DateTimeParse_TM__Enum {
    DateTimeParse_TM__Enum_NotSet = 0xffffffff,
    DateTimeParse_TM__Enum_AM = 0x00000000,
    DateTimeParse_TM__Enum_PM = 0x00000001,
};

#endif
struct DateTimeParse_TM__Enum__Boxed {
    struct DateTimeParse_TM__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum DateTimeParse_TM__Enum value;
    #else
    uint32_t value;
    #endif
};

struct DateTimeRawInfo {
    int32_t *num;
    int32_t numCount;
    int32_t month;
    int32_t year;
    int32_t dayOfWeek;
    int32_t era;
    #if defined(_CPLUSPLUS_)
    enum DateTimeParse_TM__Enum timeMark;
    #else
    uint32_t timeMark;
    #endif
    double fraction;
    bool hasSameDateAndTimeSeparators;
    bool timeZone;
};

struct DateTimeRawInfo__Boxed {
    struct DateTimeRawInfo__Class *klass;
    MonitorData *monitor;
    struct DateTimeRawInfo fields;
};

struct Int32Ptr {
    struct Int32Ptr__Class *klass;
    MonitorData *monitor;
};

struct DateTimeParse_DS__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct DateTimeParse_DS__Enum__StaticFields {
};

struct DateTimeParse_DS__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DateTimeParse_DS__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DateTimeParse_DS__Enum__VTable vtable;
};

struct DateTimeParse_DTT__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct DateTimeParse_DTT__Enum__StaticFields {
};

struct DateTimeParse_DTT__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DateTimeParse_DTT__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DateTimeParse_DTT__Enum__VTable vtable;
};

struct DateTimeToken__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct DateTimeToken__StaticFields {
};

struct DateTimeToken__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DateTimeToken__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DateTimeToken__VTable vtable;
};

struct DateTimeToken___VTable {
};

struct DateTimeToken___StaticFields {
};

struct DateTimeToken___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DateTimeToken___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DateTimeToken___VTable vtable;
};

struct Int32Ptr__VTable {
};

struct Int32Ptr__StaticFields {
};

struct Int32Ptr__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Int32Ptr__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Int32Ptr__VTable vtable;
};

struct DateTimeParse_TM__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct DateTimeParse_TM__Enum__StaticFields {
};

struct DateTimeParse_TM__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DateTimeParse_TM__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DateTimeParse_TM__Enum__VTable vtable;
};

struct DateTimeRawInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct DateTimeRawInfo__StaticFields {
};

struct DateTimeRawInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DateTimeRawInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DateTimeRawInfo__VTable vtable;
};

struct DateTimeRawInfo___VTable {
};

struct DateTimeRawInfo___StaticFields {
};

struct DateTimeRawInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DateTimeRawInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DateTimeRawInfo___VTable vtable;
};

struct DateTimeStyles___VTable {
};

struct DateTimeStyles___StaticFields {
};

struct DateTimeStyles___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DateTimeStyles___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DateTimeStyles___VTable vtable;
};

struct DateTimeParse_TM___VTable {
};

struct DateTimeParse_TM___StaticFields {
};

struct DateTimeParse_TM___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DateTimeParse_TM___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DateTimeParse_TM___VTable vtable;
};

struct Calendar___VTable {
};

struct Calendar___StaticFields {
};

struct Calendar___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Calendar___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Calendar___VTable vtable;
};

struct ParsingInfo {
    struct Calendar *calendar;
    int32_t dayOfWeek;
    #if defined(_CPLUSPLUS_)
    enum DateTimeParse_TM__Enum timeMark;
    #else
    uint32_t timeMark;
    #endif
    bool fUseHour12;
    bool fUseTwoDigitYear;
    bool fAllowInnerWhite;
    bool fAllowTrailingWhite;
    bool fCustomNumberParser;
    struct DateTimeParse_MatchNumberDelegate *parseNumberDelegate;
};

struct ParsingInfo__Boxed {
    struct ParsingInfo__Class *klass;
    MonitorData *monitor;
    struct ParsingInfo fields;
};

struct DateTimeParse_MatchNumberDelegate__Fields {
    struct MulticastDelegate__Fields _;
};

struct DateTimeParse_MatchNumberDelegate {
    struct DateTimeParse_MatchNumberDelegate__Class *klass;
    MonitorData *monitor;
    struct DateTimeParse_MatchNumberDelegate__Fields fields;
};

struct DateTimeParse_MatchNumberDelegate__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct DateTimeParse_MatchNumberDelegate__StaticFields {
};

struct DateTimeParse_MatchNumberDelegate__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DateTimeParse_MatchNumberDelegate__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DateTimeParse_MatchNumberDelegate__VTable vtable;
};

struct ParsingInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ParsingInfo__StaticFields {
};

struct ParsingInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ParsingInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ParsingInfo__VTable vtable;
};

struct ParsingInfo___VTable {
};

struct ParsingInfo___StaticFields {
};

struct ParsingInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ParsingInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ParsingInfo___VTable vtable;
};

struct TokenType___VTable {
};

struct TokenType___StaticFields {
};

struct TokenType___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TokenType___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TokenType___VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum DTSubStringType__Enum : int32_t {
    DTSubStringType__Enum_Unknown = 0x00000000,
    DTSubStringType__Enum_Invalid = 0x00000001,
    DTSubStringType__Enum_Number = 0x00000002,
    DTSubStringType__Enum_End = 0x00000003,
    DTSubStringType__Enum_Other = 0x00000004,
};

#else
enum DTSubStringType__Enum {
    DTSubStringType__Enum_Unknown = 0x00000000,
    DTSubStringType__Enum_Invalid = 0x00000001,
    DTSubStringType__Enum_Number = 0x00000002,
    DTSubStringType__Enum_End = 0x00000003,
    DTSubStringType__Enum_Other = 0x00000004,
};

#endif
struct DTSubStringType__Enum__Boxed {
    struct DTSubStringType__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum DTSubStringType__Enum value;
    #else
    uint32_t value;
    #endif
};

struct DTSubString {
    struct String *s;
    int32_t index;
    int32_t length;
    #if defined(_CPLUSPLUS_)
    enum DTSubStringType__Enum type;
    #else
    uint32_t type;
    #endif
    int32_t value;
};

struct DTSubString__Boxed {
    struct DTSubString__Class *klass;
    MonitorData *monitor;
    struct DTSubString fields;
};

struct DTSubStringType__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct DTSubStringType__Enum__StaticFields {
};

struct DTSubStringType__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DTSubStringType__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DTSubStringType__Enum__VTable vtable;
};

struct DTSubString__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct DTSubString__StaticFields {
};

struct DTSubString__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DTSubString__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DTSubString__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum Guid_GuidStyles__Enum : int32_t {
    Guid_GuidStyles__Enum_None = 0x00000000,
    Guid_GuidStyles__Enum_AllowParenthesis = 0x00000001,
    Guid_GuidStyles__Enum_AllowBraces = 0x00000002,
    Guid_GuidStyles__Enum_AllowDashes = 0x00000004,
    Guid_GuidStyles__Enum_AllowHexPrefix = 0x00000008,
    Guid_GuidStyles__Enum_RequireParenthesis = 0x00000010,
    Guid_GuidStyles__Enum_RequireBraces = 0x00000020,
    Guid_GuidStyles__Enum_RequireDashes = 0x00000040,
    Guid_GuidStyles__Enum_RequireHexPrefix = 0x00000080,
    Guid_GuidStyles__Enum_HexFormat = 0x000000a0,
    Guid_GuidStyles__Enum_NumberFormat = 0x00000000,
    Guid_GuidStyles__Enum_DigitFormat = 0x00000040,
    Guid_GuidStyles__Enum_BraceFormat = 0x00000060,
    Guid_GuidStyles__Enum_ParenthesisFormat = 0x00000050,
    Guid_GuidStyles__Enum_Any = 0x0000000f,
};

#else
enum Guid_GuidStyles__Enum {
    Guid_GuidStyles__Enum_None = 0x00000000,
    Guid_GuidStyles__Enum_AllowParenthesis = 0x00000001,
    Guid_GuidStyles__Enum_AllowBraces = 0x00000002,
    Guid_GuidStyles__Enum_AllowDashes = 0x00000004,
    Guid_GuidStyles__Enum_AllowHexPrefix = 0x00000008,
    Guid_GuidStyles__Enum_RequireParenthesis = 0x00000010,
    Guid_GuidStyles__Enum_RequireBraces = 0x00000020,
    Guid_GuidStyles__Enum_RequireDashes = 0x00000040,
    Guid_GuidStyles__Enum_RequireHexPrefix = 0x00000080,
    Guid_GuidStyles__Enum_HexFormat = 0x000000a0,
    Guid_GuidStyles__Enum_NumberFormat = 0x00000000,
    Guid_GuidStyles__Enum_DigitFormat = 0x00000040,
    Guid_GuidStyles__Enum_BraceFormat = 0x00000060,
    Guid_GuidStyles__Enum_ParenthesisFormat = 0x00000050,
    Guid_GuidStyles__Enum_Any = 0x0000000f,
};

#endif
struct Guid_GuidStyles__Enum__Boxed {
    struct Guid_GuidStyles__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum Guid_GuidStyles__Enum value;
    #else
    uint32_t value;
    #endif
};

#if defined(_CPLUSPLUS_)
enum Guid_GuidParseThrowStyle__Enum : int32_t {
    Guid_GuidParseThrowStyle__Enum_None = 0x00000000,
    Guid_GuidParseThrowStyle__Enum_All = 0x00000001,
    Guid_GuidParseThrowStyle__Enum_AllButOverflow = 0x00000002,
};

#else
enum Guid_GuidParseThrowStyle__Enum {
    Guid_GuidParseThrowStyle__Enum_None = 0x00000000,
    Guid_GuidParseThrowStyle__Enum_All = 0x00000001,
    Guid_GuidParseThrowStyle__Enum_AllButOverflow = 0x00000002,
};

#endif
struct Guid_GuidParseThrowStyle__Enum__Boxed {
    struct Guid_GuidParseThrowStyle__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum Guid_GuidParseThrowStyle__Enum value;
    #else
    uint32_t value;
    #endif
};

#if defined(_CPLUSPLUS_)
enum Guid_ParseFailureKind__Enum : int32_t {
    Guid_ParseFailureKind__Enum_None = 0x00000000,
    Guid_ParseFailureKind__Enum_ArgumentNull = 0x00000001,
    Guid_ParseFailureKind__Enum_Format = 0x00000002,
    Guid_ParseFailureKind__Enum_FormatWithParameter = 0x00000003,
    Guid_ParseFailureKind__Enum_NativeException = 0x00000004,
    Guid_ParseFailureKind__Enum_FormatWithInnerException = 0x00000005,
};

#else
enum Guid_ParseFailureKind__Enum {
    Guid_ParseFailureKind__Enum_None = 0x00000000,
    Guid_ParseFailureKind__Enum_ArgumentNull = 0x00000001,
    Guid_ParseFailureKind__Enum_Format = 0x00000002,
    Guid_ParseFailureKind__Enum_FormatWithParameter = 0x00000003,
    Guid_ParseFailureKind__Enum_NativeException = 0x00000004,
    Guid_ParseFailureKind__Enum_FormatWithInnerException = 0x00000005,
};

#endif
struct Guid_ParseFailureKind__Enum__Boxed {
    struct Guid_ParseFailureKind__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum Guid_ParseFailureKind__Enum value;
    #else
    uint32_t value;
    #endif
};

struct Guid_GuidResult {
    struct Guid parsedGuid;
    #if defined(_CPLUSPLUS_)
    enum Guid_GuidParseThrowStyle__Enum throwStyle;
    #else
    uint32_t throwStyle;
    #endif
    #if defined(_CPLUSPLUS_)
    enum Guid_ParseFailureKind__Enum m_failure;
    #else
    uint32_t m_failure;
    #endif
    struct String *m_failureMessageID;
    struct Object *m_failureMessageFormatArgument;
    struct String *m_failureArgumentName;
    struct Exception *m_innerException;
};

struct Guid_GuidResult__Boxed {
    struct Guid_GuidResult__Class *klass;
    MonitorData *monitor;
    struct Guid_GuidResult fields;
};

struct Guid_GuidStyles__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct Guid_GuidStyles__Enum__StaticFields {
};

struct Guid_GuidStyles__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Guid_GuidStyles__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Guid_GuidStyles__Enum__VTable vtable;
};

struct Guid_GuidParseThrowStyle__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct Guid_GuidParseThrowStyle__Enum__StaticFields {
};

struct Guid_GuidParseThrowStyle__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Guid_GuidParseThrowStyle__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Guid_GuidParseThrowStyle__Enum__VTable vtable;
};

struct Guid_ParseFailureKind__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct Guid_ParseFailureKind__Enum__StaticFields {
};

struct Guid_ParseFailureKind__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Guid_ParseFailureKind__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Guid_ParseFailureKind__Enum__VTable vtable;
};

struct Guid_GuidResult__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Guid_GuidResult__StaticFields {
};

struct Guid_GuidResult__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Guid_GuidResult__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Guid_GuidResult__VTable vtable;
};

struct Guid_GuidResult___VTable {
};

struct Guid_GuidResult___StaticFields {
};

struct Guid_GuidResult___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Guid_GuidResult___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Guid_GuidResult___VTable vtable;
};

struct Int16___VTable {
};

struct Int16___StaticFields {
};

struct Int16___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Int16___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Int16___VTable vtable;
};

struct IndexOutOfRangeException__Fields {
    struct SystemException__Fields _;
};

struct IndexOutOfRangeException {
    struct IndexOutOfRangeException__Class *klass;
    MonitorData *monitor;
    struct IndexOutOfRangeException__Fields fields;
};

struct IndexOutOfRangeException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct IndexOutOfRangeException__StaticFields {
};

struct IndexOutOfRangeException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IndexOutOfRangeException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IndexOutOfRangeException__VTable vtable;
};

struct InsufficientExecutionStackException__Fields {
    struct SystemException__Fields _;
};

struct InsufficientExecutionStackException {
    struct InsufficientExecutionStackException__Class *klass;
    MonitorData *monitor;
    struct InsufficientExecutionStackException__Fields fields;
};

struct InsufficientExecutionStackException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct InsufficientExecutionStackException__StaticFields {
};

struct InsufficientExecutionStackException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct InsufficientExecutionStackException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct InsufficientExecutionStackException__VTable vtable;
};

struct OutOfMemoryException__Fields {
    struct SystemException__Fields _;
};

struct OutOfMemoryException {
    struct OutOfMemoryException__Class *klass;
    MonitorData *monitor;
    struct OutOfMemoryException__Fields fields;
};

struct InsufficientMemoryException__Fields {
    struct OutOfMemoryException__Fields _;
};

struct InsufficientMemoryException {
    struct InsufficientMemoryException__Class *klass;
    MonitorData *monitor;
    struct InsufficientMemoryException__Fields fields;
};

struct OutOfMemoryException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct OutOfMemoryException__StaticFields {
};

struct OutOfMemoryException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct OutOfMemoryException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct OutOfMemoryException__VTable vtable;
};

struct InsufficientMemoryException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct InsufficientMemoryException__StaticFields {
};

struct InsufficientMemoryException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct InsufficientMemoryException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct InsufficientMemoryException__VTable vtable;
};

struct InvalidCastException__Fields {
    struct SystemException__Fields _;
};

struct InvalidCastException {
    struct InvalidCastException__Class *klass;
    MonitorData *monitor;
    struct InvalidCastException__Fields fields;
};

struct InvalidCastException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct InvalidCastException__StaticFields {
};

struct InvalidCastException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct InvalidCastException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct InvalidCastException__VTable vtable;
};

struct InvalidOperationException__Fields {
    struct SystemException__Fields _;
};

struct InvalidOperationException {
    struct InvalidOperationException__Class *klass;
    MonitorData *monitor;
    struct InvalidOperationException__Fields fields;
};

struct InvalidOperationException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct InvalidOperationException__StaticFields {
};

struct InvalidOperationException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct InvalidOperationException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct InvalidOperationException__VTable vtable;
};

struct InvalidProgramException__Fields {
    struct SystemException__Fields _;
};

struct InvalidProgramException {
    struct InvalidProgramException__Class *klass;
    MonitorData *monitor;
    struct InvalidProgramException__Fields fields;
};

struct InvalidProgramException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct InvalidProgramException__StaticFields {
};

struct InvalidProgramException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct InvalidProgramException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct InvalidProgramException__VTable vtable;
};

struct InvalidTimeZoneException__Fields {
    struct Exception__Fields _;
};

struct InvalidTimeZoneException {
    struct InvalidTimeZoneException__Class *klass;
    MonitorData *monitor;
    struct InvalidTimeZoneException__Fields fields;
};

struct InvalidTimeZoneException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct InvalidTimeZoneException__StaticFields {
};

struct InvalidTimeZoneException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct InvalidTimeZoneException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct InvalidTimeZoneException__VTable vtable;
};

struct DoublePtr {
    struct DoublePtr__Class *klass;
    MonitorData *monitor;
};

struct DoublePtr__VTable {
};

struct DoublePtr__StaticFields {
};

struct DoublePtr__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DoublePtr__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DoublePtr__VTable vtable;
};

struct MethodAccessException__Fields {
    struct MemberAccessException__Fields _;
};

struct MethodAccessException {
    struct MethodAccessException__Class *klass;
    MonitorData *monitor;
    struct MethodAccessException__Fields fields;
};

struct MethodAccessException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct MethodAccessException__StaticFields {
};

struct MethodAccessException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MethodAccessException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MethodAccessException__VTable vtable;
};

struct MissingMemberException__Fields {
    struct MemberAccessException__Fields _;
    struct String *ClassName;
    struct String *MemberName;
    struct Byte__Array *Signature;
};

struct MissingMemberException {
    struct MissingMemberException__Class *klass;
    MonitorData *monitor;
    struct MissingMemberException__Fields fields;
};

struct MissingFieldException__Fields {
    struct MissingMemberException__Fields _;
};

struct MissingFieldException {
    struct MissingFieldException__Class *klass;
    MonitorData *monitor;
    struct MissingFieldException__Fields fields;
};

struct MissingMemberException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct MissingMemberException__StaticFields {
};

struct MissingMemberException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MissingMemberException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MissingMemberException__VTable vtable;
};

struct MissingFieldException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct MissingFieldException__StaticFields {
};

struct MissingFieldException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MissingFieldException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MissingFieldException__VTable vtable;
};

struct MissingMethodException__Fields {
    struct MissingMemberException__Fields _;
    struct String *signature;
};

struct MissingMethodException {
    struct MissingMethodException__Class *klass;
    MonitorData *monitor;
    struct MissingMethodException__Fields fields;
};

struct MissingMethodException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct MissingMethodException__StaticFields {
};

struct MissingMethodException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MissingMethodException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MissingMethodException__VTable vtable;
};

struct MulticastNotSupportedException__Fields {
    struct SystemException__Fields _;
};

struct MulticastNotSupportedException {
    struct MulticastNotSupportedException__Class *klass;
    MonitorData *monitor;
    struct MulticastNotSupportedException__Fields fields;
};

struct MulticastNotSupportedException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct MulticastNotSupportedException__StaticFields {
};

struct MulticastNotSupportedException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MulticastNotSupportedException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MulticastNotSupportedException__VTable vtable;
};

struct NonSerializedAttribute {
    struct NonSerializedAttribute__Class *klass;
    MonitorData *monitor;
};

struct NonSerializedAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct NonSerializedAttribute__StaticFields {
};

struct NonSerializedAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct NonSerializedAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct NonSerializedAttribute__VTable vtable;
};

struct NotFiniteNumberException__Fields {
    struct ArithmeticException__Fields _;
    double _offendingNumber;
};

struct NotFiniteNumberException {
    struct NotFiniteNumberException__Class *klass;
    MonitorData *monitor;
    struct NotFiniteNumberException__Fields fields;
};

struct NotFiniteNumberException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct NotFiniteNumberException__StaticFields {
};

struct NotFiniteNumberException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct NotFiniteNumberException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct NotFiniteNumberException__VTable vtable;
};

struct NotImplementedException__Fields {
    struct SystemException__Fields _;
};

struct NotImplementedException {
    struct NotImplementedException__Class *klass;
    MonitorData *monitor;
    struct NotImplementedException__Fields fields;
};

struct NotImplementedException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct NotImplementedException__StaticFields {
};

struct NotImplementedException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct NotImplementedException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct NotImplementedException__VTable vtable;
};

struct NotSupportedException__Fields {
    struct SystemException__Fields _;
};

struct NotSupportedException {
    struct NotSupportedException__Class *klass;
    MonitorData *monitor;
    struct NotSupportedException__Fields fields;
};

struct NotSupportedException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct NotSupportedException__StaticFields {
};

struct NotSupportedException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct NotSupportedException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct NotSupportedException__VTable vtable;
};

struct NullReferenceException__Fields {
    struct SystemException__Fields _;
};

struct NullReferenceException {
    struct NullReferenceException__Class *klass;
    MonitorData *monitor;
    struct NullReferenceException__Fields fields;
};

struct NullReferenceException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct NullReferenceException__StaticFields {
};

struct NullReferenceException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct NullReferenceException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct NullReferenceException__VTable vtable;
};

struct Number {
    struct Number__Class *klass;
    MonitorData *monitor;
};

struct Number__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Number__StaticFields {
};

struct Number__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Number__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Number__VTable vtable;
};

struct Number_NumberBuffer {
    uint8_t *baseAddress;
    uint16_t *digits;
    int32_t precision;
    int32_t scale;
    bool sign;
};

struct Number_NumberBuffer__Boxed {
    struct Number_NumberBuffer__Class *klass;
    MonitorData *monitor;
    struct Number_NumberBuffer fields;
};

struct Number_NumberBuffer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Number_NumberBuffer__StaticFields {
    int32_t NumberBufferBytes;
};

struct Number_NumberBuffer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Number_NumberBuffer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Number_NumberBuffer__VTable vtable;
};

struct Number_NumberBuffer___VTable {
};

struct Number_NumberBuffer___StaticFields {
};

struct Number_NumberBuffer___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Number_NumberBuffer___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Number_NumberBuffer___VTable vtable;
};

struct UInt64__1__VTable {
};

struct UInt64__1__StaticFields {
};

struct UInt64__1__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UInt64__1__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UInt64__1__VTable vtable;
};

struct CharPtr___VTable {
};

struct CharPtr___StaticFields {
};

struct CharPtr___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CharPtr___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CharPtr___VTable vtable;
};

struct Single___VTable {
};

struct Single___StaticFields {
};

struct Single___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Single___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Single___VTable vtable;
};

struct ObjectDisposedException__Fields {
    struct InvalidOperationException__Fields _;
    struct String *objectName;
};

struct ObjectDisposedException {
    struct ObjectDisposedException__Class *klass;
    MonitorData *monitor;
    struct ObjectDisposedException__Fields fields;
};

struct ObjectDisposedException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct ObjectDisposedException__StaticFields {
};

struct ObjectDisposedException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ObjectDisposedException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ObjectDisposedException__VTable vtable;
};

struct __declspec(align(8)) ObsoleteAttribute__Fields {
    struct String *_message;
    bool _error;
};

struct ObsoleteAttribute {
    struct ObsoleteAttribute__Class *klass;
    MonitorData *monitor;
    struct ObsoleteAttribute__Fields fields;
};

struct ObsoleteAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct ObsoleteAttribute__StaticFields {
};

struct ObsoleteAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ObsoleteAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ObsoleteAttribute__VTable vtable;
};

struct OperationCanceledException__Fields {
    struct SystemException__Fields _;
    struct CancellationToken _cancellationToken;
};

struct OperationCanceledException {
    struct OperationCanceledException__Class *klass;
    MonitorData *monitor;
    struct OperationCanceledException__Fields fields;
};

struct OperationCanceledException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct OperationCanceledException__StaticFields {
};

struct OperationCanceledException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct OperationCanceledException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct OperationCanceledException__VTable vtable;
};

struct OverflowException__Fields {
    struct ArithmeticException__Fields _;
};

struct OverflowException {
    struct OverflowException__Class *klass;
    MonitorData *monitor;
    struct OverflowException__Fields fields;
};

struct OverflowException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct OverflowException__StaticFields {
};

struct OverflowException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct OverflowException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct OverflowException__VTable vtable;
};

struct ParamArrayAttribute {
    struct ParamArrayAttribute__Class *klass;
    MonitorData *monitor;
};

struct ParamArrayAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct ParamArrayAttribute__StaticFields {
};

struct ParamArrayAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ParamArrayAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ParamArrayAttribute__VTable vtable;
};

struct ParamsArray {
    struct Object *arg0;
    struct Object *arg1;
    struct Object *arg2;
    struct Object__Array *args;
};

struct ParamsArray__Boxed {
    struct ParamsArray__Class *klass;
    MonitorData *monitor;
    struct ParamsArray fields;
};

struct ParamsArray__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ParamsArray__StaticFields {
    struct Object__Array *oneArgArray;
    struct Object__Array *twoArgArray;
    struct Object__Array *threeArgArray;
};

struct ParamsArray__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ParamsArray__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ParamsArray__VTable vtable;
};

struct PlatformNotSupportedException__Fields {
    struct NotSupportedException__Fields _;
};

struct PlatformNotSupportedException {
    struct PlatformNotSupportedException__Class *klass;
    MonitorData *monitor;
    struct PlatformNotSupportedException__Fields fields;
};

struct PlatformNotSupportedException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct PlatformNotSupportedException__StaticFields {
};

struct PlatformNotSupportedException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PlatformNotSupportedException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PlatformNotSupportedException__VTable vtable;
};

struct __declspec(align(8)) Random__Fields {
    int32_t inext;
    int32_t inextp;
    struct Int32__Array *SeedArray;
};

struct Random {
    struct Random__Class *klass;
    MonitorData *monitor;
    struct Random__Fields fields;
};

struct Random__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Sample;
    VirtualInvokeData Next;
    VirtualInvokeData Next_1;
    VirtualInvokeData Next_2;
    VirtualInvokeData NextDouble;
    VirtualInvokeData NextBytes;
};

struct Random__StaticFields {
};

struct Random__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Random__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Random__VTable vtable;
};

struct RankException__Fields {
    struct SystemException__Fields _;
};

struct RankException {
    struct RankException__Class *klass;
    MonitorData *monitor;
    struct RankException__Fields fields;
};

struct RankException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct RankException__StaticFields {
};

struct RankException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RankException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RankException__VTable vtable;
};

struct CtorDelegate__Fields {
    struct MulticastDelegate__Fields _;
};

struct CtorDelegate {
    struct CtorDelegate__Class *klass;
    MonitorData *monitor;
    struct CtorDelegate__Fields fields;
};

struct CtorDelegate__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct CtorDelegate__StaticFields {
};

struct CtorDelegate__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CtorDelegate__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CtorDelegate__VTable vtable;
};

struct RuntimeType__Array {
    struct RuntimeType__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct RuntimeType *vector[32];
};

struct RuntimeType__Array__VTable {
};

struct RuntimeType__Array__StaticFields {
};

struct RuntimeType__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeType__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeType__Array__VTable vtable;
};

struct String__1__VTable {
};

struct String__1__StaticFields {
};

struct String__1__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct String__1__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct String__1__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum RuntimeType_MemberListType__Enum : int32_t {
    RuntimeType_MemberListType__Enum_All = 0x00000000,
    RuntimeType_MemberListType__Enum_CaseSensitive = 0x00000001,
    RuntimeType_MemberListType__Enum_CaseInsensitive = 0x00000002,
    RuntimeType_MemberListType__Enum_HandleToInfo = 0x00000003,
};

#else
enum RuntimeType_MemberListType__Enum {
    RuntimeType_MemberListType__Enum_All = 0x00000000,
    RuntimeType_MemberListType__Enum_CaseSensitive = 0x00000001,
    RuntimeType_MemberListType__Enum_CaseInsensitive = 0x00000002,
    RuntimeType_MemberListType__Enum_HandleToInfo = 0x00000003,
};

#endif
struct RuntimeType_MemberListType__Enum__Boxed {
    struct RuntimeType_MemberListType__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum RuntimeType_MemberListType__Enum value;
    #else
    uint32_t value;
    #endif
};

struct RuntimeType_MemberListType__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct RuntimeType_MemberListType__Enum__StaticFields {
};

struct RuntimeType_MemberListType__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeType_MemberListType__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeType_MemberListType__Enum__VTable vtable;
};

struct RuntimeType_MemberListType___VTable {
};

struct RuntimeType_MemberListType___StaticFields {
};

struct RuntimeType_MemberListType___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeType_MemberListType___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeType_MemberListType___VTable vtable;
};

struct RuntimeType_ListBuilder_1_System_Reflection_MethodInfo_ {
    struct MethodInfo_1__Array *_items;
    struct MethodInfo_1 *_item;
    int32_t _count;
    int32_t _capacity;
};

struct RuntimeType_ListBuilder_1_System_Reflection_MethodInfo___Boxed {
    struct RuntimeType_ListBuilder_1_System_Reflection_MethodInfo___Class *klass;
    MonitorData *monitor;
    struct RuntimeType_ListBuilder_1_System_Reflection_MethodInfo_ fields;
};

struct RuntimeType_ListBuilder_1_System_Reflection_MethodInfo___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct RuntimeType_ListBuilder_1_System_Reflection_MethodInfo___StaticFields {
};

struct RuntimeType_ListBuilder_1_System_Reflection_MethodInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeType_ListBuilder_1_System_Reflection_MethodInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeType_ListBuilder_1_System_Reflection_MethodInfo___VTable vtable;
};

struct RuntimeType_ListBuilder_1_System_Reflection_ConstructorInfo_ {
    struct ConstructorInfo__Array *_items;
    struct ConstructorInfo *_item;
    int32_t _count;
    int32_t _capacity;
};

struct RuntimeType_ListBuilder_1_System_Reflection_ConstructorInfo___Boxed {
    struct RuntimeType_ListBuilder_1_System_Reflection_ConstructorInfo___Class *klass;
    MonitorData *monitor;
    struct RuntimeType_ListBuilder_1_System_Reflection_ConstructorInfo_ fields;
};

struct RuntimeType_ListBuilder_1_System_Reflection_ConstructorInfo___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct RuntimeType_ListBuilder_1_System_Reflection_ConstructorInfo___StaticFields {
};

struct RuntimeType_ListBuilder_1_System_Reflection_ConstructorInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeType_ListBuilder_1_System_Reflection_ConstructorInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeType_ListBuilder_1_System_Reflection_ConstructorInfo___VTable vtable;
};

struct RuntimeType_ListBuilder_1_System_Reflection_PropertyInfo_ {
    struct PropertyInfo_1__Array *_items;
    struct PropertyInfo_1 *_item;
    int32_t _count;
    int32_t _capacity;
};

struct RuntimeType_ListBuilder_1_System_Reflection_PropertyInfo___Boxed {
    struct RuntimeType_ListBuilder_1_System_Reflection_PropertyInfo___Class *klass;
    MonitorData *monitor;
    struct RuntimeType_ListBuilder_1_System_Reflection_PropertyInfo_ fields;
};

struct RuntimeType_ListBuilder_1_System_Reflection_PropertyInfo___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct RuntimeType_ListBuilder_1_System_Reflection_PropertyInfo___StaticFields {
};

struct RuntimeType_ListBuilder_1_System_Reflection_PropertyInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeType_ListBuilder_1_System_Reflection_PropertyInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeType_ListBuilder_1_System_Reflection_PropertyInfo___VTable vtable;
};

struct RuntimeType_ListBuilder_1_System_Reflection_EventInfo_ {
    struct EventInfo_1__Array *_items;
    struct EventInfo_1 *_item;
    int32_t _count;
    int32_t _capacity;
};

struct RuntimeType_ListBuilder_1_System_Reflection_EventInfo___Boxed {
    struct RuntimeType_ListBuilder_1_System_Reflection_EventInfo___Class *klass;
    MonitorData *monitor;
    struct RuntimeType_ListBuilder_1_System_Reflection_EventInfo_ fields;
};

struct RuntimeType_ListBuilder_1_System_Reflection_EventInfo___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct RuntimeType_ListBuilder_1_System_Reflection_EventInfo___StaticFields {
};

struct RuntimeType_ListBuilder_1_System_Reflection_EventInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeType_ListBuilder_1_System_Reflection_EventInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeType_ListBuilder_1_System_Reflection_EventInfo___VTable vtable;
};

struct RuntimeType_ListBuilder_1_System_Reflection_FieldInfo_ {
    struct FieldInfo_1__Array *_items;
    struct FieldInfo_1 *_item;
    int32_t _count;
    int32_t _capacity;
};

struct RuntimeType_ListBuilder_1_System_Reflection_FieldInfo___Boxed {
    struct RuntimeType_ListBuilder_1_System_Reflection_FieldInfo___Class *klass;
    MonitorData *monitor;
    struct RuntimeType_ListBuilder_1_System_Reflection_FieldInfo_ fields;
};

struct RuntimeType_ListBuilder_1_System_Reflection_FieldInfo___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct RuntimeType_ListBuilder_1_System_Reflection_FieldInfo___StaticFields {
};

struct RuntimeType_ListBuilder_1_System_Reflection_FieldInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeType_ListBuilder_1_System_Reflection_FieldInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeType_ListBuilder_1_System_Reflection_FieldInfo___VTable vtable;
};

struct RuntimeType_ListBuilder_1_Type_ {
    struct Type__Array *_items;
    struct Type *_item;
    int32_t _count;
    int32_t _capacity;
};

struct RuntimeType_ListBuilder_1_Type___Boxed {
    struct RuntimeType_ListBuilder_1_Type___Class *klass;
    MonitorData *monitor;
    struct RuntimeType_ListBuilder_1_Type_ fields;
};

struct RuntimeType_ListBuilder_1_Type___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct RuntimeType_ListBuilder_1_Type___StaticFields {
};

struct RuntimeType_ListBuilder_1_Type___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeType_ListBuilder_1_Type___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeType_ListBuilder_1_Type___VTable vtable;
};

struct RuntimeModule__Fields {
    struct Module__Fields _;
};

struct RuntimeModule {
    struct RuntimeModule__Class *klass;
    MonitorData *monitor;
    struct RuntimeModule__Fields fields;
};

struct RuntimeModule__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData System_Runtime_InteropServices__Module_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Module_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Module_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Module_Invoke;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData GetType_1;
    VirtualInvokeData GetModuleVersionId;
    VirtualInvokeData get_Assembly;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ScopeName;
    VirtualInvokeData get_MDStreamVersion;
    VirtualInvokeData get_ModuleVersionId;
    VirtualInvokeData get_FullyQualifiedName;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData IsResource;
    VirtualInvokeData FindTypes;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData GetField;
    VirtualInvokeData GetFields;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetMethods;
    VirtualInvokeData GetPEKind;
    VirtualInvokeData GetType_2;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ResolveField;
    VirtualInvokeData ResolveMember;
    VirtualInvokeData ResolveMethod;
    VirtualInvokeData ResolveSignature;
    VirtualInvokeData ResolveString;
    VirtualInvokeData ResolveType;
    VirtualInvokeData GetSignerCertificate;
    VirtualInvokeData GetTypes;
    VirtualInvokeData get_CustomAttributes;
};

struct RuntimeModule__StaticFields {
};

struct RuntimeModule__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeModule__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeModule__VTable vtable;
};

struct RuntimeAssembly__Fields {
    struct Assembly__Fields _;
};

struct RuntimeAssembly {
    struct RuntimeAssembly__Class *klass;
    MonitorData *monitor;
    struct RuntimeAssembly__Fields fields;
};

struct RuntimeAssembly__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData ToString_1;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__Assembly_GetType;
    VirtualInvokeData get_CodeBase;
    VirtualInvokeData get_EscapedCodeBase;
    VirtualInvokeData GetName;
    VirtualInvokeData GetName_1;
    VirtualInvokeData get_FullName;
    VirtualInvokeData get_EntryPoint;
    VirtualInvokeData GetType;
    VirtualInvokeData GetType_1;
    VirtualInvokeData GetExportedTypes;
    VirtualInvokeData GetTypes;
    VirtualInvokeData GetManifestResourceStream;
    VirtualInvokeData GetManifestResourceStream_1;
    VirtualInvokeData GetFile;
    VirtualInvokeData GetFiles;
    VirtualInvokeData GetFiles_1;
    VirtualInvokeData GetManifestResourceNames;
    VirtualInvokeData GetManifestResourceInfo;
    VirtualInvokeData get_Location;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType_2;
    VirtualInvokeData GetSatelliteAssembly;
    VirtualInvokeData GetSatelliteAssembly_1;
    VirtualInvokeData LoadModule;
    VirtualInvokeData LoadModule_1;
    VirtualInvokeData CreateInstance;
    VirtualInvokeData CreateInstance_1;
    VirtualInvokeData CreateInstance_2;
    VirtualInvokeData GetLoadedModules;
    VirtualInvokeData GetLoadedModules_1;
    VirtualInvokeData GetModules;
    VirtualInvokeData GetModules_1;
    VirtualInvokeData GetModule;
    VirtualInvokeData GetReferencedAssemblies;
    VirtualInvokeData add_ModuleResolve;
    VirtualInvokeData remove_ModuleResolve;
    VirtualInvokeData get_Evidence;
    VirtualInvokeData get_GlobalAssemblyCache;
    VirtualInvokeData get_Evidence_1;
    VirtualInvokeData add_ModuleResolve_1;
    VirtualInvokeData remove_ModuleResolve_1;
    VirtualInvokeData get_CodeBase_1;
    VirtualInvokeData get_EscapedCodeBase_1;
    VirtualInvokeData get_FullName_1;
    VirtualInvokeData get_EntryPoint_1;
    VirtualInvokeData get_Evidence_2;
    VirtualInvokeData get_Location_1;
    VirtualInvokeData get_ImageRuntimeVersion;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData GetFiles_2;
    VirtualInvokeData GetFiles_3;
    VirtualInvokeData GetFile_1;
    VirtualInvokeData GetManifestResourceStream_2;
    VirtualInvokeData GetManifestResourceStream_3;
    VirtualInvokeData GetTypes_1;
    VirtualInvokeData GetTypes_2;
    VirtualInvokeData GetExportedTypes_1;
    VirtualInvokeData GetType_3;
    VirtualInvokeData GetType_4;
    VirtualInvokeData GetName_2;
    VirtualInvokeData GetName_3;
    VirtualInvokeData LoadModule_2;
    VirtualInvokeData CreateInstance_3;
    VirtualInvokeData GetModulesInternal;
    VirtualInvokeData GetManifestResourceNames_1;
    VirtualInvokeData GetManifestResourceInfo_1;
    VirtualInvokeData get_HostContext;
    VirtualInvokeData GetManifestModule;
    VirtualInvokeData get_ReflectionOnly;
    VirtualInvokeData get_SecurityRuleSet;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData GetType_5;
    VirtualInvokeData GetModule_1;
    VirtualInvokeData GetReferencedAssemblies_1;
    VirtualInvokeData GetModules_2;
    VirtualInvokeData GetLoadedModules_2;
    VirtualInvokeData GetSatelliteAssembly_2;
    VirtualInvokeData GetSatelliteAssembly_3;
    VirtualInvokeData get_ManifestModule;
    VirtualInvokeData get_GlobalAssemblyCache_1;
    VirtualInvokeData get_IsDynamic;
    VirtualInvokeData get_DefinedTypes;
    VirtualInvokeData get_ExportedTypes;
    VirtualInvokeData get_Modules;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData get_PermissionSet;
};

struct RuntimeAssembly__StaticFields {
};

struct RuntimeAssembly__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeAssembly__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeAssembly__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum TypeNameKind__Enum : int32_t {
    TypeNameKind__Enum_Name = 0x00000000,
    TypeNameKind__Enum_ToString = 0x00000001,
    TypeNameKind__Enum_SerializationName = 0x00000002,
    TypeNameKind__Enum_FullName = 0x00000003,
};

#else
enum TypeNameKind__Enum {
    TypeNameKind__Enum_Name = 0x00000000,
    TypeNameKind__Enum_ToString = 0x00000001,
    TypeNameKind__Enum_SerializationName = 0x00000002,
    TypeNameKind__Enum_FullName = 0x00000003,
};

#endif
struct TypeNameKind__Enum__Boxed {
    struct TypeNameKind__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum TypeNameKind__Enum value;
    #else
    uint32_t value;
    #endif
};

struct TypeNameKind__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct TypeNameKind__Enum__StaticFields {
};

struct TypeNameKind__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeNameKind__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeNameKind__Enum__VTable vtable;
};

struct RuntimeMethodInfo__Array {
    struct RuntimeMethodInfo__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct RuntimeMethodInfo *vector[32];
};

struct RuntimeMethodInfo__Array__VTable {
};

struct RuntimeMethodInfo__Array__StaticFields {
};

struct RuntimeMethodInfo__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeMethodInfo__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeMethodInfo__Array__VTable vtable;
};

struct RuntimeConstructorInfo__Array {
    struct RuntimeConstructorInfo__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct RuntimeConstructorInfo *vector[32];
};

struct RuntimeConstructorInfo__Array__VTable {
};

struct RuntimeConstructorInfo__Array__StaticFields {
};

struct RuntimeConstructorInfo__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeConstructorInfo__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeConstructorInfo__Array__VTable vtable;
};

struct RuntimePropertyInfo__Array {
    struct RuntimePropertyInfo__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct RuntimePropertyInfo *vector[32];
};

struct RuntimePropertyInfo__Array__VTable {
};

struct RuntimePropertyInfo__Array__StaticFields {
};

struct RuntimePropertyInfo__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimePropertyInfo__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimePropertyInfo__Array__VTable vtable;
};

struct MethodInfo___VTable {
};

struct MethodInfo___StaticFields {
};

struct MethodInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MethodInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MethodInfo___VTable vtable;
};

struct RuntimeFieldInfo__Array {
    struct RuntimeFieldInfo__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct RuntimeFieldInfo *vector[32];
};

struct RuntimeFieldInfo__Array__VTable {
};

struct RuntimeFieldInfo__Array__StaticFields {
};

struct RuntimeFieldInfo__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeFieldInfo__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeFieldInfo__Array__VTable vtable;
};

struct RuntimeEventInfo__Array {
    struct RuntimeEventInfo__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct RuntimeEventInfo *vector[32];
};

struct RuntimeEventInfo__Array__VTable {
};

struct RuntimeEventInfo__Array__StaticFields {
};

struct RuntimeEventInfo__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeEventInfo__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeEventInfo__Array__VTable vtable;
};

struct ReflectionOnlyType__Fields {
    struct RuntimeType__Fields _;
};

struct ReflectionOnlyType {
    struct ReflectionOnlyType__Class *klass;
    MonitorData *monitor;
    struct ReflectionOnlyType__Fields fields;
};

struct ReflectionOnlyType__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData Equals_2;
    VirtualInvokeData Equals_3;
    VirtualInvokeData FindInterfaces;
    VirtualInvokeData FindMembers;
    VirtualInvokeData GetArrayRank;
    VirtualInvokeData GetConstructor;
    VirtualInvokeData GetConstructor_1;
    VirtualInvokeData GetConstructor_2;
    VirtualInvokeData GetConstructors;
    VirtualInvokeData GetConstructors_1;
    VirtualInvokeData GetCustomAttributes_6;
    VirtualInvokeData GetCustomAttributes_7;
    VirtualInvokeData GetDefaultMembers;
    VirtualInvokeData GetElementType;
    VirtualInvokeData GetEvent;
    VirtualInvokeData GetEvent_1;
    VirtualInvokeData GetEvents;
    VirtualInvokeData GetEvents_1;
    VirtualInvokeData GetField;
    VirtualInvokeData GetField_1;
    VirtualInvokeData GetFields;
    VirtualInvokeData GetFields_1;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Type_Invoke;
    VirtualInvokeData GetInterface;
    VirtualInvokeData GetInterface_1;
    VirtualInvokeData GetInterfaceMap;
    VirtualInvokeData GetInterfaces;
    VirtualInvokeData GetMember;
    VirtualInvokeData GetMember_1;
    VirtualInvokeData GetMember_2;
    VirtualInvokeData GetMembers;
    VirtualInvokeData GetMembers_1;
    VirtualInvokeData GetMethod;
    VirtualInvokeData GetMethod_1;
    VirtualInvokeData GetMethod_2;
    VirtualInvokeData GetMethod_3;
    VirtualInvokeData GetMethod_4;
    VirtualInvokeData GetMethod_5;
    VirtualInvokeData GetMethods;
    VirtualInvokeData GetMethods_1;
    VirtualInvokeData GetNestedType;
    VirtualInvokeData GetNestedType_1;
    VirtualInvokeData GetNestedTypes;
    VirtualInvokeData GetNestedTypes_1;
    VirtualInvokeData GetProperties;
    VirtualInvokeData GetProperties_1;
    VirtualInvokeData GetProperty;
    VirtualInvokeData GetProperty_1;
    VirtualInvokeData GetProperty_2;
    VirtualInvokeData GetProperty_3;
    VirtualInvokeData GetProperty_4;
    VirtualInvokeData GetProperty_5;
    VirtualInvokeData GetProperty_6;
    VirtualInvokeData GetType;
    VirtualInvokeData InvokeMember;
    VirtualInvokeData InvokeMember_1;
    VirtualInvokeData InvokeMember_2;
    VirtualInvokeData IsAssignableFrom;
    VirtualInvokeData IsDefined_3;
    VirtualInvokeData IsInstanceOfType;
    VirtualInvokeData IsSubclassOf;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Assembly;
    VirtualInvokeData get_AssemblyQualifiedName;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_BaseType;
    VirtualInvokeData get_DeclaringType_2;
    VirtualInvokeData get_FullName;
    VirtualInvokeData get_GUID;
    VirtualInvokeData get_HasElementType;
    VirtualInvokeData get_IsAbstract;
    VirtualInvokeData get_IsAnsiClass;
    VirtualInvokeData get_IsArray;
    VirtualInvokeData get_IsAutoClass;
    VirtualInvokeData get_IsAutoLayout;
    VirtualInvokeData get_IsByRef;
    VirtualInvokeData get_IsClass;
    VirtualInvokeData get_IsCOMObject;
    VirtualInvokeData get_IsContextful;
    VirtualInvokeData get_IsEnum;
    VirtualInvokeData get_IsExplicitLayout;
    VirtualInvokeData get_IsImport;
    VirtualInvokeData get_IsInterface;
    VirtualInvokeData get_IsLayoutSequential;
    VirtualInvokeData get_IsMarshalByRef;
    VirtualInvokeData get_IsNestedAssembly;
    VirtualInvokeData get_IsNestedFamANDAssem;
    VirtualInvokeData get_IsNestedFamily;
    VirtualInvokeData get_IsNestedFamORAssem;
    VirtualInvokeData get_IsNestedPrivate;
    VirtualInvokeData get_IsNestedPublic;
    VirtualInvokeData get_IsNotPublic;
    VirtualInvokeData get_IsPointer;
    VirtualInvokeData get_IsPrimitive;
    VirtualInvokeData get_IsPublic;
    VirtualInvokeData get_IsSealed;
    VirtualInvokeData get_IsSerializable;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_IsUnicodeClass;
    VirtualInvokeData get_IsValueType;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_Module_1;
    VirtualInvokeData get_Name_2;
    VirtualInvokeData get_Namespace;
    VirtualInvokeData get_ReflectedType_2;
    VirtualInvokeData get_TypeHandle;
    VirtualInvokeData get_TypeInitializer;
    VirtualInvokeData get_UnderlyingSystemType;
    VirtualInvokeData GetMethod_6;
    VirtualInvokeData GetMethod_7;
    VirtualInvokeData GetMethods_2;
    VirtualInvokeData GetField_2;
    VirtualInvokeData GetFields_2;
    VirtualInvokeData GetProperty_7;
    VirtualInvokeData GetProperty_8;
    VirtualInvokeData GetProperties_2;
    VirtualInvokeData GetMember_3;
    VirtualInvokeData GetMembers_2;
    VirtualInvokeData InvokeMember_3;
    VirtualInvokeData get_UnderlyingSystemType_1;
    VirtualInvokeData get_DeclaringMethod;
    VirtualInvokeData MakePointerType;
    VirtualInvokeData get_StructLayoutAttribute;
    VirtualInvokeData MakeByRefType;
    VirtualInvokeData MakeArrayType;
    VirtualInvokeData MakeArrayType_1;
    VirtualInvokeData GetTypeCodeImpl;
    VirtualInvokeData get_GUID_1;
    VirtualInvokeData InvokeMember_4;
    VirtualInvokeData get_Assembly_1;
    VirtualInvokeData get_TypeHandle_1;
    VirtualInvokeData GetTypeHandleInternal;
    VirtualInvokeData get_FullName_1;
    VirtualInvokeData get_Namespace_1;
    VirtualInvokeData get_AssemblyQualifiedName_1;
    VirtualInvokeData GetArrayRank_1;
    VirtualInvokeData get_BaseType_1;
    VirtualInvokeData GetConstructorImpl;
    VirtualInvokeData GetConstructors_2;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetMethods_3;
    VirtualInvokeData GetField_3;
    VirtualInvokeData GetFields_3;
    VirtualInvokeData GetInterface_2;
    VirtualInvokeData GetInterfaces_1;
    VirtualInvokeData FindInterfaces_1;
    VirtualInvokeData GetEvent_2;
    VirtualInvokeData GetEvents_2;
    VirtualInvokeData GetEvents_3;
    VirtualInvokeData GetPropertyImpl;
    VirtualInvokeData GetProperties_3;
    VirtualInvokeData GetNestedTypes_2;
    VirtualInvokeData GetNestedType_2;
    VirtualInvokeData GetMember_4;
    VirtualInvokeData GetMember_5;
    VirtualInvokeData GetMembers_3;
    VirtualInvokeData GetDefaultMembers_1;
    VirtualInvokeData FindMembers_1;
    VirtualInvokeData get_GenericParameterAttributes;
    VirtualInvokeData get_IsEnum_1;
    VirtualInvokeData get_IsSerializable_1;
    VirtualInvokeData get_IsSzArray;
    VirtualInvokeData get_IsGenericType;
    VirtualInvokeData get_IsGenericTypeDefinition;
    VirtualInvokeData get_IsConstructedGenericType;
    VirtualInvokeData get_IsGenericParameter;
    VirtualInvokeData get_GenericParameterPosition;
    VirtualInvokeData get_ContainsGenericParameters;
    VirtualInvokeData GetGenericParameterConstraints;
    VirtualInvokeData IsValueTypeImpl;
    VirtualInvokeData GetAttributeFlagsImpl;
    VirtualInvokeData IsArrayImpl;
    VirtualInvokeData IsByRefImpl;
    VirtualInvokeData IsPointerImpl;
    VirtualInvokeData IsPrimitiveImpl;
    VirtualInvokeData IsCOMObjectImpl;
    VirtualInvokeData IsWindowsRuntimeObjectImpl;
    VirtualInvokeData IsExportedToWindowsRuntimeImpl;
    VirtualInvokeData MakeGenericType;
    VirtualInvokeData IsContextfulImpl;
    VirtualInvokeData IsMarshalByRefImpl;
    VirtualInvokeData HasProxyAttributeImpl;
    VirtualInvokeData GetElementType_1;
    VirtualInvokeData GetGenericArguments;
    VirtualInvokeData get_GenericTypeArguments;
    VirtualInvokeData GetGenericTypeDefinition;
    VirtualInvokeData HasElementTypeImpl;
    VirtualInvokeData GetEnumNames;
    VirtualInvokeData GetEnumValues;
    VirtualInvokeData GetEnumUnderlyingType;
    VirtualInvokeData IsEnumDefined;
    VirtualInvokeData GetEnumName;
    VirtualInvokeData get_IsSecurityCritical;
    VirtualInvokeData get_IsSecuritySafeCritical;
    VirtualInvokeData get_IsSecurityTransparent;
    VirtualInvokeData get_UnderlyingSystemType_2;
    VirtualInvokeData IsSubclassOf_1;
    VirtualInvokeData IsInstanceOfType_1;
    VirtualInvokeData IsAssignableFrom_1;
    VirtualInvokeData IsEquivalentTo;
    VirtualInvokeData FormatTypeName;
    VirtualInvokeData Equals_4;
    VirtualInvokeData GetInterfaceMap_1;
    VirtualInvokeData get_IsSZArray;
    VirtualInvokeData InternalResolve;
    VirtualInvokeData RuntimeResolve;
    VirtualInvokeData get_IsUserType;
    VirtualInvokeData GetMethod_8;
    VirtualInvokeData GetConstructor_3;
    VirtualInvokeData GetField_4;
    VirtualInvokeData System_Reflection_IReflectableType_GetTypeInfo;
    VirtualInvokeData AsType;
    VirtualInvokeData get_GenericTypeParameters;
    VirtualInvokeData IsAssignableFrom_2;
    VirtualInvokeData GetDeclaredEvent;
    VirtualInvokeData GetDeclaredField;
    VirtualInvokeData GetDeclaredMethod;
    VirtualInvokeData GetDeclaredMethods;
    VirtualInvokeData GetDeclaredNestedType;
    VirtualInvokeData GetDeclaredProperty;
    VirtualInvokeData get_DeclaredConstructors;
    VirtualInvokeData get_DeclaredEvents;
    VirtualInvokeData get_DeclaredFields;
    VirtualInvokeData get_DeclaredMembers;
    VirtualInvokeData get_DeclaredMethods;
    VirtualInvokeData get_DeclaredNestedTypes;
    VirtualInvokeData get_DeclaredProperties;
    VirtualInvokeData get_ImplementedInterfaces;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData Clone;
};

struct ReflectionOnlyType__StaticFields {
};

struct ReflectionOnlyType__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ReflectionOnlyType__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ReflectionOnlyType__VTable vtable;
};

struct SByte___VTable {
};

struct SByte___StaticFields {
};

struct SByte___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SByte___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SByte___VTable vtable;
};

struct SerializableAttribute {
    struct SerializableAttribute__Class *klass;
    MonitorData *monitor;
};

struct SerializableAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct SerializableAttribute__StaticFields {
};

struct SerializableAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SerializableAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SerializableAttribute__VTable vtable;
};

struct __declspec(align(8)) SharedStatics__Fields {
    struct String *_Remoting_Identity_IDGuid;
    struct Tokenizer_StringMaker *_maker;
    int32_t _Remoting_Identity_IDSeqNum;
    int64_t _memFailPointReservedMemory;
};

struct SharedStatics {
    struct SharedStatics__Class *klass;
    MonitorData *monitor;
    struct SharedStatics__Fields fields;
};

struct __declspec(align(8)) Tokenizer_StringMaker__Fields {
    struct String__Array *aStrings;
    uint32_t cStringsMax;
    uint32_t cStringsUsed;
    struct StringBuilder *_outStringBuilder;
    struct Char__Array *_outChars;
    int32_t _outIndex;
};

struct Tokenizer_StringMaker {
    struct Tokenizer_StringMaker__Class *klass;
    MonitorData *monitor;
    struct Tokenizer_StringMaker__Fields fields;
};

struct Tokenizer_StringMaker__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Tokenizer_StringMaker__StaticFields {
};

struct Tokenizer_StringMaker__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Tokenizer_StringMaker__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Tokenizer_StringMaker__VTable vtable;
};

struct SharedStatics__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct SharedStatics__StaticFields {
    struct SharedStatics *_sharedStatics;
};

struct SharedStatics__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SharedStatics__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SharedStatics__VTable vtable;
};

struct Tokenizer_StringMaker___VTable {
};

struct Tokenizer_StringMaker___StaticFields {
};

struct Tokenizer_StringMaker___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Tokenizer_StringMaker___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Tokenizer_StringMaker___VTable vtable;
};

struct StackOverflowException__Fields {
    struct SystemException__Fields _;
};

struct StackOverflowException {
    struct StackOverflowException__Class *klass;
    MonitorData *monitor;
    struct StackOverflowException__Fields fields;
};

struct StackOverflowException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct StackOverflowException__StaticFields {
};

struct StackOverflowException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StackOverflowException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StackOverflowException__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum StringComparison__Enum : int32_t {
    StringComparison__Enum_CurrentCulture = 0x00000000,
    StringComparison__Enum_CurrentCultureIgnoreCase = 0x00000001,
    StringComparison__Enum_InvariantCulture = 0x00000002,
    StringComparison__Enum_InvariantCultureIgnoreCase = 0x00000003,
    StringComparison__Enum_Ordinal = 0x00000004,
    StringComparison__Enum_OrdinalIgnoreCase = 0x00000005,
};

#else
enum StringComparison__Enum {
    StringComparison__Enum_CurrentCulture = 0x00000000,
    StringComparison__Enum_CurrentCultureIgnoreCase = 0x00000001,
    StringComparison__Enum_InvariantCulture = 0x00000002,
    StringComparison__Enum_InvariantCultureIgnoreCase = 0x00000003,
    StringComparison__Enum_Ordinal = 0x00000004,
    StringComparison__Enum_OrdinalIgnoreCase = 0x00000005,
};

#endif
struct StringComparison__Enum__Boxed {
    struct StringComparison__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum StringComparison__Enum value;
    #else
    uint32_t value;
    #endif
};

struct StringComparison__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct StringComparison__Enum__StaticFields {
};

struct StringComparison__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StringComparison__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StringComparison__Enum__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum StringSplitOptions__Enum : int32_t {
    StringSplitOptions__Enum_None = 0x00000000,
    StringSplitOptions__Enum_RemoveEmptyEntries = 0x00000001,
};

#else
enum StringSplitOptions__Enum {
    StringSplitOptions__Enum_None = 0x00000000,
    StringSplitOptions__Enum_RemoveEmptyEntries = 0x00000001,
};

#endif
struct StringSplitOptions__Enum__Boxed {
    struct StringSplitOptions__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum StringSplitOptions__Enum value;
    #else
    uint32_t value;
    #endif
};

struct StringSplitOptions__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct StringSplitOptions__Enum__StaticFields {
};

struct StringSplitOptions__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StringSplitOptions__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StringSplitOptions__Enum__VTable vtable;
};

struct Int32__1__VTable {
};

struct Int32__1__StaticFields {
};

struct Int32__1__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Int32__1__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Int32__1__VTable vtable;
};

struct SBytePtr {
    struct SBytePtr__Class *klass;
    MonitorData *monitor;
};

struct SBytePtr__VTable {
};

struct SBytePtr__StaticFields {
};

struct SBytePtr__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SBytePtr__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SBytePtr__VTable vtable;
};

struct __declspec(align(8)) Encoding__Fields {
    int32_t m_codePage;
    struct CodePageDataItem *dataItem;
    bool m_deserializedFromEverett;
    bool m_isReadOnly;
    struct EncoderFallback *encoderFallback;
    struct DecoderFallback *decoderFallback;
};

struct Encoding {
    struct Encoding__Class *klass;
    MonitorData *monitor;
    struct Encoding__Fields fields;
};

struct __declspec(align(8)) CodePageDataItem__Fields {
    int32_t m_dataIndex;
    int32_t m_uiFamilyCodePage;
    struct String *m_webName;
    struct String *m_headerName;
    struct String *m_bodyName;
    uint32_t m_flags;
};

struct CodePageDataItem {
    struct CodePageDataItem__Class *klass;
    MonitorData *monitor;
    struct CodePageDataItem__Fields fields;
};

struct __declspec(align(8)) EncoderFallback__Fields {
    bool bIsMicrosoftBestFitFallback;
};

struct EncoderFallback {
    struct EncoderFallback__Class *klass;
    MonitorData *monitor;
    struct EncoderFallback__Fields fields;
};

struct InternalEncoderBestFitFallback__Fields {
    struct EncoderFallback__Fields _;
    struct Encoding *encoding;
    struct Char__Array *arrayBestFit;
};

struct InternalEncoderBestFitFallback {
    struct InternalEncoderBestFitFallback__Class *klass;
    MonitorData *monitor;
    struct InternalEncoderBestFitFallback__Fields fields;
};

struct __declspec(align(8)) EncoderFallbackBuffer__Fields {
    uint16_t *charStart;
    uint16_t *charEnd;
    struct EncoderNLS *encoder;
    bool setEncoder;
    bool bUsedEncoder;
    bool bFallingBack;
    int32_t iRecursionCount;
};

struct EncoderFallbackBuffer {
    struct EncoderFallbackBuffer__Class *klass;
    MonitorData *monitor;
    struct EncoderFallbackBuffer__Fields fields;
};

struct __declspec(align(8)) Encoder__Fields {
    struct EncoderFallback *m_fallback;
    struct EncoderFallbackBuffer *m_fallbackBuffer;
};

struct Encoder {
    struct Encoder__Class *klass;
    MonitorData *monitor;
    struct Encoder__Fields fields;
};

struct EncoderNLS__Fields {
    struct Encoder__Fields _;
    uint16_t charLeftOver;
    struct Encoding *m_encoding;
    bool m_mustFlush;
    bool m_throwOnOverflow;
    int32_t m_charsUsed;
};

struct EncoderNLS {
    struct EncoderNLS__Class *klass;
    MonitorData *monitor;
    struct EncoderNLS__Fields fields;
};

struct InternalEncoderBestFitFallbackBuffer__Fields {
    struct EncoderFallbackBuffer__Fields _;
    uint16_t cBestFit;
    struct InternalEncoderBestFitFallback *oFallback;
    int32_t iCount;
    int32_t iSize;
};

struct InternalEncoderBestFitFallbackBuffer {
    struct InternalEncoderBestFitFallbackBuffer__Class *klass;
    MonitorData *monitor;
    struct InternalEncoderBestFitFallbackBuffer__Fields fields;
};

struct __declspec(align(8)) DecoderFallback__Fields {
    bool bIsMicrosoftBestFitFallback;
};

struct DecoderFallback {
    struct DecoderFallback__Class *klass;
    MonitorData *monitor;
    struct DecoderFallback__Fields fields;
};

struct InternalDecoderBestFitFallback__Fields {
    struct DecoderFallback__Fields _;
    struct Encoding *encoding;
    struct Char__Array *arrayBestFit;
    uint16_t cReplacement;
};

struct InternalDecoderBestFitFallback {
    struct InternalDecoderBestFitFallback__Class *klass;
    MonitorData *monitor;
    struct InternalDecoderBestFitFallback__Fields fields;
};

struct __declspec(align(8)) DecoderFallbackBuffer__Fields {
    uint8_t *byteStart;
    uint16_t *charEnd;
};

struct DecoderFallbackBuffer {
    struct DecoderFallbackBuffer__Class *klass;
    MonitorData *monitor;
    struct DecoderFallbackBuffer__Fields fields;
};

struct InternalDecoderBestFitFallbackBuffer__Fields {
    struct DecoderFallbackBuffer__Fields _;
    uint16_t cBestFit;
    int32_t iCount;
    int32_t iSize;
    struct InternalDecoderBestFitFallback *oFallback;
};

struct InternalDecoderBestFitFallbackBuffer {
    struct InternalDecoderBestFitFallbackBuffer__Class *klass;
    MonitorData *monitor;
    struct InternalDecoderBestFitFallbackBuffer__Fields fields;
};

struct ASCIIEncoding__Fields {
    struct Encoding__Fields _;
};

struct ASCIIEncoding {
    struct ASCIIEncoding__Class *klass;
    MonitorData *monitor;
    struct ASCIIEncoding__Fields fields;
};

struct __declspec(align(8)) Decoder__Fields {
    struct DecoderFallback *m_fallback;
    struct DecoderFallbackBuffer *m_fallbackBuffer;
};

struct Decoder {
    struct Decoder__Class *klass;
    MonitorData *monitor;
    struct Decoder__Fields fields;
};

struct DecoderNLS__Fields {
    struct Decoder__Fields _;
    struct Encoding *m_encoding;
    bool m_mustFlush;
    bool m_throwOnOverflow;
    int32_t m_bytesUsed;
};

struct DecoderNLS {
    struct DecoderNLS__Class *klass;
    MonitorData *monitor;
    struct DecoderNLS__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum NormalizationForm__Enum : int32_t {
    NormalizationForm__Enum_FormC = 0x00000001,
    NormalizationForm__Enum_FormD = 0x00000002,
    NormalizationForm__Enum_FormKC = 0x00000005,
    NormalizationForm__Enum_FormKD = 0x00000006,
};

#else
enum NormalizationForm__Enum {
    NormalizationForm__Enum_FormC = 0x00000001,
    NormalizationForm__Enum_FormD = 0x00000002,
    NormalizationForm__Enum_FormKC = 0x00000005,
    NormalizationForm__Enum_FormKD = 0x00000006,
};

#endif
struct NormalizationForm__Enum__Boxed {
    struct NormalizationForm__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum NormalizationForm__Enum value;
    #else
    uint32_t value;
    #endif
};

struct CodePageDataItem__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_UIFamilyCodePage;
};

struct CodePageDataItem__StaticFields {
    struct Char__Array *sep;
};

struct CodePageDataItem__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CodePageDataItem__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CodePageDataItem__VTable vtable;
};

struct Encoder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Reset;
    VirtualInvokeData __unknown;
    VirtualInvokeData GetByteCount;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData GetBytes;
    VirtualInvokeData Convert;
    VirtualInvokeData Convert_1;
};

struct Encoder__StaticFields {
};

struct Encoder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Encoder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Encoder__VTable vtable;
};

struct EncoderNLS__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Reset;
    VirtualInvokeData GetByteCount;
    VirtualInvokeData GetByteCount_1;
    VirtualInvokeData GetBytes;
    VirtualInvokeData GetBytes_1;
    VirtualInvokeData Convert;
    VirtualInvokeData Convert_1;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
    VirtualInvokeData get_HasState;
};

struct EncoderNLS__StaticFields {
};

struct EncoderNLS__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EncoderNLS__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EncoderNLS__VTable vtable;
};

struct InternalEncoderBestFitFallbackBuffer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Fallback;
    VirtualInvokeData Fallback_1;
    VirtualInvokeData GetNextChar;
    VirtualInvokeData MovePrevious;
    VirtualInvokeData get_Remaining;
    VirtualInvokeData Reset;
    VirtualInvokeData InternalFallback;
};

struct InternalEncoderBestFitFallbackBuffer__StaticFields {
    struct Object *s_InternalSyncObject;
};

struct InternalEncoderBestFitFallbackBuffer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct InternalEncoderBestFitFallbackBuffer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct InternalEncoderBestFitFallbackBuffer__VTable vtable;
};

struct EncoderFallbackBuffer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData Reset;
    VirtualInvokeData InternalFallback;
};

struct EncoderFallbackBuffer__StaticFields {
};

struct EncoderFallbackBuffer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EncoderFallbackBuffer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EncoderFallbackBuffer__VTable vtable;
};

struct InternalEncoderBestFitFallback__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateFallbackBuffer;
    VirtualInvokeData get_MaxCharCount;
};

struct InternalEncoderBestFitFallback__StaticFields {
};

struct InternalEncoderBestFitFallback__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct InternalEncoderBestFitFallback__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct InternalEncoderBestFitFallback__VTable vtable;
};

struct EncoderFallback__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
};

struct EncoderFallback__StaticFields {
    struct EncoderFallback *replacementFallback;
    struct EncoderFallback *exceptionFallback;
    struct Object *s_InternalSyncObject;
};

struct EncoderFallback__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EncoderFallback__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EncoderFallback__VTable vtable;
};

struct InternalDecoderBestFitFallbackBuffer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Fallback;
    VirtualInvokeData GetNextChar;
    VirtualInvokeData MovePrevious;
    VirtualInvokeData get_Remaining;
    VirtualInvokeData Reset;
    VirtualInvokeData InternalFallback;
    VirtualInvokeData InternalFallback_1;
};

struct InternalDecoderBestFitFallbackBuffer__StaticFields {
    struct Object *s_InternalSyncObject;
};

struct InternalDecoderBestFitFallbackBuffer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct InternalDecoderBestFitFallbackBuffer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct InternalDecoderBestFitFallbackBuffer__VTable vtable;
};

struct DecoderFallbackBuffer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData Reset;
    VirtualInvokeData InternalFallback;
    VirtualInvokeData InternalFallback_1;
};

struct DecoderFallbackBuffer__StaticFields {
};

struct DecoderFallbackBuffer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DecoderFallbackBuffer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DecoderFallbackBuffer__VTable vtable;
};

struct InternalDecoderBestFitFallback__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateFallbackBuffer;
    VirtualInvokeData get_MaxCharCount;
};

struct InternalDecoderBestFitFallback__StaticFields {
};

struct InternalDecoderBestFitFallback__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct InternalDecoderBestFitFallback__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct InternalDecoderBestFitFallback__VTable vtable;
};

struct DecoderFallback__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
};

struct DecoderFallback__StaticFields {
    struct DecoderFallback *replacementFallback;
    struct DecoderFallback *exceptionFallback;
    struct Object *s_InternalSyncObject;
};

struct DecoderFallback__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DecoderFallback__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DecoderFallback__VTable vtable;
};

struct Decoder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Reset;
    VirtualInvokeData __unknown;
    VirtualInvokeData GetCharCount;
    VirtualInvokeData GetCharCount_1;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData GetChars;
    VirtualInvokeData GetChars_1;
    VirtualInvokeData Convert;
    VirtualInvokeData Convert_1;
};

struct Decoder__StaticFields {
};

struct Decoder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Decoder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Decoder__VTable vtable;
};

struct DecoderNLS__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Reset;
    VirtualInvokeData GetCharCount;
    VirtualInvokeData GetCharCount_1;
    VirtualInvokeData GetCharCount_2;
    VirtualInvokeData GetChars;
    VirtualInvokeData GetChars_1;
    VirtualInvokeData GetChars_2;
    VirtualInvokeData Convert;
    VirtualInvokeData Convert_1;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
    VirtualInvokeData get_HasState;
};

struct DecoderNLS__StaticFields {
};

struct DecoderNLS__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DecoderNLS__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DecoderNLS__VTable vtable;
};

struct NormalizationForm__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct NormalizationForm__Enum__StaticFields {
};

struct NormalizationForm__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct NormalizationForm__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct NormalizationForm__Enum__VTable vtable;
};

struct ASCIIEncoding__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData SetDefaultFallbacks;
    VirtualInvokeData GetPreamble;
    VirtualInvokeData get_BodyName;
    VirtualInvokeData get_EncodingName;
    VirtualInvokeData get_HeaderName;
    VirtualInvokeData get_WebName;
    VirtualInvokeData get_WindowsCodePage;
    VirtualInvokeData get_IsBrowserDisplay;
    VirtualInvokeData get_IsBrowserSave;
    VirtualInvokeData get_IsMailNewsDisplay;
    VirtualInvokeData get_IsMailNewsSave;
    VirtualInvokeData get_IsSingleByte;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetByteCount;
    VirtualInvokeData GetByteCount_1;
    VirtualInvokeData GetByteCount_2;
    VirtualInvokeData GetByteCount_3;
    VirtualInvokeData GetByteCount_4;
    VirtualInvokeData GetBytes;
    VirtualInvokeData GetBytes_1;
    VirtualInvokeData GetBytes_2;
    VirtualInvokeData GetBytes_3;
    VirtualInvokeData GetBytes_4;
    VirtualInvokeData GetBytes_5;
    VirtualInvokeData GetBytes_6;
    VirtualInvokeData GetCharCount;
    VirtualInvokeData GetCharCount_1;
    VirtualInvokeData GetCharCount_2;
    VirtualInvokeData GetCharCount_3;
    VirtualInvokeData GetChars;
    VirtualInvokeData GetChars_1;
    VirtualInvokeData GetChars_2;
    VirtualInvokeData GetChars_3;
    VirtualInvokeData GetChars_4;
    VirtualInvokeData get_CodePage;
    VirtualInvokeData IsAlwaysNormalized;
    VirtualInvokeData GetDecoder;
    VirtualInvokeData GetEncoder;
    VirtualInvokeData GetMaxByteCount;
    VirtualInvokeData GetMaxCharCount;
    VirtualInvokeData GetString;
    VirtualInvokeData GetString_1;
    VirtualInvokeData GetBestFitUnicodeToBytesData;
    VirtualInvokeData GetBestFitBytesToUnicodeData;
};

struct ASCIIEncoding__StaticFields {
};

struct ASCIIEncoding__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ASCIIEncoding__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ASCIIEncoding__VTable vtable;
};

struct Encoding__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData SetDefaultFallbacks;
    VirtualInvokeData GetPreamble;
    VirtualInvokeData get_BodyName;
    VirtualInvokeData get_EncodingName;
    VirtualInvokeData get_HeaderName;
    VirtualInvokeData get_WebName;
    VirtualInvokeData get_WindowsCodePage;
    VirtualInvokeData get_IsBrowserDisplay;
    VirtualInvokeData get_IsBrowserSave;
    VirtualInvokeData get_IsMailNewsDisplay;
    VirtualInvokeData get_IsMailNewsSave;
    VirtualInvokeData get_IsSingleByte;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetByteCount;
    VirtualInvokeData GetByteCount_1;
    VirtualInvokeData __unknown;
    VirtualInvokeData GetByteCount_2;
    VirtualInvokeData GetByteCount_3;
    VirtualInvokeData GetBytes;
    VirtualInvokeData GetBytes_1;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData GetBytes_2;
    VirtualInvokeData GetBytes_3;
    VirtualInvokeData GetBytes_4;
    VirtualInvokeData GetBytes_5;
    VirtualInvokeData GetCharCount;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData GetCharCount_1;
    VirtualInvokeData GetCharCount_2;
    VirtualInvokeData GetChars;
    VirtualInvokeData GetChars_1;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData GetChars_2;
    VirtualInvokeData GetChars_3;
    VirtualInvokeData get_CodePage;
    VirtualInvokeData IsAlwaysNormalized;
    VirtualInvokeData GetDecoder;
    VirtualInvokeData GetEncoder;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData __unknown_5;
    VirtualInvokeData GetString;
    VirtualInvokeData GetString_1;
    VirtualInvokeData GetBestFitUnicodeToBytesData;
    VirtualInvokeData GetBestFitBytesToUnicodeData;
};

struct Encoding__StaticFields {
    struct Encoding *defaultEncoding;
    struct Encoding *unicodeEncoding;
    struct Encoding *bigEndianUnicode;
    struct Encoding *utf7Encoding;
    struct Encoding *utf8Encoding;
    struct Encoding *utf32Encoding;
    struct Encoding *asciiEncoding;
    struct Encoding *latin1Encoding;
    struct Hashtable *encodings;
    struct Object *s_InternalSyncObject;
};

struct Encoding__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Encoding__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Encoding__VTable vtable;
};

struct StringComparer {
    struct StringComparer__Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) CultureAwareComparer__Fields {
    struct CompareInfo *_compareInfo;
    bool _ignoreCase;
    #if defined(_CPLUSPLUS_)
    enum CompareOptions__Enum _options;
    #else
    uint32_t _options;
    #endif
};

struct CultureAwareComparer {
    struct CultureAwareComparer__Class *klass;
    MonitorData *monitor;
    struct CultureAwareComparer__Fields fields;
};

struct CultureAwareComparer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Compare;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData Compare_1;
    VirtualInvokeData Equals_2;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData Compare_2;
    VirtualInvokeData Equals_3;
    VirtualInvokeData GetHashCode_3;
};

struct CultureAwareComparer__StaticFields {
};

struct CultureAwareComparer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CultureAwareComparer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CultureAwareComparer__VTable vtable;
};

struct StringComparer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Compare;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData Compare_1;
    VirtualInvokeData Equals_2;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
};

struct StringComparer__StaticFields {
    struct StringComparer *_invariantCulture;
    struct StringComparer *_invariantCultureIgnoreCase;
    struct StringComparer *_ordinal;
    struct StringComparer *_ordinalIgnoreCase;
};

struct StringComparer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StringComparer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StringComparer__VTable vtable;
};

struct __declspec(align(8)) OrdinalComparer__Fields {
    bool _ignoreCase;
};

struct OrdinalComparer {
    struct OrdinalComparer__Class *klass;
    MonitorData *monitor;
    struct OrdinalComparer__Fields fields;
};

struct OrdinalComparer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Compare;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData Compare_1;
    VirtualInvokeData Equals_2;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData Compare_2;
    VirtualInvokeData Equals_3;
    VirtualInvokeData GetHashCode_3;
};

struct OrdinalComparer__StaticFields {
};

struct OrdinalComparer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct OrdinalComparer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct OrdinalComparer__VTable vtable;
};

struct STAThreadAttribute {
    struct STAThreadAttribute__Class *klass;
    MonitorData *monitor;
};

struct STAThreadAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct STAThreadAttribute__StaticFields {
};

struct STAThreadAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct STAThreadAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct STAThreadAttribute__VTable vtable;
};

struct MTAThreadAttribute {
    struct MTAThreadAttribute__Class *klass;
    MonitorData *monitor;
};

struct MTAThreadAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct MTAThreadAttribute__StaticFields {
};

struct MTAThreadAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MTAThreadAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MTAThreadAttribute__VTable vtable;
};

struct ThreadStaticAttribute {
    struct ThreadStaticAttribute__Class *klass;
    MonitorData *monitor;
};

struct ThreadStaticAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct ThreadStaticAttribute__StaticFields {
};

struct ThreadStaticAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ThreadStaticAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ThreadStaticAttribute__VTable vtable;
};

struct TimeoutException__Fields {
    struct SystemException__Fields _;
};

struct TimeoutException {
    struct TimeoutException__Class *klass;
    MonitorData *monitor;
    struct TimeoutException__Fields fields;
};

struct TimeoutException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct TimeoutException__StaticFields {
};

struct TimeoutException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TimeoutException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TimeoutException__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum TimeSpanStyles__Enum : int32_t {
    TimeSpanStyles__Enum_None = 0x00000000,
    TimeSpanStyles__Enum_AssumeNegative = 0x00000001,
};

#else
enum TimeSpanStyles__Enum {
    TimeSpanStyles__Enum_None = 0x00000000,
    TimeSpanStyles__Enum_AssumeNegative = 0x00000001,
};

#endif
struct TimeSpanStyles__Enum__Boxed {
    struct TimeSpanStyles__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum TimeSpanStyles__Enum value;
    #else
    uint32_t value;
    #endif
};

struct TimeSpanStyles__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct TimeSpanStyles__Enum__StaticFields {
};

struct TimeSpanStyles__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TimeSpanStyles__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TimeSpanStyles__Enum__VTable vtable;
};

struct TimeZoneInfo_TransitionTime {
    struct DateTime m_timeOfDay;
    uint8_t m_month;
    uint8_t m_week;
    uint8_t m_day;
    #if defined(_CPLUSPLUS_)
    enum DayOfWeek__Enum m_dayOfWeek;
    #else
    uint32_t m_dayOfWeek;
    #endif
    bool m_isFixedDateRule;
};

struct TimeZoneInfo_TransitionTime__Boxed {
    struct TimeZoneInfo_TransitionTime__Class *klass;
    MonitorData *monitor;
    struct TimeZoneInfo_TransitionTime fields;
};

struct __declspec(align(8)) TimeZoneInfo_AdjustmentRule__Fields {
    struct DateTime m_dateStart;
    struct DateTime m_dateEnd;
    struct TimeSpan m_daylightDelta;
    struct TimeZoneInfo_TransitionTime m_daylightTransitionStart;
    struct TimeZoneInfo_TransitionTime m_daylightTransitionEnd;
    struct TimeSpan m_baseUtcOffsetDelta;
};

struct TimeZoneInfo_AdjustmentRule {
    struct TimeZoneInfo_AdjustmentRule__Class *klass;
    MonitorData *monitor;
    struct TimeZoneInfo_AdjustmentRule__Fields fields;
};

struct TimeZoneInfo_AdjustmentRule__Array {
    struct TimeZoneInfo_AdjustmentRule__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct TimeZoneInfo_AdjustmentRule *vector[32];
};

struct TimeZoneInfo_TransitionTime__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Equals_1;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
    VirtualInvokeData System_Runtime_Serialization_IDeserializationCallback_OnDeserialization;
};

struct TimeZoneInfo_TransitionTime__StaticFields {
};

struct TimeZoneInfo_TransitionTime__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TimeZoneInfo_TransitionTime__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TimeZoneInfo_TransitionTime__VTable vtable;
};

struct TimeZoneInfo_AdjustmentRule__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Equals_1;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
    VirtualInvokeData System_Runtime_Serialization_IDeserializationCallback_OnDeserialization;
};

struct TimeZoneInfo_AdjustmentRule__StaticFields {
};

struct TimeZoneInfo_AdjustmentRule__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TimeZoneInfo_AdjustmentRule__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TimeZoneInfo_AdjustmentRule__VTable vtable;
};

struct TimeZoneInfo_AdjustmentRule__Array__VTable {
};

struct TimeZoneInfo_AdjustmentRule__Array__StaticFields {
};

struct TimeZoneInfo_AdjustmentRule__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TimeZoneInfo_AdjustmentRule__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TimeZoneInfo_AdjustmentRule__Array__VTable vtable;
};

struct __declspec(align(8)) TimeZoneInfo__Fields {
    struct TimeSpan baseUtcOffset;
    struct String *daylightDisplayName;
    struct String *displayName;
    struct String *id;
    struct List_1_KeyValuePair_2_System_DateTime_System_TimeType_ *transitions;
    struct String *standardDisplayName;
    bool supportsDaylightSavingTime;
    struct TimeZoneInfo_AdjustmentRule__Array *adjustmentRules;
};

struct TimeZoneInfo {
    struct TimeZoneInfo__Class *klass;
    MonitorData *monitor;
    struct TimeZoneInfo__Fields fields;
};

struct __declspec(align(8)) List_1_KeyValuePair_2_System_DateTime_System_TimeType___Fields {
    struct KeyValuePair_2_System_DateTime_System_TimeType___Array *_items;
    int32_t _size;
    int32_t _version;
    struct Object *_syncRoot;
};

struct List_1_KeyValuePair_2_System_DateTime_System_TimeType_ {
    struct List_1_KeyValuePair_2_System_DateTime_System_TimeType___Class *klass;
    MonitorData *monitor;
    struct List_1_KeyValuePair_2_System_DateTime_System_TimeType___Fields fields;
};

struct KeyValuePair_2_System_DateTime_System_TimeType_ {
    struct DateTime key;
    struct TimeType *value;
};

struct KeyValuePair_2_System_DateTime_System_TimeType___Boxed {
    struct KeyValuePair_2_System_DateTime_System_TimeType___Class *klass;
    MonitorData *monitor;
    struct KeyValuePair_2_System_DateTime_System_TimeType_ fields;
};

struct __declspec(align(8)) TimeType__Fields {
    int32_t Offset;
    bool IsDst;
    struct String *Name;
};

struct TimeType {
    struct TimeType__Class *klass;
    MonitorData *monitor;
    struct TimeType__Fields fields;
};

struct KeyValuePair_2_System_DateTime_System_TimeType___Array {
    struct KeyValuePair_2_System_DateTime_System_TimeType___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct KeyValuePair_2_System_DateTime_System_TimeType_ vector[32];
};

struct IEnumerator_1_KeyValuePair_2_System_DateTime_System_TimeType_ {
    struct IEnumerator_1_KeyValuePair_2_System_DateTime_System_TimeType___Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) ReadOnlyCollection_1_System_TimeZoneInfo___Fields {
    struct IList_1_System_TimeZoneInfo_ *list;
    struct Object *_syncRoot;
};

struct ReadOnlyCollection_1_System_TimeZoneInfo_ {
    struct ReadOnlyCollection_1_System_TimeZoneInfo___Class *klass;
    MonitorData *monitor;
    struct ReadOnlyCollection_1_System_TimeZoneInfo___Fields fields;
};

struct IList_1_System_TimeZoneInfo_ {
    struct IList_1_System_TimeZoneInfo___Class *klass;
    MonitorData *monitor;
};

struct TimeZoneInfo__Array {
    struct TimeZoneInfo__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct TimeZoneInfo *vector[32];
};

struct IEnumerator_1_System_TimeZoneInfo_ {
    struct IEnumerator_1_System_TimeZoneInfo___Class *klass;
    MonitorData *monitor;
};

struct TimeType__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct TimeType__StaticFields {
};

struct TimeType__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TimeType__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TimeType__VTable vtable;
};

struct KeyValuePair_2_System_DateTime_System_TimeType___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct KeyValuePair_2_System_DateTime_System_TimeType___StaticFields {
};

struct KeyValuePair_2_System_DateTime_System_TimeType___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_DateTime_System_TimeType___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_DateTime_System_TimeType___VTable vtable;
};

struct KeyValuePair_2_System_DateTime_System_TimeType___Array__VTable {
};

struct KeyValuePair_2_System_DateTime_System_TimeType___Array__StaticFields {
};

struct KeyValuePair_2_System_DateTime_System_TimeType___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_DateTime_System_TimeType___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_DateTime_System_TimeType___Array__VTable vtable;
};

struct IEnumerator_1_KeyValuePair_2_System_DateTime_System_TimeType___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_KeyValuePair_2_System_DateTime_System_TimeType___StaticFields {
};

struct IEnumerator_1_KeyValuePair_2_System_DateTime_System_TimeType___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_KeyValuePair_2_System_DateTime_System_TimeType___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_KeyValuePair_2_System_DateTime_System_TimeType___VTable vtable;
};

struct List_1_KeyValuePair_2_System_DateTime_System_TimeType___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData RemoveAt;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_T__get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_T__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IList_get_Item;
    VirtualInvokeData System_Collections_IList_set_Item;
    VirtualInvokeData System_Collections_IList_Add;
    VirtualInvokeData System_Collections_IList_Contains;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IList_get_IsReadOnly;
    VirtualInvokeData System_Collections_IList_get_IsFixedSize;
    VirtualInvokeData System_Collections_IList_IndexOf;
    VirtualInvokeData System_Collections_IList_Insert;
    VirtualInvokeData System_Collections_IList_Remove;
    VirtualInvokeData RemoveAt_1;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData get_Count_2;
};

struct List_1_KeyValuePair_2_System_DateTime_System_TimeType___StaticFields {
    struct KeyValuePair_2_System_DateTime_System_TimeType___Array *_emptyArray;
};

struct List_1_KeyValuePair_2_System_DateTime_System_TimeType___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct List_1_KeyValuePair_2_System_DateTime_System_TimeType___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct List_1_KeyValuePair_2_System_DateTime_System_TimeType___VTable vtable;
};

struct IList_1_System_TimeZoneInfo___VTable {
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData RemoveAt;
};

struct IList_1_System_TimeZoneInfo___StaticFields {
};

struct IList_1_System_TimeZoneInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IList_1_System_TimeZoneInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IList_1_System_TimeZoneInfo___VTable vtable;
};

struct TimeZoneInfo__Array__VTable {
};

struct TimeZoneInfo__Array__StaticFields {
};

struct TimeZoneInfo__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TimeZoneInfo__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TimeZoneInfo__Array__VTable vtable;
};

struct IEnumerator_1_System_TimeZoneInfo___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_System_TimeZoneInfo___StaticFields {
};

struct IEnumerator_1_System_TimeZoneInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_System_TimeZoneInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_System_TimeZoneInfo___VTable vtable;
};

struct ReadOnlyCollection_1_System_TimeZoneInfo___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Collections_Generic_IList_T__get_Item;
    VirtualInvokeData System_Collections_Generic_IList_T__set_Item;
    VirtualInvokeData IndexOf;
    VirtualInvokeData System_Collections_Generic_IList_T__Insert;
    VirtualInvokeData System_Collections_Generic_IList_T__RemoveAt;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_T__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_T__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_T__Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_T__Remove;
    VirtualInvokeData GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IList_get_Item;
    VirtualInvokeData System_Collections_IList_set_Item;
    VirtualInvokeData System_Collections_IList_Add;
    VirtualInvokeData System_Collections_IList_Contains;
    VirtualInvokeData System_Collections_IList_Clear;
    VirtualInvokeData System_Collections_IList_get_IsReadOnly;
    VirtualInvokeData System_Collections_IList_get_IsFixedSize;
    VirtualInvokeData System_Collections_IList_IndexOf;
    VirtualInvokeData System_Collections_IList_Insert;
    VirtualInvokeData System_Collections_IList_Remove;
    VirtualInvokeData System_Collections_IList_RemoveAt;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Item;
    VirtualInvokeData get_Count_2;
};

struct ReadOnlyCollection_1_System_TimeZoneInfo___StaticFields {
};

struct ReadOnlyCollection_1_System_TimeZoneInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ReadOnlyCollection_1_System_TimeZoneInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ReadOnlyCollection_1_System_TimeZoneInfo___VTable vtable;
};

struct TimeZoneInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Equals_1;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
    VirtualInvokeData System_Runtime_Serialization_IDeserializationCallback_OnDeserialization;
};

struct TimeZoneInfo__StaticFields {
    struct TimeZoneInfo *local;
    bool readlinkNotFound;
    struct TimeZoneInfo *utc;
    struct String *timeZoneDirectory;
    struct RegistryKey *timeZoneKey;
    struct RegistryKey *localZoneKey;
    struct ReadOnlyCollection_1_System_TimeZoneInfo_ *systemTimeZones;
};

struct TimeZoneInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TimeZoneInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TimeZoneInfo__VTable vtable;
};

struct StringBuilder___VTable {
};

struct StringBuilder___StaticFields {
};

struct StringBuilder___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StringBuilder___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StringBuilder___VTable vtable;
};

struct __declspec(align(8)) List_1_System_TimeZoneInfo_AdjustmentRule___Fields {
    struct TimeZoneInfo_AdjustmentRule__Array *_items;
    int32_t _size;
    int32_t _version;
    struct Object *_syncRoot;
};

struct List_1_System_TimeZoneInfo_AdjustmentRule_ {
    struct List_1_System_TimeZoneInfo_AdjustmentRule___Class *klass;
    MonitorData *monitor;
    struct List_1_System_TimeZoneInfo_AdjustmentRule___Fields fields;
};

struct IEnumerator_1_System_TimeZoneInfo_AdjustmentRule_ {
    struct IEnumerator_1_System_TimeZoneInfo_AdjustmentRule___Class *klass;
    MonitorData *monitor;
};

struct IEnumerator_1_System_TimeZoneInfo_AdjustmentRule___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_System_TimeZoneInfo_AdjustmentRule___StaticFields {
};

struct IEnumerator_1_System_TimeZoneInfo_AdjustmentRule___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_System_TimeZoneInfo_AdjustmentRule___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_System_TimeZoneInfo_AdjustmentRule___VTable vtable;
};

struct List_1_System_TimeZoneInfo_AdjustmentRule___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData RemoveAt;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_T__get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_T__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IList_get_Item;
    VirtualInvokeData System_Collections_IList_set_Item;
    VirtualInvokeData System_Collections_IList_Add;
    VirtualInvokeData System_Collections_IList_Contains;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IList_get_IsReadOnly;
    VirtualInvokeData System_Collections_IList_get_IsFixedSize;
    VirtualInvokeData System_Collections_IList_IndexOf;
    VirtualInvokeData System_Collections_IList_Insert;
    VirtualInvokeData System_Collections_IList_Remove;
    VirtualInvokeData RemoveAt_1;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData get_Count_2;
};

struct List_1_System_TimeZoneInfo_AdjustmentRule___StaticFields {
    struct TimeZoneInfo_AdjustmentRule__Array *_emptyArray;
};

struct List_1_System_TimeZoneInfo_AdjustmentRule___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct List_1_System_TimeZoneInfo_AdjustmentRule___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct List_1_System_TimeZoneInfo_AdjustmentRule___VTable vtable;
};

struct Int64__1__VTable {
};

struct Int64__1__StaticFields {
};

struct Int64__1__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Int64__1__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Int64__1__VTable vtable;
};

struct TimeZoneInfo_SYSTEMTIME {
    uint16_t wYear;
    uint16_t wMonth;
    uint16_t wDayOfWeek;
    uint16_t wDay;
    uint16_t wHour;
    uint16_t wMinute;
    uint16_t wSecond;
    uint16_t wMilliseconds;
};

struct TimeZoneInfo_SYSTEMTIME__Boxed {
    struct TimeZoneInfo_SYSTEMTIME__Class *klass;
    MonitorData *monitor;
    struct TimeZoneInfo_SYSTEMTIME fields;
};

struct TimeZoneInfo_TIME_ZONE_INFORMATION {
    int32_t Bias;
    struct String *StandardName;
    struct TimeZoneInfo_SYSTEMTIME StandardDate;
    int32_t StandardBias;
    struct String *DaylightName;
    struct TimeZoneInfo_SYSTEMTIME DaylightDate;
    int32_t DaylightBias;
};

struct TimeZoneInfo_TIME_ZONE_INFORMATION__Boxed {
    struct TimeZoneInfo_TIME_ZONE_INFORMATION__Class *klass;
    MonitorData *monitor;
    struct TimeZoneInfo_TIME_ZONE_INFORMATION fields;
};

struct TimeZoneInfo_DYNAMIC_TIME_ZONE_INFORMATION {
    struct TimeZoneInfo_TIME_ZONE_INFORMATION TZI;
    struct String *TimeZoneKeyName;
    uint8_t DynamicDaylightTimeDisabled;
};

struct TimeZoneInfo_DYNAMIC_TIME_ZONE_INFORMATION__Boxed {
    struct TimeZoneInfo_DYNAMIC_TIME_ZONE_INFORMATION__Class *klass;
    MonitorData *monitor;
    struct TimeZoneInfo_DYNAMIC_TIME_ZONE_INFORMATION fields;
};

struct TimeZoneInfo_SYSTEMTIME__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct TimeZoneInfo_SYSTEMTIME__StaticFields {
};

struct TimeZoneInfo_SYSTEMTIME__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TimeZoneInfo_SYSTEMTIME__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TimeZoneInfo_SYSTEMTIME__VTable vtable;
};

struct TimeZoneInfo_TIME_ZONE_INFORMATION__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct TimeZoneInfo_TIME_ZONE_INFORMATION__StaticFields {
};

struct TimeZoneInfo_TIME_ZONE_INFORMATION__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TimeZoneInfo_TIME_ZONE_INFORMATION__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TimeZoneInfo_TIME_ZONE_INFORMATION__VTable vtable;
};

struct TimeZoneInfo_DYNAMIC_TIME_ZONE_INFORMATION__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct TimeZoneInfo_DYNAMIC_TIME_ZONE_INFORMATION__StaticFields {
};

struct TimeZoneInfo_DYNAMIC_TIME_ZONE_INFORMATION__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TimeZoneInfo_DYNAMIC_TIME_ZONE_INFORMATION__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TimeZoneInfo_DYNAMIC_TIME_ZONE_INFORMATION__VTable vtable;
};

struct TimeZoneInfo_DYNAMIC_TIME_ZONE_INFORMATION___VTable {
};

struct TimeZoneInfo_DYNAMIC_TIME_ZONE_INFORMATION___StaticFields {
};

struct TimeZoneInfo_DYNAMIC_TIME_ZONE_INFORMATION___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TimeZoneInfo_DYNAMIC_TIME_ZONE_INFORMATION___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TimeZoneInfo_DYNAMIC_TIME_ZONE_INFORMATION___VTable vtable;
};

struct TimeZoneInfo_TIME_ZONE_INFORMATION___VTable {
};

struct TimeZoneInfo_TIME_ZONE_INFORMATION___StaticFields {
};

struct TimeZoneInfo_TIME_ZONE_INFORMATION___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TimeZoneInfo_TIME_ZONE_INFORMATION___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TimeZoneInfo_TIME_ZONE_INFORMATION___VTable vtable;
};

struct TimeZoneInfo_TransitionTime___VTable {
};

struct TimeZoneInfo_TransitionTime___StaticFields {
};

struct TimeZoneInfo_TransitionTime___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TimeZoneInfo_TransitionTime___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TimeZoneInfo_TransitionTime___VTable vtable;
};

struct __declspec(align(8)) List_1_System_TimeZoneInfo___Fields {
    struct TimeZoneInfo__Array *_items;
    int32_t _size;
    int32_t _version;
    struct Object *_syncRoot;
};

struct List_1_System_TimeZoneInfo_ {
    struct List_1_System_TimeZoneInfo___Class *klass;
    MonitorData *monitor;
    struct List_1_System_TimeZoneInfo___Fields fields;
};

struct List_1_System_TimeZoneInfo___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData RemoveAt;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_T__get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_T__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IList_get_Item;
    VirtualInvokeData System_Collections_IList_set_Item;
    VirtualInvokeData System_Collections_IList_Add;
    VirtualInvokeData System_Collections_IList_Contains;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IList_get_IsReadOnly;
    VirtualInvokeData System_Collections_IList_get_IsFixedSize;
    VirtualInvokeData System_Collections_IList_IndexOf;
    VirtualInvokeData System_Collections_IList_Insert;
    VirtualInvokeData System_Collections_IList_Remove;
    VirtualInvokeData RemoveAt_1;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData get_Count_2;
};

struct List_1_System_TimeZoneInfo___StaticFields {
    struct TimeZoneInfo__Array *_emptyArray;
};

struct List_1_System_TimeZoneInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct List_1_System_TimeZoneInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct List_1_System_TimeZoneInfo___VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum TimeZoneInfoOptions__Enum : int32_t {
    TimeZoneInfoOptions__Enum_None = 0x00000001,
    TimeZoneInfoOptions__Enum_NoThrowOnInvalidTime = 0x00000002,
};

#else
enum TimeZoneInfoOptions__Enum {
    TimeZoneInfoOptions__Enum_None = 0x00000001,
    TimeZoneInfoOptions__Enum_NoThrowOnInvalidTime = 0x00000002,
};

#endif
struct TimeZoneInfoOptions__Enum__Boxed {
    struct TimeZoneInfoOptions__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum TimeZoneInfoOptions__Enum value;
    #else
    uint32_t value;
    #endif
};

struct TimeZoneInfoOptions__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct TimeZoneInfoOptions__Enum__StaticFields {
};

struct TimeZoneInfoOptions__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TimeZoneInfoOptions__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TimeZoneInfoOptions__Enum__VTable vtable;
};

struct TimeSpan__Array {
    struct TimeSpan__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct TimeSpan vector[32];
};

struct TimeSpan__Array__VTable {
};

struct TimeSpan__Array__StaticFields {
};

struct TimeSpan__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TimeSpan__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TimeSpan__Array__VTable vtable;
};

struct __declspec(align(8)) DaylightTime__Fields {
    struct DateTime m_start;
    struct DateTime m_end;
    struct TimeSpan m_delta;
};

struct DaylightTime {
    struct DaylightTime__Class *klass;
    MonitorData *monitor;
    struct DaylightTime__Fields fields;
};

struct DaylightTime__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct DaylightTime__StaticFields {
};

struct DaylightTime__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DaylightTime__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DaylightTime__VTable vtable;
};

struct __declspec(align(8)) Dictionary_2_System_Int32_System_String___Fields {
    struct Int32__Array *buckets;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_String___Array *entries;
    int32_t count;
    int32_t version;
    int32_t freeList;
    int32_t freeCount;
    struct IEqualityComparer_1_System_Int32_ *comparer;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_String_ *keys;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_String_ *values;
    struct Object *_syncRoot;
};

struct Dictionary_2_System_Int32_System_String_ {
    struct Dictionary_2_System_Int32_System_String___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_System_Int32_System_String___Fields fields;
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_String_ {
    int32_t hashCode;
    int32_t next;
    int32_t key;
    struct String *value;
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_String___Boxed {
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_String___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_String_ fields;
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_String___Array {
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_String___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_String_ vector[32];
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_String___Fields {
    struct Dictionary_2_System_Int32_System_String_ *dictionary;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_String_ {
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_String___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_String___Fields fields;
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_String___Fields {
    struct Dictionary_2_System_Int32_System_String_ *dictionary;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_String_ {
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_String___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_String___Fields fields;
};

struct KeyValuePair_2_System_Int32_System_String_ {
    int32_t key;
    struct String *value;
};

struct KeyValuePair_2_System_Int32_System_String___Boxed {
    struct KeyValuePair_2_System_Int32_System_String___Class *klass;
    MonitorData *monitor;
    struct KeyValuePair_2_System_Int32_System_String_ fields;
};

struct KeyValuePair_2_System_Int32_System_String___Array {
    struct KeyValuePair_2_System_Int32_System_String___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct KeyValuePair_2_System_Int32_System_String_ vector[32];
};

struct IEnumerator_1_KeyValuePair_2_System_Int32_System_String_ {
    struct IEnumerator_1_KeyValuePair_2_System_Int32_System_String___Class *klass;
    MonitorData *monitor;
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_String___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_String___StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_String___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_String___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_String___VTable vtable;
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_String___Array__VTable {
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_String___Array__StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_String___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_String___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_String___Array__VTable vtable;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_String___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TKey__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_String___StaticFields {
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_String___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_String___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_String___VTable vtable;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_String___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TValue__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_String___StaticFields {
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_String___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_String___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_String___VTable vtable;
};

struct KeyValuePair_2_System_Int32_System_String___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct KeyValuePair_2_System_Int32_System_String___StaticFields {
};

struct KeyValuePair_2_System_Int32_System_String___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_Int32_System_String___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_Int32_System_String___VTable vtable;
};

struct KeyValuePair_2_System_Int32_System_String___Array__VTable {
};

struct KeyValuePair_2_System_Int32_System_String___Array__StaticFields {
};

struct KeyValuePair_2_System_Int32_System_String___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_Int32_System_String___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_Int32_System_String___Array__VTable vtable;
};

struct IEnumerator_1_KeyValuePair_2_System_Int32_System_String___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_KeyValuePair_2_System_Int32_System_String___StaticFields {
};

struct IEnumerator_1_KeyValuePair_2_System_Int32_System_String___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_KeyValuePair_2_System_Int32_System_String___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_KeyValuePair_2_System_Int32_System_String___VTable vtable;
};

struct Dictionary_2_System_Int32_System_String___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Values;
    VirtualInvokeData ContainsKey;
    VirtualInvokeData Add;
    VirtualInvokeData Remove;
    VirtualInvokeData TryGetValue;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Add;
    VirtualInvokeData Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Contains;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_System_Collections_Generic_KeyValuePair_TKey_TValue___GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_get_Item;
    VirtualInvokeData System_Collections_IDictionary_set_Item;
    VirtualInvokeData System_Collections_IDictionary_get_Keys;
    VirtualInvokeData System_Collections_IDictionary_get_Values;
    VirtualInvokeData System_Collections_IDictionary_Contains;
    VirtualInvokeData System_Collections_IDictionary_Add;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IDictionary_get_IsReadOnly;
    VirtualInvokeData System_Collections_IDictionary_get_IsFixedSize;
    VirtualInvokeData System_Collections_IDictionary_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_Remove;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData ContainsKey_1;
    VirtualInvokeData TryGetValue_1;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Values;
    VirtualInvokeData get_Count_2;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData OnDeserialization;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData OnDeserialization_1;
};

struct Dictionary_2_System_Int32_System_String___StaticFields {
};

struct Dictionary_2_System_Int32_System_String___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_System_Int32_System_String___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_System_Int32_System_String___VTable vtable;
};

struct __declspec(align(8)) Dictionary_2_System_Int32_System_TimeType___Fields {
    struct Int32__Array *buckets;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_TimeType___Array *entries;
    int32_t count;
    int32_t version;
    int32_t freeList;
    int32_t freeCount;
    struct IEqualityComparer_1_System_Int32_ *comparer;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_TimeType_ *keys;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_TimeType_ *values;
    struct Object *_syncRoot;
};

struct Dictionary_2_System_Int32_System_TimeType_ {
    struct Dictionary_2_System_Int32_System_TimeType___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_System_Int32_System_TimeType___Fields fields;
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_TimeType_ {
    int32_t hashCode;
    int32_t next;
    int32_t key;
    struct TimeType *value;
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_TimeType___Boxed {
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_TimeType___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_TimeType_ fields;
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_TimeType___Array {
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_TimeType___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_TimeType_ vector[32];
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_TimeType___Fields {
    struct Dictionary_2_System_Int32_System_TimeType_ *dictionary;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_TimeType_ {
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_TimeType___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_TimeType___Fields fields;
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_TimeType___Fields {
    struct Dictionary_2_System_Int32_System_TimeType_ *dictionary;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_TimeType_ {
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_TimeType___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_TimeType___Fields fields;
};

struct TimeType__Array {
    struct TimeType__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct TimeType *vector[32];
};

struct IEnumerator_1_System_TimeType_ {
    struct IEnumerator_1_System_TimeType___Class *klass;
    MonitorData *monitor;
};

struct ICollection_1_System_TimeType_ {
    struct ICollection_1_System_TimeType___Class *klass;
    MonitorData *monitor;
};

struct KeyValuePair_2_System_Int32_System_TimeType_ {
    int32_t key;
    struct TimeType *value;
};

struct KeyValuePair_2_System_Int32_System_TimeType___Boxed {
    struct KeyValuePair_2_System_Int32_System_TimeType___Class *klass;
    MonitorData *monitor;
    struct KeyValuePair_2_System_Int32_System_TimeType_ fields;
};

struct KeyValuePair_2_System_Int32_System_TimeType___Array {
    struct KeyValuePair_2_System_Int32_System_TimeType___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct KeyValuePair_2_System_Int32_System_TimeType_ vector[32];
};

struct IEnumerator_1_KeyValuePair_2_System_Int32_System_TimeType_ {
    struct IEnumerator_1_KeyValuePair_2_System_Int32_System_TimeType___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_TimeType_ {
    struct IEnumerable_1_System_TimeType___Class *klass;
    MonitorData *monitor;
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_TimeType___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_TimeType___StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_TimeType___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_TimeType___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_TimeType___VTable vtable;
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_TimeType___Array__VTable {
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_TimeType___Array__StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_TimeType___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_TimeType___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_Int32_System_TimeType___Array__VTable vtable;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_TimeType___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TKey__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_TimeType___StaticFields {
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_TimeType___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_TimeType___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Int32_System_TimeType___VTable vtable;
};

struct TimeType__Array__VTable {
};

struct TimeType__Array__StaticFields {
};

struct TimeType__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TimeType__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TimeType__Array__VTable vtable;
};

struct IEnumerator_1_System_TimeType___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_System_TimeType___StaticFields {
};

struct IEnumerator_1_System_TimeType___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_System_TimeType___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_System_TimeType___VTable vtable;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_TimeType___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TValue__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_TimeType___StaticFields {
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_TimeType___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_TimeType___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Int32_System_TimeType___VTable vtable;
};

struct ICollection_1_System_TimeType___VTable {
    VirtualInvokeData get_Count;
    VirtualInvokeData get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
};

struct ICollection_1_System_TimeType___StaticFields {
};

struct ICollection_1_System_TimeType___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ICollection_1_System_TimeType___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ICollection_1_System_TimeType___VTable vtable;
};

struct TimeType___VTable {
};

struct TimeType___StaticFields {
};

struct TimeType___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TimeType___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TimeType___VTable vtable;
};

struct KeyValuePair_2_System_Int32_System_TimeType___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct KeyValuePair_2_System_Int32_System_TimeType___StaticFields {
};

struct KeyValuePair_2_System_Int32_System_TimeType___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_Int32_System_TimeType___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_Int32_System_TimeType___VTable vtable;
};

struct KeyValuePair_2_System_Int32_System_TimeType___Array__VTable {
};

struct KeyValuePair_2_System_Int32_System_TimeType___Array__StaticFields {
};

struct KeyValuePair_2_System_Int32_System_TimeType___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_Int32_System_TimeType___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_Int32_System_TimeType___Array__VTable vtable;
};

struct IEnumerator_1_KeyValuePair_2_System_Int32_System_TimeType___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_KeyValuePair_2_System_Int32_System_TimeType___StaticFields {
};

struct IEnumerator_1_KeyValuePair_2_System_Int32_System_TimeType___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_KeyValuePair_2_System_Int32_System_TimeType___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_KeyValuePair_2_System_Int32_System_TimeType___VTable vtable;
};

struct IEnumerable_1_System_TimeType___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_TimeType___StaticFields {
};

struct IEnumerable_1_System_TimeType___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_TimeType___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_TimeType___VTable vtable;
};

struct Dictionary_2_System_Int32_System_TimeType___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Values;
    VirtualInvokeData ContainsKey;
    VirtualInvokeData Add;
    VirtualInvokeData Remove;
    VirtualInvokeData TryGetValue;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Add;
    VirtualInvokeData Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Contains;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_System_Collections_Generic_KeyValuePair_TKey_TValue___GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_get_Item;
    VirtualInvokeData System_Collections_IDictionary_set_Item;
    VirtualInvokeData System_Collections_IDictionary_get_Keys;
    VirtualInvokeData System_Collections_IDictionary_get_Values;
    VirtualInvokeData System_Collections_IDictionary_Contains;
    VirtualInvokeData System_Collections_IDictionary_Add;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IDictionary_get_IsReadOnly;
    VirtualInvokeData System_Collections_IDictionary_get_IsFixedSize;
    VirtualInvokeData System_Collections_IDictionary_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_Remove;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData ContainsKey_1;
    VirtualInvokeData TryGetValue_1;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Values;
    VirtualInvokeData get_Count_2;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData OnDeserialization;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData OnDeserialization_1;
};

struct Dictionary_2_System_Int32_System_TimeType___StaticFields {
};

struct Dictionary_2_System_Int32_System_TimeType___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_System_Int32_System_TimeType___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_System_Int32_System_TimeType___VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum TimeZoneInfo_StringSerializer_State__Enum : int32_t {
    TimeZoneInfo_StringSerializer_State__Enum_Escaped = 0x00000000,
    TimeZoneInfo_StringSerializer_State__Enum_NotEscaped = 0x00000001,
    TimeZoneInfo_StringSerializer_State__Enum_StartOfToken = 0x00000002,
    TimeZoneInfo_StringSerializer_State__Enum_EndOfLine = 0x00000003,
};

#else
enum TimeZoneInfo_StringSerializer_State__Enum {
    TimeZoneInfo_StringSerializer_State__Enum_Escaped = 0x00000000,
    TimeZoneInfo_StringSerializer_State__Enum_NotEscaped = 0x00000001,
    TimeZoneInfo_StringSerializer_State__Enum_StartOfToken = 0x00000002,
    TimeZoneInfo_StringSerializer_State__Enum_EndOfLine = 0x00000003,
};

#endif
struct TimeZoneInfo_StringSerializer_State__Enum__Boxed {
    struct TimeZoneInfo_StringSerializer_State__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum TimeZoneInfo_StringSerializer_State__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) TimeZoneInfo_StringSerializer__Fields {
    struct String *m_serializedText;
    int32_t m_currentTokenStartIndex;
    #if defined(_CPLUSPLUS_)
    enum TimeZoneInfo_StringSerializer_State__Enum m_state;
    #else
    uint32_t m_state;
    #endif
};

struct TimeZoneInfo_StringSerializer {
    struct TimeZoneInfo_StringSerializer__Class *klass;
    MonitorData *monitor;
    struct TimeZoneInfo_StringSerializer__Fields fields;
};

struct TimeZoneInfo_StringSerializer_State__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct TimeZoneInfo_StringSerializer_State__Enum__StaticFields {
};

struct TimeZoneInfo_StringSerializer_State__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TimeZoneInfo_StringSerializer_State__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TimeZoneInfo_StringSerializer_State__Enum__VTable vtable;
};

struct TimeZoneInfo_StringSerializer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct TimeZoneInfo_StringSerializer__StaticFields {
};

struct TimeZoneInfo_StringSerializer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TimeZoneInfo_StringSerializer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TimeZoneInfo_StringSerializer__VTable vtable;
};

struct TimeZoneInfo_TimeZoneInfoComparer {
    struct TimeZoneInfo_TimeZoneInfoComparer__Class *klass;
    MonitorData *monitor;
};

struct TimeZoneInfo_TimeZoneInfoComparer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Collections_Generic_IComparer_System_TimeZoneInfo__Compare;
};

struct TimeZoneInfo_TimeZoneInfoComparer__StaticFields {
};

struct TimeZoneInfo_TimeZoneInfoComparer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TimeZoneInfo_TimeZoneInfoComparer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TimeZoneInfo_TimeZoneInfoComparer__VTable vtable;
};

struct TimeZoneInfo_c {
    struct TimeZoneInfo_c__Class *klass;
    MonitorData *monitor;
};

struct Comparison_1_TimeZoneInfo_AdjustmentRule___Fields {
    struct MulticastDelegate__Fields _;
};

struct Comparison_1_TimeZoneInfo_AdjustmentRule_ {
    struct Comparison_1_TimeZoneInfo_AdjustmentRule___Class *klass;
    MonitorData *monitor;
    struct Comparison_1_TimeZoneInfo_AdjustmentRule___Fields fields;
};

struct Comparison_1_TimeZoneInfo_AdjustmentRule___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Comparison_1_TimeZoneInfo_AdjustmentRule___StaticFields {
};

struct Comparison_1_TimeZoneInfo_AdjustmentRule___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Comparison_1_TimeZoneInfo_AdjustmentRule___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Comparison_1_TimeZoneInfo_AdjustmentRule___VTable vtable;
};

struct TimeZoneInfo_c__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct TimeZoneInfo_c__StaticFields {
    struct TimeZoneInfo_c *__9;
    struct Comparison_1_TimeZoneInfo_AdjustmentRule_ *__9__19_0;
};

struct TimeZoneInfo_c__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TimeZoneInfo_c__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TimeZoneInfo_c__VTable vtable;
};

struct TimeZoneNotFoundException__Fields {
    struct Exception__Fields _;
};

struct TimeZoneNotFoundException {
    struct TimeZoneNotFoundException__Class *klass;
    MonitorData *monitor;
    struct TimeZoneNotFoundException__Fields fields;
};

struct TimeZoneNotFoundException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct TimeZoneNotFoundException__StaticFields {
};

struct TimeZoneNotFoundException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TimeZoneNotFoundException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TimeZoneNotFoundException__VTable vtable;
};

struct Func_2_System_Reflection_AssemblyName_System_Reflection_Assembly___Fields {
    struct MulticastDelegate__Fields _;
};

struct Func_2_System_Reflection_AssemblyName_System_Reflection_Assembly_ {
    struct Func_2_System_Reflection_AssemblyName_System_Reflection_Assembly___Class *klass;
    MonitorData *monitor;
    struct Func_2_System_Reflection_AssemblyName_System_Reflection_Assembly___Fields fields;
};

struct Func_4_System_Reflection_Assembly_String_Boolean_Type___Fields {
    struct MulticastDelegate__Fields _;
};

struct Func_4_System_Reflection_Assembly_String_Boolean_Type_ {
    struct Func_4_System_Reflection_Assembly_String_Boolean_Type___Class *klass;
    MonitorData *monitor;
    struct Func_4_System_Reflection_Assembly_String_Boolean_Type___Fields fields;
};

struct Func_2_System_Reflection_AssemblyName_System_Reflection_Assembly___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Func_2_System_Reflection_AssemblyName_System_Reflection_Assembly___StaticFields {
};

struct Func_2_System_Reflection_AssemblyName_System_Reflection_Assembly___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Func_2_System_Reflection_AssemblyName_System_Reflection_Assembly___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Func_2_System_Reflection_AssemblyName_System_Reflection_Assembly___VTable vtable;
};

struct Func_4_System_Reflection_Assembly_String_Boolean_Type___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Func_4_System_Reflection_Assembly_String_Boolean_Type___StaticFields {
};

struct Func_4_System_Reflection_Assembly_String_Boolean_Type___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Func_4_System_Reflection_Assembly_String_Boolean_Type___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Func_4_System_Reflection_Assembly_String_Boolean_Type___VTable vtable;
};

struct Array___VTable {
};

struct Array___StaticFields {
};

struct Array___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Array___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Array___VTable vtable;
};

struct TypeAccessException__Fields {
    struct TypeLoadException__Fields _;
};

struct TypeAccessException {
    struct TypeAccessException__Class *klass;
    MonitorData *monitor;
    struct TypeAccessException__Fields fields;
};

struct TypeAccessException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct TypeAccessException__StaticFields {
};

struct TypeAccessException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeAccessException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeAccessException__VTable vtable;
};

struct TypeInitializationException__Fields {
    struct SystemException__Fields _;
    struct String *_typeName;
};

struct TypeInitializationException {
    struct TypeInitializationException__Class *klass;
    MonitorData *monitor;
    struct TypeInitializationException__Fields fields;
};

struct TypeInitializationException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct TypeInitializationException__StaticFields {
};

struct TypeInitializationException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeInitializationException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeInitializationException__VTable vtable;
};

struct TypeUnloadedException__Fields {
    struct SystemException__Fields _;
};

struct TypeUnloadedException {
    struct TypeUnloadedException__Class *klass;
    MonitorData *monitor;
    struct TypeUnloadedException__Fields fields;
};

struct TypeUnloadedException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct TypeUnloadedException__StaticFields {
};

struct TypeUnloadedException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeUnloadedException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeUnloadedException__VTable vtable;
};

struct UInt16___VTable {
};

struct UInt16___StaticFields {
};

struct UInt16___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UInt16___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UInt16___VTable vtable;
};

struct UnauthorizedAccessException__Fields {
    struct SystemException__Fields _;
};

struct UnauthorizedAccessException {
    struct UnauthorizedAccessException__Class *klass;
    MonitorData *monitor;
    struct UnauthorizedAccessException__Fields fields;
};

struct UnauthorizedAccessException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct UnauthorizedAccessException__StaticFields {
};

struct UnauthorizedAccessException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UnauthorizedAccessException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UnauthorizedAccessException__VTable vtable;
};

struct Missing {
    struct Missing__Class *klass;
    MonitorData *monitor;
};

struct Missing__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
};

struct Missing__StaticFields {
    struct Missing *Value;
};

struct Missing__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Missing__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Missing__VTable vtable;
};

struct __declspec(align(8)) UnitySerializationHolder__Fields {
    struct Type__Array *m_instantiation;
    struct Int32__Array *m_elementTypes;
    int32_t m_genericParameterPosition;
    struct Type *m_declaringType;
    struct MethodBase *m_declaringMethod;
    struct String *m_data;
    struct String *m_assemblyName;
    int32_t m_unityType;
};

struct UnitySerializationHolder {
    struct UnitySerializationHolder__Class *klass;
    MonitorData *monitor;
    struct UnitySerializationHolder__Fields fields;
};

struct UnitySerializationHolder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData GetRealObject;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetRealObject_1;
};

struct UnitySerializationHolder__StaticFields {
};

struct UnitySerializationHolder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UnitySerializationHolder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UnitySerializationHolder__VTable vtable;
};

struct UnSafeCharBuffer {
    uint16_t *m_buffer;
    int32_t m_totalSize;
    int32_t m_length;
};

struct UnSafeCharBuffer__Boxed {
    struct UnSafeCharBuffer__Class *klass;
    MonitorData *monitor;
    struct UnSafeCharBuffer fields;
};

struct UnSafeCharBuffer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct UnSafeCharBuffer__StaticFields {
};

struct UnSafeCharBuffer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UnSafeCharBuffer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UnSafeCharBuffer__VTable vtable;
};

struct Version___VTable {
};

struct Version___StaticFields {
};

struct Version___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Version___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Version___VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum Version_ParseFailureKind__Enum : int32_t {
    Version_ParseFailureKind__Enum_ArgumentNullException = 0x00000000,
    Version_ParseFailureKind__Enum_ArgumentException = 0x00000001,
    Version_ParseFailureKind__Enum_ArgumentOutOfRangeException = 0x00000002,
    Version_ParseFailureKind__Enum_FormatException = 0x00000003,
};

#else
enum Version_ParseFailureKind__Enum {
    Version_ParseFailureKind__Enum_ArgumentNullException = 0x00000000,
    Version_ParseFailureKind__Enum_ArgumentException = 0x00000001,
    Version_ParseFailureKind__Enum_ArgumentOutOfRangeException = 0x00000002,
    Version_ParseFailureKind__Enum_FormatException = 0x00000003,
};

#endif
struct Version_ParseFailureKind__Enum__Boxed {
    struct Version_ParseFailureKind__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum Version_ParseFailureKind__Enum value;
    #else
    uint32_t value;
    #endif
};

struct Version_VersionResult {
    struct Version *m_parsedVersion;
    #if defined(_CPLUSPLUS_)
    enum Version_ParseFailureKind__Enum m_failure;
    #else
    uint32_t m_failure;
    #endif
    struct String *m_exceptionArgument;
    struct String *m_argumentName;
    bool m_canThrow;
};

struct Version_VersionResult__Boxed {
    struct Version_VersionResult__Class *klass;
    MonitorData *monitor;
    struct Version_VersionResult fields;
};

struct Version_ParseFailureKind__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct Version_ParseFailureKind__Enum__StaticFields {
};

struct Version_ParseFailureKind__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Version_ParseFailureKind__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Version_ParseFailureKind__Enum__VTable vtable;
};

struct Version_VersionResult__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Version_VersionResult__StaticFields {
};

struct Version_VersionResult__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Version_VersionResult__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Version_VersionResult__VTable vtable;
};

struct Version_VersionResult___VTable {
};

struct Version_VersionResult___StaticFields {
};

struct Version_VersionResult___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Version_VersionResult___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Version_VersionResult___VTable vtable;
};

struct __declspec(align(8)) AppDomainSetup__Fields {
    struct String *application_base;
    struct String *application_name;
    struct String *cache_path;
    struct String *configuration_file;
    struct String *dynamic_base;
    struct String *license_file;
    struct String *private_bin_path;
    struct String *private_bin_path_probe;
    struct String *shadow_copy_directories;
    struct String *shadow_copy_files;
    bool publisher_policy;
    bool path_changed;
    int32_t loader_optimization;
    bool disallow_binding_redirects;
    bool disallow_code_downloads;
    struct Object *_activationArguments;
    struct Object *domain_initializer;
    struct Object *application_trust;
    struct String__Array *domain_initializer_args;
    bool disallow_appbase_probe;
    struct Byte__Array *configuration_bytes;
    struct Byte__Array *serialized_non_primitives;
    struct String *_TargetFrameworkName_k__BackingField;
};

struct AppDomainSetup {
    struct AppDomainSetup__Class *klass;
    MonitorData *monitor;
    struct AppDomainSetup__Fields fields;
};

struct AppDomainSetup__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_ApplicationBase;
    VirtualInvokeData set_ApplicationBase;
    VirtualInvokeData get_ApplicationName;
    VirtualInvokeData set_ApplicationName;
    VirtualInvokeData get_CachePath;
    VirtualInvokeData set_CachePath;
    VirtualInvokeData get_ConfigurationFile;
    VirtualInvokeData set_ConfigurationFile;
    VirtualInvokeData get_DynamicBase;
    VirtualInvokeData set_DynamicBase;
    VirtualInvokeData get_LicenseFile;
    VirtualInvokeData set_LicenseFile;
    VirtualInvokeData get_PrivateBinPath;
    VirtualInvokeData set_PrivateBinPath;
    VirtualInvokeData get_PrivateBinPathProbe;
    VirtualInvokeData set_PrivateBinPathProbe;
    VirtualInvokeData get_ShadowCopyDirectories;
    VirtualInvokeData set_ShadowCopyDirectories;
    VirtualInvokeData get_ShadowCopyFiles;
    VirtualInvokeData set_ShadowCopyFiles;
};

struct AppDomainSetup__StaticFields {
};

struct AppDomainSetup__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AppDomainSetup__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AppDomainSetup__VTable vtable;
};

struct __declspec(align(8)) Context__Fields {
    int32_t domain_id;
    int32_t context_id;
    void *static_data;
    void *data;
    struct IMessageSink *server_context_sink_chain;
    struct IMessageSink *client_context_sink_chain;
    struct List_1_System_Runtime_Remoting_Contexts_IContextProperty_ *context_properties;
    struct LocalDataStoreHolder *_localDataStore;
    struct DynamicPropertyCollection *context_dynamic_properties;
    struct ContextCallbackObject *callback_object;
};

struct Context {
    struct Context__Class *klass;
    MonitorData *monitor;
    struct Context__Fields fields;
};

struct IMessageSink {
    struct IMessageSink__Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) List_1_System_Runtime_Remoting_Contexts_IContextProperty___Fields {
    struct IContextProperty__Array *_items;
    int32_t _size;
    int32_t _version;
    struct Object *_syncRoot;
};

struct List_1_System_Runtime_Remoting_Contexts_IContextProperty_ {
    struct List_1_System_Runtime_Remoting_Contexts_IContextProperty___Class *klass;
    MonitorData *monitor;
    struct List_1_System_Runtime_Remoting_Contexts_IContextProperty___Fields fields;
};

struct IContextProperty {
    struct IContextProperty__Class *klass;
    MonitorData *monitor;
};

struct IContextProperty__Array {
    struct IContextProperty__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct IContextProperty *vector[32];
};

struct IEnumerator_1_System_Runtime_Remoting_Contexts_IContextProperty_ {
    struct IEnumerator_1_System_Runtime_Remoting_Contexts_IContextProperty___Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) DynamicPropertyCollection__Fields {
    struct ArrayList *_properties;
};

struct DynamicPropertyCollection {
    struct DynamicPropertyCollection__Class *klass;
    MonitorData *monitor;
    struct DynamicPropertyCollection__Fields fields;
};

struct ContextCallbackObject__Fields {
    struct ContextBoundObject__Fields _;
};

struct ContextCallbackObject {
    struct ContextCallbackObject__Class *klass;
    MonitorData *monitor;
    struct ContextCallbackObject__Fields fields;
};

struct IMessageSink__VTable {
    VirtualInvokeData SyncProcessMessage;
    VirtualInvokeData AsyncProcessMessage;
    VirtualInvokeData get_NextSink;
};

struct IMessageSink__StaticFields {
};

struct IMessageSink__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IMessageSink__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IMessageSink__VTable vtable;
};

struct IContextProperty__VTable {
    VirtualInvokeData get_Name;
    VirtualInvokeData Freeze;
    VirtualInvokeData IsNewContextOK;
};

struct IContextProperty__StaticFields {
};

struct IContextProperty__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IContextProperty__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IContextProperty__VTable vtable;
};

struct IContextProperty__Array__VTable {
};

struct IContextProperty__Array__StaticFields {
};

struct IContextProperty__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IContextProperty__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IContextProperty__Array__VTable vtable;
};

struct IEnumerator_1_System_Runtime_Remoting_Contexts_IContextProperty___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_System_Runtime_Remoting_Contexts_IContextProperty___StaticFields {
};

struct IEnumerator_1_System_Runtime_Remoting_Contexts_IContextProperty___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_System_Runtime_Remoting_Contexts_IContextProperty___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_System_Runtime_Remoting_Contexts_IContextProperty___VTable vtable;
};

struct List_1_System_Runtime_Remoting_Contexts_IContextProperty___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData RemoveAt;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_T__get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_T__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IList_get_Item;
    VirtualInvokeData System_Collections_IList_set_Item;
    VirtualInvokeData System_Collections_IList_Add;
    VirtualInvokeData System_Collections_IList_Contains;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IList_get_IsReadOnly;
    VirtualInvokeData System_Collections_IList_get_IsFixedSize;
    VirtualInvokeData System_Collections_IList_IndexOf;
    VirtualInvokeData System_Collections_IList_Insert;
    VirtualInvokeData System_Collections_IList_Remove;
    VirtualInvokeData RemoveAt_1;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData get_Count_2;
};

struct List_1_System_Runtime_Remoting_Contexts_IContextProperty___StaticFields {
    struct IContextProperty__Array *_emptyArray;
};

struct List_1_System_Runtime_Remoting_Contexts_IContextProperty___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct List_1_System_Runtime_Remoting_Contexts_IContextProperty___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct List_1_System_Runtime_Remoting_Contexts_IContextProperty___VTable vtable;
};

struct DynamicPropertyCollection__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct DynamicPropertyCollection__StaticFields {
};

struct DynamicPropertyCollection__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DynamicPropertyCollection__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DynamicPropertyCollection__VTable vtable;
};

struct ContextCallbackObject__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
};

struct ContextCallbackObject__StaticFields {
};

struct ContextCallbackObject__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ContextCallbackObject__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ContextCallbackObject__VTable vtable;
};

struct Context__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_ContextID;
    VirtualInvokeData get_ContextProperties;
    VirtualInvokeData GetProperty;
    VirtualInvokeData SetProperty;
    VirtualInvokeData Freeze;
};

struct Context__StaticFields {
    struct Object__Array *local_slots;
    struct IMessageSink *default_server_context_sink;
    int32_t global_count;
    struct LocalDataStoreMgr *_localDataStoreMgr;
    struct DynamicPropertyCollection *global_dynamic_properties;
};

struct Context__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Context__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Context__VTable vtable;
};

struct __declspec(align(8)) CADMessageBase__Fields {
    struct Object__Array *_args;
    struct Byte__Array *_serializedArgs;
    int32_t _propertyCount;
    struct CADArgHolder *_callContext;
    struct Byte__Array *serializedMethod;
};

struct CADMessageBase {
    struct CADMessageBase__Class *klass;
    MonitorData *monitor;
    struct CADMessageBase__Fields fields;
};

struct CADMethodCallMessage__Fields {
    struct CADMessageBase__Fields _;
    struct String *_uri;
};

struct CADMethodCallMessage {
    struct CADMethodCallMessage__Class *klass;
    MonitorData *monitor;
    struct CADMethodCallMessage__Fields fields;
};

struct __declspec(align(8)) CADArgHolder__Fields {
    int32_t index;
};

struct CADArgHolder {
    struct CADArgHolder__Class *klass;
    MonitorData *monitor;
    struct CADArgHolder__Fields fields;
};

struct CADMethodReturnMessage__Fields {
    struct CADMessageBase__Fields _;
    struct Object *_returnValue;
    struct CADArgHolder *_exception;
    struct Type__Array *_sig;
};

struct CADMethodReturnMessage {
    struct CADMethodReturnMessage__Class *klass;
    MonitorData *monitor;
    struct CADMethodReturnMessage__Fields fields;
};

struct CADArgHolder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct CADArgHolder__StaticFields {
};

struct CADArgHolder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CADArgHolder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CADArgHolder__VTable vtable;
};

struct CADMessageBase__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct CADMessageBase__StaticFields {
};

struct CADMessageBase__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CADMessageBase__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CADMessageBase__VTable vtable;
};

struct CADMethodCallMessage__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct CADMethodCallMessage__StaticFields {
};

struct CADMethodCallMessage__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CADMethodCallMessage__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CADMethodCallMessage__VTable vtable;
};

struct CADMethodReturnMessage__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct CADMethodReturnMessage__StaticFields {
};

struct CADMethodReturnMessage__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CADMethodReturnMessage__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CADMethodReturnMessage__VTable vtable;
};

struct CADMethodReturnMessage___VTable {
};

struct CADMethodReturnMessage___StaticFields {
};

struct CADMethodReturnMessage___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CADMethodReturnMessage___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CADMethodReturnMessage___VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum AppDomainManagerInitializationOptions__Enum : int32_t {
    AppDomainManagerInitializationOptions__Enum_None = 0x00000000,
    AppDomainManagerInitializationOptions__Enum_RegisterWithHost = 0x00000001,
};

#else
enum AppDomainManagerInitializationOptions__Enum {
    AppDomainManagerInitializationOptions__Enum_None = 0x00000000,
    AppDomainManagerInitializationOptions__Enum_RegisterWithHost = 0x00000001,
};

#endif
struct AppDomainManagerInitializationOptions__Enum__Boxed {
    struct AppDomainManagerInitializationOptions__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum AppDomainManagerInitializationOptions__Enum value;
    #else
    uint32_t value;
    #endif
};

struct AppDomainManager__Fields {
    struct MarshalByRefObject__Fields _;
    struct ApplicationActivator *_activator;
    #if defined(_CPLUSPLUS_)
    enum AppDomainManagerInitializationOptions__Enum _flags;
    #else
    uint32_t _flags;
    #endif
};

struct AppDomainManager {
    struct AppDomainManager__Class *klass;
    MonitorData *monitor;
    struct AppDomainManager__Fields fields;
};

struct ApplicationActivator {
    struct ApplicationActivator__Class *klass;
    MonitorData *monitor;
};

struct HostExecutionContextManager {
    struct HostExecutionContextManager__Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) HostExecutionContext__Fields {
    struct Object *_state;
};

struct HostExecutionContext {
    struct HostExecutionContext__Class *klass;
    MonitorData *monitor;
    struct HostExecutionContext__Fields fields;
};

struct HostSecurityManager {
    struct HostSecurityManager__Class *klass;
    MonitorData *monitor;
};

#if defined(_CPLUSPLUS_)
enum HostSecurityManagerOptions__Enum : int32_t {
    HostSecurityManagerOptions__Enum_None = 0x00000000,
    HostSecurityManagerOptions__Enum_HostAppDomainEvidence = 0x00000001,
    HostSecurityManagerOptions__Enum_HostPolicyLevel = 0x00000002,
    HostSecurityManagerOptions__Enum_HostAssemblyEvidence = 0x00000004,
    HostSecurityManagerOptions__Enum_HostDetermineApplicationTrust = 0x00000008,
    HostSecurityManagerOptions__Enum_HostResolvePolicy = 0x00000010,
    HostSecurityManagerOptions__Enum_AllFlags = 0x0000001f,
};

#else
enum HostSecurityManagerOptions__Enum {
    HostSecurityManagerOptions__Enum_None = 0x00000000,
    HostSecurityManagerOptions__Enum_HostAppDomainEvidence = 0x00000001,
    HostSecurityManagerOptions__Enum_HostPolicyLevel = 0x00000002,
    HostSecurityManagerOptions__Enum_HostAssemblyEvidence = 0x00000004,
    HostSecurityManagerOptions__Enum_HostDetermineApplicationTrust = 0x00000008,
    HostSecurityManagerOptions__Enum_HostResolvePolicy = 0x00000010,
    HostSecurityManagerOptions__Enum_AllFlags = 0x0000001f,
};

#endif
struct HostSecurityManagerOptions__Enum__Boxed {
    struct HostSecurityManagerOptions__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum HostSecurityManagerOptions__Enum value;
    #else
    uint32_t value;
    #endif
};

struct EvidenceBase {
    struct EvidenceBase__Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) ApplicationTrust__Fields {
    struct ApplicationIdentity *_appid;
    struct PolicyStatement *_defaultPolicy;
    struct Object *_xtranfo;
    bool _trustrun;
    bool _persist;
    struct IList_1_System_Security_Policy_StrongName_ *fullTrustAssemblies;
};

struct ApplicationTrust {
    struct ApplicationTrust__Class *klass;
    MonitorData *monitor;
    struct ApplicationTrust__Fields fields;
};

struct IList_1_System_Security_Policy_StrongName_ {
    struct IList_1_System_Security_Policy_StrongName___Class *klass;
    MonitorData *monitor;
};

#if defined(_CPLUSPLUS_)
enum TrustManagerUIContext__Enum : int32_t {
    TrustManagerUIContext__Enum_Install = 0x00000000,
    TrustManagerUIContext__Enum_Upgrade = 0x00000001,
    TrustManagerUIContext__Enum_Run = 0x00000002,
};

#else
enum TrustManagerUIContext__Enum {
    TrustManagerUIContext__Enum_Install = 0x00000000,
    TrustManagerUIContext__Enum_Upgrade = 0x00000001,
    TrustManagerUIContext__Enum_Run = 0x00000002,
};

#endif
struct TrustManagerUIContext__Enum__Boxed {
    struct TrustManagerUIContext__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum TrustManagerUIContext__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) TrustManagerContext__Fields {
    bool _ignorePersistedDecision;
    bool _noPrompt;
    bool _keepAlive;
    bool _persist;
    struct ApplicationIdentity *_previousId;
    #if defined(_CPLUSPLUS_)
    enum TrustManagerUIContext__Enum _ui;
    #else
    uint32_t _ui;
    #endif
};

struct TrustManagerContext {
    struct TrustManagerContext__Class *klass;
    MonitorData *monitor;
    struct TrustManagerContext__Fields fields;
};

struct SecurityState {
    struct SecurityState__Class *klass;
    MonitorData *monitor;
};

struct IsolatedStorageSecurityState {
    struct IsolatedStorageSecurityState__Class *klass;
    MonitorData *monitor;
};

struct ApplicationActivator__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateInstance;
    VirtualInvokeData CreateInstance_1;
};

struct ApplicationActivator__StaticFields {
};

struct ApplicationActivator__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ApplicationActivator__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ApplicationActivator__VTable vtable;
};

struct AppDomainManagerInitializationOptions__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct AppDomainManagerInitializationOptions__Enum__StaticFields {
};

struct AppDomainManagerInitializationOptions__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AppDomainManagerInitializationOptions__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AppDomainManagerInitializationOptions__Enum__VTable vtable;
};

struct HostExecutionContext__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData CreateCopy;
    VirtualInvokeData Dispose_1;
};

struct HostExecutionContext__StaticFields {
};

struct HostExecutionContext__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct HostExecutionContext__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct HostExecutionContext__VTable vtable;
};

struct HostExecutionContextManager__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Capture;
    VirtualInvokeData Revert;
    VirtualInvokeData SetHostExecutionContext;
};

struct HostExecutionContextManager__StaticFields {
};

struct HostExecutionContextManager__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct HostExecutionContextManager__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct HostExecutionContextManager__VTable vtable;
};

struct HostSecurityManagerOptions__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct HostSecurityManagerOptions__Enum__StaticFields {
};

struct HostSecurityManagerOptions__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct HostSecurityManagerOptions__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct HostSecurityManagerOptions__Enum__VTable vtable;
};

struct EvidenceBase__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
};

struct EvidenceBase__StaticFields {
};

struct EvidenceBase__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EvidenceBase__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EvidenceBase__VTable vtable;
};

struct IList_1_System_Security_Policy_StrongName___VTable {
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData RemoveAt;
};

struct IList_1_System_Security_Policy_StrongName___StaticFields {
};

struct IList_1_System_Security_Policy_StrongName___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IList_1_System_Security_Policy_StrongName___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IList_1_System_Security_Policy_StrongName___VTable vtable;
};

struct ApplicationTrust__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData FromXml;
    VirtualInvokeData ToXml;
};

struct ApplicationTrust__StaticFields {
};

struct ApplicationTrust__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ApplicationTrust__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ApplicationTrust__VTable vtable;
};

struct TrustManagerUIContext__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct TrustManagerUIContext__Enum__StaticFields {
};

struct TrustManagerUIContext__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TrustManagerUIContext__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TrustManagerUIContext__Enum__VTable vtable;
};

struct TrustManagerContext__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_IgnorePersistedDecision;
    VirtualInvokeData set_IgnorePersistedDecision;
    VirtualInvokeData get_KeepAlive;
    VirtualInvokeData set_KeepAlive;
    VirtualInvokeData get_NoPrompt;
    VirtualInvokeData set_NoPrompt;
    VirtualInvokeData get_Persist;
    VirtualInvokeData set_Persist;
    VirtualInvokeData get_PreviousApplicationIdentity;
    VirtualInvokeData set_PreviousApplicationIdentity;
    VirtualInvokeData get_UIContext;
    VirtualInvokeData set_UIContext;
};

struct TrustManagerContext__StaticFields {
};

struct TrustManagerContext__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TrustManagerContext__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TrustManagerContext__VTable vtable;
};

struct HostSecurityManager__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_DomainPolicy;
    VirtualInvokeData get_Flags;
    VirtualInvokeData DetermineApplicationTrust;
    VirtualInvokeData ProvideAppDomainEvidence;
    VirtualInvokeData ProvideAssemblyEvidence;
    VirtualInvokeData ResolvePolicy;
    VirtualInvokeData GenerateAppDomainEvidence;
    VirtualInvokeData GenerateAssemblyEvidence;
    VirtualInvokeData GetHostSuppliedAppDomainEvidenceTypes;
    VirtualInvokeData GetHostSuppliedAssemblyEvidenceTypes;
};

struct HostSecurityManager__StaticFields {
};

struct HostSecurityManager__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct HostSecurityManager__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct HostSecurityManager__VTable vtable;
};

struct IsolatedStorageSecurityState__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData EnsureState;
};

struct IsolatedStorageSecurityState__StaticFields {
};

struct IsolatedStorageSecurityState__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IsolatedStorageSecurityState__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IsolatedStorageSecurityState__VTable vtable;
};

struct SecurityState__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData __unknown;
};

struct SecurityState__StaticFields {
};

struct SecurityState__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SecurityState__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SecurityState__VTable vtable;
};

struct AppDomainManager__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData get_ApplicationActivator;
    VirtualInvokeData get_EntryAssembly;
    VirtualInvokeData get_HostExecutionContextManager;
    VirtualInvokeData get_HostSecurityManager;
    VirtualInvokeData CreateDomain;
    VirtualInvokeData InitializeNewDomain;
    VirtualInvokeData CheckSecuritySettings;
};

struct AppDomainManager__StaticFields {
};

struct AppDomainManager__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AppDomainManager__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AppDomainManager__VTable vtable;
};

struct AppDomainInitializer__Fields {
    struct MulticastDelegate__Fields _;
};

struct AppDomainInitializer {
    struct AppDomainInitializer__Class *klass;
    MonitorData *monitor;
    struct AppDomainInitializer__Fields fields;
};

struct AppDomainInitializer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct AppDomainInitializer__StaticFields {
};

struct AppDomainInitializer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AppDomainInitializer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AppDomainInitializer__VTable vtable;
};

struct __declspec(align(8)) StrongName_1__Fields {
    struct StrongNamePublicKeyBlob *publickey;
    struct String *name;
    struct Version *version;
};

struct StrongName_1 {
    struct StrongName_1__Class *klass;
    MonitorData *monitor;
    struct StrongName_1__Fields fields;
};

struct __declspec(align(8)) StrongNamePublicKeyBlob__Fields {
    struct Byte__Array *pubkey;
};

struct StrongNamePublicKeyBlob {
    struct StrongNamePublicKeyBlob__Class *klass;
    MonitorData *monitor;
    struct StrongNamePublicKeyBlob__Fields fields;
};

struct StrongName_1__Array {
    struct StrongName_1__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct StrongName_1 *vector[32];
};

struct StrongNamePublicKeyBlob__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct StrongNamePublicKeyBlob__StaticFields {
};

struct StrongNamePublicKeyBlob__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StrongNamePublicKeyBlob__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StrongNamePublicKeyBlob__VTable vtable;
};

struct StrongName_1__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData CreateIdentityPermission;
    VirtualInvokeData System_Security_Policy_IBuiltInEvidence_GetRequiredSize;
    VirtualInvokeData System_Security_Policy_IBuiltInEvidence_InitFromBuffer;
    VirtualInvokeData System_Security_Policy_IBuiltInEvidence_OutputToBuffer;
};

struct StrongName_1__StaticFields {
};

struct StrongName_1__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StrongName_1__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StrongName_1__VTable vtable;
};

struct StrongName_1__Array__VTable {
};

struct StrongName_1__Array__StaticFields {
};

struct StrongName_1__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StrongName_1__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StrongName_1__Array__VTable vtable;
};

struct IEnumerable_1_System_Reflection_Emit_CustomAttributeBuilder_ {
    struct IEnumerable_1_System_Reflection_Emit_CustomAttributeBuilder___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_Reflection_Emit_CustomAttributeBuilder___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_Reflection_Emit_CustomAttributeBuilder___StaticFields {
};

struct IEnumerable_1_System_Reflection_Emit_CustomAttributeBuilder___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_Reflection_Emit_CustomAttributeBuilder___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_Reflection_Emit_CustomAttributeBuilder___VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum SecurityContextSource__Enum : int32_t {
    SecurityContextSource__Enum_CurrentAppDomain = 0x00000000,
    SecurityContextSource__Enum_CurrentAssembly = 0x00000001,
};

#else
enum SecurityContextSource__Enum {
    SecurityContextSource__Enum_CurrentAppDomain = 0x00000000,
    SecurityContextSource__Enum_CurrentAssembly = 0x00000001,
};

#endif
struct SecurityContextSource__Enum__Boxed {
    struct SecurityContextSource__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum SecurityContextSource__Enum value;
    #else
    uint32_t value;
    #endif
};

struct SecurityContextSource__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct SecurityContextSource__Enum__StaticFields {
};

struct SecurityContextSource__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SecurityContextSource__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SecurityContextSource__Enum__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum LogLevel__Enum : int32_t {
    LogLevel__Enum_Trace = 0x00000000,
    LogLevel__Enum_Status = 0x00000014,
    LogLevel__Enum_Warning = 0x00000028,
    LogLevel__Enum_Error = 0x00000032,
    LogLevel__Enum_Panic = 0x00000064,
};

#else
enum LogLevel__Enum {
    LogLevel__Enum_Trace = 0x00000000,
    LogLevel__Enum_Status = 0x00000014,
    LogLevel__Enum_Warning = 0x00000028,
    LogLevel__Enum_Error = 0x00000032,
    LogLevel__Enum_Panic = 0x00000064,
};

#endif
struct LogLevel__Enum__Boxed {
    struct LogLevel__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum LogLevel__Enum value;
    #else
    uint32_t value;
    #endif
};

struct LogLevel__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct LogLevel__Enum__StaticFields {
};

struct LogLevel__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct LogLevel__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct LogLevel__Enum__VTable vtable;
};

struct CLRConfig {
    struct CLRConfig__Class *klass;
    MonitorData *monitor;
};

struct CLRConfig__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct CLRConfig__StaticFields {
};

struct CLRConfig__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CLRConfig__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CLRConfig__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum PlatformID__Enum : int32_t {
    PlatformID__Enum_Win32S = 0x00000000,
    PlatformID__Enum_Win32Windows = 0x00000001,
    PlatformID__Enum_Win32NT = 0x00000002,
    PlatformID__Enum_WinCE = 0x00000003,
    PlatformID__Enum_Unix = 0x00000004,
    PlatformID__Enum_Xbox = 0x00000005,
    PlatformID__Enum_MacOSX = 0x00000006,
};

#else
enum PlatformID__Enum {
    PlatformID__Enum_Win32S = 0x00000000,
    PlatformID__Enum_Win32Windows = 0x00000001,
    PlatformID__Enum_Win32NT = 0x00000002,
    PlatformID__Enum_WinCE = 0x00000003,
    PlatformID__Enum_Unix = 0x00000004,
    PlatformID__Enum_Xbox = 0x00000005,
    PlatformID__Enum_MacOSX = 0x00000006,
};

#endif
struct PlatformID__Enum__Boxed {
    struct PlatformID__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum PlatformID__Enum value;
    #else
    uint32_t value;
    #endif
};

struct PlatformID__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct PlatformID__Enum__StaticFields {
};

struct PlatformID__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PlatformID__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PlatformID__Enum__VTable vtable;
};

struct __declspec(align(8)) OperatingSystem__Fields {
    #if defined(_CPLUSPLUS_)
    enum PlatformID__Enum _platform;
    #else
    uint32_t _platform;
    #endif
    struct Version *_version;
    struct String *_servicePack;
};

struct OperatingSystem {
    struct OperatingSystem__Class *klass;
    MonitorData *monitor;
    struct OperatingSystem__Fields fields;
};

struct OperatingSystem__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
};

struct OperatingSystem__StaticFields {
};

struct OperatingSystem__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct OperatingSystem__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct OperatingSystem__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum Environment_SpecialFolder__Enum : int32_t {
    Environment_SpecialFolder__Enum_MyDocuments = 0x00000005,
    Environment_SpecialFolder__Enum_Desktop = 0x00000000,
    Environment_SpecialFolder__Enum_MyComputer = 0x00000011,
    Environment_SpecialFolder__Enum_Programs = 0x00000002,
    Environment_SpecialFolder__Enum_Personal = 0x00000005,
    Environment_SpecialFolder__Enum_Favorites = 0x00000006,
    Environment_SpecialFolder__Enum_Startup = 0x00000007,
    Environment_SpecialFolder__Enum_Recent = 0x00000008,
    Environment_SpecialFolder__Enum_SendTo = 0x00000009,
    Environment_SpecialFolder__Enum_StartMenu = 0x0000000b,
    Environment_SpecialFolder__Enum_MyMusic = 0x0000000d,
    Environment_SpecialFolder__Enum_DesktopDirectory = 0x00000010,
    Environment_SpecialFolder__Enum_Templates = 0x00000015,
    Environment_SpecialFolder__Enum_ApplicationData = 0x0000001a,
    Environment_SpecialFolder__Enum_LocalApplicationData = 0x0000001c,
    Environment_SpecialFolder__Enum_InternetCache = 0x00000020,
    Environment_SpecialFolder__Enum_Cookies = 0x00000021,
    Environment_SpecialFolder__Enum_History = 0x00000022,
    Environment_SpecialFolder__Enum_CommonApplicationData = 0x00000023,
    Environment_SpecialFolder__Enum_System = 0x00000025,
    Environment_SpecialFolder__Enum_ProgramFiles = 0x00000026,
    Environment_SpecialFolder__Enum_MyPictures = 0x00000027,
    Environment_SpecialFolder__Enum_CommonProgramFiles = 0x0000002b,
    Environment_SpecialFolder__Enum_MyVideos = 0x0000000e,
    Environment_SpecialFolder__Enum_NetworkShortcuts = 0x00000013,
    Environment_SpecialFolder__Enum_Fonts = 0x00000014,
    Environment_SpecialFolder__Enum_CommonStartMenu = 0x00000016,
    Environment_SpecialFolder__Enum_CommonPrograms = 0x00000017,
    Environment_SpecialFolder__Enum_CommonStartup = 0x00000018,
    Environment_SpecialFolder__Enum_CommonDesktopDirectory = 0x00000019,
    Environment_SpecialFolder__Enum_PrinterShortcuts = 0x0000001b,
    Environment_SpecialFolder__Enum_Windows = 0x00000024,
    Environment_SpecialFolder__Enum_UserProfile = 0x00000028,
    Environment_SpecialFolder__Enum_SystemX86 = 0x00000029,
    Environment_SpecialFolder__Enum_ProgramFilesX86 = 0x0000002a,
    Environment_SpecialFolder__Enum_CommonProgramFilesX86 = 0x0000002c,
    Environment_SpecialFolder__Enum_CommonTemplates = 0x0000002d,
    Environment_SpecialFolder__Enum_CommonDocuments = 0x0000002e,
    Environment_SpecialFolder__Enum_CommonAdminTools = 0x0000002f,
    Environment_SpecialFolder__Enum_AdminTools = 0x00000030,
    Environment_SpecialFolder__Enum_CommonMusic = 0x00000035,
    Environment_SpecialFolder__Enum_CommonPictures = 0x00000036,
    Environment_SpecialFolder__Enum_CommonVideos = 0x00000037,
    Environment_SpecialFolder__Enum_Resources = 0x00000038,
    Environment_SpecialFolder__Enum_LocalizedResources = 0x00000039,
    Environment_SpecialFolder__Enum_CommonOemLinks = 0x0000003a,
    Environment_SpecialFolder__Enum_CDBurning = 0x0000003b,
};

#else
enum Environment_SpecialFolder__Enum {
    Environment_SpecialFolder__Enum_MyDocuments = 0x00000005,
    Environment_SpecialFolder__Enum_Desktop = 0x00000000,
    Environment_SpecialFolder__Enum_MyComputer = 0x00000011,
    Environment_SpecialFolder__Enum_Programs = 0x00000002,
    Environment_SpecialFolder__Enum_Personal = 0x00000005,
    Environment_SpecialFolder__Enum_Favorites = 0x00000006,
    Environment_SpecialFolder__Enum_Startup = 0x00000007,
    Environment_SpecialFolder__Enum_Recent = 0x00000008,
    Environment_SpecialFolder__Enum_SendTo = 0x00000009,
    Environment_SpecialFolder__Enum_StartMenu = 0x0000000b,
    Environment_SpecialFolder__Enum_MyMusic = 0x0000000d,
    Environment_SpecialFolder__Enum_DesktopDirectory = 0x00000010,
    Environment_SpecialFolder__Enum_Templates = 0x00000015,
    Environment_SpecialFolder__Enum_ApplicationData = 0x0000001a,
    Environment_SpecialFolder__Enum_LocalApplicationData = 0x0000001c,
    Environment_SpecialFolder__Enum_InternetCache = 0x00000020,
    Environment_SpecialFolder__Enum_Cookies = 0x00000021,
    Environment_SpecialFolder__Enum_History = 0x00000022,
    Environment_SpecialFolder__Enum_CommonApplicationData = 0x00000023,
    Environment_SpecialFolder__Enum_System = 0x00000025,
    Environment_SpecialFolder__Enum_ProgramFiles = 0x00000026,
    Environment_SpecialFolder__Enum_MyPictures = 0x00000027,
    Environment_SpecialFolder__Enum_CommonProgramFiles = 0x0000002b,
    Environment_SpecialFolder__Enum_MyVideos = 0x0000000e,
    Environment_SpecialFolder__Enum_NetworkShortcuts = 0x00000013,
    Environment_SpecialFolder__Enum_Fonts = 0x00000014,
    Environment_SpecialFolder__Enum_CommonStartMenu = 0x00000016,
    Environment_SpecialFolder__Enum_CommonPrograms = 0x00000017,
    Environment_SpecialFolder__Enum_CommonStartup = 0x00000018,
    Environment_SpecialFolder__Enum_CommonDesktopDirectory = 0x00000019,
    Environment_SpecialFolder__Enum_PrinterShortcuts = 0x0000001b,
    Environment_SpecialFolder__Enum_Windows = 0x00000024,
    Environment_SpecialFolder__Enum_UserProfile = 0x00000028,
    Environment_SpecialFolder__Enum_SystemX86 = 0x00000029,
    Environment_SpecialFolder__Enum_ProgramFilesX86 = 0x0000002a,
    Environment_SpecialFolder__Enum_CommonProgramFilesX86 = 0x0000002c,
    Environment_SpecialFolder__Enum_CommonTemplates = 0x0000002d,
    Environment_SpecialFolder__Enum_CommonDocuments = 0x0000002e,
    Environment_SpecialFolder__Enum_CommonAdminTools = 0x0000002f,
    Environment_SpecialFolder__Enum_AdminTools = 0x00000030,
    Environment_SpecialFolder__Enum_CommonMusic = 0x00000035,
    Environment_SpecialFolder__Enum_CommonPictures = 0x00000036,
    Environment_SpecialFolder__Enum_CommonVideos = 0x00000037,
    Environment_SpecialFolder__Enum_Resources = 0x00000038,
    Environment_SpecialFolder__Enum_LocalizedResources = 0x00000039,
    Environment_SpecialFolder__Enum_CommonOemLinks = 0x0000003a,
    Environment_SpecialFolder__Enum_CDBurning = 0x0000003b,
};

#endif
struct Environment_SpecialFolder__Enum__Boxed {
    struct Environment_SpecialFolder__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum Environment_SpecialFolder__Enum value;
    #else
    uint32_t value;
    #endif
};

struct Environment_SpecialFolder__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct Environment_SpecialFolder__Enum__StaticFields {
};

struct Environment_SpecialFolder__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Environment_SpecialFolder__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Environment_SpecialFolder__Enum__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum Environment_SpecialFolderOption__Enum : int32_t {
    Environment_SpecialFolderOption__Enum_None = 0x00000000,
    Environment_SpecialFolderOption__Enum_DoNotVerify = 0x00004000,
    Environment_SpecialFolderOption__Enum_Create = 0x00008000,
};

#else
enum Environment_SpecialFolderOption__Enum {
    Environment_SpecialFolderOption__Enum_None = 0x00000000,
    Environment_SpecialFolderOption__Enum_DoNotVerify = 0x00004000,
    Environment_SpecialFolderOption__Enum_Create = 0x00008000,
};

#endif
struct Environment_SpecialFolderOption__Enum__Boxed {
    struct Environment_SpecialFolderOption__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum Environment_SpecialFolderOption__Enum value;
    #else
    uint32_t value;
    #endif
};

struct Environment_SpecialFolderOption__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct Environment_SpecialFolderOption__Enum__StaticFields {
};

struct Environment_SpecialFolderOption__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Environment_SpecialFolderOption__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Environment_SpecialFolderOption__Enum__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum EnvironmentVariableTarget__Enum : int32_t {
    EnvironmentVariableTarget__Enum_Process = 0x00000000,
    EnvironmentVariableTarget__Enum_User = 0x00000001,
    EnvironmentVariableTarget__Enum_Machine = 0x00000002,
};

#else
enum EnvironmentVariableTarget__Enum {
    EnvironmentVariableTarget__Enum_Process = 0x00000000,
    EnvironmentVariableTarget__Enum_User = 0x00000001,
    EnvironmentVariableTarget__Enum_Machine = 0x00000002,
};

#endif
struct EnvironmentVariableTarget__Enum__Boxed {
    struct EnvironmentVariableTarget__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum EnvironmentVariableTarget__Enum value;
    #else
    uint32_t value;
    #endif
};

struct EnvironmentVariableTarget__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct EnvironmentVariableTarget__Enum__StaticFields {
};

struct EnvironmentVariableTarget__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EnvironmentVariableTarget__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EnvironmentVariableTarget__Enum__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum ContractFailureKind__Enum : int32_t {
    ContractFailureKind__Enum_Precondition = 0x00000000,
    ContractFailureKind__Enum_Postcondition = 0x00000001,
    ContractFailureKind__Enum_PostconditionOnException = 0x00000002,
    ContractFailureKind__Enum_Invariant = 0x00000003,
    ContractFailureKind__Enum_Assert = 0x00000004,
    ContractFailureKind__Enum_Assume = 0x00000005,
};

#else
enum ContractFailureKind__Enum {
    ContractFailureKind__Enum_Precondition = 0x00000000,
    ContractFailureKind__Enum_Postcondition = 0x00000001,
    ContractFailureKind__Enum_PostconditionOnException = 0x00000002,
    ContractFailureKind__Enum_Invariant = 0x00000003,
    ContractFailureKind__Enum_Assert = 0x00000004,
    ContractFailureKind__Enum_Assume = 0x00000005,
};

#endif
struct ContractFailureKind__Enum__Boxed {
    struct ContractFailureKind__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum ContractFailureKind__Enum value;
    #else
    uint32_t value;
    #endif
};

struct ContractFailureKind__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct ContractFailureKind__Enum__StaticFields {
};

struct ContractFailureKind__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ContractFailureKind__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ContractFailureKind__Enum__VTable vtable;
};

struct RuntimeMethodHandleInternal {
    void *m_handle;
};

struct RuntimeMethodHandleInternal__Boxed {
    struct RuntimeMethodHandleInternal__Class *klass;
    MonitorData *monitor;
    struct RuntimeMethodHandleInternal fields;
};

struct RuntimeMethodHandleInternal__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct RuntimeMethodHandleInternal__StaticFields {
};

struct RuntimeMethodHandleInternal__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeMethodHandleInternal__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeMethodHandleInternal__VTable vtable;
};

struct TypeNameParser {
    struct TypeNameParser__Class *klass;
    MonitorData *monitor;
};

struct TypeNameParser__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct TypeNameParser__StaticFields {
};

struct TypeNameParser__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeNameParser__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeNameParser__VTable vtable;
};

struct __declspec(align(8)) ActivationArguments__Fields {
    struct ActivationContext *_context;
    struct ApplicationIdentity *_identity;
    struct String__Array *_data;
};

struct ActivationArguments {
    struct ActivationArguments__Class *klass;
    MonitorData *monitor;
    struct ActivationArguments__Fields fields;
};

struct ActivationArguments__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
};

struct ActivationArguments__StaticFields {
};

struct ActivationArguments__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ActivationArguments__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ActivationArguments__VTable vtable;
};

struct ArgIterator {
    void *sig;
    void *args;
    int32_t next_arg;
    int32_t num_args;
};

struct ArgIterator__Boxed {
    struct ArgIterator__Class *klass;
    MonitorData *monitor;
    struct ArgIterator fields;
};

struct ArgIterator__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ArgIterator__StaticFields {
};

struct ArgIterator__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ArgIterator__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ArgIterator__VTable vtable;
};

struct RuntimeArgumentHandle {
    void *args;
};

struct RuntimeArgumentHandle__Boxed {
    struct RuntimeArgumentHandle__Class *klass;
    MonitorData *monitor;
    struct RuntimeArgumentHandle fields;
};

struct RuntimeArgumentHandle__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct RuntimeArgumentHandle__StaticFields {
};

struct RuntimeArgumentHandle__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeArgumentHandle__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeArgumentHandle__VTable vtable;
};

struct TextWriter__Fields {
    struct MarshalByRefObject__Fields _;
    struct Char__Array *CoreNewLine;
    struct IFormatProvider *InternalFormatProvider;
};

struct TextWriter {
    struct TextWriter__Class *klass;
    MonitorData *monitor;
    struct TextWriter__Fields fields;
};

struct StreamWriter__Fields {
    struct TextWriter__Fields _;
    struct Stream *stream;
    struct Encoding *encoding;
    struct Encoder *encoder;
    struct Byte__Array *byteBuffer;
    struct Char__Array *charBuffer;
    int32_t charPos;
    int32_t charLen;
    bool autoFlush;
    bool haveWrittenPreamble;
    bool closable;
    struct Task *_asyncWriteTask;
};

struct StreamWriter {
    struct StreamWriter__Class *klass;
    MonitorData *monitor;
    struct StreamWriter__Fields fields;
};

struct StreamWriter__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_FormatProvider;
    VirtualInvokeData Close;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData Flush;
    VirtualInvokeData get_Encoding;
    VirtualInvokeData get_NewLine;
    VirtualInvokeData set_NewLine;
    VirtualInvokeData Write;
    VirtualInvokeData Write_1;
    VirtualInvokeData Write_2;
    VirtualInvokeData Write_3;
    VirtualInvokeData Write_4;
    VirtualInvokeData Write_5;
    VirtualInvokeData Write_6;
    VirtualInvokeData Write_7;
    VirtualInvokeData Write_8;
    VirtualInvokeData Write_9;
    VirtualInvokeData Write_10;
    VirtualInvokeData Write_11;
    VirtualInvokeData Write_12;
    VirtualInvokeData Write_13;
    VirtualInvokeData Write_14;
    VirtualInvokeData Write_15;
    VirtualInvokeData Write_16;
    VirtualInvokeData WriteLine;
    VirtualInvokeData WriteLine_1;
    VirtualInvokeData WriteLine_2;
    VirtualInvokeData WriteLine_3;
    VirtualInvokeData WriteLine_4;
    VirtualInvokeData WriteLine_5;
    VirtualInvokeData WriteLine_6;
    VirtualInvokeData WriteLine_7;
    VirtualInvokeData WriteLine_8;
    VirtualInvokeData WriteLine_9;
    VirtualInvokeData WriteLine_10;
    VirtualInvokeData WriteLine_11;
    VirtualInvokeData WriteLine_12;
    VirtualInvokeData WriteLine_13;
    VirtualInvokeData WriteLine_14;
    VirtualInvokeData WriteLine_15;
    VirtualInvokeData WriteLine_16;
    VirtualInvokeData WriteLine_17;
    VirtualInvokeData WriteAsync;
    VirtualInvokeData WriteAsync_1;
    VirtualInvokeData WriteAsync_2;
    VirtualInvokeData WriteLineAsync;
    VirtualInvokeData WriteLineAsync_1;
    VirtualInvokeData WriteLineAsync_2;
    VirtualInvokeData WriteLineAsync_3;
    VirtualInvokeData FlushAsync;
    VirtualInvokeData get_AutoFlush;
    VirtualInvokeData set_AutoFlush;
    VirtualInvokeData get_BaseStream;
};

struct StreamWriter__StaticFields {
    struct StreamWriter *Null;
    struct Encoding *_UTF8NoBOM;
};

struct StreamWriter__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StreamWriter__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StreamWriter__VTable vtable;
};

struct TextWriter__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_FormatProvider;
    VirtualInvokeData Close;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData Flush;
    VirtualInvokeData __unknown;
    VirtualInvokeData get_NewLine;
    VirtualInvokeData set_NewLine;
    VirtualInvokeData Write;
    VirtualInvokeData Write_1;
    VirtualInvokeData Write_2;
    VirtualInvokeData Write_3;
    VirtualInvokeData Write_4;
    VirtualInvokeData Write_5;
    VirtualInvokeData Write_6;
    VirtualInvokeData Write_7;
    VirtualInvokeData Write_8;
    VirtualInvokeData Write_9;
    VirtualInvokeData Write_10;
    VirtualInvokeData Write_11;
    VirtualInvokeData Write_12;
    VirtualInvokeData Write_13;
    VirtualInvokeData Write_14;
    VirtualInvokeData Write_15;
    VirtualInvokeData Write_16;
    VirtualInvokeData WriteLine;
    VirtualInvokeData WriteLine_1;
    VirtualInvokeData WriteLine_2;
    VirtualInvokeData WriteLine_3;
    VirtualInvokeData WriteLine_4;
    VirtualInvokeData WriteLine_5;
    VirtualInvokeData WriteLine_6;
    VirtualInvokeData WriteLine_7;
    VirtualInvokeData WriteLine_8;
    VirtualInvokeData WriteLine_9;
    VirtualInvokeData WriteLine_10;
    VirtualInvokeData WriteLine_11;
    VirtualInvokeData WriteLine_12;
    VirtualInvokeData WriteLine_13;
    VirtualInvokeData WriteLine_14;
    VirtualInvokeData WriteLine_15;
    VirtualInvokeData WriteLine_16;
    VirtualInvokeData WriteLine_17;
    VirtualInvokeData WriteAsync;
    VirtualInvokeData WriteAsync_1;
    VirtualInvokeData WriteAsync_2;
    VirtualInvokeData WriteLineAsync;
    VirtualInvokeData WriteLineAsync_1;
    VirtualInvokeData WriteLineAsync_2;
    VirtualInvokeData WriteLineAsync_3;
    VirtualInvokeData FlushAsync;
};

struct TextWriter__StaticFields {
    struct TextWriter *Null;
    struct Action_1_Object_ *_WriteCharDelegate;
    struct Action_1_Object_ *_WriteStringDelegate;
    struct Action_1_Object_ *_WriteCharArrayRangeDelegate;
    struct Action_1_Object_ *_WriteLineCharDelegate;
    struct Action_1_Object_ *_WriteLineStringDelegate;
    struct Action_1_Object_ *_WriteLineCharArrayRangeDelegate;
    struct Action_1_Object_ *_FlushDelegate;
};

struct TextWriter__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TextWriter__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TextWriter__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum ConsoleColor__Enum : int32_t {
    ConsoleColor__Enum_Black = 0x00000000,
    ConsoleColor__Enum_DarkBlue = 0x00000001,
    ConsoleColor__Enum_DarkGreen = 0x00000002,
    ConsoleColor__Enum_DarkCyan = 0x00000003,
    ConsoleColor__Enum_DarkRed = 0x00000004,
    ConsoleColor__Enum_DarkMagenta = 0x00000005,
    ConsoleColor__Enum_DarkYellow = 0x00000006,
    ConsoleColor__Enum_Gray = 0x00000007,
    ConsoleColor__Enum_DarkGray = 0x00000008,
    ConsoleColor__Enum_Blue = 0x00000009,
    ConsoleColor__Enum_Green = 0x0000000a,
    ConsoleColor__Enum_Cyan = 0x0000000b,
    ConsoleColor__Enum_Red = 0x0000000c,
    ConsoleColor__Enum_Magenta = 0x0000000d,
    ConsoleColor__Enum_Yellow = 0x0000000e,
    ConsoleColor__Enum_White = 0x0000000f,
};

#else
enum ConsoleColor__Enum {
    ConsoleColor__Enum_Black = 0x00000000,
    ConsoleColor__Enum_DarkBlue = 0x00000001,
    ConsoleColor__Enum_DarkGreen = 0x00000002,
    ConsoleColor__Enum_DarkCyan = 0x00000003,
    ConsoleColor__Enum_DarkRed = 0x00000004,
    ConsoleColor__Enum_DarkMagenta = 0x00000005,
    ConsoleColor__Enum_DarkYellow = 0x00000006,
    ConsoleColor__Enum_Gray = 0x00000007,
    ConsoleColor__Enum_DarkGray = 0x00000008,
    ConsoleColor__Enum_Blue = 0x00000009,
    ConsoleColor__Enum_Green = 0x0000000a,
    ConsoleColor__Enum_Cyan = 0x0000000b,
    ConsoleColor__Enum_Red = 0x0000000c,
    ConsoleColor__Enum_Magenta = 0x0000000d,
    ConsoleColor__Enum_Yellow = 0x0000000e,
    ConsoleColor__Enum_White = 0x0000000f,
};

#endif
struct ConsoleColor__Enum__Boxed {
    struct ConsoleColor__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum ConsoleColor__Enum value;
    #else
    uint32_t value;
    #endif
};

struct ConsoleColor__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct ConsoleColor__Enum__StaticFields {
};

struct ConsoleColor__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ConsoleColor__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ConsoleColor__Enum__VTable vtable;
};

struct Console_WindowsConsole_WindowsCancelHandler__Fields {
    struct MulticastDelegate__Fields _;
};

struct Console_WindowsConsole_WindowsCancelHandler {
    struct Console_WindowsConsole_WindowsCancelHandler__Class *klass;
    MonitorData *monitor;
    struct Console_WindowsConsole_WindowsCancelHandler__Fields fields;
};

struct Console_WindowsConsole_WindowsCancelHandler__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Console_WindowsConsole_WindowsCancelHandler__StaticFields {
};

struct Console_WindowsConsole_WindowsCancelHandler__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Console_WindowsConsole_WindowsCancelHandler__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Console_WindowsConsole_WindowsCancelHandler__VTable vtable;
};

struct Console_WindowsConsole {
    struct Console_WindowsConsole__Class *klass;
    MonitorData *monitor;
};

struct Console_WindowsConsole__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Console_WindowsConsole__StaticFields {
    bool ctrlHandlerAdded;
    struct Console_WindowsConsole_WindowsCancelHandler *cancelHandler;
};

struct Console_WindowsConsole__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Console_WindowsConsole__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Console_WindowsConsole__VTable vtable;
};

struct Console_InternalCancelHandler__Fields {
    struct MulticastDelegate__Fields _;
};

struct Console_InternalCancelHandler {
    struct Console_InternalCancelHandler__Class *klass;
    MonitorData *monitor;
    struct Console_InternalCancelHandler__Fields fields;
};

struct Console_InternalCancelHandler__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Console_InternalCancelHandler__StaticFields {
};

struct Console_InternalCancelHandler__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Console_InternalCancelHandler__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Console_InternalCancelHandler__VTable vtable;
};

struct IConsoleDriver {
    struct IConsoleDriver__Class *klass;
    MonitorData *monitor;
};

struct IConsoleDriver__VTable {
    VirtualInvokeData get_BackgroundColor;
    VirtualInvokeData set_BackgroundColor;
    VirtualInvokeData get_BufferHeight;
    VirtualInvokeData set_BufferHeight;
    VirtualInvokeData get_BufferWidth;
    VirtualInvokeData set_BufferWidth;
    VirtualInvokeData get_CapsLock;
    VirtualInvokeData get_CursorLeft;
    VirtualInvokeData set_CursorLeft;
    VirtualInvokeData get_CursorSize;
    VirtualInvokeData set_CursorSize;
    VirtualInvokeData get_CursorTop;
    VirtualInvokeData set_CursorTop;
    VirtualInvokeData get_CursorVisible;
    VirtualInvokeData set_CursorVisible;
    VirtualInvokeData get_ForegroundColor;
    VirtualInvokeData set_ForegroundColor;
    VirtualInvokeData get_KeyAvailable;
    VirtualInvokeData get_Initialized;
    VirtualInvokeData get_LargestWindowHeight;
    VirtualInvokeData get_LargestWindowWidth;
    VirtualInvokeData get_NumberLock;
    VirtualInvokeData get_Title;
    VirtualInvokeData set_Title;
    VirtualInvokeData get_TreatControlCAsInput;
    VirtualInvokeData set_TreatControlCAsInput;
    VirtualInvokeData get_WindowHeight;
    VirtualInvokeData set_WindowHeight;
    VirtualInvokeData get_WindowLeft;
    VirtualInvokeData set_WindowLeft;
    VirtualInvokeData get_WindowTop;
    VirtualInvokeData set_WindowTop;
    VirtualInvokeData get_WindowWidth;
    VirtualInvokeData set_WindowWidth;
    VirtualInvokeData Init;
    VirtualInvokeData Beep;
    VirtualInvokeData Clear;
    VirtualInvokeData MoveBufferArea;
    VirtualInvokeData ReadKey;
    VirtualInvokeData ResetColor;
    VirtualInvokeData SetBufferSize;
    VirtualInvokeData SetCursorPosition;
    VirtualInvokeData SetWindowPosition;
    VirtualInvokeData SetWindowSize;
    VirtualInvokeData ReadLine;
};

struct IConsoleDriver__StaticFields {
};

struct IConsoleDriver__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IConsoleDriver__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IConsoleDriver__VTable vtable;
};

struct Int32Ptr___VTable {
};

struct Int32Ptr___StaticFields {
};

struct Int32Ptr___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Int32Ptr___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Int32Ptr___VTable vtable;
};

struct ControlCharacters {
    struct ControlCharacters__Class *klass;
    MonitorData *monitor;
};

struct ControlCharacters__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ControlCharacters__StaticFields {
};

struct ControlCharacters__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ControlCharacters__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ControlCharacters__VTable vtable;
};

struct __declspec(align(8)) DelegateSerializationHolder__Fields {
    struct Delegate *_delegate;
};

struct DelegateSerializationHolder {
    struct DelegateSerializationHolder__Class *klass;
    MonitorData *monitor;
    struct DelegateSerializationHolder__Fields fields;
};

struct DelegateSerializationHolder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData GetRealObject;
};

struct DelegateSerializationHolder__StaticFields {
};

struct DelegateSerializationHolder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DelegateSerializationHolder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DelegateSerializationHolder__VTable vtable;
};

struct __declspec(align(8)) DelegateSerializationHolder_DelegateEntry__Fields {
    struct String *type;
    struct String *assembly;
    struct Object *target;
    struct String *targetTypeAssembly;
    struct String *targetTypeName;
    struct String *methodName;
    struct DelegateSerializationHolder_DelegateEntry *delegateEntry;
};

struct DelegateSerializationHolder_DelegateEntry {
    struct DelegateSerializationHolder_DelegateEntry__Class *klass;
    MonitorData *monitor;
    struct DelegateSerializationHolder_DelegateEntry__Fields fields;
};

struct DelegateSerializationHolder_DelegateEntry__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct DelegateSerializationHolder_DelegateEntry__StaticFields {
};

struct DelegateSerializationHolder_DelegateEntry__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DelegateSerializationHolder_DelegateEntry__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DelegateSerializationHolder_DelegateEntry__VTable vtable;
};

struct __declspec(align(8)) Identity__Fields {
    struct String *_objectUri;
    struct IMessageSink *_channelSink;
    struct IMessageSink *_envoySink;
    struct DynamicPropertyCollection *_clientDynamicProperties;
    struct DynamicPropertyCollection *_serverDynamicProperties;
    struct ObjRef *_objRef;
    bool _disposed;
};

struct Identity {
    struct Identity__Class *klass;
    MonitorData *monitor;
    struct Identity__Fields fields;
};

struct ServerIdentity__Fields {
    struct Identity__Fields _;
    struct Type *_objectType;
    struct MarshalByRefObject *_serverObject;
    struct IMessageSink *_serverSink;
    struct Context *_context;
    struct Lease *_lease;
};

struct ServerIdentity {
    struct ServerIdentity__Class *klass;
    MonitorData *monitor;
    struct ServerIdentity__Fields fields;
};

struct ClientIdentity__Fields {
    struct Identity__Fields _;
    struct WeakReference *_proxyReference;
};

struct ClientIdentity {
    struct ClientIdentity__Class *klass;
    MonitorData *monitor;
    struct ClientIdentity__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum LeaseState__Enum : int32_t {
    LeaseState__Enum_Null = 0x00000000,
    LeaseState__Enum_Initial = 0x00000001,
    LeaseState__Enum_Active = 0x00000002,
    LeaseState__Enum_Renewing = 0x00000003,
    LeaseState__Enum_Expired = 0x00000004,
};

#else
enum LeaseState__Enum {
    LeaseState__Enum_Null = 0x00000000,
    LeaseState__Enum_Initial = 0x00000001,
    LeaseState__Enum_Active = 0x00000002,
    LeaseState__Enum_Renewing = 0x00000003,
    LeaseState__Enum_Expired = 0x00000004,
};

#endif
struct LeaseState__Enum__Boxed {
    struct LeaseState__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum LeaseState__Enum value;
    #else
    uint32_t value;
    #endif
};

struct Lease__Fields {
    struct MarshalByRefObject__Fields _;
    struct DateTime _leaseExpireTime;
    #if defined(_CPLUSPLUS_)
    enum LeaseState__Enum _currentState;
    #else
    uint32_t _currentState;
    #endif
    struct TimeSpan _initialLeaseTime;
    struct TimeSpan _renewOnCallTime;
    struct TimeSpan _sponsorshipTimeout;
    struct ArrayList *_sponsors;
    struct Queue *_renewingSponsors;
    struct Lease_RenewalDelegate *_renewalDelegate;
};

struct Lease {
    struct Lease__Class *klass;
    MonitorData *monitor;
    struct Lease__Fields fields;
};

struct __declspec(align(8)) Queue__Fields {
    struct Object__Array *_array;
    int32_t _head;
    int32_t _tail;
    int32_t _size;
    int32_t _growFactor;
    int32_t _version;
    struct Object *_syncRoot;
};

struct Queue {
    struct Queue__Class *klass;
    MonitorData *monitor;
    struct Queue__Fields fields;
};

struct Lease_RenewalDelegate__Fields {
    struct MulticastDelegate__Fields _;
};

struct Lease_RenewalDelegate {
    struct Lease_RenewalDelegate__Class *klass;
    MonitorData *monitor;
    struct Lease_RenewalDelegate__Fields fields;
};

struct ILease {
    struct ILease__Class *klass;
    MonitorData *monitor;
};

struct ISponsor {
    struct ISponsor__Class *klass;
    MonitorData *monitor;
};

struct ClientActivatedIdentity__Fields {
    struct ServerIdentity__Fields _;
    struct MarshalByRefObject *_targetThis;
};

struct ClientActivatedIdentity {
    struct ClientActivatedIdentity__Class *klass;
    MonitorData *monitor;
    struct ClientActivatedIdentity__Fields fields;
};

struct IMessage {
    struct IMessage__Class *klass;
    MonitorData *monitor;
};

struct IMessageCtrl {
    struct IMessageCtrl__Class *klass;
    MonitorData *monitor;
};

struct ClientIdentity__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
};

struct ClientIdentity__StaticFields {
};

struct ClientIdentity__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ClientIdentity__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ClientIdentity__VTable vtable;
};

struct Identity__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData __unknown;
};

struct Identity__StaticFields {
};

struct Identity__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Identity__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Identity__VTable vtable;
};

struct LeaseState__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct LeaseState__Enum__StaticFields {
};

struct LeaseState__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct LeaseState__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct LeaseState__Enum__VTable vtable;
};

struct Queue__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CopyTo;
    VirtualInvokeData get_Count;
    VirtualInvokeData get_SyncRoot;
    VirtualInvokeData get_IsSynchronized;
    VirtualInvokeData GetEnumerator;
    VirtualInvokeData Clone;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData Clone_1;
    VirtualInvokeData get_IsSynchronized_1;
    VirtualInvokeData get_SyncRoot_1;
    VirtualInvokeData Clear;
    VirtualInvokeData CopyTo_1;
    VirtualInvokeData Enqueue;
    VirtualInvokeData GetEnumerator_1;
    VirtualInvokeData Dequeue;
    VirtualInvokeData Peek;
    VirtualInvokeData Contains;
    VirtualInvokeData ToArray;
    VirtualInvokeData TrimToSize;
};

struct Queue__StaticFields {
};

struct Queue__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Queue__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Queue__VTable vtable;
};

struct ILease__VTable {
    VirtualInvokeData get_CurrentLeaseTime;
    VirtualInvokeData get_CurrentState;
    VirtualInvokeData get_InitialLeaseTime;
    VirtualInvokeData set_InitialLeaseTime;
    VirtualInvokeData get_RenewOnCallTime;
    VirtualInvokeData set_RenewOnCallTime;
    VirtualInvokeData get_SponsorshipTimeout;
    VirtualInvokeData set_SponsorshipTimeout;
    VirtualInvokeData Register;
    VirtualInvokeData Register_1;
    VirtualInvokeData Renew;
    VirtualInvokeData Unregister;
};

struct ILease__StaticFields {
};

struct ILease__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ILease__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ILease__VTable vtable;
};

struct Lease_RenewalDelegate__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Lease_RenewalDelegate__StaticFields {
};

struct Lease_RenewalDelegate__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Lease_RenewalDelegate__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Lease_RenewalDelegate__VTable vtable;
};

struct ISponsor__VTable {
    VirtualInvokeData Renewal;
};

struct ISponsor__StaticFields {
};

struct ISponsor__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ISponsor__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ISponsor__VTable vtable;
};

struct Lease__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData get_CurrentLeaseTime;
    VirtualInvokeData get_CurrentState;
    VirtualInvokeData get_InitialLeaseTime;
    VirtualInvokeData set_InitialLeaseTime;
    VirtualInvokeData get_RenewOnCallTime;
    VirtualInvokeData set_RenewOnCallTime;
    VirtualInvokeData get_SponsorshipTimeout;
    VirtualInvokeData set_SponsorshipTimeout;
    VirtualInvokeData Register;
    VirtualInvokeData Register_1;
    VirtualInvokeData Renew;
    VirtualInvokeData Unregister;
};

struct Lease__StaticFields {
};

struct Lease__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Lease__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Lease__VTable vtable;
};

struct IMessage__VTable {
    VirtualInvokeData get_Properties;
};

struct IMessage__StaticFields {
};

struct IMessage__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IMessage__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IMessage__VTable vtable;
};

struct IMessageCtrl__VTable {
    VirtualInvokeData Cancel;
};

struct IMessageCtrl__StaticFields {
};

struct IMessageCtrl__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IMessageCtrl__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IMessageCtrl__VTable vtable;
};

struct ClientActivatedIdentity__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData OnLifetimeExpired;
    VirtualInvokeData SyncObjectProcessMessage;
    VirtualInvokeData AsyncObjectProcessMessage;
};

struct ClientActivatedIdentity__StaticFields {
};

struct ClientActivatedIdentity__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ClientActivatedIdentity__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ClientActivatedIdentity__VTable vtable;
};

struct ServerIdentity__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData OnLifetimeExpired;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
};

struct ServerIdentity__StaticFields {
};

struct ServerIdentity__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ServerIdentity__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ServerIdentity__VTable vtable;
};

struct ModuleHandle {
    void *value;
};

struct ModuleHandle__Boxed {
    struct ModuleHandle__Class *klass;
    MonitorData *monitor;
    struct ModuleHandle fields;
};

struct ModuleHandle__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ModuleHandle__StaticFields {
    struct ModuleHandle EmptyHandle;
};

struct ModuleHandle__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ModuleHandle__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ModuleHandle__VTable vtable;
};

struct RuntimeTypeHandle__Array {
    struct RuntimeTypeHandle__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct RuntimeTypeHandle vector[32];
};

struct RuntimeTypeHandle__Array__VTable {
};

struct RuntimeTypeHandle__Array__StaticFields {
};

struct RuntimeTypeHandle__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeTypeHandle__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeTypeHandle__Array__VTable vtable;
};

struct __declspec(align(8)) MonoAsyncCall__Fields {
    struct Object *msg;
    void *cb_method;
    struct Object *cb_target;
    struct Object *state;
    struct Object *res;
    struct Object *out_args;
};

struct MonoAsyncCall {
    struct MonoAsyncCall__Class *klass;
    MonitorData *monitor;
    struct MonoAsyncCall__Fields fields;
};

struct MonoAsyncCall__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct MonoAsyncCall__StaticFields {
};

struct MonoAsyncCall__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoAsyncCall__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoAsyncCall__VTable vtable;
};

struct __declspec(align(8)) MonoCQItem__Fields {
    struct Object__Array *array;
    struct Byte__Array *array_state;
    int32_t head;
    int32_t tail;
};

struct MonoCQItem {
    struct MonoCQItem__Class *klass;
    MonitorData *monitor;
    struct MonoCQItem__Fields fields;
};

struct MonoCQItem__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct MonoCQItem__StaticFields {
};

struct MonoCQItem__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoCQItem__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoCQItem__VTable vtable;
};

struct __declspec(align(8)) CustomAttributeData__Fields {
    struct ConstructorInfo *ctorInfo;
    struct IList_1_System_Reflection_CustomAttributeTypedArgument_ *ctorArgs;
    struct IList_1_System_Reflection_CustomAttributeNamedArgument_ *namedArgs;
    struct CustomAttributeData_LazyCAttrData *lazyData;
};

struct CustomAttributeData {
    struct CustomAttributeData__Class *klass;
    MonitorData *monitor;
    struct CustomAttributeData__Fields fields;
};

struct IList_1_System_Reflection_CustomAttributeTypedArgument_ {
    struct IList_1_System_Reflection_CustomAttributeTypedArgument___Class *klass;
    MonitorData *monitor;
};

struct IList_1_System_Reflection_CustomAttributeNamedArgument_ {
    struct IList_1_System_Reflection_CustomAttributeNamedArgument___Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) CustomAttributeData_LazyCAttrData__Fields {
    struct Assembly *assembly;
    void *data;
    uint32_t data_length;
};

struct CustomAttributeData_LazyCAttrData {
    struct CustomAttributeData_LazyCAttrData__Class *klass;
    MonitorData *monitor;
    struct CustomAttributeData_LazyCAttrData__Fields fields;
};

struct CustomAttributeData__Array {
    struct CustomAttributeData__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct CustomAttributeData *vector[32];
};

struct IList_1_System_Reflection_CustomAttributeTypedArgument___VTable {
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData RemoveAt;
};

struct IList_1_System_Reflection_CustomAttributeTypedArgument___StaticFields {
};

struct IList_1_System_Reflection_CustomAttributeTypedArgument___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IList_1_System_Reflection_CustomAttributeTypedArgument___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IList_1_System_Reflection_CustomAttributeTypedArgument___VTable vtable;
};

struct IList_1_System_Reflection_CustomAttributeNamedArgument___VTable {
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData RemoveAt;
};

struct IList_1_System_Reflection_CustomAttributeNamedArgument___StaticFields {
};

struct IList_1_System_Reflection_CustomAttributeNamedArgument___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IList_1_System_Reflection_CustomAttributeNamedArgument___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IList_1_System_Reflection_CustomAttributeNamedArgument___VTable vtable;
};

struct CustomAttributeData_LazyCAttrData__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct CustomAttributeData_LazyCAttrData__StaticFields {
};

struct CustomAttributeData_LazyCAttrData__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CustomAttributeData_LazyCAttrData__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CustomAttributeData_LazyCAttrData__VTable vtable;
};

struct CustomAttributeData__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Constructor;
    VirtualInvokeData get_ConstructorArguments;
    VirtualInvokeData get_NamedArguments;
};

struct CustomAttributeData__StaticFields {
};

struct CustomAttributeData__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CustomAttributeData__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CustomAttributeData__VTable vtable;
};

struct CustomAttributeData__Array__VTable {
};

struct CustomAttributeData__Array__StaticFields {
};

struct CustomAttributeData__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CustomAttributeData__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CustomAttributeData__Array__VTable vtable;
};

struct __declspec(align(8)) MonoCustomAttrs_AttributeInfo__Fields {
    struct AttributeUsageAttribute *_usage;
    int32_t _inheritanceLevel;
};

struct MonoCustomAttrs_AttributeInfo {
    struct MonoCustomAttrs_AttributeInfo__Class *klass;
    MonitorData *monitor;
    struct MonoCustomAttrs_AttributeInfo__Fields fields;
};

struct MonoCustomAttrs_AttributeInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct MonoCustomAttrs_AttributeInfo__StaticFields {
};

struct MonoCustomAttrs_AttributeInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoCustomAttrs_AttributeInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoCustomAttrs_AttributeInfo__VTable vtable;
};

struct __declspec(align(8)) MonoListItem__Fields {
    struct MonoListItem *next;
    struct Object *data;
};

struct MonoListItem {
    struct MonoListItem__Class *klass;
    MonitorData *monitor;
    struct MonoListItem__Fields fields;
};

struct MonoListItem__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct MonoListItem__StaticFields {
};

struct MonoListItem__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoListItem__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoListItem__VTable vtable;
};

struct MonoType__Fields {
    struct RuntimeType__Fields _;
};

struct MonoType {
    struct MonoType__Class *klass;
    MonitorData *monitor;
    struct MonoType__Fields fields;
};

struct MonoType__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData Equals_2;
    VirtualInvokeData Equals_3;
    VirtualInvokeData FindInterfaces;
    VirtualInvokeData FindMembers;
    VirtualInvokeData GetArrayRank;
    VirtualInvokeData GetConstructor;
    VirtualInvokeData GetConstructor_1;
    VirtualInvokeData GetConstructor_2;
    VirtualInvokeData GetConstructors;
    VirtualInvokeData GetConstructors_1;
    VirtualInvokeData GetCustomAttributes_6;
    VirtualInvokeData GetCustomAttributes_7;
    VirtualInvokeData GetDefaultMembers;
    VirtualInvokeData GetElementType;
    VirtualInvokeData GetEvent;
    VirtualInvokeData GetEvent_1;
    VirtualInvokeData GetEvents;
    VirtualInvokeData GetEvents_1;
    VirtualInvokeData GetField;
    VirtualInvokeData GetField_1;
    VirtualInvokeData GetFields;
    VirtualInvokeData GetFields_1;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Type_Invoke;
    VirtualInvokeData GetInterface;
    VirtualInvokeData GetInterface_1;
    VirtualInvokeData GetInterfaceMap;
    VirtualInvokeData GetInterfaces;
    VirtualInvokeData GetMember;
    VirtualInvokeData GetMember_1;
    VirtualInvokeData GetMember_2;
    VirtualInvokeData GetMembers;
    VirtualInvokeData GetMembers_1;
    VirtualInvokeData GetMethod;
    VirtualInvokeData GetMethod_1;
    VirtualInvokeData GetMethod_2;
    VirtualInvokeData GetMethod_3;
    VirtualInvokeData GetMethod_4;
    VirtualInvokeData GetMethod_5;
    VirtualInvokeData GetMethods;
    VirtualInvokeData GetMethods_1;
    VirtualInvokeData GetNestedType;
    VirtualInvokeData GetNestedType_1;
    VirtualInvokeData GetNestedTypes;
    VirtualInvokeData GetNestedTypes_1;
    VirtualInvokeData GetProperties;
    VirtualInvokeData GetProperties_1;
    VirtualInvokeData GetProperty;
    VirtualInvokeData GetProperty_1;
    VirtualInvokeData GetProperty_2;
    VirtualInvokeData GetProperty_3;
    VirtualInvokeData GetProperty_4;
    VirtualInvokeData GetProperty_5;
    VirtualInvokeData GetProperty_6;
    VirtualInvokeData GetType;
    VirtualInvokeData InvokeMember;
    VirtualInvokeData InvokeMember_1;
    VirtualInvokeData InvokeMember_2;
    VirtualInvokeData IsAssignableFrom;
    VirtualInvokeData IsDefined_3;
    VirtualInvokeData IsInstanceOfType;
    VirtualInvokeData IsSubclassOf;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Assembly;
    VirtualInvokeData get_AssemblyQualifiedName;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_BaseType;
    VirtualInvokeData get_DeclaringType_2;
    VirtualInvokeData get_FullName;
    VirtualInvokeData get_GUID;
    VirtualInvokeData get_HasElementType;
    VirtualInvokeData get_IsAbstract;
    VirtualInvokeData get_IsAnsiClass;
    VirtualInvokeData get_IsArray;
    VirtualInvokeData get_IsAutoClass;
    VirtualInvokeData get_IsAutoLayout;
    VirtualInvokeData get_IsByRef;
    VirtualInvokeData get_IsClass;
    VirtualInvokeData get_IsCOMObject;
    VirtualInvokeData get_IsContextful;
    VirtualInvokeData get_IsEnum;
    VirtualInvokeData get_IsExplicitLayout;
    VirtualInvokeData get_IsImport;
    VirtualInvokeData get_IsInterface;
    VirtualInvokeData get_IsLayoutSequential;
    VirtualInvokeData get_IsMarshalByRef;
    VirtualInvokeData get_IsNestedAssembly;
    VirtualInvokeData get_IsNestedFamANDAssem;
    VirtualInvokeData get_IsNestedFamily;
    VirtualInvokeData get_IsNestedFamORAssem;
    VirtualInvokeData get_IsNestedPrivate;
    VirtualInvokeData get_IsNestedPublic;
    VirtualInvokeData get_IsNotPublic;
    VirtualInvokeData get_IsPointer;
    VirtualInvokeData get_IsPrimitive;
    VirtualInvokeData get_IsPublic;
    VirtualInvokeData get_IsSealed;
    VirtualInvokeData get_IsSerializable;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_IsUnicodeClass;
    VirtualInvokeData get_IsValueType;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_Module_1;
    VirtualInvokeData get_Name_2;
    VirtualInvokeData get_Namespace;
    VirtualInvokeData get_ReflectedType_2;
    VirtualInvokeData get_TypeHandle;
    VirtualInvokeData get_TypeInitializer;
    VirtualInvokeData get_UnderlyingSystemType;
    VirtualInvokeData GetMethod_6;
    VirtualInvokeData GetMethod_7;
    VirtualInvokeData GetMethods_2;
    VirtualInvokeData GetField_2;
    VirtualInvokeData GetFields_2;
    VirtualInvokeData GetProperty_7;
    VirtualInvokeData GetProperty_8;
    VirtualInvokeData GetProperties_2;
    VirtualInvokeData GetMember_3;
    VirtualInvokeData GetMembers_2;
    VirtualInvokeData InvokeMember_3;
    VirtualInvokeData get_UnderlyingSystemType_1;
    VirtualInvokeData get_DeclaringMethod;
    VirtualInvokeData MakePointerType;
    VirtualInvokeData get_StructLayoutAttribute;
    VirtualInvokeData MakeByRefType;
    VirtualInvokeData MakeArrayType;
    VirtualInvokeData MakeArrayType_1;
    VirtualInvokeData GetTypeCodeImpl;
    VirtualInvokeData get_GUID_1;
    VirtualInvokeData InvokeMember_4;
    VirtualInvokeData get_Assembly_1;
    VirtualInvokeData get_TypeHandle_1;
    VirtualInvokeData GetTypeHandleInternal;
    VirtualInvokeData get_FullName_1;
    VirtualInvokeData get_Namespace_1;
    VirtualInvokeData get_AssemblyQualifiedName_1;
    VirtualInvokeData GetArrayRank_1;
    VirtualInvokeData get_BaseType_1;
    VirtualInvokeData GetConstructorImpl;
    VirtualInvokeData GetConstructors_2;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetMethods_3;
    VirtualInvokeData GetField_3;
    VirtualInvokeData GetFields_3;
    VirtualInvokeData GetInterface_2;
    VirtualInvokeData GetInterfaces_1;
    VirtualInvokeData FindInterfaces_1;
    VirtualInvokeData GetEvent_2;
    VirtualInvokeData GetEvents_2;
    VirtualInvokeData GetEvents_3;
    VirtualInvokeData GetPropertyImpl;
    VirtualInvokeData GetProperties_3;
    VirtualInvokeData GetNestedTypes_2;
    VirtualInvokeData GetNestedType_2;
    VirtualInvokeData GetMember_4;
    VirtualInvokeData GetMember_5;
    VirtualInvokeData GetMembers_3;
    VirtualInvokeData GetDefaultMembers_1;
    VirtualInvokeData FindMembers_1;
    VirtualInvokeData get_GenericParameterAttributes;
    VirtualInvokeData get_IsEnum_1;
    VirtualInvokeData get_IsSerializable_1;
    VirtualInvokeData get_IsSzArray;
    VirtualInvokeData get_IsGenericType;
    VirtualInvokeData get_IsGenericTypeDefinition;
    VirtualInvokeData get_IsConstructedGenericType;
    VirtualInvokeData get_IsGenericParameter;
    VirtualInvokeData get_GenericParameterPosition;
    VirtualInvokeData get_ContainsGenericParameters;
    VirtualInvokeData GetGenericParameterConstraints;
    VirtualInvokeData IsValueTypeImpl;
    VirtualInvokeData GetAttributeFlagsImpl;
    VirtualInvokeData IsArrayImpl;
    VirtualInvokeData IsByRefImpl;
    VirtualInvokeData IsPointerImpl;
    VirtualInvokeData IsPrimitiveImpl;
    VirtualInvokeData IsCOMObjectImpl;
    VirtualInvokeData IsWindowsRuntimeObjectImpl;
    VirtualInvokeData IsExportedToWindowsRuntimeImpl;
    VirtualInvokeData MakeGenericType;
    VirtualInvokeData IsContextfulImpl;
    VirtualInvokeData IsMarshalByRefImpl;
    VirtualInvokeData HasProxyAttributeImpl;
    VirtualInvokeData GetElementType_1;
    VirtualInvokeData GetGenericArguments;
    VirtualInvokeData get_GenericTypeArguments;
    VirtualInvokeData GetGenericTypeDefinition;
    VirtualInvokeData HasElementTypeImpl;
    VirtualInvokeData GetEnumNames;
    VirtualInvokeData GetEnumValues;
    VirtualInvokeData GetEnumUnderlyingType;
    VirtualInvokeData IsEnumDefined;
    VirtualInvokeData GetEnumName;
    VirtualInvokeData get_IsSecurityCritical;
    VirtualInvokeData get_IsSecuritySafeCritical;
    VirtualInvokeData get_IsSecurityTransparent;
    VirtualInvokeData get_UnderlyingSystemType_2;
    VirtualInvokeData IsSubclassOf_1;
    VirtualInvokeData IsInstanceOfType_1;
    VirtualInvokeData IsAssignableFrom_1;
    VirtualInvokeData IsEquivalentTo;
    VirtualInvokeData FormatTypeName;
    VirtualInvokeData Equals_4;
    VirtualInvokeData GetInterfaceMap_1;
    VirtualInvokeData get_IsSZArray;
    VirtualInvokeData InternalResolve;
    VirtualInvokeData RuntimeResolve;
    VirtualInvokeData get_IsUserType;
    VirtualInvokeData GetMethod_8;
    VirtualInvokeData GetConstructor_3;
    VirtualInvokeData GetField_4;
    VirtualInvokeData System_Reflection_IReflectableType_GetTypeInfo;
    VirtualInvokeData AsType;
    VirtualInvokeData get_GenericTypeParameters;
    VirtualInvokeData IsAssignableFrom_2;
    VirtualInvokeData GetDeclaredEvent;
    VirtualInvokeData GetDeclaredField;
    VirtualInvokeData GetDeclaredMethod;
    VirtualInvokeData GetDeclaredMethods;
    VirtualInvokeData GetDeclaredNestedType;
    VirtualInvokeData GetDeclaredProperty;
    VirtualInvokeData get_DeclaredConstructors;
    VirtualInvokeData get_DeclaredEvents;
    VirtualInvokeData get_DeclaredFields;
    VirtualInvokeData get_DeclaredMembers;
    VirtualInvokeData get_DeclaredMethods;
    VirtualInvokeData get_DeclaredNestedTypes;
    VirtualInvokeData get_DeclaredProperties;
    VirtualInvokeData get_ImplementedInterfaces;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData Clone;
};

struct MonoType__StaticFields {
};

struct MonoType__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoType__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoType__VTable vtable;
};

struct NullConsoleDriver {
    struct NullConsoleDriver__Class *klass;
    MonitorData *monitor;
};

struct NullConsoleDriver__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_BackgroundColor;
    VirtualInvokeData set_BackgroundColor;
    VirtualInvokeData get_BufferHeight;
    VirtualInvokeData set_BufferHeight;
    VirtualInvokeData get_BufferWidth;
    VirtualInvokeData set_BufferWidth;
    VirtualInvokeData get_CapsLock;
    VirtualInvokeData get_CursorLeft;
    VirtualInvokeData set_CursorLeft;
    VirtualInvokeData get_CursorSize;
    VirtualInvokeData set_CursorSize;
    VirtualInvokeData get_CursorTop;
    VirtualInvokeData set_CursorTop;
    VirtualInvokeData get_CursorVisible;
    VirtualInvokeData set_CursorVisible;
    VirtualInvokeData get_ForegroundColor;
    VirtualInvokeData set_ForegroundColor;
    VirtualInvokeData get_KeyAvailable;
    VirtualInvokeData get_Initialized;
    VirtualInvokeData get_LargestWindowHeight;
    VirtualInvokeData get_LargestWindowWidth;
    VirtualInvokeData get_NumberLock;
    VirtualInvokeData get_Title;
    VirtualInvokeData set_Title;
    VirtualInvokeData get_TreatControlCAsInput;
    VirtualInvokeData set_TreatControlCAsInput;
    VirtualInvokeData get_WindowHeight;
    VirtualInvokeData set_WindowHeight;
    VirtualInvokeData get_WindowLeft;
    VirtualInvokeData set_WindowLeft;
    VirtualInvokeData get_WindowTop;
    VirtualInvokeData set_WindowTop;
    VirtualInvokeData get_WindowWidth;
    VirtualInvokeData set_WindowWidth;
    VirtualInvokeData Init;
    VirtualInvokeData Beep;
    VirtualInvokeData Clear;
    VirtualInvokeData MoveBufferArea;
    VirtualInvokeData ReadKey;
    VirtualInvokeData ResetColor;
    VirtualInvokeData SetBufferSize;
    VirtualInvokeData SetCursorPosition;
    VirtualInvokeData SetWindowPosition;
    VirtualInvokeData SetWindowSize;
    VirtualInvokeData ReadLine;
};

struct NullConsoleDriver__StaticFields {
    struct ConsoleKeyInfo EmptyConsoleKeyInfo;
};

struct NullConsoleDriver__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct NullConsoleDriver__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct NullConsoleDriver__VTable vtable;
};

struct UInt64Ptr {
    struct UInt64Ptr__Class *klass;
    MonitorData *monitor;
};

struct Int64Ptr {
    struct Int64Ptr__Class *klass;
    MonitorData *monitor;
};

struct UInt64Ptr__VTable {
};

struct UInt64Ptr__StaticFields {
};

struct UInt64Ptr__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UInt64Ptr__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UInt64Ptr__VTable vtable;
};

struct UInt64Ptr___VTable {
};

struct UInt64Ptr___StaticFields {
};

struct UInt64Ptr___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UInt64Ptr___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UInt64Ptr___VTable vtable;
};

struct Int64Ptr__VTable {
};

struct Int64Ptr__StaticFields {
};

struct Int64Ptr__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Int64Ptr__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Int64Ptr__VTable vtable;
};

struct Int64Ptr___VTable {
};

struct Int64Ptr___StaticFields {
};

struct Int64Ptr___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Int64Ptr___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Int64Ptr___VTable vtable;
};

struct __declspec(align(8)) NumberFormatter__Fields {
    struct NumberFormatInfo *_nfi;
    struct Char__Array *_cbuf;
    bool _NaN;
    bool _infinity;
    bool _isCustomFormat;
    bool _specifierIsUpper;
    bool _positive;
    uint16_t _specifier;
    int32_t _precision;
    int32_t _defPrecision;
    int32_t _digitsLen;
    int32_t _offset;
    int32_t _decPointPos;
    uint32_t _val1;
    uint32_t _val2;
    uint32_t _val3;
    uint32_t _val4;
    int32_t _ind;
};

struct NumberFormatter {
    struct NumberFormatter__Class *klass;
    MonitorData *monitor;
    struct NumberFormatter__Fields fields;
};

struct NumberFormatter__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct NumberFormatter__StaticFields {
    uint64_t *MantissaBitsTable;
    int32_t *TensExponentTable;
    uint16_t *DigitLowerTable;
    uint16_t *DigitUpperTable;
    int64_t *TenPowersList;
    int32_t *DecHexDigits;
    struct NumberFormatter *threadNumberFormatter;
    struct NumberFormatter *userFormatProvider;
};

struct NumberFormatter__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct NumberFormatter__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct NumberFormatter__VTable vtable;
};

struct __declspec(align(8)) Thread__Fields {
    struct InternalThread *internal_thread;
    struct Object *m_ThreadStartArg;
    struct Object *pending_exception;
    struct IPrincipal *principal;
    int32_t principal_version;
    struct MulticastDelegate *m_Delegate;
    struct ExecutionContext *m_ExecutionContext;
    bool m_ExecutionContextBelongsToOuterScope;
};

struct Thread {
    struct Thread__Class *klass;
    MonitorData *monitor;
    struct Thread__Fields fields;
};

struct __declspec(align(8)) AsyncLocal_1_System_Globalization_CultureInfo___Fields {
    struct Action_1_System_Threading_AsyncLocalValueChangedArgs_1_ *m_valueChangedHandler;
};

struct AsyncLocal_1_System_Globalization_CultureInfo_ {
    struct AsyncLocal_1_System_Globalization_CultureInfo___Class *klass;
    MonitorData *monitor;
    struct AsyncLocal_1_System_Globalization_CultureInfo___Fields fields;
};

struct Action_1_System_Threading_AsyncLocalValueChangedArgs_1___Fields {
    struct MulticastDelegate__Fields _;
};

struct Action_1_System_Threading_AsyncLocalValueChangedArgs_1_ {
    struct Action_1_System_Threading_AsyncLocalValueChangedArgs_1___Class *klass;
    MonitorData *monitor;
    struct Action_1_System_Threading_AsyncLocalValueChangedArgs_1___Fields fields;
};

struct AsyncLocalValueChangedArgs_1_System_Globalization_CultureInfo_ {
    struct CultureInfo *_PreviousValue_k__BackingField;
    struct CultureInfo *_CurrentValue_k__BackingField;
    bool _ThreadContextChanged_k__BackingField;
};

struct AsyncLocalValueChangedArgs_1_System_Globalization_CultureInfo___Boxed {
    struct AsyncLocalValueChangedArgs_1_System_Globalization_CultureInfo___Class *klass;
    MonitorData *monitor;
    struct AsyncLocalValueChangedArgs_1_System_Globalization_CultureInfo_ fields;
};

#if defined(_CPLUSPLUS_)
enum ThreadState__Enum : int32_t {
    ThreadState__Enum_Running = 0x00000000,
    ThreadState__Enum_StopRequested = 0x00000001,
    ThreadState__Enum_SuspendRequested = 0x00000002,
    ThreadState__Enum_Background = 0x00000004,
    ThreadState__Enum_Unstarted = 0x00000008,
    ThreadState__Enum_Stopped = 0x00000010,
    ThreadState__Enum_WaitSleepJoin = 0x00000020,
    ThreadState__Enum_Suspended = 0x00000040,
    ThreadState__Enum_AbortRequested = 0x00000080,
    ThreadState__Enum_Aborted = 0x00000100,
};

#else
enum ThreadState__Enum {
    ThreadState__Enum_Running = 0x00000000,
    ThreadState__Enum_StopRequested = 0x00000001,
    ThreadState__Enum_SuspendRequested = 0x00000002,
    ThreadState__Enum_Background = 0x00000004,
    ThreadState__Enum_Unstarted = 0x00000008,
    ThreadState__Enum_Stopped = 0x00000010,
    ThreadState__Enum_WaitSleepJoin = 0x00000020,
    ThreadState__Enum_Suspended = 0x00000040,
    ThreadState__Enum_AbortRequested = 0x00000080,
    ThreadState__Enum_Aborted = 0x00000100,
};

#endif
struct ThreadState__Enum__Boxed {
    struct ThreadState__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum ThreadState__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) InternalThread__Fields {
    int32_t lock_thread_id;
    void *handle;
    void *native_handle;
    void *unused3;
    void *name;
    int32_t name_len;
    #if defined(_CPLUSPLUS_)
    enum ThreadState__Enum state;
    #else
    uint32_t state;
    #endif
    struct Object *abort_exc;
    int32_t abort_state_handle;
    int64_t thread_id;
    void *debugger_thread;
    void *static_data;
    void *runtime_thread_info;
    struct Object *current_appcontext;
    struct Object *root_domain_thread;
    struct Byte__Array *_serialized_principal;
    int32_t _serialized_principal_version;
    void *appdomain_refs;
    int32_t interruption_requested;
    void *synch_cs;
    bool threadpool_thread;
    bool thread_interrupt_requested;
    int32_t stack_size;
    uint8_t apartment_state;
    int32_t critical_region_level;
    int32_t managed_id;
    int32_t small_id;
    void *manage_callback;
    void *unused4;
    void *flags;
    void *thread_pinning_ref;
    void *abort_protected_block_count;
    int32_t priority;
    void *owned_mutex;
    void *suspended_event;
    int32_t self_suspended;
    void *unused1;
    void *unused2;
    void *last;
};

struct InternalThread {
    struct InternalThread__Class *klass;
    MonitorData *monitor;
    struct InternalThread__Fields fields;
};

struct AsyncLocalValueChangedArgs_1_System_Globalization_CultureInfo___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct AsyncLocalValueChangedArgs_1_System_Globalization_CultureInfo___StaticFields {
};

struct AsyncLocalValueChangedArgs_1_System_Globalization_CultureInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AsyncLocalValueChangedArgs_1_System_Globalization_CultureInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AsyncLocalValueChangedArgs_1_System_Globalization_CultureInfo___VTable vtable;
};

struct Action_1_System_Threading_AsyncLocalValueChangedArgs_1___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Action_1_System_Threading_AsyncLocalValueChangedArgs_1___StaticFields {
};

struct Action_1_System_Threading_AsyncLocalValueChangedArgs_1___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Action_1_System_Threading_AsyncLocalValueChangedArgs_1___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Action_1_System_Threading_AsyncLocalValueChangedArgs_1___VTable vtable;
};

struct AsyncLocal_1_System_Globalization_CultureInfo___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Threading_IAsyncLocal_OnValueChanged;
};

struct AsyncLocal_1_System_Globalization_CultureInfo___StaticFields {
};

struct AsyncLocal_1_System_Globalization_CultureInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AsyncLocal_1_System_Globalization_CultureInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AsyncLocal_1_System_Globalization_CultureInfo___VTable vtable;
};

struct ThreadState__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct ThreadState__Enum__StaticFields {
};

struct ThreadState__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ThreadState__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ThreadState__Enum__VTable vtable;
};

struct InternalThread__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct InternalThread__StaticFields {
};

struct InternalThread__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct InternalThread__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct InternalThread__VTable vtable;
};

struct Thread__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Thread_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Thread_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Thread_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Thread_Invoke;
};

struct Thread__StaticFields {
    struct LocalDataStoreMgr *s_LocalDataStoreMgr;
    struct LocalDataStoreHolder *s_LocalDataStore;
    struct CultureInfo *m_CurrentCulture;
    struct CultureInfo *m_CurrentUICulture;
    struct AsyncLocal_1_System_Globalization_CultureInfo_ *s_asyncLocalCurrentCulture;
    struct AsyncLocal_1_System_Globalization_CultureInfo_ *s_asyncLocalCurrentUICulture;
    struct Thread *current_thread;
};

struct Thread__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Thread__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Thread__VTable vtable;
};

struct __declspec(align(8)) NumberFormatter_CustomInfo__Fields {
    bool UseGroup;
    int32_t DecimalDigits;
    int32_t DecimalPointPos;
    int32_t DecimalTailSharpDigits;
    int32_t IntegerDigits;
    int32_t IntegerHeadSharpDigits;
    int32_t IntegerHeadPos;
    bool UseExponent;
    int32_t ExponentDigits;
    int32_t ExponentTailSharpDigits;
    bool ExponentNegativeSignOnly;
    int32_t DividePlaces;
    int32_t Percents;
    int32_t Permilles;
};

struct NumberFormatter_CustomInfo {
    struct NumberFormatter_CustomInfo__Class *klass;
    MonitorData *monitor;
    struct NumberFormatter_CustomInfo__Fields fields;
};

struct NumberFormatter_CustomInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct NumberFormatter_CustomInfo__StaticFields {
};

struct NumberFormatter_CustomInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct NumberFormatter_CustomInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct NumberFormatter_CustomInfo__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum TypeNameFormatFlags__Enum : int32_t {
    TypeNameFormatFlags__Enum_FormatBasic = 0x00000000,
    TypeNameFormatFlags__Enum_FormatNamespace = 0x00000001,
    TypeNameFormatFlags__Enum_FormatFullInst = 0x00000002,
    TypeNameFormatFlags__Enum_FormatAssembly = 0x00000004,
    TypeNameFormatFlags__Enum_FormatSignature = 0x00000008,
    TypeNameFormatFlags__Enum_FormatNoVersion = 0x00000010,
    TypeNameFormatFlags__Enum_FormatAngleBrackets = 0x00000040,
    TypeNameFormatFlags__Enum_FormatStubInfo = 0x00000080,
    TypeNameFormatFlags__Enum_FormatGenericParam = 0x00000100,
    TypeNameFormatFlags__Enum_FormatSerialization = 0x00000103,
};

#else
enum TypeNameFormatFlags__Enum {
    TypeNameFormatFlags__Enum_FormatBasic = 0x00000000,
    TypeNameFormatFlags__Enum_FormatNamespace = 0x00000001,
    TypeNameFormatFlags__Enum_FormatFullInst = 0x00000002,
    TypeNameFormatFlags__Enum_FormatAssembly = 0x00000004,
    TypeNameFormatFlags__Enum_FormatSignature = 0x00000008,
    TypeNameFormatFlags__Enum_FormatNoVersion = 0x00000010,
    TypeNameFormatFlags__Enum_FormatAngleBrackets = 0x00000040,
    TypeNameFormatFlags__Enum_FormatStubInfo = 0x00000080,
    TypeNameFormatFlags__Enum_FormatGenericParam = 0x00000100,
    TypeNameFormatFlags__Enum_FormatSerialization = 0x00000103,
};

#endif
struct TypeNameFormatFlags__Enum__Boxed {
    struct TypeNameFormatFlags__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum TypeNameFormatFlags__Enum value;
    #else
    uint32_t value;
    #endif
};

struct TypeNameFormatFlags__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct TypeNameFormatFlags__Enum__StaticFields {
};

struct TypeNameFormatFlags__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeNameFormatFlags__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeNameFormatFlags__Enum__VTable vtable;
};

struct __declspec(align(8)) TermInfoDriver__Fields {
    struct TermInfoReader *reader;
    int32_t cursorLeft;
    int32_t cursorTop;
    struct String *title;
    struct String *titleFormat;
    bool cursorVisible;
    struct String *csrVisible;
    struct String *csrInvisible;
    struct String *clear;
    struct String *bell;
    struct String *term;
    struct StreamReader *stdin_1;
    struct CStreamWriter *stdout_1;
    int32_t windowWidth;
    int32_t windowHeight;
    int32_t bufferHeight;
    int32_t bufferWidth;
    struct Char__Array *buffer;
    int32_t readpos;
    int32_t writepos;
    struct String *keypadXmit;
    struct String *keypadLocal;
    bool controlCAsInput;
    bool inited;
    struct Object *initLock;
    bool initKeys;
    struct String *origPair;
    struct String *origColors;
    struct String *cursorAddress;
    #if defined(_CPLUSPLUS_)
    enum ConsoleColor__Enum fgcolor;
    #else
    uint32_t fgcolor;
    #endif
    #if defined(_CPLUSPLUS_)
    enum ConsoleColor__Enum bgcolor;
    #else
    uint32_t bgcolor;
    #endif
    struct String *setfgcolor;
    struct String *setbgcolor;
    int32_t maxColors;
    bool noGetPosition;
    struct Hashtable *keymap;
    struct ByteMatcher *rootmap;
    int32_t rl_startx;
    int32_t rl_starty;
    struct Byte__Array *control_characters;
    struct Char__Array *echobuf;
    int32_t echon;
};

struct TermInfoDriver {
    struct TermInfoDriver__Class *klass;
    MonitorData *monitor;
    struct TermInfoDriver__Fields fields;
};

struct __declspec(align(8)) TermInfoReader__Fields {
    int16_t boolSize;
    int16_t numSize;
    int16_t strOffsets;
    struct Byte__Array *buffer;
    int32_t booleansOffset;
};

struct TermInfoReader {
    struct TermInfoReader__Class *klass;
    MonitorData *monitor;
    struct TermInfoReader__Fields fields;
};

struct StreamReader__Fields {
    struct TextReader__Fields _;
    struct Stream *stream;
    struct Encoding *encoding;
    struct Decoder *decoder;
    struct Byte__Array *byteBuffer;
    struct Char__Array *charBuffer;
    struct Byte__Array *_preamble;
    int32_t charPos;
    int32_t charLen;
    int32_t byteLen;
    int32_t bytePos;
    int32_t _maxCharsPerBuffer;
    bool _detectEncoding;
    bool _checkPreamble;
    bool _isBlocked;
    bool _closable;
    struct Task *_asyncReadTask;
};

struct StreamReader {
    struct StreamReader__Class *klass;
    MonitorData *monitor;
    struct StreamReader__Fields fields;
};

struct CStreamWriter__Fields {
    struct StreamWriter__Fields _;
    struct TermInfoDriver *driver;
};

struct CStreamWriter {
    struct CStreamWriter__Class *klass;
    MonitorData *monitor;
    struct CStreamWriter__Fields fields;
};

struct __declspec(align(8)) ByteMatcher__Fields {
    struct Hashtable *map;
    struct Hashtable *starts;
};

struct ByteMatcher {
    struct ByteMatcher__Class *klass;
    MonitorData *monitor;
    struct ByteMatcher__Fields fields;
};

struct TermInfoReader__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct TermInfoReader__StaticFields {
};

struct TermInfoReader__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TermInfoReader__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TermInfoReader__VTable vtable;
};

struct StreamReader__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData Dispose;
    VirtualInvokeData Close;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData Peek;
    VirtualInvokeData Read;
    VirtualInvokeData Read_1;
    VirtualInvokeData ReadToEnd;
    VirtualInvokeData ReadBlock;
    VirtualInvokeData ReadLine;
    VirtualInvokeData ReadLineAsync;
    VirtualInvokeData ReadToEndAsync;
    VirtualInvokeData ReadAsync;
    VirtualInvokeData ReadAsyncInternal;
    VirtualInvokeData ReadBlockAsync;
    VirtualInvokeData get_CurrentEncoding;
    VirtualInvokeData get_BaseStream;
    VirtualInvokeData ReadBuffer;
};

struct StreamReader__StaticFields {
    struct StreamReader *Null;
};

struct StreamReader__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StreamReader__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StreamReader__VTable vtable;
};

struct CStreamWriter__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_FormatProvider;
    VirtualInvokeData Close;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData Flush;
    VirtualInvokeData get_Encoding;
    VirtualInvokeData get_NewLine;
    VirtualInvokeData set_NewLine;
    VirtualInvokeData Write;
    VirtualInvokeData Write_1;
    VirtualInvokeData Write_2;
    VirtualInvokeData Write_3;
    VirtualInvokeData Write_4;
    VirtualInvokeData Write_5;
    VirtualInvokeData Write_6;
    VirtualInvokeData Write_7;
    VirtualInvokeData Write_8;
    VirtualInvokeData Write_9;
    VirtualInvokeData Write_10;
    VirtualInvokeData Write_11;
    VirtualInvokeData Write_12;
    VirtualInvokeData Write_13;
    VirtualInvokeData Write_14;
    VirtualInvokeData Write_15;
    VirtualInvokeData Write_16;
    VirtualInvokeData WriteLine;
    VirtualInvokeData WriteLine_1;
    VirtualInvokeData WriteLine_2;
    VirtualInvokeData WriteLine_3;
    VirtualInvokeData WriteLine_4;
    VirtualInvokeData WriteLine_5;
    VirtualInvokeData WriteLine_6;
    VirtualInvokeData WriteLine_7;
    VirtualInvokeData WriteLine_8;
    VirtualInvokeData WriteLine_9;
    VirtualInvokeData WriteLine_10;
    VirtualInvokeData WriteLine_11;
    VirtualInvokeData WriteLine_12;
    VirtualInvokeData WriteLine_13;
    VirtualInvokeData WriteLine_14;
    VirtualInvokeData WriteLine_15;
    VirtualInvokeData WriteLine_16;
    VirtualInvokeData WriteLine_17;
    VirtualInvokeData WriteAsync;
    VirtualInvokeData WriteAsync_1;
    VirtualInvokeData WriteAsync_2;
    VirtualInvokeData WriteLineAsync;
    VirtualInvokeData WriteLineAsync_1;
    VirtualInvokeData WriteLineAsync_2;
    VirtualInvokeData WriteLineAsync_3;
    VirtualInvokeData FlushAsync;
    VirtualInvokeData get_AutoFlush;
    VirtualInvokeData set_AutoFlush;
    VirtualInvokeData get_BaseStream;
};

struct CStreamWriter__StaticFields {
};

struct CStreamWriter__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CStreamWriter__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CStreamWriter__VTable vtable;
};

struct ByteMatcher__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ByteMatcher__StaticFields {
};

struct ByteMatcher__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ByteMatcher__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ByteMatcher__VTable vtable;
};

struct TermInfoDriver__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_BackgroundColor;
    VirtualInvokeData set_BackgroundColor;
    VirtualInvokeData get_BufferHeight;
    VirtualInvokeData set_BufferHeight;
    VirtualInvokeData get_BufferWidth;
    VirtualInvokeData set_BufferWidth;
    VirtualInvokeData get_CapsLock;
    VirtualInvokeData get_CursorLeft;
    VirtualInvokeData set_CursorLeft;
    VirtualInvokeData get_CursorSize;
    VirtualInvokeData set_CursorSize;
    VirtualInvokeData get_CursorTop;
    VirtualInvokeData set_CursorTop;
    VirtualInvokeData get_CursorVisible;
    VirtualInvokeData set_CursorVisible;
    VirtualInvokeData get_ForegroundColor;
    VirtualInvokeData set_ForegroundColor;
    VirtualInvokeData get_KeyAvailable;
    VirtualInvokeData get_Initialized;
    VirtualInvokeData get_LargestWindowHeight;
    VirtualInvokeData get_LargestWindowWidth;
    VirtualInvokeData get_NumberLock;
    VirtualInvokeData get_Title;
    VirtualInvokeData set_Title;
    VirtualInvokeData get_TreatControlCAsInput;
    VirtualInvokeData set_TreatControlCAsInput;
    VirtualInvokeData get_WindowHeight;
    VirtualInvokeData set_WindowHeight;
    VirtualInvokeData get_WindowLeft;
    VirtualInvokeData set_WindowLeft;
    VirtualInvokeData get_WindowTop;
    VirtualInvokeData set_WindowTop;
    VirtualInvokeData get_WindowWidth;
    VirtualInvokeData set_WindowWidth;
    VirtualInvokeData Init;
    VirtualInvokeData Beep;
    VirtualInvokeData Clear;
    VirtualInvokeData MoveBufferArea;
    VirtualInvokeData ReadKey;
    VirtualInvokeData ResetColor;
    VirtualInvokeData SetBufferSize;
    VirtualInvokeData SetCursorPosition;
    VirtualInvokeData SetWindowPosition;
    VirtualInvokeData SetWindowSize;
    VirtualInvokeData ReadLine;
};

struct TermInfoDriver__StaticFields {
    int32_t *native_terminal_size;
    int32_t terminal_size;
    struct String__Array *locations;
    struct Int32__Array *_consoleColorToAnsiCode;
};

struct TermInfoDriver__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TermInfoDriver__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TermInfoDriver__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum TermInfoStrings__Enum : int32_t {
    TermInfoStrings__Enum_BackTab = 0x00000000,
    TermInfoStrings__Enum_Bell = 0x00000001,
    TermInfoStrings__Enum_CarriageReturn = 0x00000002,
    TermInfoStrings__Enum_ChangeScrollRegion = 0x00000003,
    TermInfoStrings__Enum_ClearAllTabs = 0x00000004,
    TermInfoStrings__Enum_ClearScreen = 0x00000005,
    TermInfoStrings__Enum_ClrEol = 0x00000006,
    TermInfoStrings__Enum_ClrEos = 0x00000007,
    TermInfoStrings__Enum_ColumnAddress = 0x00000008,
    TermInfoStrings__Enum_CommandCharacter = 0x00000009,
    TermInfoStrings__Enum_CursorAddress = 0x0000000a,
    TermInfoStrings__Enum_CursorDown = 0x0000000b,
    TermInfoStrings__Enum_CursorHome = 0x0000000c,
    TermInfoStrings__Enum_CursorInvisible = 0x0000000d,
    TermInfoStrings__Enum_CursorLeft = 0x0000000e,
    TermInfoStrings__Enum_CursorMemAddress = 0x0000000f,
    TermInfoStrings__Enum_CursorNormal = 0x00000010,
    TermInfoStrings__Enum_CursorRight = 0x00000011,
    TermInfoStrings__Enum_CursorToLl = 0x00000012,
    TermInfoStrings__Enum_CursorUp = 0x00000013,
    TermInfoStrings__Enum_CursorVisible = 0x00000014,
    TermInfoStrings__Enum_DeleteCharacter = 0x00000015,
    TermInfoStrings__Enum_DeleteLine = 0x00000016,
    TermInfoStrings__Enum_DisStatusLine = 0x00000017,
    TermInfoStrings__Enum_DownHalfLine = 0x00000018,
    TermInfoStrings__Enum_EnterAltCharsetMode = 0x00000019,
    TermInfoStrings__Enum_EnterBlinkMode = 0x0000001a,
    TermInfoStrings__Enum_EnterBoldMode = 0x0000001b,
    TermInfoStrings__Enum_EnterCaMode = 0x0000001c,
    TermInfoStrings__Enum_EnterDeleteMode = 0x0000001d,
    TermInfoStrings__Enum_EnterDimMode = 0x0000001e,
    TermInfoStrings__Enum_EnterInsertMode = 0x0000001f,
    TermInfoStrings__Enum_EnterSecureMode = 0x00000020,
    TermInfoStrings__Enum_EnterProtectedMode = 0x00000021,
    TermInfoStrings__Enum_EnterReverseMode = 0x00000022,
    TermInfoStrings__Enum_EnterStandoutMode = 0x00000023,
    TermInfoStrings__Enum_EnterUnderlineMode = 0x00000024,
    TermInfoStrings__Enum_EraseChars = 0x00000025,
    TermInfoStrings__Enum_ExitAltCharsetMode = 0x00000026,
    TermInfoStrings__Enum_ExitAttributeMode = 0x00000027,
    TermInfoStrings__Enum_ExitCaMode = 0x00000028,
    TermInfoStrings__Enum_ExitDeleteMode = 0x00000029,
    TermInfoStrings__Enum_ExitInsertMode = 0x0000002a,
    TermInfoStrings__Enum_ExitStandoutMode = 0x0000002b,
    TermInfoStrings__Enum_ExitUnderlineMode = 0x0000002c,
    TermInfoStrings__Enum_FlashScreen = 0x0000002d,
    TermInfoStrings__Enum_FormFeed = 0x0000002e,
    TermInfoStrings__Enum_FromStatusLine = 0x0000002f,
    TermInfoStrings__Enum_Init1string = 0x00000030,
    TermInfoStrings__Enum_Init2string = 0x00000031,
    TermInfoStrings__Enum_Init3string = 0x00000032,
    TermInfoStrings__Enum_InitFile = 0x00000033,
    TermInfoStrings__Enum_InsertCharacter = 0x00000034,
    TermInfoStrings__Enum_InsertLine = 0x00000035,
    TermInfoStrings__Enum_InsertPadding = 0x00000036,
    TermInfoStrings__Enum_KeyBackspace = 0x00000037,
    TermInfoStrings__Enum_KeyCatab = 0x00000038,
    TermInfoStrings__Enum_KeyClear = 0x00000039,
    TermInfoStrings__Enum_KeyCtab = 0x0000003a,
    TermInfoStrings__Enum_KeyDc = 0x0000003b,
    TermInfoStrings__Enum_KeyDl = 0x0000003c,
    TermInfoStrings__Enum_KeyDown = 0x0000003d,
    TermInfoStrings__Enum_KeyEic = 0x0000003e,
    TermInfoStrings__Enum_KeyEol = 0x0000003f,
    TermInfoStrings__Enum_KeyEos = 0x00000040,
    TermInfoStrings__Enum_KeyF0 = 0x00000041,
    TermInfoStrings__Enum_KeyF1 = 0x00000042,
    TermInfoStrings__Enum_KeyF10 = 0x00000043,
    TermInfoStrings__Enum_KeyF2 = 0x00000044,
    TermInfoStrings__Enum_KeyF3 = 0x00000045,
    TermInfoStrings__Enum_KeyF4 = 0x00000046,
    TermInfoStrings__Enum_KeyF5 = 0x00000047,
    TermInfoStrings__Enum_KeyF6 = 0x00000048,
    TermInfoStrings__Enum_KeyF7 = 0x00000049,
    TermInfoStrings__Enum_KeyF8 = 0x0000004a,
    TermInfoStrings__Enum_KeyF9 = 0x0000004b,
    TermInfoStrings__Enum_KeyHome = 0x0000004c,
    TermInfoStrings__Enum_KeyIc = 0x0000004d,
    TermInfoStrings__Enum_KeyIl = 0x0000004e,
    TermInfoStrings__Enum_KeyLeft = 0x0000004f,
    TermInfoStrings__Enum_KeyLl = 0x00000050,
    TermInfoStrings__Enum_KeyNpage = 0x00000051,
    TermInfoStrings__Enum_KeyPpage = 0x00000052,
    TermInfoStrings__Enum_KeyRight = 0x00000053,
    TermInfoStrings__Enum_KeySf = 0x00000054,
    TermInfoStrings__Enum_KeySr = 0x00000055,
    TermInfoStrings__Enum_KeyStab = 0x00000056,
    TermInfoStrings__Enum_KeyUp = 0x00000057,
    TermInfoStrings__Enum_KeypadLocal = 0x00000058,
    TermInfoStrings__Enum_KeypadXmit = 0x00000059,
    TermInfoStrings__Enum_LabF0 = 0x0000005a,
    TermInfoStrings__Enum_LabF1 = 0x0000005b,
    TermInfoStrings__Enum_LabF10 = 0x0000005c,
    TermInfoStrings__Enum_LabF2 = 0x0000005d,
    TermInfoStrings__Enum_LabF3 = 0x0000005e,
    TermInfoStrings__Enum_LabF4 = 0x0000005f,
    TermInfoStrings__Enum_LabF5 = 0x00000060,
    TermInfoStrings__Enum_LabF6 = 0x00000061,
    TermInfoStrings__Enum_LabF7 = 0x00000062,
    TermInfoStrings__Enum_LabF8 = 0x00000063,
    TermInfoStrings__Enum_LabF9 = 0x00000064,
    TermInfoStrings__Enum_MetaOff = 0x00000065,
    TermInfoStrings__Enum_MetaOn = 0x00000066,
    TermInfoStrings__Enum_Newline = 0x00000067,
    TermInfoStrings__Enum_PadChar = 0x00000068,
    TermInfoStrings__Enum_ParmDch = 0x00000069,
    TermInfoStrings__Enum_ParmDeleteLine = 0x0000006a,
    TermInfoStrings__Enum_ParmDownCursor = 0x0000006b,
    TermInfoStrings__Enum_ParmIch = 0x0000006c,
    TermInfoStrings__Enum_ParmIndex = 0x0000006d,
    TermInfoStrings__Enum_ParmInsertLine = 0x0000006e,
    TermInfoStrings__Enum_ParmLeftCursor = 0x0000006f,
    TermInfoStrings__Enum_ParmRightCursor = 0x00000070,
    TermInfoStrings__Enum_ParmRindex = 0x00000071,
    TermInfoStrings__Enum_ParmUpCursor = 0x00000072,
    TermInfoStrings__Enum_PkeyKey = 0x00000073,
    TermInfoStrings__Enum_PkeyLocal = 0x00000074,
    TermInfoStrings__Enum_PkeyXmit = 0x00000075,
    TermInfoStrings__Enum_PrintScreen = 0x00000076,
    TermInfoStrings__Enum_PrtrOff = 0x00000077,
    TermInfoStrings__Enum_PrtrOn = 0x00000078,
    TermInfoStrings__Enum_RepeatChar = 0x00000079,
    TermInfoStrings__Enum_Reset1string = 0x0000007a,
    TermInfoStrings__Enum_Reset2string = 0x0000007b,
    TermInfoStrings__Enum_Reset3string = 0x0000007c,
    TermInfoStrings__Enum_ResetFile = 0x0000007d,
    TermInfoStrings__Enum_RestoreCursor = 0x0000007e,
    TermInfoStrings__Enum_RowAddress = 0x0000007f,
    TermInfoStrings__Enum_SaveCursor = 0x00000080,
    TermInfoStrings__Enum_ScrollForward = 0x00000081,
    TermInfoStrings__Enum_ScrollReverse = 0x00000082,
    TermInfoStrings__Enum_SetAttributes = 0x00000083,
    TermInfoStrings__Enum_SetTab = 0x00000084,
    TermInfoStrings__Enum_SetWindow = 0x00000085,
    TermInfoStrings__Enum_Tab = 0x00000086,
    TermInfoStrings__Enum_ToStatusLine = 0x00000087,
    TermInfoStrings__Enum_UnderlineChar = 0x00000088,
    TermInfoStrings__Enum_UpHalfLine = 0x00000089,
    TermInfoStrings__Enum_InitProg = 0x0000008a,
    TermInfoStrings__Enum_KeyA1 = 0x0000008b,
    TermInfoStrings__Enum_KeyA3 = 0x0000008c,
    TermInfoStrings__Enum_KeyB2 = 0x0000008d,
    TermInfoStrings__Enum_KeyC1 = 0x0000008e,
    TermInfoStrings__Enum_KeyC3 = 0x0000008f,
    TermInfoStrings__Enum_PrtrNon = 0x00000090,
    TermInfoStrings__Enum_CharPadding = 0x00000091,
    TermInfoStrings__Enum_AcsChars = 0x00000092,
    TermInfoStrings__Enum_PlabNorm = 0x00000093,
    TermInfoStrings__Enum_KeyBtab = 0x00000094,
    TermInfoStrings__Enum_EnterXonMode = 0x00000095,
    TermInfoStrings__Enum_ExitXonMode = 0x00000096,
    TermInfoStrings__Enum_EnterAmMode = 0x00000097,
    TermInfoStrings__Enum_ExitAmMode = 0x00000098,
    TermInfoStrings__Enum_XonCharacter = 0x00000099,
    TermInfoStrings__Enum_XoffCharacter = 0x0000009a,
    TermInfoStrings__Enum_EnaAcs = 0x0000009b,
    TermInfoStrings__Enum_LabelOn = 0x0000009c,
    TermInfoStrings__Enum_LabelOff = 0x0000009d,
    TermInfoStrings__Enum_KeyBeg = 0x0000009e,
    TermInfoStrings__Enum_KeyCancel = 0x0000009f,
    TermInfoStrings__Enum_KeyClose = 0x000000a0,
    TermInfoStrings__Enum_KeyCommand = 0x000000a1,
    TermInfoStrings__Enum_KeyCopy = 0x000000a2,
    TermInfoStrings__Enum_KeyCreate = 0x000000a3,
    TermInfoStrings__Enum_KeyEnd = 0x000000a4,
    TermInfoStrings__Enum_KeyEnter = 0x000000a5,
    TermInfoStrings__Enum_KeyExit = 0x000000a6,
    TermInfoStrings__Enum_KeyFind = 0x000000a7,
    TermInfoStrings__Enum_KeyHelp = 0x000000a8,
    TermInfoStrings__Enum_KeyMark = 0x000000a9,
    TermInfoStrings__Enum_KeyMessage = 0x000000aa,
    TermInfoStrings__Enum_KeyMove = 0x000000ab,
    TermInfoStrings__Enum_KeyNext = 0x000000ac,
    TermInfoStrings__Enum_KeyOpen = 0x000000ad,
    TermInfoStrings__Enum_KeyOptions = 0x000000ae,
    TermInfoStrings__Enum_KeyPrevious = 0x000000af,
    TermInfoStrings__Enum_KeyPrint = 0x000000b0,
    TermInfoStrings__Enum_KeyRedo = 0x000000b1,
    TermInfoStrings__Enum_KeyReference = 0x000000b2,
    TermInfoStrings__Enum_KeyRefresh = 0x000000b3,
    TermInfoStrings__Enum_KeyReplace = 0x000000b4,
    TermInfoStrings__Enum_KeyRestart = 0x000000b5,
    TermInfoStrings__Enum_KeyResume = 0x000000b6,
    TermInfoStrings__Enum_KeySave = 0x000000b7,
    TermInfoStrings__Enum_KeySuspend = 0x000000b8,
    TermInfoStrings__Enum_KeyUndo = 0x000000b9,
    TermInfoStrings__Enum_KeySbeg = 0x000000ba,
    TermInfoStrings__Enum_KeyScancel = 0x000000bb,
    TermInfoStrings__Enum_KeyScommand = 0x000000bc,
    TermInfoStrings__Enum_KeyScopy = 0x000000bd,
    TermInfoStrings__Enum_KeyScreate = 0x000000be,
    TermInfoStrings__Enum_KeySdc = 0x000000bf,
    TermInfoStrings__Enum_KeySdl = 0x000000c0,
    TermInfoStrings__Enum_KeySelect = 0x000000c1,
    TermInfoStrings__Enum_KeySend = 0x000000c2,
    TermInfoStrings__Enum_KeySeol = 0x000000c3,
    TermInfoStrings__Enum_KeySexit = 0x000000c4,
    TermInfoStrings__Enum_KeySfind = 0x000000c5,
    TermInfoStrings__Enum_KeyShelp = 0x000000c6,
    TermInfoStrings__Enum_KeyShome = 0x000000c7,
    TermInfoStrings__Enum_KeySic = 0x000000c8,
    TermInfoStrings__Enum_KeySleft = 0x000000c9,
    TermInfoStrings__Enum_KeySmessage = 0x000000ca,
    TermInfoStrings__Enum_KeySmove = 0x000000cb,
    TermInfoStrings__Enum_KeySnext = 0x000000cc,
    TermInfoStrings__Enum_KeySoptions = 0x000000cd,
    TermInfoStrings__Enum_KeySprevious = 0x000000ce,
    TermInfoStrings__Enum_KeySprint = 0x000000cf,
    TermInfoStrings__Enum_KeySredo = 0x000000d0,
    TermInfoStrings__Enum_KeySreplace = 0x000000d1,
    TermInfoStrings__Enum_KeySright = 0x000000d2,
    TermInfoStrings__Enum_KeySrsume = 0x000000d3,
    TermInfoStrings__Enum_KeySsave = 0x000000d4,
    TermInfoStrings__Enum_KeySsuspend = 0x000000d5,
    TermInfoStrings__Enum_KeySundo = 0x000000d6,
    TermInfoStrings__Enum_ReqForInput = 0x000000d7,
    TermInfoStrings__Enum_KeyF11 = 0x000000d8,
    TermInfoStrings__Enum_KeyF12 = 0x000000d9,
    TermInfoStrings__Enum_KeyF13 = 0x000000da,
    TermInfoStrings__Enum_KeyF14 = 0x000000db,
    TermInfoStrings__Enum_KeyF15 = 0x000000dc,
    TermInfoStrings__Enum_KeyF16 = 0x000000dd,
    TermInfoStrings__Enum_KeyF17 = 0x000000de,
    TermInfoStrings__Enum_KeyF18 = 0x000000df,
    TermInfoStrings__Enum_KeyF19 = 0x000000e0,
    TermInfoStrings__Enum_KeyF20 = 0x000000e1,
    TermInfoStrings__Enum_KeyF21 = 0x000000e2,
    TermInfoStrings__Enum_KeyF22 = 0x000000e3,
    TermInfoStrings__Enum_KeyF23 = 0x000000e4,
    TermInfoStrings__Enum_KeyF24 = 0x000000e5,
    TermInfoStrings__Enum_KeyF25 = 0x000000e6,
    TermInfoStrings__Enum_KeyF26 = 0x000000e7,
    TermInfoStrings__Enum_KeyF27 = 0x000000e8,
    TermInfoStrings__Enum_KeyF28 = 0x000000e9,
    TermInfoStrings__Enum_KeyF29 = 0x000000ea,
    TermInfoStrings__Enum_KeyF30 = 0x000000eb,
    TermInfoStrings__Enum_KeyF31 = 0x000000ec,
    TermInfoStrings__Enum_KeyF32 = 0x000000ed,
    TermInfoStrings__Enum_KeyF33 = 0x000000ee,
    TermInfoStrings__Enum_KeyF34 = 0x000000ef,
    TermInfoStrings__Enum_KeyF35 = 0x000000f0,
    TermInfoStrings__Enum_KeyF36 = 0x000000f1,
    TermInfoStrings__Enum_KeyF37 = 0x000000f2,
    TermInfoStrings__Enum_KeyF38 = 0x000000f3,
    TermInfoStrings__Enum_KeyF39 = 0x000000f4,
    TermInfoStrings__Enum_KeyF40 = 0x000000f5,
    TermInfoStrings__Enum_KeyF41 = 0x000000f6,
    TermInfoStrings__Enum_KeyF42 = 0x000000f7,
    TermInfoStrings__Enum_KeyF43 = 0x000000f8,
    TermInfoStrings__Enum_KeyF44 = 0x000000f9,
    TermInfoStrings__Enum_KeyF45 = 0x000000fa,
    TermInfoStrings__Enum_KeyF46 = 0x000000fb,
    TermInfoStrings__Enum_KeyF47 = 0x000000fc,
    TermInfoStrings__Enum_KeyF48 = 0x000000fd,
    TermInfoStrings__Enum_KeyF49 = 0x000000fe,
    TermInfoStrings__Enum_KeyF50 = 0x000000ff,
    TermInfoStrings__Enum_KeyF51 = 0x00000100,
    TermInfoStrings__Enum_KeyF52 = 0x00000101,
    TermInfoStrings__Enum_KeyF53 = 0x00000102,
    TermInfoStrings__Enum_KeyF54 = 0x00000103,
    TermInfoStrings__Enum_KeyF55 = 0x00000104,
    TermInfoStrings__Enum_KeyF56 = 0x00000105,
    TermInfoStrings__Enum_KeyF57 = 0x00000106,
    TermInfoStrings__Enum_KeyF58 = 0x00000107,
    TermInfoStrings__Enum_KeyF59 = 0x00000108,
    TermInfoStrings__Enum_KeyF60 = 0x00000109,
    TermInfoStrings__Enum_KeyF61 = 0x0000010a,
    TermInfoStrings__Enum_KeyF62 = 0x0000010b,
    TermInfoStrings__Enum_KeyF63 = 0x0000010c,
    TermInfoStrings__Enum_ClrBol = 0x0000010d,
    TermInfoStrings__Enum_ClearMargins = 0x0000010e,
    TermInfoStrings__Enum_SetLeftMargin = 0x0000010f,
    TermInfoStrings__Enum_SetRightMargin = 0x00000110,
    TermInfoStrings__Enum_LabelFormat = 0x00000111,
    TermInfoStrings__Enum_SetClock = 0x00000112,
    TermInfoStrings__Enum_DisplayClock = 0x00000113,
    TermInfoStrings__Enum_RemoveClock = 0x00000114,
    TermInfoStrings__Enum_CreateWindow = 0x00000115,
    TermInfoStrings__Enum_GotoWindow = 0x00000116,
    TermInfoStrings__Enum_Hangup = 0x00000117,
    TermInfoStrings__Enum_DialPhone = 0x00000118,
    TermInfoStrings__Enum_QuickDial = 0x00000119,
    TermInfoStrings__Enum_Tone = 0x0000011a,
    TermInfoStrings__Enum_Pulse = 0x0000011b,
    TermInfoStrings__Enum_FlashHook = 0x0000011c,
    TermInfoStrings__Enum_FixedPause = 0x0000011d,
    TermInfoStrings__Enum_WaitTone = 0x0000011e,
    TermInfoStrings__Enum_User0 = 0x0000011f,
    TermInfoStrings__Enum_User1 = 0x00000120,
    TermInfoStrings__Enum_User2 = 0x00000121,
    TermInfoStrings__Enum_User3 = 0x00000122,
    TermInfoStrings__Enum_User4 = 0x00000123,
    TermInfoStrings__Enum_User5 = 0x00000124,
    TermInfoStrings__Enum_User6 = 0x00000125,
    TermInfoStrings__Enum_User7 = 0x00000126,
    TermInfoStrings__Enum_User8 = 0x00000127,
    TermInfoStrings__Enum_User9 = 0x00000128,
    TermInfoStrings__Enum_OrigPair = 0x00000129,
    TermInfoStrings__Enum_OrigColors = 0x0000012a,
    TermInfoStrings__Enum_InitializeColor = 0x0000012b,
    TermInfoStrings__Enum_InitializePair = 0x0000012c,
    TermInfoStrings__Enum_SetColorPair = 0x0000012d,
    TermInfoStrings__Enum_SetForeground = 0x0000012e,
    TermInfoStrings__Enum_SetBackground = 0x0000012f,
    TermInfoStrings__Enum_ChangeCharPitch = 0x00000130,
    TermInfoStrings__Enum_ChangeLinePitch = 0x00000131,
    TermInfoStrings__Enum_ChangeResHorz = 0x00000132,
    TermInfoStrings__Enum_ChangeResVert = 0x00000133,
    TermInfoStrings__Enum_DefineChar = 0x00000134,
    TermInfoStrings__Enum_EnterDoublewideMode = 0x00000135,
    TermInfoStrings__Enum_EnterDraftQuality = 0x00000136,
    TermInfoStrings__Enum_EnterItalicsMode = 0x00000137,
    TermInfoStrings__Enum_EnterLeftwardMode = 0x00000138,
    TermInfoStrings__Enum_EnterMicroMode = 0x00000139,
    TermInfoStrings__Enum_EnterNearLetterQuality = 0x0000013a,
    TermInfoStrings__Enum_EnterNormalQuality = 0x0000013b,
    TermInfoStrings__Enum_EnterShadowMode = 0x0000013c,
    TermInfoStrings__Enum_EnterSubscriptMode = 0x0000013d,
    TermInfoStrings__Enum_EnterSuperscriptMode = 0x0000013e,
    TermInfoStrings__Enum_EnterUpwardMode = 0x0000013f,
    TermInfoStrings__Enum_ExitDoublewideMode = 0x00000140,
    TermInfoStrings__Enum_ExitItalicsMode = 0x00000141,
    TermInfoStrings__Enum_ExitLeftwardMode = 0x00000142,
    TermInfoStrings__Enum_ExitMicroMode = 0x00000143,
    TermInfoStrings__Enum_ExitShadowMode = 0x00000144,
    TermInfoStrings__Enum_ExitSubscriptMode = 0x00000145,
    TermInfoStrings__Enum_ExitSuperscriptMode = 0x00000146,
    TermInfoStrings__Enum_ExitUpwardMode = 0x00000147,
    TermInfoStrings__Enum_MicroColumnAddress = 0x00000148,
    TermInfoStrings__Enum_MicroDown = 0x00000149,
    TermInfoStrings__Enum_MicroLeft = 0x0000014a,
    TermInfoStrings__Enum_MicroRight = 0x0000014b,
    TermInfoStrings__Enum_MicroRowAddress = 0x0000014c,
    TermInfoStrings__Enum_MicroUp = 0x0000014d,
    TermInfoStrings__Enum_OrderOfPins = 0x0000014e,
    TermInfoStrings__Enum_ParmDownMicro = 0x0000014f,
    TermInfoStrings__Enum_ParmLeftMicro = 0x00000150,
    TermInfoStrings__Enum_ParmRightMicro = 0x00000151,
    TermInfoStrings__Enum_ParmUpMicro = 0x00000152,
    TermInfoStrings__Enum_SelectCharSet = 0x00000153,
    TermInfoStrings__Enum_SetBottomMargin = 0x00000154,
    TermInfoStrings__Enum_SetBottomMarginParm = 0x00000155,
    TermInfoStrings__Enum_SetLeftMarginParm = 0x00000156,
    TermInfoStrings__Enum_SetRightMarginParm = 0x00000157,
    TermInfoStrings__Enum_SetTopMargin = 0x00000158,
    TermInfoStrings__Enum_SetTopMarginParm = 0x00000159,
    TermInfoStrings__Enum_StartBitImage = 0x0000015a,
    TermInfoStrings__Enum_StartCharSetDef = 0x0000015b,
    TermInfoStrings__Enum_StopBitImage = 0x0000015c,
    TermInfoStrings__Enum_StopCharSetDef = 0x0000015d,
    TermInfoStrings__Enum_SubscriptCharacters = 0x0000015e,
    TermInfoStrings__Enum_SuperscriptCharacters = 0x0000015f,
    TermInfoStrings__Enum_TheseCauseCr = 0x00000160,
    TermInfoStrings__Enum_ZeroMotion = 0x00000161,
    TermInfoStrings__Enum_CharSetNames = 0x00000162,
    TermInfoStrings__Enum_KeyMouse = 0x00000163,
    TermInfoStrings__Enum_MouseInfo = 0x00000164,
    TermInfoStrings__Enum_ReqMousePos = 0x00000165,
    TermInfoStrings__Enum_GetMouse = 0x00000166,
    TermInfoStrings__Enum_SetAForeground = 0x00000167,
    TermInfoStrings__Enum_SetABackground = 0x00000168,
    TermInfoStrings__Enum_PkeyPlab = 0x00000169,
    TermInfoStrings__Enum_DeviceType = 0x0000016a,
    TermInfoStrings__Enum_CodeSetInit = 0x0000016b,
    TermInfoStrings__Enum_Set0DesSeq = 0x0000016c,
    TermInfoStrings__Enum_Set1DesSeq = 0x0000016d,
    TermInfoStrings__Enum_Set2DesSeq = 0x0000016e,
    TermInfoStrings__Enum_Set3DesSeq = 0x0000016f,
    TermInfoStrings__Enum_SetLrMargin = 0x00000170,
    TermInfoStrings__Enum_SetTbMargin = 0x00000171,
    TermInfoStrings__Enum_BitImageRepeat = 0x00000172,
    TermInfoStrings__Enum_BitImageNewline = 0x00000173,
    TermInfoStrings__Enum_BitImageCarriageReturn = 0x00000174,
    TermInfoStrings__Enum_ColorNames = 0x00000175,
    TermInfoStrings__Enum_DefineBitImageRegion = 0x00000176,
    TermInfoStrings__Enum_EndBitImageRegion = 0x00000177,
    TermInfoStrings__Enum_SetColorBand = 0x00000178,
    TermInfoStrings__Enum_SetPageLength = 0x00000179,
    TermInfoStrings__Enum_DisplayPcChar = 0x0000017a,
    TermInfoStrings__Enum_EnterPcCharsetMode = 0x0000017b,
    TermInfoStrings__Enum_ExitPcCharsetMode = 0x0000017c,
    TermInfoStrings__Enum_EnterScancodeMode = 0x0000017d,
    TermInfoStrings__Enum_ExitScancodeMode = 0x0000017e,
    TermInfoStrings__Enum_PcTermOptions = 0x0000017f,
    TermInfoStrings__Enum_ScancodeEscape = 0x00000180,
    TermInfoStrings__Enum_AltScancodeEsc = 0x00000181,
    TermInfoStrings__Enum_EnterHorizontalHlMode = 0x00000182,
    TermInfoStrings__Enum_EnterLeftHlMode = 0x00000183,
    TermInfoStrings__Enum_EnterLowHlMode = 0x00000184,
    TermInfoStrings__Enum_EnterRightHlMode = 0x00000185,
    TermInfoStrings__Enum_EnterTopHlMode = 0x00000186,
    TermInfoStrings__Enum_EnterVerticalHlMode = 0x00000187,
    TermInfoStrings__Enum_SetAAttributes = 0x00000188,
    TermInfoStrings__Enum_SetPglenInch = 0x00000189,
    TermInfoStrings__Enum_Last = 0x0000018a,
};

#else
enum TermInfoStrings__Enum {
    TermInfoStrings__Enum_BackTab = 0x00000000,
    TermInfoStrings__Enum_Bell = 0x00000001,
    TermInfoStrings__Enum_CarriageReturn = 0x00000002,
    TermInfoStrings__Enum_ChangeScrollRegion = 0x00000003,
    TermInfoStrings__Enum_ClearAllTabs = 0x00000004,
    TermInfoStrings__Enum_ClearScreen = 0x00000005,
    TermInfoStrings__Enum_ClrEol = 0x00000006,
    TermInfoStrings__Enum_ClrEos = 0x00000007,
    TermInfoStrings__Enum_ColumnAddress = 0x00000008,
    TermInfoStrings__Enum_CommandCharacter = 0x00000009,
    TermInfoStrings__Enum_CursorAddress = 0x0000000a,
    TermInfoStrings__Enum_CursorDown = 0x0000000b,
    TermInfoStrings__Enum_CursorHome = 0x0000000c,
    TermInfoStrings__Enum_CursorInvisible = 0x0000000d,
    TermInfoStrings__Enum_CursorLeft = 0x0000000e,
    TermInfoStrings__Enum_CursorMemAddress = 0x0000000f,
    TermInfoStrings__Enum_CursorNormal = 0x00000010,
    TermInfoStrings__Enum_CursorRight = 0x00000011,
    TermInfoStrings__Enum_CursorToLl = 0x00000012,
    TermInfoStrings__Enum_CursorUp = 0x00000013,
    TermInfoStrings__Enum_CursorVisible = 0x00000014,
    TermInfoStrings__Enum_DeleteCharacter = 0x00000015,
    TermInfoStrings__Enum_DeleteLine = 0x00000016,
    TermInfoStrings__Enum_DisStatusLine = 0x00000017,
    TermInfoStrings__Enum_DownHalfLine = 0x00000018,
    TermInfoStrings__Enum_EnterAltCharsetMode = 0x00000019,
    TermInfoStrings__Enum_EnterBlinkMode = 0x0000001a,
    TermInfoStrings__Enum_EnterBoldMode = 0x0000001b,
    TermInfoStrings__Enum_EnterCaMode = 0x0000001c,
    TermInfoStrings__Enum_EnterDeleteMode = 0x0000001d,
    TermInfoStrings__Enum_EnterDimMode = 0x0000001e,
    TermInfoStrings__Enum_EnterInsertMode = 0x0000001f,
    TermInfoStrings__Enum_EnterSecureMode = 0x00000020,
    TermInfoStrings__Enum_EnterProtectedMode = 0x00000021,
    TermInfoStrings__Enum_EnterReverseMode = 0x00000022,
    TermInfoStrings__Enum_EnterStandoutMode = 0x00000023,
    TermInfoStrings__Enum_EnterUnderlineMode = 0x00000024,
    TermInfoStrings__Enum_EraseChars = 0x00000025,
    TermInfoStrings__Enum_ExitAltCharsetMode = 0x00000026,
    TermInfoStrings__Enum_ExitAttributeMode = 0x00000027,
    TermInfoStrings__Enum_ExitCaMode = 0x00000028,
    TermInfoStrings__Enum_ExitDeleteMode = 0x00000029,
    TermInfoStrings__Enum_ExitInsertMode = 0x0000002a,
    TermInfoStrings__Enum_ExitStandoutMode = 0x0000002b,
    TermInfoStrings__Enum_ExitUnderlineMode = 0x0000002c,
    TermInfoStrings__Enum_FlashScreen = 0x0000002d,
    TermInfoStrings__Enum_FormFeed = 0x0000002e,
    TermInfoStrings__Enum_FromStatusLine = 0x0000002f,
    TermInfoStrings__Enum_Init1string = 0x00000030,
    TermInfoStrings__Enum_Init2string = 0x00000031,
    TermInfoStrings__Enum_Init3string = 0x00000032,
    TermInfoStrings__Enum_InitFile = 0x00000033,
    TermInfoStrings__Enum_InsertCharacter = 0x00000034,
    TermInfoStrings__Enum_InsertLine = 0x00000035,
    TermInfoStrings__Enum_InsertPadding = 0x00000036,
    TermInfoStrings__Enum_KeyBackspace = 0x00000037,
    TermInfoStrings__Enum_KeyCatab = 0x00000038,
    TermInfoStrings__Enum_KeyClear = 0x00000039,
    TermInfoStrings__Enum_KeyCtab = 0x0000003a,
    TermInfoStrings__Enum_KeyDc = 0x0000003b,
    TermInfoStrings__Enum_KeyDl = 0x0000003c,
    TermInfoStrings__Enum_KeyDown = 0x0000003d,
    TermInfoStrings__Enum_KeyEic = 0x0000003e,
    TermInfoStrings__Enum_KeyEol = 0x0000003f,
    TermInfoStrings__Enum_KeyEos = 0x00000040,
    TermInfoStrings__Enum_KeyF0 = 0x00000041,
    TermInfoStrings__Enum_KeyF1 = 0x00000042,
    TermInfoStrings__Enum_KeyF10 = 0x00000043,
    TermInfoStrings__Enum_KeyF2 = 0x00000044,
    TermInfoStrings__Enum_KeyF3 = 0x00000045,
    TermInfoStrings__Enum_KeyF4 = 0x00000046,
    TermInfoStrings__Enum_KeyF5 = 0x00000047,
    TermInfoStrings__Enum_KeyF6 = 0x00000048,
    TermInfoStrings__Enum_KeyF7 = 0x00000049,
    TermInfoStrings__Enum_KeyF8 = 0x0000004a,
    TermInfoStrings__Enum_KeyF9 = 0x0000004b,
    TermInfoStrings__Enum_KeyHome = 0x0000004c,
    TermInfoStrings__Enum_KeyIc = 0x0000004d,
    TermInfoStrings__Enum_KeyIl = 0x0000004e,
    TermInfoStrings__Enum_KeyLeft = 0x0000004f,
    TermInfoStrings__Enum_KeyLl = 0x00000050,
    TermInfoStrings__Enum_KeyNpage = 0x00000051,
    TermInfoStrings__Enum_KeyPpage = 0x00000052,
    TermInfoStrings__Enum_KeyRight = 0x00000053,
    TermInfoStrings__Enum_KeySf = 0x00000054,
    TermInfoStrings__Enum_KeySr = 0x00000055,
    TermInfoStrings__Enum_KeyStab = 0x00000056,
    TermInfoStrings__Enum_KeyUp = 0x00000057,
    TermInfoStrings__Enum_KeypadLocal = 0x00000058,
    TermInfoStrings__Enum_KeypadXmit = 0x00000059,
    TermInfoStrings__Enum_LabF0 = 0x0000005a,
    TermInfoStrings__Enum_LabF1 = 0x0000005b,
    TermInfoStrings__Enum_LabF10 = 0x0000005c,
    TermInfoStrings__Enum_LabF2 = 0x0000005d,
    TermInfoStrings__Enum_LabF3 = 0x0000005e,
    TermInfoStrings__Enum_LabF4 = 0x0000005f,
    TermInfoStrings__Enum_LabF5 = 0x00000060,
    TermInfoStrings__Enum_LabF6 = 0x00000061,
    TermInfoStrings__Enum_LabF7 = 0x00000062,
    TermInfoStrings__Enum_LabF8 = 0x00000063,
    TermInfoStrings__Enum_LabF9 = 0x00000064,
    TermInfoStrings__Enum_MetaOff = 0x00000065,
    TermInfoStrings__Enum_MetaOn = 0x00000066,
    TermInfoStrings__Enum_Newline = 0x00000067,
    TermInfoStrings__Enum_PadChar = 0x00000068,
    TermInfoStrings__Enum_ParmDch = 0x00000069,
    TermInfoStrings__Enum_ParmDeleteLine = 0x0000006a,
    TermInfoStrings__Enum_ParmDownCursor = 0x0000006b,
    TermInfoStrings__Enum_ParmIch = 0x0000006c,
    TermInfoStrings__Enum_ParmIndex = 0x0000006d,
    TermInfoStrings__Enum_ParmInsertLine = 0x0000006e,
    TermInfoStrings__Enum_ParmLeftCursor = 0x0000006f,
    TermInfoStrings__Enum_ParmRightCursor = 0x00000070,
    TermInfoStrings__Enum_ParmRindex = 0x00000071,
    TermInfoStrings__Enum_ParmUpCursor = 0x00000072,
    TermInfoStrings__Enum_PkeyKey = 0x00000073,
    TermInfoStrings__Enum_PkeyLocal = 0x00000074,
    TermInfoStrings__Enum_PkeyXmit = 0x00000075,
    TermInfoStrings__Enum_PrintScreen = 0x00000076,
    TermInfoStrings__Enum_PrtrOff = 0x00000077,
    TermInfoStrings__Enum_PrtrOn = 0x00000078,
    TermInfoStrings__Enum_RepeatChar = 0x00000079,
    TermInfoStrings__Enum_Reset1string = 0x0000007a,
    TermInfoStrings__Enum_Reset2string = 0x0000007b,
    TermInfoStrings__Enum_Reset3string = 0x0000007c,
    TermInfoStrings__Enum_ResetFile = 0x0000007d,
    TermInfoStrings__Enum_RestoreCursor = 0x0000007e,
    TermInfoStrings__Enum_RowAddress = 0x0000007f,
    TermInfoStrings__Enum_SaveCursor = 0x00000080,
    TermInfoStrings__Enum_ScrollForward = 0x00000081,
    TermInfoStrings__Enum_ScrollReverse = 0x00000082,
    TermInfoStrings__Enum_SetAttributes = 0x00000083,
    TermInfoStrings__Enum_SetTab = 0x00000084,
    TermInfoStrings__Enum_SetWindow = 0x00000085,
    TermInfoStrings__Enum_Tab = 0x00000086,
    TermInfoStrings__Enum_ToStatusLine = 0x00000087,
    TermInfoStrings__Enum_UnderlineChar = 0x00000088,
    TermInfoStrings__Enum_UpHalfLine = 0x00000089,
    TermInfoStrings__Enum_InitProg = 0x0000008a,
    TermInfoStrings__Enum_KeyA1 = 0x0000008b,
    TermInfoStrings__Enum_KeyA3 = 0x0000008c,
    TermInfoStrings__Enum_KeyB2 = 0x0000008d,
    TermInfoStrings__Enum_KeyC1 = 0x0000008e,
    TermInfoStrings__Enum_KeyC3 = 0x0000008f,
    TermInfoStrings__Enum_PrtrNon = 0x00000090,
    TermInfoStrings__Enum_CharPadding = 0x00000091,
    TermInfoStrings__Enum_AcsChars = 0x00000092,
    TermInfoStrings__Enum_PlabNorm = 0x00000093,
    TermInfoStrings__Enum_KeyBtab = 0x00000094,
    TermInfoStrings__Enum_EnterXonMode = 0x00000095,
    TermInfoStrings__Enum_ExitXonMode = 0x00000096,
    TermInfoStrings__Enum_EnterAmMode = 0x00000097,
    TermInfoStrings__Enum_ExitAmMode = 0x00000098,
    TermInfoStrings__Enum_XonCharacter = 0x00000099,
    TermInfoStrings__Enum_XoffCharacter = 0x0000009a,
    TermInfoStrings__Enum_EnaAcs = 0x0000009b,
    TermInfoStrings__Enum_LabelOn = 0x0000009c,
    TermInfoStrings__Enum_LabelOff = 0x0000009d,
    TermInfoStrings__Enum_KeyBeg = 0x0000009e,
    TermInfoStrings__Enum_KeyCancel = 0x0000009f,
    TermInfoStrings__Enum_KeyClose = 0x000000a0,
    TermInfoStrings__Enum_KeyCommand = 0x000000a1,
    TermInfoStrings__Enum_KeyCopy = 0x000000a2,
    TermInfoStrings__Enum_KeyCreate = 0x000000a3,
    TermInfoStrings__Enum_KeyEnd = 0x000000a4,
    TermInfoStrings__Enum_KeyEnter = 0x000000a5,
    TermInfoStrings__Enum_KeyExit = 0x000000a6,
    TermInfoStrings__Enum_KeyFind = 0x000000a7,
    TermInfoStrings__Enum_KeyHelp = 0x000000a8,
    TermInfoStrings__Enum_KeyMark = 0x000000a9,
    TermInfoStrings__Enum_KeyMessage = 0x000000aa,
    TermInfoStrings__Enum_KeyMove = 0x000000ab,
    TermInfoStrings__Enum_KeyNext = 0x000000ac,
    TermInfoStrings__Enum_KeyOpen = 0x000000ad,
    TermInfoStrings__Enum_KeyOptions = 0x000000ae,
    TermInfoStrings__Enum_KeyPrevious = 0x000000af,
    TermInfoStrings__Enum_KeyPrint = 0x000000b0,
    TermInfoStrings__Enum_KeyRedo = 0x000000b1,
    TermInfoStrings__Enum_KeyReference = 0x000000b2,
    TermInfoStrings__Enum_KeyRefresh = 0x000000b3,
    TermInfoStrings__Enum_KeyReplace = 0x000000b4,
    TermInfoStrings__Enum_KeyRestart = 0x000000b5,
    TermInfoStrings__Enum_KeyResume = 0x000000b6,
    TermInfoStrings__Enum_KeySave = 0x000000b7,
    TermInfoStrings__Enum_KeySuspend = 0x000000b8,
    TermInfoStrings__Enum_KeyUndo = 0x000000b9,
    TermInfoStrings__Enum_KeySbeg = 0x000000ba,
    TermInfoStrings__Enum_KeyScancel = 0x000000bb,
    TermInfoStrings__Enum_KeyScommand = 0x000000bc,
    TermInfoStrings__Enum_KeyScopy = 0x000000bd,
    TermInfoStrings__Enum_KeyScreate = 0x000000be,
    TermInfoStrings__Enum_KeySdc = 0x000000bf,
    TermInfoStrings__Enum_KeySdl = 0x000000c0,
    TermInfoStrings__Enum_KeySelect = 0x000000c1,
    TermInfoStrings__Enum_KeySend = 0x000000c2,
    TermInfoStrings__Enum_KeySeol = 0x000000c3,
    TermInfoStrings__Enum_KeySexit = 0x000000c4,
    TermInfoStrings__Enum_KeySfind = 0x000000c5,
    TermInfoStrings__Enum_KeyShelp = 0x000000c6,
    TermInfoStrings__Enum_KeyShome = 0x000000c7,
    TermInfoStrings__Enum_KeySic = 0x000000c8,
    TermInfoStrings__Enum_KeySleft = 0x000000c9,
    TermInfoStrings__Enum_KeySmessage = 0x000000ca,
    TermInfoStrings__Enum_KeySmove = 0x000000cb,
    TermInfoStrings__Enum_KeySnext = 0x000000cc,
    TermInfoStrings__Enum_KeySoptions = 0x000000cd,
    TermInfoStrings__Enum_KeySprevious = 0x000000ce,
    TermInfoStrings__Enum_KeySprint = 0x000000cf,
    TermInfoStrings__Enum_KeySredo = 0x000000d0,
    TermInfoStrings__Enum_KeySreplace = 0x000000d1,
    TermInfoStrings__Enum_KeySright = 0x000000d2,
    TermInfoStrings__Enum_KeySrsume = 0x000000d3,
    TermInfoStrings__Enum_KeySsave = 0x000000d4,
    TermInfoStrings__Enum_KeySsuspend = 0x000000d5,
    TermInfoStrings__Enum_KeySundo = 0x000000d6,
    TermInfoStrings__Enum_ReqForInput = 0x000000d7,
    TermInfoStrings__Enum_KeyF11 = 0x000000d8,
    TermInfoStrings__Enum_KeyF12 = 0x000000d9,
    TermInfoStrings__Enum_KeyF13 = 0x000000da,
    TermInfoStrings__Enum_KeyF14 = 0x000000db,
    TermInfoStrings__Enum_KeyF15 = 0x000000dc,
    TermInfoStrings__Enum_KeyF16 = 0x000000dd,
    TermInfoStrings__Enum_KeyF17 = 0x000000de,
    TermInfoStrings__Enum_KeyF18 = 0x000000df,
    TermInfoStrings__Enum_KeyF19 = 0x000000e0,
    TermInfoStrings__Enum_KeyF20 = 0x000000e1,
    TermInfoStrings__Enum_KeyF21 = 0x000000e2,
    TermInfoStrings__Enum_KeyF22 = 0x000000e3,
    TermInfoStrings__Enum_KeyF23 = 0x000000e4,
    TermInfoStrings__Enum_KeyF24 = 0x000000e5,
    TermInfoStrings__Enum_KeyF25 = 0x000000e6,
    TermInfoStrings__Enum_KeyF26 = 0x000000e7,
    TermInfoStrings__Enum_KeyF27 = 0x000000e8,
    TermInfoStrings__Enum_KeyF28 = 0x000000e9,
    TermInfoStrings__Enum_KeyF29 = 0x000000ea,
    TermInfoStrings__Enum_KeyF30 = 0x000000eb,
    TermInfoStrings__Enum_KeyF31 = 0x000000ec,
    TermInfoStrings__Enum_KeyF32 = 0x000000ed,
    TermInfoStrings__Enum_KeyF33 = 0x000000ee,
    TermInfoStrings__Enum_KeyF34 = 0x000000ef,
    TermInfoStrings__Enum_KeyF35 = 0x000000f0,
    TermInfoStrings__Enum_KeyF36 = 0x000000f1,
    TermInfoStrings__Enum_KeyF37 = 0x000000f2,
    TermInfoStrings__Enum_KeyF38 = 0x000000f3,
    TermInfoStrings__Enum_KeyF39 = 0x000000f4,
    TermInfoStrings__Enum_KeyF40 = 0x000000f5,
    TermInfoStrings__Enum_KeyF41 = 0x000000f6,
    TermInfoStrings__Enum_KeyF42 = 0x000000f7,
    TermInfoStrings__Enum_KeyF43 = 0x000000f8,
    TermInfoStrings__Enum_KeyF44 = 0x000000f9,
    TermInfoStrings__Enum_KeyF45 = 0x000000fa,
    TermInfoStrings__Enum_KeyF46 = 0x000000fb,
    TermInfoStrings__Enum_KeyF47 = 0x000000fc,
    TermInfoStrings__Enum_KeyF48 = 0x000000fd,
    TermInfoStrings__Enum_KeyF49 = 0x000000fe,
    TermInfoStrings__Enum_KeyF50 = 0x000000ff,
    TermInfoStrings__Enum_KeyF51 = 0x00000100,
    TermInfoStrings__Enum_KeyF52 = 0x00000101,
    TermInfoStrings__Enum_KeyF53 = 0x00000102,
    TermInfoStrings__Enum_KeyF54 = 0x00000103,
    TermInfoStrings__Enum_KeyF55 = 0x00000104,
    TermInfoStrings__Enum_KeyF56 = 0x00000105,
    TermInfoStrings__Enum_KeyF57 = 0x00000106,
    TermInfoStrings__Enum_KeyF58 = 0x00000107,
    TermInfoStrings__Enum_KeyF59 = 0x00000108,
    TermInfoStrings__Enum_KeyF60 = 0x00000109,
    TermInfoStrings__Enum_KeyF61 = 0x0000010a,
    TermInfoStrings__Enum_KeyF62 = 0x0000010b,
    TermInfoStrings__Enum_KeyF63 = 0x0000010c,
    TermInfoStrings__Enum_ClrBol = 0x0000010d,
    TermInfoStrings__Enum_ClearMargins = 0x0000010e,
    TermInfoStrings__Enum_SetLeftMargin = 0x0000010f,
    TermInfoStrings__Enum_SetRightMargin = 0x00000110,
    TermInfoStrings__Enum_LabelFormat = 0x00000111,
    TermInfoStrings__Enum_SetClock = 0x00000112,
    TermInfoStrings__Enum_DisplayClock = 0x00000113,
    TermInfoStrings__Enum_RemoveClock = 0x00000114,
    TermInfoStrings__Enum_CreateWindow = 0x00000115,
    TermInfoStrings__Enum_GotoWindow = 0x00000116,
    TermInfoStrings__Enum_Hangup = 0x00000117,
    TermInfoStrings__Enum_DialPhone = 0x00000118,
    TermInfoStrings__Enum_QuickDial = 0x00000119,
    TermInfoStrings__Enum_Tone = 0x0000011a,
    TermInfoStrings__Enum_Pulse = 0x0000011b,
    TermInfoStrings__Enum_FlashHook = 0x0000011c,
    TermInfoStrings__Enum_FixedPause = 0x0000011d,
    TermInfoStrings__Enum_WaitTone = 0x0000011e,
    TermInfoStrings__Enum_User0 = 0x0000011f,
    TermInfoStrings__Enum_User1 = 0x00000120,
    TermInfoStrings__Enum_User2 = 0x00000121,
    TermInfoStrings__Enum_User3 = 0x00000122,
    TermInfoStrings__Enum_User4 = 0x00000123,
    TermInfoStrings__Enum_User5 = 0x00000124,
    TermInfoStrings__Enum_User6 = 0x00000125,
    TermInfoStrings__Enum_User7 = 0x00000126,
    TermInfoStrings__Enum_User8 = 0x00000127,
    TermInfoStrings__Enum_User9 = 0x00000128,
    TermInfoStrings__Enum_OrigPair = 0x00000129,
    TermInfoStrings__Enum_OrigColors = 0x0000012a,
    TermInfoStrings__Enum_InitializeColor = 0x0000012b,
    TermInfoStrings__Enum_InitializePair = 0x0000012c,
    TermInfoStrings__Enum_SetColorPair = 0x0000012d,
    TermInfoStrings__Enum_SetForeground = 0x0000012e,
    TermInfoStrings__Enum_SetBackground = 0x0000012f,
    TermInfoStrings__Enum_ChangeCharPitch = 0x00000130,
    TermInfoStrings__Enum_ChangeLinePitch = 0x00000131,
    TermInfoStrings__Enum_ChangeResHorz = 0x00000132,
    TermInfoStrings__Enum_ChangeResVert = 0x00000133,
    TermInfoStrings__Enum_DefineChar = 0x00000134,
    TermInfoStrings__Enum_EnterDoublewideMode = 0x00000135,
    TermInfoStrings__Enum_EnterDraftQuality = 0x00000136,
    TermInfoStrings__Enum_EnterItalicsMode = 0x00000137,
    TermInfoStrings__Enum_EnterLeftwardMode = 0x00000138,
    TermInfoStrings__Enum_EnterMicroMode = 0x00000139,
    TermInfoStrings__Enum_EnterNearLetterQuality = 0x0000013a,
    TermInfoStrings__Enum_EnterNormalQuality = 0x0000013b,
    TermInfoStrings__Enum_EnterShadowMode = 0x0000013c,
    TermInfoStrings__Enum_EnterSubscriptMode = 0x0000013d,
    TermInfoStrings__Enum_EnterSuperscriptMode = 0x0000013e,
    TermInfoStrings__Enum_EnterUpwardMode = 0x0000013f,
    TermInfoStrings__Enum_ExitDoublewideMode = 0x00000140,
    TermInfoStrings__Enum_ExitItalicsMode = 0x00000141,
    TermInfoStrings__Enum_ExitLeftwardMode = 0x00000142,
    TermInfoStrings__Enum_ExitMicroMode = 0x00000143,
    TermInfoStrings__Enum_ExitShadowMode = 0x00000144,
    TermInfoStrings__Enum_ExitSubscriptMode = 0x00000145,
    TermInfoStrings__Enum_ExitSuperscriptMode = 0x00000146,
    TermInfoStrings__Enum_ExitUpwardMode = 0x00000147,
    TermInfoStrings__Enum_MicroColumnAddress = 0x00000148,
    TermInfoStrings__Enum_MicroDown = 0x00000149,
    TermInfoStrings__Enum_MicroLeft = 0x0000014a,
    TermInfoStrings__Enum_MicroRight = 0x0000014b,
    TermInfoStrings__Enum_MicroRowAddress = 0x0000014c,
    TermInfoStrings__Enum_MicroUp = 0x0000014d,
    TermInfoStrings__Enum_OrderOfPins = 0x0000014e,
    TermInfoStrings__Enum_ParmDownMicro = 0x0000014f,
    TermInfoStrings__Enum_ParmLeftMicro = 0x00000150,
    TermInfoStrings__Enum_ParmRightMicro = 0x00000151,
    TermInfoStrings__Enum_ParmUpMicro = 0x00000152,
    TermInfoStrings__Enum_SelectCharSet = 0x00000153,
    TermInfoStrings__Enum_SetBottomMargin = 0x00000154,
    TermInfoStrings__Enum_SetBottomMarginParm = 0x00000155,
    TermInfoStrings__Enum_SetLeftMarginParm = 0x00000156,
    TermInfoStrings__Enum_SetRightMarginParm = 0x00000157,
    TermInfoStrings__Enum_SetTopMargin = 0x00000158,
    TermInfoStrings__Enum_SetTopMarginParm = 0x00000159,
    TermInfoStrings__Enum_StartBitImage = 0x0000015a,
    TermInfoStrings__Enum_StartCharSetDef = 0x0000015b,
    TermInfoStrings__Enum_StopBitImage = 0x0000015c,
    TermInfoStrings__Enum_StopCharSetDef = 0x0000015d,
    TermInfoStrings__Enum_SubscriptCharacters = 0x0000015e,
    TermInfoStrings__Enum_SuperscriptCharacters = 0x0000015f,
    TermInfoStrings__Enum_TheseCauseCr = 0x00000160,
    TermInfoStrings__Enum_ZeroMotion = 0x00000161,
    TermInfoStrings__Enum_CharSetNames = 0x00000162,
    TermInfoStrings__Enum_KeyMouse = 0x00000163,
    TermInfoStrings__Enum_MouseInfo = 0x00000164,
    TermInfoStrings__Enum_ReqMousePos = 0x00000165,
    TermInfoStrings__Enum_GetMouse = 0x00000166,
    TermInfoStrings__Enum_SetAForeground = 0x00000167,
    TermInfoStrings__Enum_SetABackground = 0x00000168,
    TermInfoStrings__Enum_PkeyPlab = 0x00000169,
    TermInfoStrings__Enum_DeviceType = 0x0000016a,
    TermInfoStrings__Enum_CodeSetInit = 0x0000016b,
    TermInfoStrings__Enum_Set0DesSeq = 0x0000016c,
    TermInfoStrings__Enum_Set1DesSeq = 0x0000016d,
    TermInfoStrings__Enum_Set2DesSeq = 0x0000016e,
    TermInfoStrings__Enum_Set3DesSeq = 0x0000016f,
    TermInfoStrings__Enum_SetLrMargin = 0x00000170,
    TermInfoStrings__Enum_SetTbMargin = 0x00000171,
    TermInfoStrings__Enum_BitImageRepeat = 0x00000172,
    TermInfoStrings__Enum_BitImageNewline = 0x00000173,
    TermInfoStrings__Enum_BitImageCarriageReturn = 0x00000174,
    TermInfoStrings__Enum_ColorNames = 0x00000175,
    TermInfoStrings__Enum_DefineBitImageRegion = 0x00000176,
    TermInfoStrings__Enum_EndBitImageRegion = 0x00000177,
    TermInfoStrings__Enum_SetColorBand = 0x00000178,
    TermInfoStrings__Enum_SetPageLength = 0x00000179,
    TermInfoStrings__Enum_DisplayPcChar = 0x0000017a,
    TermInfoStrings__Enum_EnterPcCharsetMode = 0x0000017b,
    TermInfoStrings__Enum_ExitPcCharsetMode = 0x0000017c,
    TermInfoStrings__Enum_EnterScancodeMode = 0x0000017d,
    TermInfoStrings__Enum_ExitScancodeMode = 0x0000017e,
    TermInfoStrings__Enum_PcTermOptions = 0x0000017f,
    TermInfoStrings__Enum_ScancodeEscape = 0x00000180,
    TermInfoStrings__Enum_AltScancodeEsc = 0x00000181,
    TermInfoStrings__Enum_EnterHorizontalHlMode = 0x00000182,
    TermInfoStrings__Enum_EnterLeftHlMode = 0x00000183,
    TermInfoStrings__Enum_EnterLowHlMode = 0x00000184,
    TermInfoStrings__Enum_EnterRightHlMode = 0x00000185,
    TermInfoStrings__Enum_EnterTopHlMode = 0x00000186,
    TermInfoStrings__Enum_EnterVerticalHlMode = 0x00000187,
    TermInfoStrings__Enum_SetAAttributes = 0x00000188,
    TermInfoStrings__Enum_SetPglenInch = 0x00000189,
    TermInfoStrings__Enum_Last = 0x0000018a,
};

#endif
struct TermInfoStrings__Enum__Boxed {
    struct TermInfoStrings__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum TermInfoStrings__Enum value;
    #else
    uint32_t value;
    #endif
};

struct TermInfoStrings__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct TermInfoStrings__Enum__StaticFields {
};

struct TermInfoStrings__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TermInfoStrings__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TermInfoStrings__Enum__VTable vtable;
};

struct ParameterizedStrings_FormatParam {
    int32_t _int32_1;
    struct String *_string;
};

struct ParameterizedStrings_FormatParam__Boxed {
    struct ParameterizedStrings_FormatParam__Class *klass;
    MonitorData *monitor;
    struct ParameterizedStrings_FormatParam fields;
};

struct ParameterizedStrings_FormatParam__Array {
    struct ParameterizedStrings_FormatParam__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct ParameterizedStrings_FormatParam vector[32];
};

struct ParameterizedStrings_FormatParam__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ParameterizedStrings_FormatParam__StaticFields {
};

struct ParameterizedStrings_FormatParam__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ParameterizedStrings_FormatParam__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ParameterizedStrings_FormatParam__VTable vtable;
};

struct ParameterizedStrings_FormatParam__Array__VTable {
};

struct ParameterizedStrings_FormatParam__Array__StaticFields {
};

struct ParameterizedStrings_FormatParam__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ParameterizedStrings_FormatParam__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ParameterizedStrings_FormatParam__Array__VTable vtable;
};

struct __declspec(align(8)) ParameterizedStrings_LowLevelStack__Fields {
    struct ParameterizedStrings_FormatParam__Array *_arr;
    int32_t _count;
};

struct ParameterizedStrings_LowLevelStack {
    struct ParameterizedStrings_LowLevelStack__Class *klass;
    MonitorData *monitor;
    struct ParameterizedStrings_LowLevelStack__Fields fields;
};

struct ParameterizedStrings_LowLevelStack__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ParameterizedStrings_LowLevelStack__StaticFields {
};

struct ParameterizedStrings_LowLevelStack__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ParameterizedStrings_LowLevelStack__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ParameterizedStrings_LowLevelStack__VTable vtable;
};

struct ParameterizedStrings_FormatParam___VTable {
};

struct ParameterizedStrings_FormatParam___StaticFields {
};

struct ParameterizedStrings_FormatParam___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ParameterizedStrings_FormatParam___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ParameterizedStrings_FormatParam___VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum TermInfoBooleans__Enum : int32_t {
    TermInfoBooleans__Enum_AutoLeftMargin = 0x00000000,
    TermInfoBooleans__Enum_AutoRightMargin = 0x00000001,
    TermInfoBooleans__Enum_NoEscCtlc = 0x00000002,
    TermInfoBooleans__Enum_CeolStandoutGlitch = 0x00000003,
    TermInfoBooleans__Enum_EatNewlineGlitch = 0x00000004,
    TermInfoBooleans__Enum_EraseOverstrike = 0x00000005,
    TermInfoBooleans__Enum_GenericType = 0x00000006,
    TermInfoBooleans__Enum_HardCopy = 0x00000007,
    TermInfoBooleans__Enum_HasMetaKey = 0x00000008,
    TermInfoBooleans__Enum_HasStatusLine = 0x00000009,
    TermInfoBooleans__Enum_InsertNullGlitch = 0x0000000a,
    TermInfoBooleans__Enum_MemoryAbove = 0x0000000b,
    TermInfoBooleans__Enum_MemoryBelow = 0x0000000c,
    TermInfoBooleans__Enum_MoveInsertMode = 0x0000000d,
    TermInfoBooleans__Enum_MoveStandoutMode = 0x0000000e,
    TermInfoBooleans__Enum_OverStrike = 0x0000000f,
    TermInfoBooleans__Enum_StatusLineEscOk = 0x00000010,
    TermInfoBooleans__Enum_DestTabsMagicSmso = 0x00000011,
    TermInfoBooleans__Enum_TildeGlitch = 0x00000012,
    TermInfoBooleans__Enum_TransparentUnderline = 0x00000013,
    TermInfoBooleans__Enum_XonXoff = 0x00000014,
    TermInfoBooleans__Enum_NeedsXonXoff = 0x00000015,
    TermInfoBooleans__Enum_PrtrSilent = 0x00000016,
    TermInfoBooleans__Enum_HardCursor = 0x00000017,
    TermInfoBooleans__Enum_NonRevRmcup = 0x00000018,
    TermInfoBooleans__Enum_NoPadChar = 0x00000019,
    TermInfoBooleans__Enum_NonDestScrollRegion = 0x0000001a,
    TermInfoBooleans__Enum_CanChange = 0x0000001b,
    TermInfoBooleans__Enum_BackColorErase = 0x0000001c,
    TermInfoBooleans__Enum_HueLightnessSaturation = 0x0000001d,
    TermInfoBooleans__Enum_ColAddrGlitch = 0x0000001e,
    TermInfoBooleans__Enum_CrCancelsMicroMode = 0x0000001f,
    TermInfoBooleans__Enum_HasPrintWheel = 0x00000020,
    TermInfoBooleans__Enum_RowAddrGlitch = 0x00000021,
    TermInfoBooleans__Enum_SemiAutoRightMargin = 0x00000022,
    TermInfoBooleans__Enum_CpiChangesRes = 0x00000023,
    TermInfoBooleans__Enum_LpiChangesRes = 0x00000024,
    TermInfoBooleans__Enum_Last = 0x00000025,
};

#else
enum TermInfoBooleans__Enum {
    TermInfoBooleans__Enum_AutoLeftMargin = 0x00000000,
    TermInfoBooleans__Enum_AutoRightMargin = 0x00000001,
    TermInfoBooleans__Enum_NoEscCtlc = 0x00000002,
    TermInfoBooleans__Enum_CeolStandoutGlitch = 0x00000003,
    TermInfoBooleans__Enum_EatNewlineGlitch = 0x00000004,
    TermInfoBooleans__Enum_EraseOverstrike = 0x00000005,
    TermInfoBooleans__Enum_GenericType = 0x00000006,
    TermInfoBooleans__Enum_HardCopy = 0x00000007,
    TermInfoBooleans__Enum_HasMetaKey = 0x00000008,
    TermInfoBooleans__Enum_HasStatusLine = 0x00000009,
    TermInfoBooleans__Enum_InsertNullGlitch = 0x0000000a,
    TermInfoBooleans__Enum_MemoryAbove = 0x0000000b,
    TermInfoBooleans__Enum_MemoryBelow = 0x0000000c,
    TermInfoBooleans__Enum_MoveInsertMode = 0x0000000d,
    TermInfoBooleans__Enum_MoveStandoutMode = 0x0000000e,
    TermInfoBooleans__Enum_OverStrike = 0x0000000f,
    TermInfoBooleans__Enum_StatusLineEscOk = 0x00000010,
    TermInfoBooleans__Enum_DestTabsMagicSmso = 0x00000011,
    TermInfoBooleans__Enum_TildeGlitch = 0x00000012,
    TermInfoBooleans__Enum_TransparentUnderline = 0x00000013,
    TermInfoBooleans__Enum_XonXoff = 0x00000014,
    TermInfoBooleans__Enum_NeedsXonXoff = 0x00000015,
    TermInfoBooleans__Enum_PrtrSilent = 0x00000016,
    TermInfoBooleans__Enum_HardCursor = 0x00000017,
    TermInfoBooleans__Enum_NonRevRmcup = 0x00000018,
    TermInfoBooleans__Enum_NoPadChar = 0x00000019,
    TermInfoBooleans__Enum_NonDestScrollRegion = 0x0000001a,
    TermInfoBooleans__Enum_CanChange = 0x0000001b,
    TermInfoBooleans__Enum_BackColorErase = 0x0000001c,
    TermInfoBooleans__Enum_HueLightnessSaturation = 0x0000001d,
    TermInfoBooleans__Enum_ColAddrGlitch = 0x0000001e,
    TermInfoBooleans__Enum_CrCancelsMicroMode = 0x0000001f,
    TermInfoBooleans__Enum_HasPrintWheel = 0x00000020,
    TermInfoBooleans__Enum_RowAddrGlitch = 0x00000021,
    TermInfoBooleans__Enum_SemiAutoRightMargin = 0x00000022,
    TermInfoBooleans__Enum_CpiChangesRes = 0x00000023,
    TermInfoBooleans__Enum_LpiChangesRes = 0x00000024,
    TermInfoBooleans__Enum_Last = 0x00000025,
};

#endif
struct TermInfoBooleans__Enum__Boxed {
    struct TermInfoBooleans__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum TermInfoBooleans__Enum value;
    #else
    uint32_t value;
    #endif
};

struct TermInfoBooleans__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct TermInfoBooleans__Enum__StaticFields {
};

struct TermInfoBooleans__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TermInfoBooleans__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TermInfoBooleans__Enum__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum TermInfoNumbers__Enum : int32_t {
    TermInfoNumbers__Enum_Columns = 0x00000000,
    TermInfoNumbers__Enum_InitTabs = 0x00000001,
    TermInfoNumbers__Enum_Lines = 0x00000002,
    TermInfoNumbers__Enum_LinesOfMemory = 0x00000003,
    TermInfoNumbers__Enum_MagicCookieGlitch = 0x00000004,
    TermInfoNumbers__Enum_PaddingBaudRate = 0x00000005,
    TermInfoNumbers__Enum_VirtualTerminal = 0x00000006,
    TermInfoNumbers__Enum_WidthStatusLine = 0x00000007,
    TermInfoNumbers__Enum_NumLabels = 0x00000008,
    TermInfoNumbers__Enum_LabelHeight = 0x00000009,
    TermInfoNumbers__Enum_LabelWidth = 0x0000000a,
    TermInfoNumbers__Enum_MaxAttributes = 0x0000000b,
    TermInfoNumbers__Enum_MaximumWindows = 0x0000000c,
    TermInfoNumbers__Enum_MaxColors = 0x0000000d,
    TermInfoNumbers__Enum_MaxPairs = 0x0000000e,
    TermInfoNumbers__Enum_NoColorVideo = 0x0000000f,
    TermInfoNumbers__Enum_BufferCapacity = 0x00000010,
    TermInfoNumbers__Enum_DotVertSpacing = 0x00000011,
    TermInfoNumbers__Enum_DotHorzSpacing = 0x00000012,
    TermInfoNumbers__Enum_MaxMicroAddress = 0x00000013,
    TermInfoNumbers__Enum_MaxMicroJump = 0x00000014,
    TermInfoNumbers__Enum_MicroColSize = 0x00000015,
    TermInfoNumbers__Enum_MicroLineSize = 0x00000016,
    TermInfoNumbers__Enum_NumberOfPins = 0x00000017,
    TermInfoNumbers__Enum_OutputResChar = 0x00000018,
    TermInfoNumbers__Enum_OutputResLine = 0x00000019,
    TermInfoNumbers__Enum_OutputResHorzInch = 0x0000001a,
    TermInfoNumbers__Enum_OutputResVertInch = 0x0000001b,
    TermInfoNumbers__Enum_PrintRate = 0x0000001c,
    TermInfoNumbers__Enum_WideCharSize = 0x0000001d,
    TermInfoNumbers__Enum_Buttons = 0x0000001e,
    TermInfoNumbers__Enum_BitImageEntwining = 0x0000001f,
    TermInfoNumbers__Enum_BitImageType = 0x00000020,
    TermInfoNumbers__Enum_Last = 0x00000021,
};

#else
enum TermInfoNumbers__Enum {
    TermInfoNumbers__Enum_Columns = 0x00000000,
    TermInfoNumbers__Enum_InitTabs = 0x00000001,
    TermInfoNumbers__Enum_Lines = 0x00000002,
    TermInfoNumbers__Enum_LinesOfMemory = 0x00000003,
    TermInfoNumbers__Enum_MagicCookieGlitch = 0x00000004,
    TermInfoNumbers__Enum_PaddingBaudRate = 0x00000005,
    TermInfoNumbers__Enum_VirtualTerminal = 0x00000006,
    TermInfoNumbers__Enum_WidthStatusLine = 0x00000007,
    TermInfoNumbers__Enum_NumLabels = 0x00000008,
    TermInfoNumbers__Enum_LabelHeight = 0x00000009,
    TermInfoNumbers__Enum_LabelWidth = 0x0000000a,
    TermInfoNumbers__Enum_MaxAttributes = 0x0000000b,
    TermInfoNumbers__Enum_MaximumWindows = 0x0000000c,
    TermInfoNumbers__Enum_MaxColors = 0x0000000d,
    TermInfoNumbers__Enum_MaxPairs = 0x0000000e,
    TermInfoNumbers__Enum_NoColorVideo = 0x0000000f,
    TermInfoNumbers__Enum_BufferCapacity = 0x00000010,
    TermInfoNumbers__Enum_DotVertSpacing = 0x00000011,
    TermInfoNumbers__Enum_DotHorzSpacing = 0x00000012,
    TermInfoNumbers__Enum_MaxMicroAddress = 0x00000013,
    TermInfoNumbers__Enum_MaxMicroJump = 0x00000014,
    TermInfoNumbers__Enum_MicroColSize = 0x00000015,
    TermInfoNumbers__Enum_MicroLineSize = 0x00000016,
    TermInfoNumbers__Enum_NumberOfPins = 0x00000017,
    TermInfoNumbers__Enum_OutputResChar = 0x00000018,
    TermInfoNumbers__Enum_OutputResLine = 0x00000019,
    TermInfoNumbers__Enum_OutputResHorzInch = 0x0000001a,
    TermInfoNumbers__Enum_OutputResVertInch = 0x0000001b,
    TermInfoNumbers__Enum_PrintRate = 0x0000001c,
    TermInfoNumbers__Enum_WideCharSize = 0x0000001d,
    TermInfoNumbers__Enum_Buttons = 0x0000001e,
    TermInfoNumbers__Enum_BitImageEntwining = 0x0000001f,
    TermInfoNumbers__Enum_BitImageType = 0x00000020,
    TermInfoNumbers__Enum_Last = 0x00000021,
};

#endif
struct TermInfoNumbers__Enum__Boxed {
    struct TermInfoNumbers__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum TermInfoNumbers__Enum value;
    #else
    uint32_t value;
    #endif
};

struct TermInfoNumbers__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct TermInfoNumbers__Enum__StaticFields {
};

struct TermInfoNumbers__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TermInfoNumbers__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TermInfoNumbers__Enum__VTable vtable;
};

struct TimeZone {
    struct TimeZone__Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) CurrentSystemTimeZone__Fields {
    struct TimeZoneInfo *LocalTimeZone;
};

struct CurrentSystemTimeZone {
    struct CurrentSystemTimeZone__Class *klass;
    MonitorData *monitor;
    struct CurrentSystemTimeZone__Fields fields;
};

struct CurrentSystemTimeZone__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_DaylightName;
    VirtualInvokeData get_StandardName;
    VirtualInvokeData GetDaylightChanges;
    VirtualInvokeData GetUtcOffset;
    VirtualInvokeData IsDaylightSavingTime;
    VirtualInvokeData ToLocalTime;
    VirtualInvokeData ToUniversalTime;
};

struct CurrentSystemTimeZone__StaticFields {
};

struct CurrentSystemTimeZone__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CurrentSystemTimeZone__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CurrentSystemTimeZone__VTable vtable;
};

struct TimeZone__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData IsDaylightSavingTime;
    VirtualInvokeData ToLocalTime;
    VirtualInvokeData ToUniversalTime;
};

struct TimeZone__StaticFields {
    struct TimeZone *currentTimeZone;
    struct Object *tz_lock;
    int64_t timezone_check;
};

struct TimeZone__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TimeZone__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TimeZone__VTable vtable;
};

struct TypeName {
    struct TypeName__Class *klass;
    MonitorData *monitor;
};

struct TypeName__VTable {
    VirtualInvokeData get_DisplayName;
    VirtualInvokeData NestedName;
};

struct TypeName__StaticFields {
};

struct TypeName__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeName__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeName__VTable vtable;
};

struct TypeNames {
    struct TypeNames__Class *klass;
    MonitorData *monitor;
};

struct TypeNames__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct TypeNames__StaticFields {
};

struct TypeNames__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeNames__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeNames__VTable vtable;
};

struct TypeNames_ATypeName {
    struct TypeNames_ATypeName__Class *klass;
    MonitorData *monitor;
};

struct TypeIdentifier {
    struct TypeIdentifier__Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) TypeNames_Display__Fields {
    struct String *displayName;
};

struct TypeNames_Display {
    struct TypeNames_Display__Class *klass;
    MonitorData *monitor;
    struct TypeNames_Display__Fields fields;
};

struct TypeIdentifier__VTable {
    VirtualInvokeData get_InternalName;
};

struct TypeIdentifier__StaticFields {
};

struct TypeIdentifier__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeIdentifier__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeIdentifier__VTable vtable;
};

struct TypeNames_Display__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_DisplayName;
    VirtualInvokeData NestedName;
    VirtualInvokeData Equals_1;
    VirtualInvokeData get_DisplayName_1;
    VirtualInvokeData NestedName_1;
};

struct TypeNames_Display__StaticFields {
};

struct TypeNames_Display__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeNames_Display__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeNames_Display__VTable vtable;
};

struct TypeNames_ATypeName__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_DisplayName;
    VirtualInvokeData NestedName;
    VirtualInvokeData Equals_1;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
};

struct TypeNames_ATypeName__StaticFields {
};

struct TypeNames_ATypeName__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeNames_ATypeName__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeNames_ATypeName__VTable vtable;
};

struct TypeIdentifiers {
    struct TypeIdentifiers__Class *klass;
    MonitorData *monitor;
};

struct TypeIdentifiers__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct TypeIdentifiers__StaticFields {
};

struct TypeIdentifiers__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeIdentifiers__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeIdentifiers__VTable vtable;
};

struct __declspec(align(8)) TypeIdentifiers_Display__Fields {
    struct String *displayName;
    struct String *internal_name;
};

struct TypeIdentifiers_Display {
    struct TypeIdentifiers_Display__Class *klass;
    MonitorData *monitor;
    struct TypeIdentifiers_Display__Fields fields;
};

struct TypeIdentifiers_Display__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_DisplayName;
    VirtualInvokeData NestedName;
    VirtualInvokeData Equals_1;
    VirtualInvokeData get_DisplayName_1;
    VirtualInvokeData NestedName_1;
    VirtualInvokeData get_InternalName;
};

struct TypeIdentifiers_Display__StaticFields {
};

struct TypeIdentifiers_Display__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeIdentifiers_Display__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeIdentifiers_Display__VTable vtable;
};

struct __declspec(align(8)) TypeIdentifiers_Internal__Fields {
    struct String *internalName;
    struct String *display_name;
};

struct TypeIdentifiers_Internal {
    struct TypeIdentifiers_Internal__Class *klass;
    MonitorData *monitor;
    struct TypeIdentifiers_Internal__Fields fields;
};

struct TypeIdentifiers_Internal__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_DisplayName;
    VirtualInvokeData NestedName;
    VirtualInvokeData Equals_1;
    VirtualInvokeData get_DisplayName_1;
    VirtualInvokeData NestedName_1;
    VirtualInvokeData get_InternalName;
};

struct TypeIdentifiers_Internal__StaticFields {
};

struct TypeIdentifiers_Internal__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeIdentifiers_Internal__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeIdentifiers_Internal__VTable vtable;
};

struct __declspec(align(8)) TypeIdentifiers_NoEscape__Fields {
    struct String *simpleName;
};

struct TypeIdentifiers_NoEscape {
    struct TypeIdentifiers_NoEscape__Class *klass;
    MonitorData *monitor;
    struct TypeIdentifiers_NoEscape__Fields fields;
};

struct TypeIdentifiers_NoEscape__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_DisplayName;
    VirtualInvokeData NestedName;
    VirtualInvokeData Equals_1;
    VirtualInvokeData get_DisplayName_1;
    VirtualInvokeData NestedName_1;
    VirtualInvokeData get_InternalName;
};

struct TypeIdentifiers_NoEscape__StaticFields {
};

struct TypeIdentifiers_NoEscape__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeIdentifiers_NoEscape__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeIdentifiers_NoEscape__VTable vtable;
};

struct __declspec(align(8)) ArraySpec__Fields {
    int32_t dimensions;
    bool bound;
};

struct ArraySpec {
    struct ArraySpec__Class *klass;
    MonitorData *monitor;
    struct ArraySpec__Fields fields;
};

struct ArraySpec__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Resolve;
    VirtualInvokeData Append;
};

struct ArraySpec__StaticFields {
};

struct ArraySpec__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ArraySpec__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ArraySpec__VTable vtable;
};

struct __declspec(align(8)) PointerSpec__Fields {
    int32_t pointer_level;
};

struct PointerSpec {
    struct PointerSpec__Class *klass;
    MonitorData *monitor;
    struct PointerSpec__Fields fields;
};

struct PointerSpec__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Resolve;
    VirtualInvokeData Append;
};

struct PointerSpec__StaticFields {
};

struct PointerSpec__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PointerSpec__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PointerSpec__VTable vtable;
};

struct __declspec(align(8)) TypeSpec__Fields {
    struct TypeIdentifier *name;
    struct String *assembly_name;
    struct List_1_System_TypeIdentifier_ *nested;
    struct List_1_System_TypeSpec_ *generic_params;
    struct List_1_System_ModifierSpec_ *modifier_spec;
    bool is_byref;
    struct String *display_fullname;
};

struct TypeSpec {
    struct TypeSpec__Class *klass;
    MonitorData *monitor;
    struct TypeSpec__Fields fields;
};

struct __declspec(align(8)) List_1_System_TypeIdentifier___Fields {
    struct TypeIdentifier__Array *_items;
    int32_t _size;
    int32_t _version;
    struct Object *_syncRoot;
};

struct List_1_System_TypeIdentifier_ {
    struct List_1_System_TypeIdentifier___Class *klass;
    MonitorData *monitor;
    struct List_1_System_TypeIdentifier___Fields fields;
};

struct TypeIdentifier__Array {
    struct TypeIdentifier__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct TypeIdentifier *vector[32];
};

struct IEnumerator_1_System_TypeIdentifier_ {
    struct IEnumerator_1_System_TypeIdentifier___Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) List_1_System_TypeSpec___Fields {
    struct TypeSpec__Array *_items;
    int32_t _size;
    int32_t _version;
    struct Object *_syncRoot;
};

struct List_1_System_TypeSpec_ {
    struct List_1_System_TypeSpec___Class *klass;
    MonitorData *monitor;
    struct List_1_System_TypeSpec___Fields fields;
};

struct TypeSpec__Array {
    struct TypeSpec__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct TypeSpec *vector[32];
};

struct IEnumerator_1_System_TypeSpec_ {
    struct IEnumerator_1_System_TypeSpec___Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) List_1_System_ModifierSpec___Fields {
    struct ModifierSpec__Array *_items;
    int32_t _size;
    int32_t _version;
    struct Object *_syncRoot;
};

struct List_1_System_ModifierSpec_ {
    struct List_1_System_ModifierSpec___Class *klass;
    MonitorData *monitor;
    struct List_1_System_ModifierSpec___Fields fields;
};

struct ModifierSpec {
    struct ModifierSpec__Class *klass;
    MonitorData *monitor;
};

struct ModifierSpec__Array {
    struct ModifierSpec__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct ModifierSpec *vector[32];
};

struct IEnumerator_1_System_ModifierSpec_ {
    struct IEnumerator_1_System_ModifierSpec___Class *klass;
    MonitorData *monitor;
};

struct TypeIdentifier__Array__VTable {
};

struct TypeIdentifier__Array__StaticFields {
};

struct TypeIdentifier__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeIdentifier__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeIdentifier__Array__VTable vtable;
};

struct IEnumerator_1_System_TypeIdentifier___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_System_TypeIdentifier___StaticFields {
};

struct IEnumerator_1_System_TypeIdentifier___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_System_TypeIdentifier___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_System_TypeIdentifier___VTable vtable;
};

struct List_1_System_TypeIdentifier___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData RemoveAt;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_T__get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_T__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IList_get_Item;
    VirtualInvokeData System_Collections_IList_set_Item;
    VirtualInvokeData System_Collections_IList_Add;
    VirtualInvokeData System_Collections_IList_Contains;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IList_get_IsReadOnly;
    VirtualInvokeData System_Collections_IList_get_IsFixedSize;
    VirtualInvokeData System_Collections_IList_IndexOf;
    VirtualInvokeData System_Collections_IList_Insert;
    VirtualInvokeData System_Collections_IList_Remove;
    VirtualInvokeData RemoveAt_1;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData get_Count_2;
};

struct List_1_System_TypeIdentifier___StaticFields {
    struct TypeIdentifier__Array *_emptyArray;
};

struct List_1_System_TypeIdentifier___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct List_1_System_TypeIdentifier___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct List_1_System_TypeIdentifier___VTable vtable;
};

struct TypeSpec__Array__VTable {
};

struct TypeSpec__Array__StaticFields {
};

struct TypeSpec__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeSpec__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeSpec__Array__VTable vtable;
};

struct IEnumerator_1_System_TypeSpec___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_System_TypeSpec___StaticFields {
};

struct IEnumerator_1_System_TypeSpec___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_System_TypeSpec___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_System_TypeSpec___VTable vtable;
};

struct List_1_System_TypeSpec___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData RemoveAt;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_T__get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_T__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IList_get_Item;
    VirtualInvokeData System_Collections_IList_set_Item;
    VirtualInvokeData System_Collections_IList_Add;
    VirtualInvokeData System_Collections_IList_Contains;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IList_get_IsReadOnly;
    VirtualInvokeData System_Collections_IList_get_IsFixedSize;
    VirtualInvokeData System_Collections_IList_IndexOf;
    VirtualInvokeData System_Collections_IList_Insert;
    VirtualInvokeData System_Collections_IList_Remove;
    VirtualInvokeData RemoveAt_1;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData get_Count_2;
};

struct List_1_System_TypeSpec___StaticFields {
    struct TypeSpec__Array *_emptyArray;
};

struct List_1_System_TypeSpec___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct List_1_System_TypeSpec___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct List_1_System_TypeSpec___VTable vtable;
};

struct ModifierSpec__VTable {
    VirtualInvokeData Resolve;
    VirtualInvokeData Append;
};

struct ModifierSpec__StaticFields {
};

struct ModifierSpec__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ModifierSpec__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ModifierSpec__VTable vtable;
};

struct ModifierSpec__Array__VTable {
};

struct ModifierSpec__Array__StaticFields {
};

struct ModifierSpec__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ModifierSpec__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ModifierSpec__Array__VTable vtable;
};

struct IEnumerator_1_System_ModifierSpec___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_System_ModifierSpec___StaticFields {
};

struct IEnumerator_1_System_ModifierSpec___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_System_ModifierSpec___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_System_ModifierSpec___VTable vtable;
};

struct List_1_System_ModifierSpec___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData IndexOf;
    VirtualInvokeData Insert;
    VirtualInvokeData RemoveAt;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_T__get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_T__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IList_get_Item;
    VirtualInvokeData System_Collections_IList_set_Item;
    VirtualInvokeData System_Collections_IList_Add;
    VirtualInvokeData System_Collections_IList_Contains;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IList_get_IsReadOnly;
    VirtualInvokeData System_Collections_IList_get_IsFixedSize;
    VirtualInvokeData System_Collections_IList_IndexOf;
    VirtualInvokeData System_Collections_IList_Insert;
    VirtualInvokeData System_Collections_IList_Remove;
    VirtualInvokeData RemoveAt_1;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData get_Count_2;
};

struct List_1_System_ModifierSpec___StaticFields {
    struct ModifierSpec__Array *_emptyArray;
};

struct List_1_System_ModifierSpec___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct List_1_System_ModifierSpec___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct List_1_System_ModifierSpec___VTable vtable;
};

struct TypeSpec__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct TypeSpec__StaticFields {
};

struct TypeSpec__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeSpec__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeSpec__VTable vtable;
};

struct IEnumerable_1_System_TypeName_ {
    struct IEnumerable_1_System_TypeName___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_TypeName___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_TypeName___StaticFields {
};

struct IEnumerable_1_System_TypeName___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_TypeName___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_TypeName___VTable vtable;
};

struct IEnumerable_1_System_ModifierSpec_ {
    struct IEnumerable_1_System_ModifierSpec___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_ModifierSpec___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_ModifierSpec___StaticFields {
};

struct IEnumerable_1_System_ModifierSpec___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_ModifierSpec___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_ModifierSpec___VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum TypeSpec_DisplayNameFormat__Enum : int32_t {
    TypeSpec_DisplayNameFormat__Enum_Default = 0x00000000,
    TypeSpec_DisplayNameFormat__Enum_WANT_ASSEMBLY = 0x00000001,
    TypeSpec_DisplayNameFormat__Enum_NO_MODIFIERS = 0x00000002,
};

#else
enum TypeSpec_DisplayNameFormat__Enum {
    TypeSpec_DisplayNameFormat__Enum_Default = 0x00000000,
    TypeSpec_DisplayNameFormat__Enum_WANT_ASSEMBLY = 0x00000001,
    TypeSpec_DisplayNameFormat__Enum_NO_MODIFIERS = 0x00000002,
};

#endif
struct TypeSpec_DisplayNameFormat__Enum__Boxed {
    struct TypeSpec_DisplayNameFormat__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum TypeSpec_DisplayNameFormat__Enum value;
    #else
    uint32_t value;
    #endif
};

struct TypeSpec_DisplayNameFormat__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct TypeSpec_DisplayNameFormat__Enum__StaticFields {
};

struct TypeSpec_DisplayNameFormat__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeSpec_DisplayNameFormat__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeSpec_DisplayNameFormat__Enum__VTable vtable;
};

struct __declspec(align(8)) TypeSpec_TypeSpecTypeName__Fields {
    struct TypeSpec *ts;
    bool want_modifiers;
};

struct TypeSpec_TypeSpecTypeName {
    struct TypeSpec_TypeSpecTypeName__Class *klass;
    MonitorData *monitor;
    struct TypeSpec_TypeSpecTypeName__Fields fields;
};

struct TypeSpec_TypeSpecTypeName__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_DisplayName;
    VirtualInvokeData NestedName;
    VirtualInvokeData Equals_1;
    VirtualInvokeData get_DisplayName_1;
    VirtualInvokeData NestedName_1;
};

struct TypeSpec_TypeSpecTypeName__StaticFields {
};

struct TypeSpec_TypeSpecTypeName__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeSpec_TypeSpecTypeName__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeSpec_TypeSpecTypeName__VTable vtable;
};

struct BRECORD {
    void *pvRecord;
    void *pRecInfo;
};

struct BRECORD__Boxed {
    struct BRECORD__Class *klass;
    MonitorData *monitor;
    struct BRECORD fields;
};

struct Variant {
    int16_t vt;
    uint16_t wReserved1;
    uint16_t wReserved2;
    uint16_t wReserved3;
    int64_t llVal;
    int32_t lVal;
    uint8_t bVal;
    int16_t iVal;
    float fltVal;
    double dblVal;
    int16_t boolVal;
    void *bstrVal;
    int8_t cVal;
    uint16_t uiVal;
    uint32_t ulVal;
    uint64_t ullVal;
    int32_t intVal;
    uint32_t uintVal;
    void *pdispVal;
    struct BRECORD bRecord;
};

struct Variant__Boxed {
    struct Variant__Class *klass;
    MonitorData *monitor;
    struct Variant fields;
};

struct BRECORD__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct BRECORD__StaticFields {
};

struct BRECORD__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct BRECORD__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct BRECORD__VTable vtable;
};

struct Variant__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Variant__StaticFields {
};

struct Variant__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Variant__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Variant__VTable vtable;
};

struct Coord {
    int16_t X;
    int16_t Y;
};

struct Coord__Boxed {
    struct Coord__Class *klass;
    MonitorData *monitor;
    struct Coord fields;
};

struct Coord__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Coord__StaticFields {
};

struct Coord__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Coord__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Coord__VTable vtable;
};

struct SmallRect {
    int16_t Left;
    int16_t Top;
    int16_t Right;
    int16_t Bottom;
};

struct SmallRect__Boxed {
    struct SmallRect__Class *klass;
    MonitorData *monitor;
    struct SmallRect fields;
};

struct SmallRect__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct SmallRect__StaticFields {
};

struct SmallRect__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SmallRect__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SmallRect__VTable vtable;
};

struct __declspec(align(8)) WindowsConsoleDriver__Fields {
    void *inputHandle;
    void *outputHandle;
    int16_t defaultAttribute;
};

struct WindowsConsoleDriver {
    struct WindowsConsoleDriver__Class *klass;
    MonitorData *monitor;
    struct WindowsConsoleDriver__Fields fields;
};

struct WindowsConsoleDriver__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_BackgroundColor;
    VirtualInvokeData set_BackgroundColor;
    VirtualInvokeData get_BufferHeight;
    VirtualInvokeData set_BufferHeight;
    VirtualInvokeData get_BufferWidth;
    VirtualInvokeData set_BufferWidth;
    VirtualInvokeData get_CapsLock;
    VirtualInvokeData get_CursorLeft;
    VirtualInvokeData set_CursorLeft;
    VirtualInvokeData get_CursorSize;
    VirtualInvokeData set_CursorSize;
    VirtualInvokeData get_CursorTop;
    VirtualInvokeData set_CursorTop;
    VirtualInvokeData get_CursorVisible;
    VirtualInvokeData set_CursorVisible;
    VirtualInvokeData get_ForegroundColor;
    VirtualInvokeData set_ForegroundColor;
    VirtualInvokeData get_KeyAvailable;
    VirtualInvokeData get_Initialized;
    VirtualInvokeData get_LargestWindowHeight;
    VirtualInvokeData get_LargestWindowWidth;
    VirtualInvokeData get_NumberLock;
    VirtualInvokeData get_Title;
    VirtualInvokeData set_Title;
    VirtualInvokeData get_TreatControlCAsInput;
    VirtualInvokeData set_TreatControlCAsInput;
    VirtualInvokeData get_WindowHeight;
    VirtualInvokeData set_WindowHeight;
    VirtualInvokeData get_WindowLeft;
    VirtualInvokeData set_WindowLeft;
    VirtualInvokeData get_WindowTop;
    VirtualInvokeData set_WindowTop;
    VirtualInvokeData get_WindowWidth;
    VirtualInvokeData set_WindowWidth;
    VirtualInvokeData Init;
    VirtualInvokeData Beep;
    VirtualInvokeData Clear;
    VirtualInvokeData MoveBufferArea;
    VirtualInvokeData ReadKey;
    VirtualInvokeData ResetColor;
    VirtualInvokeData SetBufferSize;
    VirtualInvokeData SetCursorPosition;
    VirtualInvokeData SetWindowPosition;
    VirtualInvokeData SetWindowSize;
    VirtualInvokeData ReadLine;
};

struct WindowsConsoleDriver__StaticFields {
};

struct WindowsConsoleDriver__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct WindowsConsoleDriver__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct WindowsConsoleDriver__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum Handles__Enum : int32_t {
    Handles__Enum_STD_INPUT = 0xfffffff6,
    Handles__Enum_STD_OUTPUT = 0xfffffff5,
    Handles__Enum_STD_ERROR = 0xfffffff4,
};

#else
enum Handles__Enum {
    Handles__Enum_STD_INPUT = 0xfffffff6,
    Handles__Enum_STD_OUTPUT = 0xfffffff5,
    Handles__Enum_STD_ERROR = 0xfffffff4,
};

#endif
struct Handles__Enum__Boxed {
    struct Handles__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum Handles__Enum value;
    #else
    uint32_t value;
    #endif
};

struct Handles__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct Handles__Enum__StaticFields {
};

struct Handles__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Handles__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Handles__Enum__VTable vtable;
};

struct ConsoleScreenBufferInfo {
    struct Coord Size;
    struct Coord CursorPosition;
    int16_t Attribute;
    struct SmallRect Window;
    struct Coord MaxWindowSize;
};

struct ConsoleScreenBufferInfo__Boxed {
    struct ConsoleScreenBufferInfo__Class *klass;
    MonitorData *monitor;
    struct ConsoleScreenBufferInfo fields;
};

struct ConsoleScreenBufferInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ConsoleScreenBufferInfo__StaticFields {
};

struct ConsoleScreenBufferInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ConsoleScreenBufferInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ConsoleScreenBufferInfo__VTable vtable;
};

struct ConsoleScreenBufferInfo___VTable {
};

struct ConsoleScreenBufferInfo___StaticFields {
};

struct ConsoleScreenBufferInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ConsoleScreenBufferInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ConsoleScreenBufferInfo___VTable vtable;
};

struct SmallRect___VTable {
};

struct SmallRect___StaticFields {
};

struct SmallRect___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SmallRect___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SmallRect___VTable vtable;
};

struct ConsoleCursorInfo {
    int32_t Size;
    bool Visible;
};

struct ConsoleCursorInfo__Boxed {
    struct ConsoleCursorInfo__Class *klass;
    MonitorData *monitor;
    struct ConsoleCursorInfo fields;
};

struct ConsoleCursorInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ConsoleCursorInfo__StaticFields {
};

struct ConsoleCursorInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ConsoleCursorInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ConsoleCursorInfo__VTable vtable;
};

struct ConsoleCursorInfo___VTable {
};

struct ConsoleCursorInfo___StaticFields {
};

struct ConsoleCursorInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ConsoleCursorInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ConsoleCursorInfo___VTable vtable;
};

struct InputRecord {
    int16_t EventType;
    bool KeyDown;
    int16_t RepeatCount;
    int16_t VirtualKeyCode;
    int16_t VirtualScanCode;
    uint16_t Character;
    int32_t ControlKeyState;
    int32_t pad1;
    bool pad2;
};

struct InputRecord__Boxed {
    struct InputRecord__Class *klass;
    MonitorData *monitor;
    struct InputRecord fields;
};

struct InputRecord__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct InputRecord__StaticFields {
};

struct InputRecord__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct InputRecord__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct InputRecord__VTable vtable;
};

struct InputRecord___VTable {
};

struct InputRecord___StaticFields {
};

struct InputRecord___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct InputRecord___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct InputRecord___VTable vtable;
};

struct CharInfo {
    uint16_t Character;
    int16_t Attributes;
};

struct CharInfo__Boxed {
    struct CharInfo__Class *klass;
    MonitorData *monitor;
    struct CharInfo fields;
};

struct CharInfo__Array {
    struct CharInfo__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct CharInfo vector[32];
};

struct CharInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct CharInfo__StaticFields {
};

struct CharInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CharInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CharInfo__VTable vtable;
};

struct CharInfo__Array__VTable {
};

struct CharInfo__Array__StaticFields {
};

struct CharInfo__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CharInfo__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CharInfo__Array__VTable vtable;
};

struct _ComObject {
    struct _ComObject__Class *klass;
    MonitorData *monitor;
};

struct _ComObject__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct _ComObject__StaticFields {
};

struct _ComObject__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct _ComObject__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct _ComObject__VTable vtable;
};

struct AssemblyHash {
    #if defined(_CPLUSPLUS_)
    enum AssemblyHashAlgorithm__Enum _algorithm;
    #else
    uint32_t _algorithm;
    #endif
    struct Byte__Array *_value;
};

struct AssemblyHash__Boxed {
    struct AssemblyHash__Class *klass;
    MonitorData *monitor;
    struct AssemblyHash fields;
};

struct AssemblyHash__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
};

struct AssemblyHash__StaticFields {
    struct AssemblyHash Empty;
};

struct AssemblyHash__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyHash__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyHash__VTable vtable;
};

struct __declspec(align(8)) CodePageEncoding__Fields {
    int32_t m_codePage;
    bool m_isReadOnly;
    bool m_deserializedFromEverett;
    struct EncoderFallback *encoderFallback;
    struct DecoderFallback *decoderFallback;
    struct Encoding *realEncoding;
};

struct CodePageEncoding {
    struct CodePageEncoding__Class *klass;
    MonitorData *monitor;
    struct CodePageEncoding__Fields fields;
};

struct CodePageEncoding__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
    VirtualInvokeData GetRealObject;
};

struct CodePageEncoding__StaticFields {
};

struct CodePageEncoding__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CodePageEncoding__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CodePageEncoding__VTable vtable;
};

struct __declspec(align(8)) CodePageEncoding_Decoder__Fields {
    struct Encoding *realEncoding;
};

struct CodePageEncoding_Decoder {
    struct CodePageEncoding_Decoder__Class *klass;
    MonitorData *monitor;
    struct CodePageEncoding_Decoder__Fields fields;
};

struct CodePageEncoding_Decoder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
    VirtualInvokeData GetRealObject;
};

struct CodePageEncoding_Decoder__StaticFields {
};

struct CodePageEncoding_Decoder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CodePageEncoding_Decoder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CodePageEncoding_Decoder__VTable vtable;
};

struct DecoderExceptionFallback__Fields {
    struct DecoderFallback__Fields _;
};

struct DecoderExceptionFallback {
    struct DecoderExceptionFallback__Class *klass;
    MonitorData *monitor;
    struct DecoderExceptionFallback__Fields fields;
};

struct DecoderExceptionFallback__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateFallbackBuffer;
    VirtualInvokeData get_MaxCharCount;
};

struct DecoderExceptionFallback__StaticFields {
};

struct DecoderExceptionFallback__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DecoderExceptionFallback__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DecoderExceptionFallback__VTable vtable;
};

struct DecoderExceptionFallbackBuffer__Fields {
    struct DecoderFallbackBuffer__Fields _;
};

struct DecoderExceptionFallbackBuffer {
    struct DecoderExceptionFallbackBuffer__Class *klass;
    MonitorData *monitor;
    struct DecoderExceptionFallbackBuffer__Fields fields;
};

struct DecoderExceptionFallbackBuffer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Fallback;
    VirtualInvokeData GetNextChar;
    VirtualInvokeData MovePrevious;
    VirtualInvokeData get_Remaining;
    VirtualInvokeData Reset;
    VirtualInvokeData InternalFallback;
    VirtualInvokeData InternalFallback_1;
};

struct DecoderExceptionFallbackBuffer__StaticFields {
};

struct DecoderExceptionFallbackBuffer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DecoderExceptionFallbackBuffer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DecoderExceptionFallbackBuffer__VTable vtable;
};

struct DecoderFallbackException__Fields {
    struct ArgumentException__Fields _;
    struct Byte__Array *bytesUnknown;
    int32_t index;
};

struct DecoderFallbackException {
    struct DecoderFallbackException__Class *klass;
    MonitorData *monitor;
    struct DecoderFallbackException__Fields fields;
};

struct DecoderFallbackException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
    VirtualInvokeData get_ParamName;
};

struct DecoderFallbackException__StaticFields {
};

struct DecoderFallbackException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DecoderFallbackException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DecoderFallbackException__VTable vtable;
};

struct DecoderReplacementFallback__Fields {
    struct DecoderFallback__Fields _;
    struct String *strDefault;
};

struct DecoderReplacementFallback {
    struct DecoderReplacementFallback__Class *klass;
    MonitorData *monitor;
    struct DecoderReplacementFallback__Fields fields;
};

struct DecoderReplacementFallback__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateFallbackBuffer;
    VirtualInvokeData get_MaxCharCount;
};

struct DecoderReplacementFallback__StaticFields {
};

struct DecoderReplacementFallback__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DecoderReplacementFallback__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DecoderReplacementFallback__VTable vtable;
};

struct DecoderReplacementFallbackBuffer__Fields {
    struct DecoderFallbackBuffer__Fields _;
    struct String *strDefault;
    int32_t fallbackCount;
    int32_t fallbackIndex;
};

struct DecoderReplacementFallbackBuffer {
    struct DecoderReplacementFallbackBuffer__Class *klass;
    MonitorData *monitor;
    struct DecoderReplacementFallbackBuffer__Fields fields;
};

struct DecoderReplacementFallbackBuffer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Fallback;
    VirtualInvokeData GetNextChar;
    VirtualInvokeData MovePrevious;
    VirtualInvokeData get_Remaining;
    VirtualInvokeData Reset;
    VirtualInvokeData InternalFallback;
    VirtualInvokeData InternalFallback_1;
};

struct DecoderReplacementFallbackBuffer__StaticFields {
};

struct DecoderReplacementFallbackBuffer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DecoderReplacementFallbackBuffer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DecoderReplacementFallbackBuffer__VTable vtable;
};

struct EncoderExceptionFallback__Fields {
    struct EncoderFallback__Fields _;
};

struct EncoderExceptionFallback {
    struct EncoderExceptionFallback__Class *klass;
    MonitorData *monitor;
    struct EncoderExceptionFallback__Fields fields;
};

struct EncoderExceptionFallback__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateFallbackBuffer;
    VirtualInvokeData get_MaxCharCount;
};

struct EncoderExceptionFallback__StaticFields {
};

struct EncoderExceptionFallback__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EncoderExceptionFallback__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EncoderExceptionFallback__VTable vtable;
};

struct EncoderExceptionFallbackBuffer__Fields {
    struct EncoderFallbackBuffer__Fields _;
};

struct EncoderExceptionFallbackBuffer {
    struct EncoderExceptionFallbackBuffer__Class *klass;
    MonitorData *monitor;
    struct EncoderExceptionFallbackBuffer__Fields fields;
};

struct EncoderExceptionFallbackBuffer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Fallback;
    VirtualInvokeData Fallback_1;
    VirtualInvokeData GetNextChar;
    VirtualInvokeData MovePrevious;
    VirtualInvokeData get_Remaining;
    VirtualInvokeData Reset;
    VirtualInvokeData InternalFallback;
};

struct EncoderExceptionFallbackBuffer__StaticFields {
};

struct EncoderExceptionFallbackBuffer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EncoderExceptionFallbackBuffer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EncoderExceptionFallbackBuffer__VTable vtable;
};

struct EncoderFallbackException__Fields {
    struct ArgumentException__Fields _;
    uint16_t charUnknown;
    uint16_t charUnknownHigh;
    uint16_t charUnknownLow;
    int32_t index;
};

struct EncoderFallbackException {
    struct EncoderFallbackException__Class *klass;
    MonitorData *monitor;
    struct EncoderFallbackException__Fields fields;
};

struct EncoderFallbackException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
    VirtualInvokeData get_ParamName;
};

struct EncoderFallbackException__StaticFields {
};

struct EncoderFallbackException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EncoderFallbackException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EncoderFallbackException__VTable vtable;
};

struct EncoderReplacementFallback__Fields {
    struct EncoderFallback__Fields _;
    struct String *strDefault;
};

struct EncoderReplacementFallback {
    struct EncoderReplacementFallback__Class *klass;
    MonitorData *monitor;
    struct EncoderReplacementFallback__Fields fields;
};

struct EncoderReplacementFallback__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateFallbackBuffer;
    VirtualInvokeData get_MaxCharCount;
};

struct EncoderReplacementFallback__StaticFields {
};

struct EncoderReplacementFallback__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EncoderReplacementFallback__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EncoderReplacementFallback__VTable vtable;
};

struct EncoderReplacementFallbackBuffer__Fields {
    struct EncoderFallbackBuffer__Fields _;
    struct String *strDefault;
    int32_t fallbackCount;
    int32_t fallbackIndex;
};

struct EncoderReplacementFallbackBuffer {
    struct EncoderReplacementFallbackBuffer__Class *klass;
    MonitorData *monitor;
    struct EncoderReplacementFallbackBuffer__Fields fields;
};

struct EncoderReplacementFallbackBuffer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Fallback;
    VirtualInvokeData Fallback_1;
    VirtualInvokeData GetNextChar;
    VirtualInvokeData MovePrevious;
    VirtualInvokeData get_Remaining;
    VirtualInvokeData Reset;
    VirtualInvokeData InternalFallback;
};

struct EncoderReplacementFallbackBuffer__StaticFields {
};

struct EncoderReplacementFallbackBuffer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EncoderReplacementFallbackBuffer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EncoderReplacementFallbackBuffer__VTable vtable;
};

struct EncodingProvider {
    struct EncodingProvider__Class *klass;
    MonitorData *monitor;
};

struct EncodingProvider__Array {
    struct EncodingProvider__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct EncodingProvider *vector[32];
};

struct EncodingProvider__Array__VTable {
};

struct EncodingProvider__Array__StaticFields {
};

struct EncodingProvider__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EncodingProvider__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EncodingProvider__Array__VTable vtable;
};

struct EncodingProvider__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData GetEncoding;
    VirtualInvokeData GetEncoding_1;
};

struct EncodingProvider__StaticFields {
    struct Object *s_InternalSyncObject;
    struct EncodingProvider__Array *s_providers;
};

struct EncodingProvider__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EncodingProvider__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EncodingProvider__VTable vtable;
};

struct __declspec(align(8)) EncodingInfo__Fields {
    int32_t iCodePage;
    struct String *strEncodingName;
    struct String *strDisplayName;
};

struct EncodingInfo {
    struct EncodingInfo__Class *klass;
    MonitorData *monitor;
    struct EncodingInfo__Fields fields;
};

struct EncodingInfo__Array {
    struct EncodingInfo__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct EncodingInfo *vector[32];
};

struct EncodingInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct EncodingInfo__StaticFields {
};

struct EncodingInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EncodingInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EncodingInfo__VTable vtable;
};

struct EncodingInfo__Array__VTable {
};

struct EncodingInfo__Array__StaticFields {
};

struct EncodingInfo__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EncodingInfo__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EncodingInfo__Array__VTable vtable;
};

struct Encoding_DefaultEncoder__Fields {
    struct Encoder__Fields _;
    struct Encoding *m_encoding;
    bool m_hasInitializedEncoding;
    uint16_t charLeftOver;
};

struct Encoding_DefaultEncoder {
    struct Encoding_DefaultEncoder__Class *klass;
    MonitorData *monitor;
    struct Encoding_DefaultEncoder__Fields fields;
};

struct Encoding_DefaultEncoder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Reset;
    VirtualInvokeData GetByteCount;
    VirtualInvokeData GetByteCount_1;
    VirtualInvokeData GetBytes;
    VirtualInvokeData GetBytes_1;
    VirtualInvokeData Convert;
    VirtualInvokeData Convert_1;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
    VirtualInvokeData GetRealObject;
};

struct Encoding_DefaultEncoder__StaticFields {
};

struct Encoding_DefaultEncoder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Encoding_DefaultEncoder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Encoding_DefaultEncoder__VTable vtable;
};

struct Encoding_DefaultDecoder__Fields {
    struct Decoder__Fields _;
    struct Encoding *m_encoding;
    bool m_hasInitializedEncoding;
};

struct Encoding_DefaultDecoder {
    struct Encoding_DefaultDecoder__Class *klass;
    MonitorData *monitor;
    struct Encoding_DefaultDecoder__Fields fields;
};

struct Encoding_DefaultDecoder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Reset;
    VirtualInvokeData GetCharCount;
    VirtualInvokeData GetCharCount_1;
    VirtualInvokeData GetCharCount_2;
    VirtualInvokeData GetChars;
    VirtualInvokeData GetChars_1;
    VirtualInvokeData GetChars_2;
    VirtualInvokeData Convert;
    VirtualInvokeData Convert_1;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
    VirtualInvokeData GetRealObject;
};

struct Encoding_DefaultDecoder__StaticFields {
};

struct Encoding_DefaultDecoder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Encoding_DefaultDecoder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Encoding_DefaultDecoder__VTable vtable;
};

struct __declspec(align(8)) Encoding_EncodingCharBuffer__Fields {
    uint16_t *chars;
    uint16_t *charStart;
    uint16_t *charEnd;
    int32_t charCountResult;
    struct Encoding *enc;
    struct DecoderNLS *decoder;
    uint8_t *byteStart;
    uint8_t *byteEnd;
    uint8_t *bytes;
    struct DecoderFallbackBuffer *fallbackBuffer;
};

struct Encoding_EncodingCharBuffer {
    struct Encoding_EncodingCharBuffer__Class *klass;
    MonitorData *monitor;
    struct Encoding_EncodingCharBuffer__Fields fields;
};

struct Encoding_EncodingCharBuffer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Encoding_EncodingCharBuffer__StaticFields {
};

struct Encoding_EncodingCharBuffer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Encoding_EncodingCharBuffer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Encoding_EncodingCharBuffer__VTable vtable;
};

struct __declspec(align(8)) Encoding_EncodingByteBuffer__Fields {
    uint8_t *bytes;
    uint8_t *byteStart;
    uint8_t *byteEnd;
    uint16_t *chars;
    uint16_t *charStart;
    uint16_t *charEnd;
    int32_t byteCountResult;
    struct Encoding *enc;
    struct EncoderNLS *encoder;
    struct EncoderFallbackBuffer *fallbackBuffer;
};

struct Encoding_EncodingByteBuffer {
    struct Encoding_EncodingByteBuffer__Class *klass;
    MonitorData *monitor;
    struct Encoding_EncodingByteBuffer__Fields fields;
};

struct Encoding_EncodingByteBuffer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Encoding_EncodingByteBuffer__StaticFields {
};

struct Encoding_EncodingByteBuffer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Encoding_EncodingByteBuffer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Encoding_EncodingByteBuffer__VTable vtable;
};

struct EncodingNLS__Fields {
    struct Encoding__Fields _;
};

struct EncodingNLS {
    struct EncodingNLS__Class *klass;
    MonitorData *monitor;
    struct EncodingNLS__Fields fields;
};

struct Latin1Encoding__Fields {
    struct EncodingNLS__Fields _;
};

struct Latin1Encoding {
    struct Latin1Encoding__Class *klass;
    MonitorData *monitor;
    struct Latin1Encoding__Fields fields;
};

struct Latin1Encoding__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData SetDefaultFallbacks;
    VirtualInvokeData GetPreamble;
    VirtualInvokeData get_BodyName;
    VirtualInvokeData get_EncodingName;
    VirtualInvokeData get_HeaderName;
    VirtualInvokeData get_WebName;
    VirtualInvokeData get_WindowsCodePage;
    VirtualInvokeData get_IsBrowserDisplay;
    VirtualInvokeData get_IsBrowserSave;
    VirtualInvokeData get_IsMailNewsDisplay;
    VirtualInvokeData get_IsMailNewsSave;
    VirtualInvokeData get_IsSingleByte;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetByteCount;
    VirtualInvokeData GetByteCount_1;
    VirtualInvokeData GetByteCount_2;
    VirtualInvokeData GetByteCount_3;
    VirtualInvokeData GetByteCount_4;
    VirtualInvokeData GetBytes;
    VirtualInvokeData GetBytes_1;
    VirtualInvokeData GetBytes_2;
    VirtualInvokeData GetBytes_3;
    VirtualInvokeData GetBytes_4;
    VirtualInvokeData GetBytes_5;
    VirtualInvokeData GetBytes_6;
    VirtualInvokeData GetCharCount;
    VirtualInvokeData GetCharCount_1;
    VirtualInvokeData GetCharCount_2;
    VirtualInvokeData GetCharCount_3;
    VirtualInvokeData GetChars;
    VirtualInvokeData GetChars_1;
    VirtualInvokeData GetChars_2;
    VirtualInvokeData GetChars_3;
    VirtualInvokeData GetChars_4;
    VirtualInvokeData get_CodePage;
    VirtualInvokeData IsAlwaysNormalized;
    VirtualInvokeData GetDecoder;
    VirtualInvokeData GetEncoder;
    VirtualInvokeData GetMaxByteCount;
    VirtualInvokeData GetMaxCharCount;
    VirtualInvokeData GetString;
    VirtualInvokeData GetString_1;
    VirtualInvokeData GetBestFitUnicodeToBytesData;
    VirtualInvokeData GetBestFitBytesToUnicodeData;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
};

struct Latin1Encoding__StaticFields {
    struct Char__Array *arrayCharBestFit;
};

struct Latin1Encoding__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Latin1Encoding__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Latin1Encoding__VTable vtable;
};

struct EncodingNLS__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData SetDefaultFallbacks;
    VirtualInvokeData GetPreamble;
    VirtualInvokeData get_BodyName;
    VirtualInvokeData get_EncodingName;
    VirtualInvokeData get_HeaderName;
    VirtualInvokeData get_WebName;
    VirtualInvokeData get_WindowsCodePage;
    VirtualInvokeData get_IsBrowserDisplay;
    VirtualInvokeData get_IsBrowserSave;
    VirtualInvokeData get_IsMailNewsDisplay;
    VirtualInvokeData get_IsMailNewsSave;
    VirtualInvokeData get_IsSingleByte;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetByteCount;
    VirtualInvokeData GetByteCount_1;
    VirtualInvokeData GetByteCount_2;
    VirtualInvokeData GetByteCount_3;
    VirtualInvokeData GetByteCount_4;
    VirtualInvokeData GetBytes;
    VirtualInvokeData GetBytes_1;
    VirtualInvokeData GetBytes_2;
    VirtualInvokeData GetBytes_3;
    VirtualInvokeData GetBytes_4;
    VirtualInvokeData GetBytes_5;
    VirtualInvokeData GetBytes_6;
    VirtualInvokeData GetCharCount;
    VirtualInvokeData GetCharCount_1;
    VirtualInvokeData GetCharCount_2;
    VirtualInvokeData GetCharCount_3;
    VirtualInvokeData GetChars;
    VirtualInvokeData GetChars_1;
    VirtualInvokeData GetChars_2;
    VirtualInvokeData GetChars_3;
    VirtualInvokeData GetChars_4;
    VirtualInvokeData get_CodePage;
    VirtualInvokeData IsAlwaysNormalized;
    VirtualInvokeData GetDecoder;
    VirtualInvokeData GetEncoder;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData GetString;
    VirtualInvokeData GetString_1;
    VirtualInvokeData GetBestFitUnicodeToBytesData;
    VirtualInvokeData GetBestFitBytesToUnicodeData;
};

struct EncodingNLS__StaticFields {
};

struct EncodingNLS__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EncodingNLS__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EncodingNLS__VTable vtable;
};

struct __declspec(align(8)) MLangCodePageEncoding__Fields {
    int32_t m_codePage;
    bool m_isReadOnly;
    bool m_deserializedFromEverett;
    struct EncoderFallback *encoderFallback;
    struct DecoderFallback *decoderFallback;
    struct Encoding *realEncoding;
};

struct MLangCodePageEncoding {
    struct MLangCodePageEncoding__Class *klass;
    MonitorData *monitor;
    struct MLangCodePageEncoding__Fields fields;
};

struct MLangCodePageEncoding__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
    VirtualInvokeData GetRealObject;
};

struct MLangCodePageEncoding__StaticFields {
};

struct MLangCodePageEncoding__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MLangCodePageEncoding__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MLangCodePageEncoding__VTable vtable;
};

struct __declspec(align(8)) MLangCodePageEncoding_MLangEncoder__Fields {
    struct Encoding *realEncoding;
};

struct MLangCodePageEncoding_MLangEncoder {
    struct MLangCodePageEncoding_MLangEncoder__Class *klass;
    MonitorData *monitor;
    struct MLangCodePageEncoding_MLangEncoder__Fields fields;
};

struct MLangCodePageEncoding_MLangEncoder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
    VirtualInvokeData GetRealObject;
};

struct MLangCodePageEncoding_MLangEncoder__StaticFields {
};

struct MLangCodePageEncoding_MLangEncoder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MLangCodePageEncoding_MLangEncoder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MLangCodePageEncoding_MLangEncoder__VTable vtable;
};

struct __declspec(align(8)) MLangCodePageEncoding_MLangDecoder__Fields {
    struct Encoding *realEncoding;
};

struct MLangCodePageEncoding_MLangDecoder {
    struct MLangCodePageEncoding_MLangDecoder__Class *klass;
    MonitorData *monitor;
    struct MLangCodePageEncoding_MLangDecoder__Fields fields;
};

struct MLangCodePageEncoding_MLangDecoder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
    VirtualInvokeData GetRealObject;
};

struct MLangCodePageEncoding_MLangDecoder__StaticFields {
};

struct MLangCodePageEncoding_MLangDecoder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MLangCodePageEncoding_MLangDecoder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MLangCodePageEncoding_MLangDecoder__VTable vtable;
};

struct __declspec(align(8)) SurrogateEncoder__Fields {
    struct Encoding *realEncoding;
};

struct SurrogateEncoder {
    struct SurrogateEncoder__Class *klass;
    MonitorData *monitor;
    struct SurrogateEncoder__Fields fields;
};

struct SurrogateEncoder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
    VirtualInvokeData GetRealObject;
};

struct SurrogateEncoder__StaticFields {
};

struct SurrogateEncoder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SurrogateEncoder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SurrogateEncoder__VTable vtable;
};

struct UnicodeEncoding__Fields {
    struct Encoding__Fields _;
    bool isThrowException;
    bool bigEndian;
    bool byteOrderMark;
};

struct UnicodeEncoding {
    struct UnicodeEncoding__Class *klass;
    MonitorData *monitor;
    struct UnicodeEncoding__Fields fields;
};

struct UnicodeEncoding__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData SetDefaultFallbacks;
    VirtualInvokeData GetPreamble;
    VirtualInvokeData get_BodyName;
    VirtualInvokeData get_EncodingName;
    VirtualInvokeData get_HeaderName;
    VirtualInvokeData get_WebName;
    VirtualInvokeData get_WindowsCodePage;
    VirtualInvokeData get_IsBrowserDisplay;
    VirtualInvokeData get_IsBrowserSave;
    VirtualInvokeData get_IsMailNewsDisplay;
    VirtualInvokeData get_IsMailNewsSave;
    VirtualInvokeData get_IsSingleByte;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetByteCount;
    VirtualInvokeData GetByteCount_1;
    VirtualInvokeData GetByteCount_2;
    VirtualInvokeData GetByteCount_3;
    VirtualInvokeData GetByteCount_4;
    VirtualInvokeData GetBytes;
    VirtualInvokeData GetBytes_1;
    VirtualInvokeData GetBytes_2;
    VirtualInvokeData GetBytes_3;
    VirtualInvokeData GetBytes_4;
    VirtualInvokeData GetBytes_5;
    VirtualInvokeData GetBytes_6;
    VirtualInvokeData GetCharCount;
    VirtualInvokeData GetCharCount_1;
    VirtualInvokeData GetCharCount_2;
    VirtualInvokeData GetCharCount_3;
    VirtualInvokeData GetChars;
    VirtualInvokeData GetChars_1;
    VirtualInvokeData GetChars_2;
    VirtualInvokeData GetChars_3;
    VirtualInvokeData GetChars_4;
    VirtualInvokeData get_CodePage;
    VirtualInvokeData IsAlwaysNormalized;
    VirtualInvokeData GetDecoder;
    VirtualInvokeData GetEncoder;
    VirtualInvokeData GetMaxByteCount;
    VirtualInvokeData GetMaxCharCount;
    VirtualInvokeData GetString;
    VirtualInvokeData GetString_1;
    VirtualInvokeData GetBestFitUnicodeToBytesData;
    VirtualInvokeData GetBestFitBytesToUnicodeData;
};

struct UnicodeEncoding__StaticFields {
    uint64_t highLowPatternMask;
};

struct UnicodeEncoding__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UnicodeEncoding__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UnicodeEncoding__VTable vtable;
};

struct UnicodeEncoding_Decoder__Fields {
    struct DecoderNLS__Fields _;
    int32_t lastByte;
    uint16_t lastChar;
};

struct UnicodeEncoding_Decoder {
    struct UnicodeEncoding_Decoder__Class *klass;
    MonitorData *monitor;
    struct UnicodeEncoding_Decoder__Fields fields;
};

struct UnicodeEncoding_Decoder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Reset;
    VirtualInvokeData GetCharCount;
    VirtualInvokeData GetCharCount_1;
    VirtualInvokeData GetCharCount_2;
    VirtualInvokeData GetChars;
    VirtualInvokeData GetChars_1;
    VirtualInvokeData GetChars_2;
    VirtualInvokeData Convert;
    VirtualInvokeData Convert_1;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
    VirtualInvokeData get_HasState;
};

struct UnicodeEncoding_Decoder__StaticFields {
};

struct UnicodeEncoding_Decoder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UnicodeEncoding_Decoder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UnicodeEncoding_Decoder__VTable vtable;
};

struct UTF32Encoding__Fields {
    struct Encoding__Fields _;
    bool emitUTF32ByteOrderMark;
    bool isThrowException;
    bool bigEndian;
};

struct UTF32Encoding {
    struct UTF32Encoding__Class *klass;
    MonitorData *monitor;
    struct UTF32Encoding__Fields fields;
};

struct UTF32Encoding__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData SetDefaultFallbacks;
    VirtualInvokeData GetPreamble;
    VirtualInvokeData get_BodyName;
    VirtualInvokeData get_EncodingName;
    VirtualInvokeData get_HeaderName;
    VirtualInvokeData get_WebName;
    VirtualInvokeData get_WindowsCodePage;
    VirtualInvokeData get_IsBrowserDisplay;
    VirtualInvokeData get_IsBrowserSave;
    VirtualInvokeData get_IsMailNewsDisplay;
    VirtualInvokeData get_IsMailNewsSave;
    VirtualInvokeData get_IsSingleByte;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetByteCount;
    VirtualInvokeData GetByteCount_1;
    VirtualInvokeData GetByteCount_2;
    VirtualInvokeData GetByteCount_3;
    VirtualInvokeData GetByteCount_4;
    VirtualInvokeData GetBytes;
    VirtualInvokeData GetBytes_1;
    VirtualInvokeData GetBytes_2;
    VirtualInvokeData GetBytes_3;
    VirtualInvokeData GetBytes_4;
    VirtualInvokeData GetBytes_5;
    VirtualInvokeData GetBytes_6;
    VirtualInvokeData GetCharCount;
    VirtualInvokeData GetCharCount_1;
    VirtualInvokeData GetCharCount_2;
    VirtualInvokeData GetCharCount_3;
    VirtualInvokeData GetChars;
    VirtualInvokeData GetChars_1;
    VirtualInvokeData GetChars_2;
    VirtualInvokeData GetChars_3;
    VirtualInvokeData GetChars_4;
    VirtualInvokeData get_CodePage;
    VirtualInvokeData IsAlwaysNormalized;
    VirtualInvokeData GetDecoder;
    VirtualInvokeData GetEncoder;
    VirtualInvokeData GetMaxByteCount;
    VirtualInvokeData GetMaxCharCount;
    VirtualInvokeData GetString;
    VirtualInvokeData GetString_1;
    VirtualInvokeData GetBestFitUnicodeToBytesData;
    VirtualInvokeData GetBestFitBytesToUnicodeData;
};

struct UTF32Encoding__StaticFields {
};

struct UTF32Encoding__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UTF32Encoding__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UTF32Encoding__VTable vtable;
};

struct UTF32Encoding_UTF32Decoder__Fields {
    struct DecoderNLS__Fields _;
    int32_t iChar;
    int32_t readByteCount;
};

struct UTF32Encoding_UTF32Decoder {
    struct UTF32Encoding_UTF32Decoder__Class *klass;
    MonitorData *monitor;
    struct UTF32Encoding_UTF32Decoder__Fields fields;
};

struct UTF32Encoding_UTF32Decoder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Reset;
    VirtualInvokeData GetCharCount;
    VirtualInvokeData GetCharCount_1;
    VirtualInvokeData GetCharCount_2;
    VirtualInvokeData GetChars;
    VirtualInvokeData GetChars_1;
    VirtualInvokeData GetChars_2;
    VirtualInvokeData Convert;
    VirtualInvokeData Convert_1;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
    VirtualInvokeData get_HasState;
};

struct UTF32Encoding_UTF32Decoder__StaticFields {
};

struct UTF32Encoding_UTF32Decoder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UTF32Encoding_UTF32Decoder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UTF32Encoding_UTF32Decoder__VTable vtable;
};

struct UTF7Encoding__Fields {
    struct Encoding__Fields _;
    struct Byte__Array *base64Bytes;
    struct SByte__Array *base64Values;
    struct Boolean__Array *directEncode;
    bool m_allowOptionals;
};

struct UTF7Encoding {
    struct UTF7Encoding__Class *klass;
    MonitorData *monitor;
    struct UTF7Encoding__Fields fields;
};

struct SByte__Array {
    struct SByte__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    int8_t vector[32];
};

struct SByte__Array__VTable {
};

struct SByte__Array__StaticFields {
};

struct SByte__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SByte__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SByte__Array__VTable vtable;
};

struct UTF7Encoding__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData SetDefaultFallbacks;
    VirtualInvokeData GetPreamble;
    VirtualInvokeData get_BodyName;
    VirtualInvokeData get_EncodingName;
    VirtualInvokeData get_HeaderName;
    VirtualInvokeData get_WebName;
    VirtualInvokeData get_WindowsCodePage;
    VirtualInvokeData get_IsBrowserDisplay;
    VirtualInvokeData get_IsBrowserSave;
    VirtualInvokeData get_IsMailNewsDisplay;
    VirtualInvokeData get_IsMailNewsSave;
    VirtualInvokeData get_IsSingleByte;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetByteCount;
    VirtualInvokeData GetByteCount_1;
    VirtualInvokeData GetByteCount_2;
    VirtualInvokeData GetByteCount_3;
    VirtualInvokeData GetByteCount_4;
    VirtualInvokeData GetBytes;
    VirtualInvokeData GetBytes_1;
    VirtualInvokeData GetBytes_2;
    VirtualInvokeData GetBytes_3;
    VirtualInvokeData GetBytes_4;
    VirtualInvokeData GetBytes_5;
    VirtualInvokeData GetBytes_6;
    VirtualInvokeData GetCharCount;
    VirtualInvokeData GetCharCount_1;
    VirtualInvokeData GetCharCount_2;
    VirtualInvokeData GetCharCount_3;
    VirtualInvokeData GetChars;
    VirtualInvokeData GetChars_1;
    VirtualInvokeData GetChars_2;
    VirtualInvokeData GetChars_3;
    VirtualInvokeData GetChars_4;
    VirtualInvokeData get_CodePage;
    VirtualInvokeData IsAlwaysNormalized;
    VirtualInvokeData GetDecoder;
    VirtualInvokeData GetEncoder;
    VirtualInvokeData GetMaxByteCount;
    VirtualInvokeData GetMaxCharCount;
    VirtualInvokeData GetString;
    VirtualInvokeData GetString_1;
    VirtualInvokeData GetBestFitUnicodeToBytesData;
    VirtualInvokeData GetBestFitBytesToUnicodeData;
};

struct UTF7Encoding__StaticFields {
};

struct UTF7Encoding__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UTF7Encoding__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UTF7Encoding__VTable vtable;
};

struct UTF7Encoding_Decoder__Fields {
    struct DecoderNLS__Fields _;
    int32_t bits;
    int32_t bitCount;
    bool firstByte;
};

struct UTF7Encoding_Decoder {
    struct UTF7Encoding_Decoder__Class *klass;
    MonitorData *monitor;
    struct UTF7Encoding_Decoder__Fields fields;
};

struct UTF7Encoding_Decoder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Reset;
    VirtualInvokeData GetCharCount;
    VirtualInvokeData GetCharCount_1;
    VirtualInvokeData GetCharCount_2;
    VirtualInvokeData GetChars;
    VirtualInvokeData GetChars_1;
    VirtualInvokeData GetChars_2;
    VirtualInvokeData Convert;
    VirtualInvokeData Convert_1;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
    VirtualInvokeData get_HasState;
};

struct UTF7Encoding_Decoder__StaticFields {
};

struct UTF7Encoding_Decoder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UTF7Encoding_Decoder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UTF7Encoding_Decoder__VTable vtable;
};

struct UTF7Encoding_Encoder__Fields {
    struct EncoderNLS__Fields _;
    int32_t bits;
    int32_t bitCount;
};

struct UTF7Encoding_Encoder {
    struct UTF7Encoding_Encoder__Class *klass;
    MonitorData *monitor;
    struct UTF7Encoding_Encoder__Fields fields;
};

struct UTF7Encoding_Encoder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Reset;
    VirtualInvokeData GetByteCount;
    VirtualInvokeData GetByteCount_1;
    VirtualInvokeData GetBytes;
    VirtualInvokeData GetBytes_1;
    VirtualInvokeData Convert;
    VirtualInvokeData Convert_1;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
    VirtualInvokeData get_HasState;
};

struct UTF7Encoding_Encoder__StaticFields {
};

struct UTF7Encoding_Encoder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UTF7Encoding_Encoder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UTF7Encoding_Encoder__VTable vtable;
};

struct UTF7Encoding_DecoderUTF7Fallback__Fields {
    struct DecoderFallback__Fields _;
};

struct UTF7Encoding_DecoderUTF7Fallback {
    struct UTF7Encoding_DecoderUTF7Fallback__Class *klass;
    MonitorData *monitor;
    struct UTF7Encoding_DecoderUTF7Fallback__Fields fields;
};

struct UTF7Encoding_DecoderUTF7Fallback__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateFallbackBuffer;
    VirtualInvokeData get_MaxCharCount;
};

struct UTF7Encoding_DecoderUTF7Fallback__StaticFields {
};

struct UTF7Encoding_DecoderUTF7Fallback__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UTF7Encoding_DecoderUTF7Fallback__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UTF7Encoding_DecoderUTF7Fallback__VTable vtable;
};

struct UTF7Encoding_DecoderUTF7FallbackBuffer__Fields {
    struct DecoderFallbackBuffer__Fields _;
    uint16_t cFallback;
    int32_t iCount;
    int32_t iSize;
};

struct UTF7Encoding_DecoderUTF7FallbackBuffer {
    struct UTF7Encoding_DecoderUTF7FallbackBuffer__Class *klass;
    MonitorData *monitor;
    struct UTF7Encoding_DecoderUTF7FallbackBuffer__Fields fields;
};

struct UTF7Encoding_DecoderUTF7FallbackBuffer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Fallback;
    VirtualInvokeData GetNextChar;
    VirtualInvokeData MovePrevious;
    VirtualInvokeData get_Remaining;
    VirtualInvokeData Reset;
    VirtualInvokeData InternalFallback;
    VirtualInvokeData InternalFallback_1;
};

struct UTF7Encoding_DecoderUTF7FallbackBuffer__StaticFields {
};

struct UTF7Encoding_DecoderUTF7FallbackBuffer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UTF7Encoding_DecoderUTF7FallbackBuffer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UTF7Encoding_DecoderUTF7FallbackBuffer__VTable vtable;
};

struct UTF8Encoding__Fields {
    struct Encoding__Fields _;
    bool emitUTF8Identifier;
    bool isThrowException;
};

struct UTF8Encoding {
    struct UTF8Encoding__Class *klass;
    MonitorData *monitor;
    struct UTF8Encoding__Fields fields;
};

struct UTF8Encoding__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData SetDefaultFallbacks;
    VirtualInvokeData GetPreamble;
    VirtualInvokeData get_BodyName;
    VirtualInvokeData get_EncodingName;
    VirtualInvokeData get_HeaderName;
    VirtualInvokeData get_WebName;
    VirtualInvokeData get_WindowsCodePage;
    VirtualInvokeData get_IsBrowserDisplay;
    VirtualInvokeData get_IsBrowserSave;
    VirtualInvokeData get_IsMailNewsDisplay;
    VirtualInvokeData get_IsMailNewsSave;
    VirtualInvokeData get_IsSingleByte;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetByteCount;
    VirtualInvokeData GetByteCount_1;
    VirtualInvokeData GetByteCount_2;
    VirtualInvokeData GetByteCount_3;
    VirtualInvokeData GetByteCount_4;
    VirtualInvokeData GetBytes;
    VirtualInvokeData GetBytes_1;
    VirtualInvokeData GetBytes_2;
    VirtualInvokeData GetBytes_3;
    VirtualInvokeData GetBytes_4;
    VirtualInvokeData GetBytes_5;
    VirtualInvokeData GetBytes_6;
    VirtualInvokeData GetCharCount;
    VirtualInvokeData GetCharCount_1;
    VirtualInvokeData GetCharCount_2;
    VirtualInvokeData GetCharCount_3;
    VirtualInvokeData GetChars;
    VirtualInvokeData GetChars_1;
    VirtualInvokeData GetChars_2;
    VirtualInvokeData GetChars_3;
    VirtualInvokeData GetChars_4;
    VirtualInvokeData get_CodePage;
    VirtualInvokeData IsAlwaysNormalized;
    VirtualInvokeData GetDecoder;
    VirtualInvokeData GetEncoder;
    VirtualInvokeData GetMaxByteCount;
    VirtualInvokeData GetMaxCharCount;
    VirtualInvokeData GetString;
    VirtualInvokeData GetString_1;
    VirtualInvokeData GetBestFitUnicodeToBytesData;
    VirtualInvokeData GetBestFitBytesToUnicodeData;
};

struct UTF8Encoding__StaticFields {
};

struct UTF8Encoding__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UTF8Encoding__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UTF8Encoding__VTable vtable;
};

struct UTF8Encoding_UTF8Encoder__Fields {
    struct EncoderNLS__Fields _;
    int32_t surrogateChar;
};

struct UTF8Encoding_UTF8Encoder {
    struct UTF8Encoding_UTF8Encoder__Class *klass;
    MonitorData *monitor;
    struct UTF8Encoding_UTF8Encoder__Fields fields;
};

struct UTF8Encoding_UTF8Encoder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Reset;
    VirtualInvokeData GetByteCount;
    VirtualInvokeData GetByteCount_1;
    VirtualInvokeData GetBytes;
    VirtualInvokeData GetBytes_1;
    VirtualInvokeData Convert;
    VirtualInvokeData Convert_1;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
    VirtualInvokeData get_HasState;
};

struct UTF8Encoding_UTF8Encoder__StaticFields {
};

struct UTF8Encoding_UTF8Encoder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UTF8Encoding_UTF8Encoder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UTF8Encoding_UTF8Encoder__VTable vtable;
};

struct UTF8Encoding_UTF8Decoder__Fields {
    struct DecoderNLS__Fields _;
    int32_t bits;
};

struct UTF8Encoding_UTF8Decoder {
    struct UTF8Encoding_UTF8Decoder__Class *klass;
    MonitorData *monitor;
    struct UTF8Encoding_UTF8Decoder__Fields fields;
};

struct UTF8Encoding_UTF8Decoder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Reset;
    VirtualInvokeData GetCharCount;
    VirtualInvokeData GetCharCount_1;
    VirtualInvokeData GetCharCount_2;
    VirtualInvokeData GetChars;
    VirtualInvokeData GetChars_1;
    VirtualInvokeData GetChars_2;
    VirtualInvokeData Convert;
    VirtualInvokeData Convert_1;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
    VirtualInvokeData get_HasState;
};

struct UTF8Encoding_UTF8Decoder__StaticFields {
};

struct UTF8Encoding_UTF8Decoder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UTF8Encoding_UTF8Decoder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UTF8Encoding_UTF8Decoder__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum NormalizationCheck__Enum : int32_t {
    NormalizationCheck__Enum_Yes = 0x00000000,
    NormalizationCheck__Enum_No = 0x00000001,
    NormalizationCheck__Enum_Maybe = 0x00000002,
};

#else
enum NormalizationCheck__Enum {
    NormalizationCheck__Enum_Yes = 0x00000000,
    NormalizationCheck__Enum_No = 0x00000001,
    NormalizationCheck__Enum_Maybe = 0x00000002,
};

#endif
struct NormalizationCheck__Enum__Boxed {
    struct NormalizationCheck__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum NormalizationCheck__Enum value;
    #else
    uint32_t value;
    #endif
};

struct NormalizationCheck__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct NormalizationCheck__Enum__StaticFields {
};

struct NormalizationCheck__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct NormalizationCheck__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct NormalizationCheck__Enum__VTable vtable;
};

struct Normalization {
    struct Normalization__Class *klass;
    MonitorData *monitor;
};

struct Int16Ptr {
    struct Int16Ptr__Class *klass;
    MonitorData *monitor;
};

struct UInt16Ptr {
    struct UInt16Ptr__Class *klass;
    MonitorData *monitor;
};

struct Int16Ptr__VTable {
};

struct Int16Ptr__StaticFields {
};

struct Int16Ptr__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Int16Ptr__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Int16Ptr__VTable vtable;
};

struct UInt16Ptr__VTable {
};

struct UInt16Ptr__StaticFields {
};

struct UInt16Ptr__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UInt16Ptr__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UInt16Ptr__VTable vtable;
};

struct Normalization__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Normalization__StaticFields {
    uint8_t *props;
    int32_t *mappedChars;
    int16_t *charMapIndex;
    int16_t *helperIndex;
    uint16_t *mapIdxToComposite;
    uint8_t *combiningClass;
    struct Object *forLock;
    bool isReady;
};

struct Normalization__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Normalization__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Normalization__VTable vtable;
};

struct FastResourceComparer {
    struct FastResourceComparer__Class *klass;
    MonitorData *monitor;
};

struct FastResourceComparer__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Compare;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData Compare_1;
    VirtualInvokeData Equals_2;
    VirtualInvokeData GetHashCode_2;
};

struct FastResourceComparer__StaticFields {
    struct FastResourceComparer *Default;
};

struct FastResourceComparer__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FastResourceComparer__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FastResourceComparer__VTable vtable;
};

struct __declspec(align(8)) FileBasedResourceGroveler__Fields {
    struct ResourceManager_ResourceManagerMediator *_mediator;
};

struct FileBasedResourceGroveler {
    struct FileBasedResourceGroveler__Class *klass;
    MonitorData *monitor;
    struct FileBasedResourceGroveler__Fields fields;
};

struct __declspec(align(8)) ResourceManager_ResourceManagerMediator__Fields {
    struct ResourceManager *_rm;
};

struct ResourceManager_ResourceManagerMediator {
    struct ResourceManager_ResourceManagerMediator__Class *klass;
    MonitorData *monitor;
    struct ResourceManager_ResourceManagerMediator__Fields fields;
};

#if defined(_CPLUSPLUS_)
enum UltimateResourceFallbackLocation__Enum : int32_t {
    UltimateResourceFallbackLocation__Enum_MainAssembly = 0x00000000,
    UltimateResourceFallbackLocation__Enum_Satellite = 0x00000001,
};

#else
enum UltimateResourceFallbackLocation__Enum {
    UltimateResourceFallbackLocation__Enum_MainAssembly = 0x00000000,
    UltimateResourceFallbackLocation__Enum_Satellite = 0x00000001,
};

#endif
struct UltimateResourceFallbackLocation__Enum__Boxed {
    struct UltimateResourceFallbackLocation__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum UltimateResourceFallbackLocation__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) ResourceManager__Fields {
    struct String *BaseNameField;
    struct Hashtable *ResourceSets;
    struct Dictionary_2_System_String_System_Resources_ResourceSet_ *_resourceSets;
    struct String *moduleDir;
    struct Assembly *MainAssembly;
    struct Type *_locationInfo;
    struct Type *_userResourceSet;
    struct CultureInfo *_neutralResourcesCulture;
    struct ResourceManager_CultureNameResourceSetPair *_lastUsedResourceCache;
    bool _ignoreCase;
    bool UseManifest;
    bool UseSatelliteAssem;
    #if defined(_CPLUSPLUS_)
    enum UltimateResourceFallbackLocation__Enum _fallbackLoc;
    #else
    uint32_t _fallbackLoc;
    #endif
    struct Version *_satelliteContractVersion;
    bool _lookedForSatelliteContractVersion;
    struct Assembly *_callingAssembly;
    struct RuntimeAssembly *m_callingAssembly;
    struct IResourceGroveler *resourceGroveler;
};

struct ResourceManager {
    struct ResourceManager__Class *klass;
    MonitorData *monitor;
    struct ResourceManager__Fields fields;
};

struct __declspec(align(8)) Dictionary_2_System_String_System_Resources_ResourceSet___Fields {
    struct Int32__Array *buckets;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceSet___Array *entries;
    int32_t count;
    int32_t version;
    int32_t freeList;
    int32_t freeCount;
    struct IEqualityComparer_1_System_String_ *comparer;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceSet_ *keys;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceSet_ *values;
    struct Object *_syncRoot;
};

struct Dictionary_2_System_String_System_Resources_ResourceSet_ {
    struct Dictionary_2_System_String_System_Resources_ResourceSet___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_System_String_System_Resources_ResourceSet___Fields fields;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceSet_ {
    int32_t hashCode;
    int32_t next;
    struct String *key;
    struct ResourceSet *value;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceSet___Boxed {
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceSet___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceSet_ fields;
};

struct __declspec(align(8)) ResourceSet__Fields {
    struct IResourceReader *Reader;
    struct Hashtable *Table;
    struct Hashtable *_caseInsensitiveTable;
};

struct ResourceSet {
    struct ResourceSet__Class *klass;
    MonitorData *monitor;
    struct ResourceSet__Fields fields;
};

struct IResourceReader {
    struct IResourceReader__Class *klass;
    MonitorData *monitor;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceSet___Array {
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceSet___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceSet_ vector[32];
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceSet___Fields {
    struct Dictionary_2_System_String_System_Resources_ResourceSet_ *dictionary;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceSet_ {
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceSet___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceSet___Fields fields;
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceSet___Fields {
    struct Dictionary_2_System_String_System_Resources_ResourceSet_ *dictionary;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceSet_ {
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceSet___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceSet___Fields fields;
};

struct ResourceSet__Array {
    struct ResourceSet__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct ResourceSet *vector[32];
};

struct IEnumerator_1_System_Resources_ResourceSet_ {
    struct IEnumerator_1_System_Resources_ResourceSet___Class *klass;
    MonitorData *monitor;
};

struct ICollection_1_System_Resources_ResourceSet_ {
    struct ICollection_1_System_Resources_ResourceSet___Class *klass;
    MonitorData *monitor;
};

struct KeyValuePair_2_System_String_System_Resources_ResourceSet_ {
    struct String *key;
    struct ResourceSet *value;
};

struct KeyValuePair_2_System_String_System_Resources_ResourceSet___Boxed {
    struct KeyValuePair_2_System_String_System_Resources_ResourceSet___Class *klass;
    MonitorData *monitor;
    struct KeyValuePair_2_System_String_System_Resources_ResourceSet_ fields;
};

struct KeyValuePair_2_System_String_System_Resources_ResourceSet___Array {
    struct KeyValuePair_2_System_String_System_Resources_ResourceSet___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct KeyValuePair_2_System_String_System_Resources_ResourceSet_ vector[32];
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_Resources_ResourceSet_ {
    struct IEnumerator_1_KeyValuePair_2_System_String_System_Resources_ResourceSet___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_Resources_ResourceSet_ {
    struct IEnumerable_1_System_Resources_ResourceSet___Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) ResourceManager_CultureNameResourceSetPair__Fields {
    struct String *lastCultureName;
    struct ResourceSet *lastResourceSet;
};

struct ResourceManager_CultureNameResourceSetPair {
    struct ResourceManager_CultureNameResourceSetPair__Class *klass;
    MonitorData *monitor;
    struct ResourceManager_CultureNameResourceSetPair__Fields fields;
};

struct IResourceGroveler {
    struct IResourceGroveler__Class *klass;
    MonitorData *monitor;
};

struct IResourceReader__VTable {
    VirtualInvokeData Close;
    VirtualInvokeData GetEnumerator;
};

struct IResourceReader__StaticFields {
};

struct IResourceReader__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IResourceReader__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IResourceReader__VTable vtable;
};

struct ResourceSet__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData Close;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData GetDefaultReader;
    VirtualInvokeData GetDefaultWriter;
    VirtualInvokeData GetEnumerator;
    VirtualInvokeData GetString;
    VirtualInvokeData GetString_1;
    VirtualInvokeData GetObject;
    VirtualInvokeData GetObject_1;
    VirtualInvokeData ReadResources;
};

struct ResourceSet__StaticFields {
};

struct ResourceSet__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ResourceSet__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ResourceSet__VTable vtable;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceSet___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceSet___StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceSet___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceSet___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceSet___VTable vtable;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceSet___Array__VTable {
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceSet___Array__StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceSet___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceSet___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceSet___Array__VTable vtable;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceSet___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TKey__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceSet___StaticFields {
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceSet___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceSet___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceSet___VTable vtable;
};

struct ResourceSet__Array__VTable {
};

struct ResourceSet__Array__StaticFields {
};

struct ResourceSet__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ResourceSet__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ResourceSet__Array__VTable vtable;
};

struct IEnumerator_1_System_Resources_ResourceSet___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_System_Resources_ResourceSet___StaticFields {
};

struct IEnumerator_1_System_Resources_ResourceSet___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_System_Resources_ResourceSet___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_System_Resources_ResourceSet___VTable vtable;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceSet___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TValue__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceSet___StaticFields {
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceSet___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceSet___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceSet___VTable vtable;
};

struct ICollection_1_System_Resources_ResourceSet___VTable {
    VirtualInvokeData get_Count;
    VirtualInvokeData get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
};

struct ICollection_1_System_Resources_ResourceSet___StaticFields {
};

struct ICollection_1_System_Resources_ResourceSet___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ICollection_1_System_Resources_ResourceSet___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ICollection_1_System_Resources_ResourceSet___VTable vtable;
};

struct ResourceSet___VTable {
};

struct ResourceSet___StaticFields {
};

struct ResourceSet___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ResourceSet___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ResourceSet___VTable vtable;
};

struct KeyValuePair_2_System_String_System_Resources_ResourceSet___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct KeyValuePair_2_System_String_System_Resources_ResourceSet___StaticFields {
};

struct KeyValuePair_2_System_String_System_Resources_ResourceSet___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_String_System_Resources_ResourceSet___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_String_System_Resources_ResourceSet___VTable vtable;
};

struct KeyValuePair_2_System_String_System_Resources_ResourceSet___Array__VTable {
};

struct KeyValuePair_2_System_String_System_Resources_ResourceSet___Array__StaticFields {
};

struct KeyValuePair_2_System_String_System_Resources_ResourceSet___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_String_System_Resources_ResourceSet___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_String_System_Resources_ResourceSet___Array__VTable vtable;
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_Resources_ResourceSet___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_Resources_ResourceSet___StaticFields {
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_Resources_ResourceSet___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_KeyValuePair_2_System_String_System_Resources_ResourceSet___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_KeyValuePair_2_System_String_System_Resources_ResourceSet___VTable vtable;
};

struct IEnumerable_1_System_Resources_ResourceSet___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_Resources_ResourceSet___StaticFields {
};

struct IEnumerable_1_System_Resources_ResourceSet___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_Resources_ResourceSet___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_Resources_ResourceSet___VTable vtable;
};

struct Dictionary_2_System_String_System_Resources_ResourceSet___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Values;
    VirtualInvokeData ContainsKey;
    VirtualInvokeData Add;
    VirtualInvokeData Remove;
    VirtualInvokeData TryGetValue;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Add;
    VirtualInvokeData Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Contains;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_System_Collections_Generic_KeyValuePair_TKey_TValue___GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_get_Item;
    VirtualInvokeData System_Collections_IDictionary_set_Item;
    VirtualInvokeData System_Collections_IDictionary_get_Keys;
    VirtualInvokeData System_Collections_IDictionary_get_Values;
    VirtualInvokeData System_Collections_IDictionary_Contains;
    VirtualInvokeData System_Collections_IDictionary_Add;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IDictionary_get_IsReadOnly;
    VirtualInvokeData System_Collections_IDictionary_get_IsFixedSize;
    VirtualInvokeData System_Collections_IDictionary_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_Remove;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData ContainsKey_1;
    VirtualInvokeData TryGetValue_1;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Values;
    VirtualInvokeData get_Count_2;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData OnDeserialization;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData OnDeserialization_1;
};

struct Dictionary_2_System_String_System_Resources_ResourceSet___StaticFields {
};

struct Dictionary_2_System_String_System_Resources_ResourceSet___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_System_String_System_Resources_ResourceSet___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_System_String_System_Resources_ResourceSet___VTable vtable;
};

struct ResourceManager_CultureNameResourceSetPair__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ResourceManager_CultureNameResourceSetPair__StaticFields {
};

struct ResourceManager_CultureNameResourceSetPair__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ResourceManager_CultureNameResourceSetPair__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ResourceManager_CultureNameResourceSetPair__VTable vtable;
};

struct UltimateResourceFallbackLocation__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct UltimateResourceFallbackLocation__Enum__StaticFields {
};

struct UltimateResourceFallbackLocation__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UltimateResourceFallbackLocation__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UltimateResourceFallbackLocation__Enum__VTable vtable;
};

struct IResourceGroveler__VTable {
    VirtualInvokeData GrovelForResourceSet;
    VirtualInvokeData HasNeutralResources;
};

struct IResourceGroveler__StaticFields {
};

struct IResourceGroveler__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IResourceGroveler__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IResourceGroveler__VTable vtable;
};

struct ResourceManager__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_BaseName;
    VirtualInvokeData get_IgnoreCase;
    VirtualInvokeData set_IgnoreCase;
    VirtualInvokeData get_ResourceSetType;
    VirtualInvokeData ReleaseAllResources;
    VirtualInvokeData GetResourceFileName;
    VirtualInvokeData GetResourceSet;
    VirtualInvokeData InternalGetResourceSet;
    VirtualInvokeData GetString;
    VirtualInvokeData GetString_1;
    VirtualInvokeData GetObject;
    VirtualInvokeData GetObject_1;
};

struct ResourceManager__StaticFields {
    int32_t MagicNumber;
    int32_t HeaderVersionNumber;
    struct Type *_minResourceSet;
    struct String *ResReaderTypeName;
    struct String *ResSetTypeName;
    struct String *MscorlibName;
    int32_t DEBUG;
};

struct ResourceManager__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ResourceManager__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ResourceManager__VTable vtable;
};

struct ResourceManager_ResourceManagerMediator__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ResourceManager_ResourceManagerMediator__StaticFields {
};

struct ResourceManager_ResourceManagerMediator__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ResourceManager_ResourceManagerMediator__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ResourceManager_ResourceManagerMediator__VTable vtable;
};

struct FileBasedResourceGroveler__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GrovelForResourceSet;
    VirtualInvokeData HasNeutralResources;
};

struct FileBasedResourceGroveler__StaticFields {
};

struct FileBasedResourceGroveler__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FileBasedResourceGroveler__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FileBasedResourceGroveler__VTable vtable;
};

struct __declspec(align(8)) ManifestBasedResourceGroveler__Fields {
    struct ResourceManager_ResourceManagerMediator *_mediator;
};

struct ManifestBasedResourceGroveler {
    struct ManifestBasedResourceGroveler__Class *klass;
    MonitorData *monitor;
    struct ManifestBasedResourceGroveler__Fields fields;
};

struct ManifestBasedResourceGroveler__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GrovelForResourceSet;
    VirtualInvokeData HasNeutralResources;
};

struct ManifestBasedResourceGroveler__StaticFields {
};

struct ManifestBasedResourceGroveler__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ManifestBasedResourceGroveler__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ManifestBasedResourceGroveler__VTable vtable;
};

struct UltimateResourceFallbackLocation___VTable {
};

struct UltimateResourceFallbackLocation___StaticFields {
};

struct UltimateResourceFallbackLocation___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UltimateResourceFallbackLocation___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UltimateResourceFallbackLocation___VTable vtable;
};

struct MissingManifestResourceException__Fields {
    struct SystemException__Fields _;
};

struct MissingManifestResourceException {
    struct MissingManifestResourceException__Class *klass;
    MonitorData *monitor;
    struct MissingManifestResourceException__Fields fields;
};

struct MissingManifestResourceException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct MissingManifestResourceException__StaticFields {
};

struct MissingManifestResourceException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MissingManifestResourceException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MissingManifestResourceException__VTable vtable;
};

struct MissingSatelliteAssemblyException__Fields {
    struct SystemException__Fields _;
    struct String *_cultureName;
};

struct MissingSatelliteAssemblyException {
    struct MissingSatelliteAssemblyException__Class *klass;
    MonitorData *monitor;
    struct MissingSatelliteAssemblyException__Fields fields;
};

struct MissingSatelliteAssemblyException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct MissingSatelliteAssemblyException__StaticFields {
};

struct MissingSatelliteAssemblyException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MissingSatelliteAssemblyException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MissingSatelliteAssemblyException__VTable vtable;
};

struct __declspec(align(8)) NeutralResourcesLanguageAttribute__Fields {
    struct String *_culture;
    #if defined(_CPLUSPLUS_)
    enum UltimateResourceFallbackLocation__Enum _fallbackLoc;
    #else
    uint32_t _fallbackLoc;
    #endif
};

struct NeutralResourcesLanguageAttribute {
    struct NeutralResourcesLanguageAttribute__Class *klass;
    MonitorData *monitor;
    struct NeutralResourcesLanguageAttribute__Fields fields;
};

struct NeutralResourcesLanguageAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct NeutralResourcesLanguageAttribute__StaticFields {
};

struct NeutralResourcesLanguageAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct NeutralResourcesLanguageAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct NeutralResourcesLanguageAttribute__VTable vtable;
};

struct __declspec(align(8)) ResourceFallbackManager__Fields {
    struct CultureInfo *m_startingCulture;
    struct CultureInfo *m_neutralResourcesCulture;
    bool m_useParents;
};

struct ResourceFallbackManager {
    struct ResourceFallbackManager__Class *klass;
    MonitorData *monitor;
    struct ResourceFallbackManager__Fields fields;
};

struct ResourceFallbackManager__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
};

struct ResourceFallbackManager__StaticFields {
};

struct ResourceFallbackManager__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ResourceFallbackManager__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ResourceFallbackManager__VTable vtable;
};

struct __declspec(align(8)) ResourceFallbackManager_GetEnumerator_d_5__Fields {
    int32_t __1__state;
    struct CultureInfo *__2__current;
    struct ResourceFallbackManager *__4__this;
    struct CultureInfo *_currentCulture_5__1;
    bool _reachedNeutralResourcesCulture_5__2;
};

struct ResourceFallbackManager_GetEnumerator_d_5 {
    struct ResourceFallbackManager_GetEnumerator_d_5__Class *klass;
    MonitorData *monitor;
    struct ResourceFallbackManager_GetEnumerator_d_5__Fields fields;
};

struct ResourceFallbackManager_GetEnumerator_d_5__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Collections_Generic_IEnumerator_System_Globalization_CultureInfo__get_Current;
    VirtualInvokeData System_IDisposable_Dispose;
    VirtualInvokeData MoveNext;
    VirtualInvokeData System_Collections_IEnumerator_get_Current;
    VirtualInvokeData System_Collections_IEnumerator_Reset;
};

struct ResourceFallbackManager_GetEnumerator_d_5__StaticFields {
};

struct ResourceFallbackManager_GetEnumerator_d_5__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ResourceFallbackManager_GetEnumerator_d_5__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ResourceFallbackManager_GetEnumerator_d_5__VTable vtable;
};

struct ResourceLocator {
    struct Object *_value;
    int32_t _dataPos;
};

struct ResourceLocator__Boxed {
    struct ResourceLocator__Class *klass;
    MonitorData *monitor;
    struct ResourceLocator fields;
};

struct ResourceLocator__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ResourceLocator__StaticFields {
};

struct ResourceLocator__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ResourceLocator__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ResourceLocator__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum ResourceTypeCode__Enum : int32_t {
    ResourceTypeCode__Enum_Null = 0x00000000,
    ResourceTypeCode__Enum_String = 0x00000001,
    ResourceTypeCode__Enum_Boolean = 0x00000002,
    ResourceTypeCode__Enum_Char = 0x00000003,
    ResourceTypeCode__Enum_Byte = 0x00000004,
    ResourceTypeCode__Enum_SByte = 0x00000005,
    ResourceTypeCode__Enum_Int16 = 0x00000006,
    ResourceTypeCode__Enum_UInt16 = 0x00000007,
    ResourceTypeCode__Enum_Int32 = 0x00000008,
    ResourceTypeCode__Enum_UInt32 = 0x00000009,
    ResourceTypeCode__Enum_Int64 = 0x0000000a,
    ResourceTypeCode__Enum_UInt64 = 0x0000000b,
    ResourceTypeCode__Enum_Single = 0x0000000c,
    ResourceTypeCode__Enum_Double = 0x0000000d,
    ResourceTypeCode__Enum_Decimal = 0x0000000e,
    ResourceTypeCode__Enum_DateTime = 0x0000000f,
    ResourceTypeCode__Enum_TimeSpan = 0x00000010,
    ResourceTypeCode__Enum_LastPrimitive = 0x00000010,
    ResourceTypeCode__Enum_ByteArray = 0x00000020,
    ResourceTypeCode__Enum_Stream = 0x00000021,
    ResourceTypeCode__Enum_StartOfUserTypes = 0x00000040,
};

#else
enum ResourceTypeCode__Enum {
    ResourceTypeCode__Enum_Null = 0x00000000,
    ResourceTypeCode__Enum_String = 0x00000001,
    ResourceTypeCode__Enum_Boolean = 0x00000002,
    ResourceTypeCode__Enum_Char = 0x00000003,
    ResourceTypeCode__Enum_Byte = 0x00000004,
    ResourceTypeCode__Enum_SByte = 0x00000005,
    ResourceTypeCode__Enum_Int16 = 0x00000006,
    ResourceTypeCode__Enum_UInt16 = 0x00000007,
    ResourceTypeCode__Enum_Int32 = 0x00000008,
    ResourceTypeCode__Enum_UInt32 = 0x00000009,
    ResourceTypeCode__Enum_Int64 = 0x0000000a,
    ResourceTypeCode__Enum_UInt64 = 0x0000000b,
    ResourceTypeCode__Enum_Single = 0x0000000c,
    ResourceTypeCode__Enum_Double = 0x0000000d,
    ResourceTypeCode__Enum_Decimal = 0x0000000e,
    ResourceTypeCode__Enum_DateTime = 0x0000000f,
    ResourceTypeCode__Enum_TimeSpan = 0x00000010,
    ResourceTypeCode__Enum_LastPrimitive = 0x00000010,
    ResourceTypeCode__Enum_ByteArray = 0x00000020,
    ResourceTypeCode__Enum_Stream = 0x00000021,
    ResourceTypeCode__Enum_StartOfUserTypes = 0x00000040,
};

#endif
struct ResourceTypeCode__Enum__Boxed {
    struct ResourceTypeCode__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum ResourceTypeCode__Enum value;
    #else
    uint32_t value;
    #endif
};

struct ResourceTypeCode__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct ResourceTypeCode__Enum__StaticFields {
};

struct ResourceTypeCode__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ResourceTypeCode__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ResourceTypeCode__Enum__VTable vtable;
};

struct __declspec(align(8)) ResourceReader__Fields {
    struct BinaryReader *_store;
    struct Dictionary_2_System_String_System_Resources_ResourceLocator_ *_resCache;
    int64_t _nameSectionOffset;
    int64_t _dataSectionOffset;
    struct Int32__Array *_nameHashes;
    int32_t *_nameHashesPtr;
    struct Int32__Array *_namePositions;
    int32_t *_namePositionsPtr;
    struct RuntimeType__Array *_typeTable;
    struct Int32__Array *_typeNamePositions;
    struct BinaryFormatter *_objFormatter;
    int32_t _numResources;
    struct UnmanagedMemoryStream *_ums;
    int32_t _version;
};

struct ResourceReader {
    struct ResourceReader__Class *klass;
    MonitorData *monitor;
    struct ResourceReader__Fields fields;
};

struct __declspec(align(8)) BinaryReader__Fields {
    struct Stream *m_stream;
    struct Byte__Array *m_buffer;
    struct Decoder *m_decoder;
    struct Byte__Array *m_charBytes;
    struct Char__Array *m_singleChar;
    struct Char__Array *m_charBuffer;
    int32_t m_maxCharsSize;
    bool m_2BytesPerChar;
    bool m_isMemoryStream;
    bool m_leaveOpen;
};

struct BinaryReader {
    struct BinaryReader__Class *klass;
    MonitorData *monitor;
    struct BinaryReader__Fields fields;
};

struct __declspec(align(8)) Dictionary_2_System_String_System_Resources_ResourceLocator___Fields {
    struct Int32__Array *buckets;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceLocator___Array *entries;
    int32_t count;
    int32_t version;
    int32_t freeList;
    int32_t freeCount;
    struct IEqualityComparer_1_System_String_ *comparer;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceLocator_ *keys;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceLocator_ *values;
    struct Object *_syncRoot;
};

struct Dictionary_2_System_String_System_Resources_ResourceLocator_ {
    struct Dictionary_2_System_String_System_Resources_ResourceLocator___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_System_String_System_Resources_ResourceLocator___Fields fields;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceLocator_ {
    int32_t hashCode;
    int32_t next;
    struct String *key;
    struct ResourceLocator value;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceLocator___Boxed {
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceLocator___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceLocator_ fields;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceLocator___Array {
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceLocator___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceLocator_ vector[32];
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceLocator___Fields {
    struct Dictionary_2_System_String_System_Resources_ResourceLocator_ *dictionary;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceLocator_ {
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceLocator___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceLocator___Fields fields;
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceLocator___Fields {
    struct Dictionary_2_System_String_System_Resources_ResourceLocator_ *dictionary;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceLocator_ {
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceLocator___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceLocator___Fields fields;
};

struct ResourceLocator__Array {
    struct ResourceLocator__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct ResourceLocator vector[32];
};

struct IEnumerator_1_System_Resources_ResourceLocator_ {
    struct IEnumerator_1_System_Resources_ResourceLocator___Class *klass;
    MonitorData *monitor;
};

struct ICollection_1_System_Resources_ResourceLocator_ {
    struct ICollection_1_System_Resources_ResourceLocator___Class *klass;
    MonitorData *monitor;
};

struct KeyValuePair_2_System_String_System_Resources_ResourceLocator_ {
    struct String *key;
    struct ResourceLocator value;
};

struct KeyValuePair_2_System_String_System_Resources_ResourceLocator___Boxed {
    struct KeyValuePair_2_System_String_System_Resources_ResourceLocator___Class *klass;
    MonitorData *monitor;
    struct KeyValuePair_2_System_String_System_Resources_ResourceLocator_ fields;
};

struct KeyValuePair_2_System_String_System_Resources_ResourceLocator___Array {
    struct KeyValuePair_2_System_String_System_Resources_ResourceLocator___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct KeyValuePair_2_System_String_System_Resources_ResourceLocator_ vector[32];
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_Resources_ResourceLocator_ {
    struct IEnumerator_1_KeyValuePair_2_System_String_System_Resources_ResourceLocator___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_Resources_ResourceLocator_ {
    struct IEnumerable_1_System_Resources_ResourceLocator___Class *klass;
    MonitorData *monitor;
};

#if defined(_CPLUSPLUS_)
enum FormatterTypeStyle__Enum : int32_t {
    FormatterTypeStyle__Enum_TypesWhenNeeded = 0x00000000,
    FormatterTypeStyle__Enum_TypesAlways = 0x00000001,
    FormatterTypeStyle__Enum_XsdString = 0x00000002,
};

#else
enum FormatterTypeStyle__Enum {
    FormatterTypeStyle__Enum_TypesWhenNeeded = 0x00000000,
    FormatterTypeStyle__Enum_TypesAlways = 0x00000001,
    FormatterTypeStyle__Enum_XsdString = 0x00000002,
};

#endif
struct FormatterTypeStyle__Enum__Boxed {
    struct FormatterTypeStyle__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum FormatterTypeStyle__Enum value;
    #else
    uint32_t value;
    #endif
};

#if defined(_CPLUSPLUS_)
enum FormatterAssemblyStyle__Enum : int32_t {
    FormatterAssemblyStyle__Enum_Simple = 0x00000000,
    FormatterAssemblyStyle__Enum_Full = 0x00000001,
};

#else
enum FormatterAssemblyStyle__Enum {
    FormatterAssemblyStyle__Enum_Simple = 0x00000000,
    FormatterAssemblyStyle__Enum_Full = 0x00000001,
};

#endif
struct FormatterAssemblyStyle__Enum__Boxed {
    struct FormatterAssemblyStyle__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum FormatterAssemblyStyle__Enum value;
    #else
    uint32_t value;
    #endif
};

#if defined(_CPLUSPLUS_)
enum TypeFilterLevel__Enum : int32_t {
    TypeFilterLevel__Enum_Low = 0x00000002,
    TypeFilterLevel__Enum_Full = 0x00000003,
};

#else
enum TypeFilterLevel__Enum {
    TypeFilterLevel__Enum_Low = 0x00000002,
    TypeFilterLevel__Enum_Full = 0x00000003,
};

#endif
struct TypeFilterLevel__Enum__Boxed {
    struct TypeFilterLevel__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum TypeFilterLevel__Enum value;
    #else
    uint32_t value;
    #endif
};

struct __declspec(align(8)) BinaryFormatter__Fields {
    struct ISurrogateSelector *m_surrogates;
    struct StreamingContext m_context;
    struct SerializationBinder *m_binder;
    #if defined(_CPLUSPLUS_)
    enum FormatterTypeStyle__Enum m_typeFormat;
    #else
    uint32_t m_typeFormat;
    #endif
    #if defined(_CPLUSPLUS_)
    enum FormatterAssemblyStyle__Enum m_assemblyFormat;
    #else
    uint32_t m_assemblyFormat;
    #endif
    #if defined(_CPLUSPLUS_)
    enum TypeFilterLevel__Enum m_securityLevel;
    #else
    uint32_t m_securityLevel;
    #endif
    struct Object__Array *m_crossAppDomainArray;
};

struct BinaryFormatter {
    struct BinaryFormatter__Class *klass;
    MonitorData *monitor;
    struct BinaryFormatter__Fields fields;
};

struct ISurrogateSelector {
    struct ISurrogateSelector__Class *klass;
    MonitorData *monitor;
};

struct SerializationBinder {
    struct SerializationBinder__Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) Dictionary_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Fields {
    struct Int32__Array *buckets;
    struct Dictionary_2_TKey_TValue_Entry_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Array *entries;
    int32_t count;
    int32_t version;
    int32_t freeList;
    int32_t freeCount;
    struct IEqualityComparer_1_System_Type_ *comparer;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation_ *keys;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation_ *values;
    struct Object *_syncRoot;
};

struct Dictionary_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation_ {
    struct Dictionary_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Fields fields;
};

struct Dictionary_2_TKey_TValue_Entry_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation_ {
    int32_t hashCode;
    int32_t next;
    struct Type *key;
    struct TypeInformation *value;
};

struct Dictionary_2_TKey_TValue_Entry_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Boxed {
    struct Dictionary_2_TKey_TValue_Entry_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_Entry_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation_ fields;
};

struct __declspec(align(8)) TypeInformation__Fields {
    struct String *fullTypeName;
    struct String *assemblyString;
    bool hasTypeForwardedFrom;
};

struct TypeInformation {
    struct TypeInformation__Class *klass;
    MonitorData *monitor;
    struct TypeInformation__Fields fields;
};

struct Dictionary_2_TKey_TValue_Entry_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Array {
    struct Dictionary_2_TKey_TValue_Entry_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Dictionary_2_TKey_TValue_Entry_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation_ vector[32];
};

struct IEqualityComparer_1_System_Type_ {
    struct IEqualityComparer_1_System_Type___Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_KeyCollection_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Fields {
    struct Dictionary_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation_ *dictionary;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation_ {
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Fields fields;
};

struct IEnumerator_1_System_Type_ {
    struct IEnumerator_1_System_Type___Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_ValueCollection_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Fields {
    struct Dictionary_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation_ *dictionary;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation_ {
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Fields fields;
};

struct TypeInformation__Array {
    struct TypeInformation__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct TypeInformation *vector[32];
};

struct IEnumerator_1_System_Runtime_Serialization_Formatters_Binary_TypeInformation_ {
    struct IEnumerator_1_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Class *klass;
    MonitorData *monitor;
};

struct ICollection_1_System_Type_ {
    struct ICollection_1_System_Type___Class *klass;
    MonitorData *monitor;
};

struct ICollection_1_System_Runtime_Serialization_Formatters_Binary_TypeInformation_ {
    struct ICollection_1_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Class *klass;
    MonitorData *monitor;
};

struct KeyValuePair_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation_ {
    struct Type *key;
    struct TypeInformation *value;
};

struct KeyValuePair_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Boxed {
    struct KeyValuePair_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Class *klass;
    MonitorData *monitor;
    struct KeyValuePair_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation_ fields;
};

struct KeyValuePair_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Array {
    struct KeyValuePair_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct KeyValuePair_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation_ vector[32];
};

struct IEnumerator_1_KeyValuePair_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation_ {
    struct IEnumerator_1_KeyValuePair_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_Runtime_Serialization_Formatters_Binary_TypeInformation_ {
    struct IEnumerable_1_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Class *klass;
    MonitorData *monitor;
};

struct HeaderHandler__Fields {
    struct MulticastDelegate__Fields _;
};

struct HeaderHandler {
    struct HeaderHandler__Class *klass;
    MonitorData *monitor;
    struct HeaderHandler__Fields fields;
};

struct BinaryReader__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_BaseStream;
    VirtualInvokeData Close;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData PeekChar;
    VirtualInvokeData Read;
    VirtualInvokeData ReadBoolean;
    VirtualInvokeData ReadByte;
    VirtualInvokeData ReadSByte;
    VirtualInvokeData ReadChar;
    VirtualInvokeData ReadInt16;
    VirtualInvokeData ReadUInt16;
    VirtualInvokeData ReadInt32;
    VirtualInvokeData ReadUInt32;
    VirtualInvokeData ReadInt64;
    VirtualInvokeData ReadUInt64;
    VirtualInvokeData ReadSingle;
    VirtualInvokeData ReadDouble;
    VirtualInvokeData ReadDecimal;
    VirtualInvokeData ReadString;
    VirtualInvokeData Read_1;
    VirtualInvokeData ReadChars;
    VirtualInvokeData Read_2;
    VirtualInvokeData ReadBytes;
    VirtualInvokeData FillBuffer;
};

struct BinaryReader__StaticFields {
};

struct BinaryReader__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct BinaryReader__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct BinaryReader__VTable vtable;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceLocator___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceLocator___StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceLocator___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceLocator___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceLocator___VTable vtable;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceLocator___Array__VTable {
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceLocator___Array__StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceLocator___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceLocator___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceLocator___Array__VTable vtable;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceLocator___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TKey__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceLocator___StaticFields {
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceLocator___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceLocator___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceLocator___VTable vtable;
};

struct ResourceLocator__Array__VTable {
};

struct ResourceLocator__Array__StaticFields {
};

struct ResourceLocator__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ResourceLocator__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ResourceLocator__Array__VTable vtable;
};

struct IEnumerator_1_System_Resources_ResourceLocator___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_System_Resources_ResourceLocator___StaticFields {
};

struct IEnumerator_1_System_Resources_ResourceLocator___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_System_Resources_ResourceLocator___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_System_Resources_ResourceLocator___VTable vtable;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceLocator___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TValue__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceLocator___StaticFields {
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceLocator___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceLocator___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceLocator___VTable vtable;
};

struct ICollection_1_System_Resources_ResourceLocator___VTable {
    VirtualInvokeData get_Count;
    VirtualInvokeData get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
};

struct ICollection_1_System_Resources_ResourceLocator___StaticFields {
};

struct ICollection_1_System_Resources_ResourceLocator___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ICollection_1_System_Resources_ResourceLocator___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ICollection_1_System_Resources_ResourceLocator___VTable vtable;
};

struct ResourceLocator___VTable {
};

struct ResourceLocator___StaticFields {
};

struct ResourceLocator___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ResourceLocator___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ResourceLocator___VTable vtable;
};

struct KeyValuePair_2_System_String_System_Resources_ResourceLocator___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct KeyValuePair_2_System_String_System_Resources_ResourceLocator___StaticFields {
};

struct KeyValuePair_2_System_String_System_Resources_ResourceLocator___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_String_System_Resources_ResourceLocator___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_String_System_Resources_ResourceLocator___VTable vtable;
};

struct KeyValuePair_2_System_String_System_Resources_ResourceLocator___Array__VTable {
};

struct KeyValuePair_2_System_String_System_Resources_ResourceLocator___Array__StaticFields {
};

struct KeyValuePair_2_System_String_System_Resources_ResourceLocator___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_String_System_Resources_ResourceLocator___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_String_System_Resources_ResourceLocator___Array__VTable vtable;
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_Resources_ResourceLocator___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_Resources_ResourceLocator___StaticFields {
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_Resources_ResourceLocator___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_KeyValuePair_2_System_String_System_Resources_ResourceLocator___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_KeyValuePair_2_System_String_System_Resources_ResourceLocator___VTable vtable;
};

struct IEnumerable_1_System_Resources_ResourceLocator___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_Resources_ResourceLocator___StaticFields {
};

struct IEnumerable_1_System_Resources_ResourceLocator___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_Resources_ResourceLocator___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_Resources_ResourceLocator___VTable vtable;
};

struct Dictionary_2_System_String_System_Resources_ResourceLocator___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Values;
    VirtualInvokeData ContainsKey;
    VirtualInvokeData Add;
    VirtualInvokeData Remove;
    VirtualInvokeData TryGetValue;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Add;
    VirtualInvokeData Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Contains;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_System_Collections_Generic_KeyValuePair_TKey_TValue___GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_get_Item;
    VirtualInvokeData System_Collections_IDictionary_set_Item;
    VirtualInvokeData System_Collections_IDictionary_get_Keys;
    VirtualInvokeData System_Collections_IDictionary_get_Values;
    VirtualInvokeData System_Collections_IDictionary_Contains;
    VirtualInvokeData System_Collections_IDictionary_Add;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IDictionary_get_IsReadOnly;
    VirtualInvokeData System_Collections_IDictionary_get_IsFixedSize;
    VirtualInvokeData System_Collections_IDictionary_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_Remove;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData ContainsKey_1;
    VirtualInvokeData TryGetValue_1;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Values;
    VirtualInvokeData get_Count_2;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData OnDeserialization;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData OnDeserialization_1;
};

struct Dictionary_2_System_String_System_Resources_ResourceLocator___StaticFields {
};

struct Dictionary_2_System_String_System_Resources_ResourceLocator___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_System_String_System_Resources_ResourceLocator___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_System_String_System_Resources_ResourceLocator___VTable vtable;
};

struct ISurrogateSelector__VTable {
    VirtualInvokeData ChainSelector;
    VirtualInvokeData GetSurrogate;
    VirtualInvokeData GetNextSelector;
};

struct ISurrogateSelector__StaticFields {
};

struct ISurrogateSelector__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ISurrogateSelector__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ISurrogateSelector__VTable vtable;
};

struct SerializationBinder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData BindToName;
    VirtualInvokeData __unknown;
};

struct SerializationBinder__StaticFields {
};

struct SerializationBinder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SerializationBinder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SerializationBinder__VTable vtable;
};

struct FormatterTypeStyle__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct FormatterTypeStyle__Enum__StaticFields {
};

struct FormatterTypeStyle__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FormatterTypeStyle__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FormatterTypeStyle__Enum__VTable vtable;
};

struct FormatterAssemblyStyle__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct FormatterAssemblyStyle__Enum__StaticFields {
};

struct FormatterAssemblyStyle__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FormatterAssemblyStyle__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FormatterAssemblyStyle__Enum__VTable vtable;
};

struct TypeFilterLevel__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct TypeFilterLevel__Enum__StaticFields {
};

struct TypeFilterLevel__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeFilterLevel__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeFilterLevel__Enum__VTable vtable;
};

struct TypeInformation__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct TypeInformation__StaticFields {
};

struct TypeInformation__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeInformation__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeInformation__VTable vtable;
};

struct Dictionary_2_TKey_TValue_Entry_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Dictionary_2_TKey_TValue_Entry_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___VTable vtable;
};

struct Dictionary_2_TKey_TValue_Entry_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Array__VTable {
};

struct Dictionary_2_TKey_TValue_Entry_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Array__StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Array__VTable vtable;
};

struct IEqualityComparer_1_System_Type___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData GetHashCode;
};

struct IEqualityComparer_1_System_Type___StaticFields {
};

struct IEqualityComparer_1_System_Type___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEqualityComparer_1_System_Type___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEqualityComparer_1_System_Type___VTable vtable;
};

struct IEnumerator_1_System_Type___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_System_Type___StaticFields {
};

struct IEnumerator_1_System_Type___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_System_Type___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_System_Type___VTable vtable;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TKey__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___StaticFields {
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___VTable vtable;
};

struct TypeInformation__Array__VTable {
};

struct TypeInformation__Array__StaticFields {
};

struct TypeInformation__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeInformation__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeInformation__Array__VTable vtable;
};

struct IEnumerator_1_System_Runtime_Serialization_Formatters_Binary_TypeInformation___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_System_Runtime_Serialization_Formatters_Binary_TypeInformation___StaticFields {
};

struct IEnumerator_1_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_System_Runtime_Serialization_Formatters_Binary_TypeInformation___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_System_Runtime_Serialization_Formatters_Binary_TypeInformation___VTable vtable;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TValue__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___StaticFields {
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___VTable vtable;
};

struct ICollection_1_System_Type___VTable {
    VirtualInvokeData get_Count;
    VirtualInvokeData get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
};

struct ICollection_1_System_Type___StaticFields {
};

struct ICollection_1_System_Type___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ICollection_1_System_Type___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ICollection_1_System_Type___VTable vtable;
};

struct ICollection_1_System_Runtime_Serialization_Formatters_Binary_TypeInformation___VTable {
    VirtualInvokeData get_Count;
    VirtualInvokeData get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
};

struct ICollection_1_System_Runtime_Serialization_Formatters_Binary_TypeInformation___StaticFields {
};

struct ICollection_1_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ICollection_1_System_Runtime_Serialization_Formatters_Binary_TypeInformation___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ICollection_1_System_Runtime_Serialization_Formatters_Binary_TypeInformation___VTable vtable;
};

struct TypeInformation___VTable {
};

struct TypeInformation___StaticFields {
};

struct TypeInformation___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeInformation___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeInformation___VTable vtable;
};

struct KeyValuePair_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct KeyValuePair_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___StaticFields {
};

struct KeyValuePair_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___VTable vtable;
};

struct KeyValuePair_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Array__VTable {
};

struct KeyValuePair_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Array__StaticFields {
};

struct KeyValuePair_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Array__VTable vtable;
};

struct IEnumerator_1_KeyValuePair_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_KeyValuePair_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___StaticFields {
};

struct IEnumerator_1_KeyValuePair_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_KeyValuePair_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_KeyValuePair_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___VTable vtable;
};

struct IEnumerable_1_System_Runtime_Serialization_Formatters_Binary_TypeInformation___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_Runtime_Serialization_Formatters_Binary_TypeInformation___StaticFields {
};

struct IEnumerable_1_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_Runtime_Serialization_Formatters_Binary_TypeInformation___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_Runtime_Serialization_Formatters_Binary_TypeInformation___VTable vtable;
};

struct Dictionary_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Values;
    VirtualInvokeData ContainsKey;
    VirtualInvokeData Add;
    VirtualInvokeData Remove;
    VirtualInvokeData TryGetValue;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Add;
    VirtualInvokeData Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Contains;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_System_Collections_Generic_KeyValuePair_TKey_TValue___GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_get_Item;
    VirtualInvokeData System_Collections_IDictionary_set_Item;
    VirtualInvokeData System_Collections_IDictionary_get_Keys;
    VirtualInvokeData System_Collections_IDictionary_get_Values;
    VirtualInvokeData System_Collections_IDictionary_Contains;
    VirtualInvokeData System_Collections_IDictionary_Add;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IDictionary_get_IsReadOnly;
    VirtualInvokeData System_Collections_IDictionary_get_IsFixedSize;
    VirtualInvokeData System_Collections_IDictionary_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_Remove;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData ContainsKey_1;
    VirtualInvokeData TryGetValue_1;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Values;
    VirtualInvokeData get_Count_2;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData OnDeserialization;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData OnDeserialization_1;
};

struct Dictionary_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___StaticFields {
};

struct Dictionary_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation___VTable vtable;
};

struct HeaderHandler__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct HeaderHandler__StaticFields {
};

struct HeaderHandler__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct HeaderHandler__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct HeaderHandler__VTable vtable;
};

struct BinaryFormatter__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Deserialize;
    VirtualInvokeData Serialize;
    VirtualInvokeData Deserialize_1;
    VirtualInvokeData Serialize_1;
    VirtualInvokeData get_SurrogateSelector;
    VirtualInvokeData set_SurrogateSelector;
    VirtualInvokeData get_Binder;
    VirtualInvokeData set_Binder;
    VirtualInvokeData get_Context;
    VirtualInvokeData set_Context;
};

struct BinaryFormatter__StaticFields {
    struct Dictionary_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation_ *typeNameCache;
};

struct BinaryFormatter__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct BinaryFormatter__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct BinaryFormatter__VTable vtable;
};

struct ResourceReader__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Close;
    VirtualInvokeData GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData Dispose;
};

struct ResourceReader__StaticFields {
};

struct ResourceReader__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ResourceReader__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ResourceReader__VTable vtable;
};

struct __declspec(align(8)) ResourceReader_ResourceEnumerator__Fields {
    struct ResourceReader *_reader;
    bool _currentIsValid;
    int32_t _currentName;
    int32_t _dataPosition;
};

struct ResourceReader_ResourceEnumerator {
    struct ResourceReader_ResourceEnumerator__Class *klass;
    MonitorData *monitor;
    struct ResourceReader_ResourceEnumerator__Fields fields;
};

struct DictionaryEntry {
    struct Object *_key;
    struct Object *_value;
};

struct DictionaryEntry__Boxed {
    struct DictionaryEntry__Class *klass;
    MonitorData *monitor;
    struct DictionaryEntry fields;
};

struct DictionaryEntry__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct DictionaryEntry__StaticFields {
};

struct DictionaryEntry__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DictionaryEntry__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DictionaryEntry__VTable vtable;
};

struct ResourceReader_ResourceEnumerator__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Key;
    VirtualInvokeData get_Value;
    VirtualInvokeData get_Entry;
    VirtualInvokeData MoveNext;
    VirtualInvokeData get_Current;
    VirtualInvokeData Reset;
};

struct ResourceReader_ResourceEnumerator__StaticFields {
};

struct ResourceReader_ResourceEnumerator__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ResourceReader_ResourceEnumerator__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ResourceReader_ResourceEnumerator__VTable vtable;
};

struct ResourceTypeCode___VTable {
};

struct ResourceTypeCode___StaticFields {
};

struct ResourceTypeCode___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ResourceTypeCode___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ResourceTypeCode___VTable vtable;
};

struct __declspec(align(8)) ResourceWriter__Fields {
    struct Func_2_Type_String_ *typeConverter;
    struct Dictionary_2_System_String_System_Object_ *_resourceList;
    struct Stream *_output;
    struct Dictionary_2_System_String_System_Object_ *_caseInsensitiveDups;
    struct Dictionary_2_System_String_System_Resources_ResourceWriter_PrecannedResource_ *_preserializedData;
};

struct ResourceWriter {
    struct ResourceWriter__Class *klass;
    MonitorData *monitor;
    struct ResourceWriter__Fields fields;
};

struct Func_2_Type_String___Fields {
    struct MulticastDelegate__Fields _;
};

struct Func_2_Type_String_ {
    struct Func_2_Type_String___Class *klass;
    MonitorData *monitor;
    struct Func_2_Type_String___Fields fields;
};

struct __declspec(align(8)) Dictionary_2_System_String_System_Resources_ResourceWriter_PrecannedResource___Fields {
    struct Int32__Array *buckets;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceWriter_PrecannedResource___Array *entries;
    int32_t count;
    int32_t version;
    int32_t freeList;
    int32_t freeCount;
    struct IEqualityComparer_1_System_String_ *comparer;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceWriter_PrecannedResource_ *keys;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceWriter_PrecannedResource_ *values;
    struct Object *_syncRoot;
};

struct Dictionary_2_System_String_System_Resources_ResourceWriter_PrecannedResource_ {
    struct Dictionary_2_System_String_System_Resources_ResourceWriter_PrecannedResource___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_System_String_System_Resources_ResourceWriter_PrecannedResource___Fields fields;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceWriter_PrecannedResource_ {
    int32_t hashCode;
    int32_t next;
    struct String *key;
    struct ResourceWriter_PrecannedResource *value;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceWriter_PrecannedResource___Boxed {
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceWriter_PrecannedResource___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceWriter_PrecannedResource_ fields;
};

struct __declspec(align(8)) ResourceWriter_PrecannedResource__Fields {
    struct String *TypeName;
    struct Byte__Array *Data;
};

struct ResourceWriter_PrecannedResource {
    struct ResourceWriter_PrecannedResource__Class *klass;
    MonitorData *monitor;
    struct ResourceWriter_PrecannedResource__Fields fields;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceWriter_PrecannedResource___Array {
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceWriter_PrecannedResource___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceWriter_PrecannedResource_ vector[32];
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceWriter_PrecannedResource___Fields {
    struct Dictionary_2_System_String_System_Resources_ResourceWriter_PrecannedResource_ *dictionary;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceWriter_PrecannedResource_ {
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceWriter_PrecannedResource___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceWriter_PrecannedResource___Fields fields;
};

struct __declspec(align(8)) Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceWriter_PrecannedResource___Fields {
    struct Dictionary_2_System_String_System_Resources_ResourceWriter_PrecannedResource_ *dictionary;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceWriter_PrecannedResource_ {
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceWriter_PrecannedResource___Class *klass;
    MonitorData *monitor;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceWriter_PrecannedResource___Fields fields;
};

struct ResourceWriter_PrecannedResource__Array {
    struct ResourceWriter_PrecannedResource__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct ResourceWriter_PrecannedResource *vector[32];
};

struct IEnumerator_1_System_Resources_ResourceWriter_PrecannedResource_ {
    struct IEnumerator_1_System_Resources_ResourceWriter_PrecannedResource___Class *klass;
    MonitorData *monitor;
};

struct ICollection_1_System_Resources_ResourceWriter_PrecannedResource_ {
    struct ICollection_1_System_Resources_ResourceWriter_PrecannedResource___Class *klass;
    MonitorData *monitor;
};

struct KeyValuePair_2_System_String_System_Resources_ResourceWriter_PrecannedResource_ {
    struct String *key;
    struct ResourceWriter_PrecannedResource *value;
};

struct KeyValuePair_2_System_String_System_Resources_ResourceWriter_PrecannedResource___Boxed {
    struct KeyValuePair_2_System_String_System_Resources_ResourceWriter_PrecannedResource___Class *klass;
    MonitorData *monitor;
    struct KeyValuePair_2_System_String_System_Resources_ResourceWriter_PrecannedResource_ fields;
};

struct KeyValuePair_2_System_String_System_Resources_ResourceWriter_PrecannedResource___Array {
    struct KeyValuePair_2_System_String_System_Resources_ResourceWriter_PrecannedResource___Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct KeyValuePair_2_System_String_System_Resources_ResourceWriter_PrecannedResource_ vector[32];
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_Resources_ResourceWriter_PrecannedResource_ {
    struct IEnumerator_1_KeyValuePair_2_System_String_System_Resources_ResourceWriter_PrecannedResource___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_Resources_ResourceWriter_PrecannedResource_ {
    struct IEnumerable_1_System_Resources_ResourceWriter_PrecannedResource___Class *klass;
    MonitorData *monitor;
};

struct Func_2_Type_String___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Func_2_Type_String___StaticFields {
};

struct Func_2_Type_String___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Func_2_Type_String___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Func_2_Type_String___VTable vtable;
};

struct ResourceWriter_PrecannedResource__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ResourceWriter_PrecannedResource__StaticFields {
};

struct ResourceWriter_PrecannedResource__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ResourceWriter_PrecannedResource__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ResourceWriter_PrecannedResource__VTable vtable;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceWriter_PrecannedResource___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceWriter_PrecannedResource___StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceWriter_PrecannedResource___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceWriter_PrecannedResource___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceWriter_PrecannedResource___VTable vtable;
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceWriter_PrecannedResource___Array__VTable {
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceWriter_PrecannedResource___Array__StaticFields {
};

struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceWriter_PrecannedResource___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceWriter_PrecannedResource___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_Entry_System_String_System_Resources_ResourceWriter_PrecannedResource___Array__VTable vtable;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceWriter_PrecannedResource___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TKey__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TKey__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceWriter_PrecannedResource___StaticFields {
};

struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceWriter_PrecannedResource___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceWriter_PrecannedResource___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_KeyCollection_System_String_System_Resources_ResourceWriter_PrecannedResource___VTable vtable;
};

struct ResourceWriter_PrecannedResource__Array__VTable {
};

struct ResourceWriter_PrecannedResource__Array__StaticFields {
};

struct ResourceWriter_PrecannedResource__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ResourceWriter_PrecannedResource__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ResourceWriter_PrecannedResource__Array__VTable vtable;
};

struct IEnumerator_1_System_Resources_ResourceWriter_PrecannedResource___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_System_Resources_ResourceWriter_PrecannedResource___StaticFields {
};

struct IEnumerator_1_System_Resources_ResourceWriter_PrecannedResource___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_System_Resources_ResourceWriter_PrecannedResource___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_System_Resources_ResourceWriter_PrecannedResource___VTable vtable;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceWriter_PrecannedResource___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_TValue__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_TValue__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData get_Count_2;
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceWriter_PrecannedResource___StaticFields {
};

struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceWriter_PrecannedResource___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceWriter_PrecannedResource___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_TKey_TValue_ValueCollection_System_String_System_Resources_ResourceWriter_PrecannedResource___VTable vtable;
};

struct ICollection_1_System_Resources_ResourceWriter_PrecannedResource___VTable {
    VirtualInvokeData get_Count;
    VirtualInvokeData get_IsReadOnly;
    VirtualInvokeData Add;
    VirtualInvokeData Clear;
    VirtualInvokeData Contains;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Remove;
};

struct ICollection_1_System_Resources_ResourceWriter_PrecannedResource___StaticFields {
};

struct ICollection_1_System_Resources_ResourceWriter_PrecannedResource___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ICollection_1_System_Resources_ResourceWriter_PrecannedResource___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ICollection_1_System_Resources_ResourceWriter_PrecannedResource___VTable vtable;
};

struct ResourceWriter_PrecannedResource___VTable {
};

struct ResourceWriter_PrecannedResource___StaticFields {
};

struct ResourceWriter_PrecannedResource___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ResourceWriter_PrecannedResource___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ResourceWriter_PrecannedResource___VTable vtable;
};

struct KeyValuePair_2_System_String_System_Resources_ResourceWriter_PrecannedResource___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct KeyValuePair_2_System_String_System_Resources_ResourceWriter_PrecannedResource___StaticFields {
};

struct KeyValuePair_2_System_String_System_Resources_ResourceWriter_PrecannedResource___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_String_System_Resources_ResourceWriter_PrecannedResource___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_String_System_Resources_ResourceWriter_PrecannedResource___VTable vtable;
};

struct KeyValuePair_2_System_String_System_Resources_ResourceWriter_PrecannedResource___Array__VTable {
};

struct KeyValuePair_2_System_String_System_Resources_ResourceWriter_PrecannedResource___Array__StaticFields {
};

struct KeyValuePair_2_System_String_System_Resources_ResourceWriter_PrecannedResource___Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct KeyValuePair_2_System_String_System_Resources_ResourceWriter_PrecannedResource___Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct KeyValuePair_2_System_String_System_Resources_ResourceWriter_PrecannedResource___Array__VTable vtable;
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_Resources_ResourceWriter_PrecannedResource___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_Resources_ResourceWriter_PrecannedResource___StaticFields {
};

struct IEnumerator_1_KeyValuePair_2_System_String_System_Resources_ResourceWriter_PrecannedResource___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_KeyValuePair_2_System_String_System_Resources_ResourceWriter_PrecannedResource___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_KeyValuePair_2_System_String_System_Resources_ResourceWriter_PrecannedResource___VTable vtable;
};

struct IEnumerable_1_System_Resources_ResourceWriter_PrecannedResource___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_Resources_ResourceWriter_PrecannedResource___StaticFields {
};

struct IEnumerable_1_System_Resources_ResourceWriter_PrecannedResource___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_Resources_ResourceWriter_PrecannedResource___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_Resources_ResourceWriter_PrecannedResource___VTable vtable;
};

struct Dictionary_2_System_String_System_Resources_ResourceWriter_PrecannedResource___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_Item;
    VirtualInvokeData set_Item;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IDictionary_TKey_TValue__get_Values;
    VirtualInvokeData ContainsKey;
    VirtualInvokeData Add;
    VirtualInvokeData Remove;
    VirtualInvokeData TryGetValue;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Add;
    VirtualInvokeData Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Contains;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_System_Collections_Generic_KeyValuePair_TKey_TValue___Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_System_Collections_Generic_KeyValuePair_TKey_TValue___GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_get_Item;
    VirtualInvokeData System_Collections_IDictionary_set_Item;
    VirtualInvokeData System_Collections_IDictionary_get_Keys;
    VirtualInvokeData System_Collections_IDictionary_get_Values;
    VirtualInvokeData System_Collections_IDictionary_Contains;
    VirtualInvokeData System_Collections_IDictionary_Add;
    VirtualInvokeData Clear_1;
    VirtualInvokeData System_Collections_IDictionary_get_IsReadOnly;
    VirtualInvokeData System_Collections_IDictionary_get_IsFixedSize;
    VirtualInvokeData System_Collections_IDictionary_GetEnumerator;
    VirtualInvokeData System_Collections_IDictionary_Remove;
    VirtualInvokeData System_Collections_ICollection_CopyTo;
    VirtualInvokeData get_Count_1;
    VirtualInvokeData System_Collections_ICollection_get_SyncRoot;
    VirtualInvokeData System_Collections_ICollection_get_IsSynchronized;
    VirtualInvokeData ContainsKey_1;
    VirtualInvokeData TryGetValue_1;
    VirtualInvokeData get_Item_1;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Keys;
    VirtualInvokeData System_Collections_Generic_IReadOnlyDictionary_TKey_TValue__get_Values;
    VirtualInvokeData get_Count_2;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData OnDeserialization;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData OnDeserialization_1;
};

struct Dictionary_2_System_String_System_Resources_ResourceWriter_PrecannedResource___StaticFields {
};

struct Dictionary_2_System_String_System_Resources_ResourceWriter_PrecannedResource___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Dictionary_2_System_String_System_Resources_ResourceWriter_PrecannedResource___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Dictionary_2_System_String_System_Resources_ResourceWriter_PrecannedResource___VTable vtable;
};

struct ResourceWriter__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData AddResource;
    VirtualInvokeData AddResource_1;
    VirtualInvokeData AddResource_2;
    VirtualInvokeData Close;
    VirtualInvokeData Generate;
    VirtualInvokeData Dispose;
};

struct ResourceWriter__StaticFields {
};

struct ResourceWriter__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ResourceWriter__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ResourceWriter__VTable vtable;
};

struct __declspec(align(8)) BinaryWriter__Fields {
    struct Stream *OutStream;
    struct Byte__Array *_buffer;
    struct Encoding *_encoding;
    struct Encoder *_encoder;
    bool _leaveOpen;
    struct Char__Array *_tmpOneCharBuffer;
    struct Byte__Array *_largeByteBuffer;
    int32_t _maxChars;
};

struct BinaryWriter {
    struct BinaryWriter__Class *klass;
    MonitorData *monitor;
    struct BinaryWriter__Fields fields;
};

struct IFormatter {
    struct IFormatter__Class *klass;
    MonitorData *monitor;
};

struct BinaryWriter__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData Close;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData get_BaseStream;
    VirtualInvokeData Flush;
    VirtualInvokeData Seek;
    VirtualInvokeData Write;
    VirtualInvokeData Write_1;
    VirtualInvokeData Write_2;
    VirtualInvokeData Write_3;
    VirtualInvokeData Write_4;
    VirtualInvokeData Write_5;
    VirtualInvokeData Write_6;
    VirtualInvokeData Write_7;
    VirtualInvokeData Write_8;
    VirtualInvokeData Write_9;
    VirtualInvokeData Write_10;
    VirtualInvokeData Write_11;
    VirtualInvokeData Write_12;
    VirtualInvokeData Write_13;
    VirtualInvokeData Write_14;
    VirtualInvokeData Write_15;
    VirtualInvokeData Write_16;
    VirtualInvokeData Write_17;
};

struct BinaryWriter__StaticFields {
    struct BinaryWriter *Null;
};

struct BinaryWriter__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct BinaryWriter__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct BinaryWriter__VTable vtable;
};

struct IFormatter__VTable {
    VirtualInvokeData Deserialize;
    VirtualInvokeData Serialize;
    VirtualInvokeData get_SurrogateSelector;
    VirtualInvokeData set_SurrogateSelector;
    VirtualInvokeData get_Binder;
    VirtualInvokeData set_Binder;
    VirtualInvokeData get_Context;
    VirtualInvokeData set_Context;
};

struct IFormatter__StaticFields {
};

struct IFormatter__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IFormatter__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IFormatter__VTable vtable;
};

struct __declspec(align(8)) ResourceWriter_StreamWrapper__Fields {
    struct Stream *m_stream;
    bool m_closeAfterWrite;
};

struct ResourceWriter_StreamWrapper {
    struct ResourceWriter_StreamWrapper__Class *klass;
    MonitorData *monitor;
    struct ResourceWriter_StreamWrapper__Fields fields;
};

struct ResourceWriter_StreamWrapper__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ResourceWriter_StreamWrapper__StaticFields {
};

struct ResourceWriter_StreamWrapper__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ResourceWriter_StreamWrapper__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ResourceWriter_StreamWrapper__VTable vtable;
};

struct RuntimeResourceSet__Fields {
    struct ResourceSet__Fields _;
    struct Dictionary_2_System_String_System_Resources_ResourceLocator_ *_resCache;
    struct ResourceReader *_defaultReader;
    struct Dictionary_2_System_String_System_Resources_ResourceLocator_ *_caseInsensitiveTable;
    bool _haveReadFromReader;
};

struct RuntimeResourceSet {
    struct RuntimeResourceSet__Class *klass;
    MonitorData *monitor;
    struct RuntimeResourceSet__Fields fields;
};

struct RuntimeResourceSet__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Dispose;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData Close;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData GetDefaultReader;
    VirtualInvokeData GetDefaultWriter;
    VirtualInvokeData GetEnumerator;
    VirtualInvokeData GetString;
    VirtualInvokeData GetString_1;
    VirtualInvokeData GetObject;
    VirtualInvokeData GetObject_1;
    VirtualInvokeData ReadResources;
};

struct RuntimeResourceSet__StaticFields {
};

struct RuntimeResourceSet__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeResourceSet__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeResourceSet__VTable vtable;
};

struct __declspec(align(8)) SatelliteContractVersionAttribute__Fields {
    struct String *_version;
};

struct SatelliteContractVersionAttribute {
    struct SatelliteContractVersionAttribute__Class *klass;
    MonitorData *monitor;
    struct SatelliteContractVersionAttribute__Fields fields;
};

struct SatelliteContractVersionAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct SatelliteContractVersionAttribute__StaticFields {
};

struct SatelliteContractVersionAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SatelliteContractVersionAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SatelliteContractVersionAttribute__VTable vtable;
};

struct __declspec(align(8)) NameOrId__Fields {
    struct String *name;
    int32_t id;
};

struct NameOrId {
    struct NameOrId__Class *klass;
    MonitorData *monitor;
    struct NameOrId__Fields fields;
};

struct NameOrId__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct NameOrId__StaticFields {
};

struct NameOrId__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct NameOrId__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct NameOrId__VTable vtable;
};

struct __declspec(align(8)) Win32Resource__Fields {
    struct NameOrId *type;
    struct NameOrId *name;
    int32_t language;
};

struct Win32Resource {
    struct Win32Resource__Class *klass;
    MonitorData *monitor;
    struct Win32Resource__Fields fields;
};

struct Win32EncodedResource__Fields {
    struct Win32Resource__Fields _;
    struct Byte__Array *data;
};

struct Win32EncodedResource {
    struct Win32EncodedResource__Class *klass;
    MonitorData *monitor;
    struct Win32EncodedResource__Fields fields;
};

struct Win32EncodedResource__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData WriteTo;
};

struct Win32EncodedResource__StaticFields {
};

struct Win32EncodedResource__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Win32EncodedResource__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Win32EncodedResource__VTable vtable;
};

struct Win32Resource__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData __unknown;
};

struct Win32Resource__StaticFields {
};

struct Win32Resource__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Win32Resource__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Win32Resource__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum Win32ResourceType__Enum : int32_t {
    Win32ResourceType__Enum_RT_CURSOR = 0x00000001,
    Win32ResourceType__Enum_RT_FONT = 0x00000008,
    Win32ResourceType__Enum_RT_BITMAP = 0x00000002,
    Win32ResourceType__Enum_RT_ICON = 0x00000003,
    Win32ResourceType__Enum_RT_MENU = 0x00000004,
    Win32ResourceType__Enum_RT_DIALOG = 0x00000005,
    Win32ResourceType__Enum_RT_STRING = 0x00000006,
    Win32ResourceType__Enum_RT_FONTDIR = 0x00000007,
    Win32ResourceType__Enum_RT_ACCELERATOR = 0x00000009,
    Win32ResourceType__Enum_RT_RCDATA = 0x0000000a,
    Win32ResourceType__Enum_RT_MESSAGETABLE = 0x0000000b,
    Win32ResourceType__Enum_RT_GROUP_CURSOR = 0x0000000c,
    Win32ResourceType__Enum_RT_GROUP_ICON = 0x0000000e,
    Win32ResourceType__Enum_RT_VERSION = 0x00000010,
    Win32ResourceType__Enum_RT_DLGINCLUDE = 0x00000011,
    Win32ResourceType__Enum_RT_PLUGPLAY = 0x00000013,
    Win32ResourceType__Enum_RT_VXD = 0x00000014,
    Win32ResourceType__Enum_RT_ANICURSOR = 0x00000015,
    Win32ResourceType__Enum_RT_ANIICON = 0x00000016,
    Win32ResourceType__Enum_RT_HTML = 0x00000017,
};

#else
enum Win32ResourceType__Enum {
    Win32ResourceType__Enum_RT_CURSOR = 0x00000001,
    Win32ResourceType__Enum_RT_FONT = 0x00000008,
    Win32ResourceType__Enum_RT_BITMAP = 0x00000002,
    Win32ResourceType__Enum_RT_ICON = 0x00000003,
    Win32ResourceType__Enum_RT_MENU = 0x00000004,
    Win32ResourceType__Enum_RT_DIALOG = 0x00000005,
    Win32ResourceType__Enum_RT_STRING = 0x00000006,
    Win32ResourceType__Enum_RT_FONTDIR = 0x00000007,
    Win32ResourceType__Enum_RT_ACCELERATOR = 0x00000009,
    Win32ResourceType__Enum_RT_RCDATA = 0x0000000a,
    Win32ResourceType__Enum_RT_MESSAGETABLE = 0x0000000b,
    Win32ResourceType__Enum_RT_GROUP_CURSOR = 0x0000000c,
    Win32ResourceType__Enum_RT_GROUP_ICON = 0x0000000e,
    Win32ResourceType__Enum_RT_VERSION = 0x00000010,
    Win32ResourceType__Enum_RT_DLGINCLUDE = 0x00000011,
    Win32ResourceType__Enum_RT_PLUGPLAY = 0x00000013,
    Win32ResourceType__Enum_RT_VXD = 0x00000014,
    Win32ResourceType__Enum_RT_ANICURSOR = 0x00000015,
    Win32ResourceType__Enum_RT_ANIICON = 0x00000016,
    Win32ResourceType__Enum_RT_HTML = 0x00000017,
};

#endif
struct Win32ResourceType__Enum__Boxed {
    struct Win32ResourceType__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum Win32ResourceType__Enum value;
    #else
    uint32_t value;
    #endif
};

struct Win32ResourceType__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct Win32ResourceType__Enum__StaticFields {
};

struct Win32ResourceType__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Win32ResourceType__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Win32ResourceType__Enum__VTable vtable;
};

struct Win32IconResource__Fields {
    struct Win32Resource__Fields _;
    struct ICONDIRENTRY *icon;
};

struct Win32IconResource {
    struct Win32IconResource__Class *klass;
    MonitorData *monitor;
    struct Win32IconResource__Fields fields;
};

struct __declspec(align(8)) ICONDIRENTRY__Fields {
    uint8_t bWidth;
    uint8_t bHeight;
    uint8_t bColorCount;
    uint8_t bReserved;
    int16_t wPlanes;
    int16_t wBitCount;
    int32_t dwBytesInRes;
    int32_t dwImageOffset;
    struct Byte__Array *image;
};

struct ICONDIRENTRY {
    struct ICONDIRENTRY__Class *klass;
    MonitorData *monitor;
    struct ICONDIRENTRY__Fields fields;
};

struct ICONDIRENTRY__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ICONDIRENTRY__StaticFields {
};

struct ICONDIRENTRY__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ICONDIRENTRY__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ICONDIRENTRY__VTable vtable;
};

struct Win32IconResource__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData WriteTo;
};

struct Win32IconResource__StaticFields {
};

struct Win32IconResource__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Win32IconResource__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Win32IconResource__VTable vtable;
};

struct Win32GroupIconResource__Fields {
    struct Win32Resource__Fields _;
    struct Win32IconResource__Array *icons;
};

struct Win32GroupIconResource {
    struct Win32GroupIconResource__Class *klass;
    MonitorData *monitor;
    struct Win32GroupIconResource__Fields fields;
};

struct Win32IconResource__Array {
    struct Win32IconResource__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Win32IconResource *vector[32];
};

struct Win32IconResource__Array__VTable {
};

struct Win32IconResource__Array__StaticFields {
};

struct Win32IconResource__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Win32IconResource__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Win32IconResource__Array__VTable vtable;
};

struct Win32GroupIconResource__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData WriteTo;
};

struct Win32GroupIconResource__StaticFields {
};

struct Win32GroupIconResource__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Win32GroupIconResource__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Win32GroupIconResource__VTable vtable;
};

struct Win32VersionResource__Fields {
    struct Win32Resource__Fields _;
    struct String__Array *WellKnownProperties;
    int64_t signature;
    int32_t struct_version;
    int64_t file_version;
    int64_t product_version;
    int32_t file_flags_mask;
    int32_t file_flags;
    int32_t file_os;
    int32_t file_type;
    int32_t file_subtype;
    int64_t file_date;
    int32_t file_lang;
    int32_t file_codepage;
    struct Hashtable *properties;
};

struct Win32VersionResource {
    struct Win32VersionResource__Class *klass;
    MonitorData *monitor;
    struct Win32VersionResource__Fields fields;
};

struct Win32VersionResource__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData WriteTo;
    VirtualInvokeData set_Item;
    VirtualInvokeData get_Comments;
    VirtualInvokeData set_Comments;
    VirtualInvokeData get_CompanyName;
    VirtualInvokeData set_CompanyName;
    VirtualInvokeData get_LegalCopyright;
    VirtualInvokeData set_LegalCopyright;
    VirtualInvokeData get_LegalTrademarks;
    VirtualInvokeData set_LegalTrademarks;
    VirtualInvokeData get_OriginalFilename;
    VirtualInvokeData set_OriginalFilename;
    VirtualInvokeData get_ProductName;
    VirtualInvokeData set_ProductName;
    VirtualInvokeData get_ProductVersion;
    VirtualInvokeData set_ProductVersion;
    VirtualInvokeData get_InternalName;
    VirtualInvokeData set_InternalName;
    VirtualInvokeData get_FileDescription;
    VirtualInvokeData set_FileDescription;
    VirtualInvokeData get_FileLanguage;
    VirtualInvokeData set_FileLanguage;
    VirtualInvokeData get_FileVersion;
    VirtualInvokeData set_FileVersion;
};

struct Win32VersionResource__StaticFields {
};

struct Win32VersionResource__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Win32VersionResource__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Win32VersionResource__VTable vtable;
};

struct __declspec(align(8)) Win32ResFileReader__Fields {
    struct Stream *res_file;
};

struct Win32ResFileReader {
    struct Win32ResFileReader__Class *klass;
    MonitorData *monitor;
    struct Win32ResFileReader__Fields fields;
};

struct Win32ResFileReader__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Win32ResFileReader__StaticFields {
};

struct Win32ResFileReader__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Win32ResFileReader__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Win32ResFileReader__VTable vtable;
};

struct __declspec(align(8)) Win32IconFileReader__Fields {
    struct Stream *iconFile;
};

struct Win32IconFileReader {
    struct Win32IconFileReader__Class *klass;
    MonitorData *monitor;
    struct Win32IconFileReader__Fields fields;
};

struct Win32IconFileReader__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Win32IconFileReader__StaticFields {
};

struct Win32IconFileReader__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Win32IconFileReader__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Win32IconFileReader__VTable vtable;
};

struct ICONDIRENTRY__Array {
    struct ICONDIRENTRY__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct ICONDIRENTRY *vector[32];
};

struct ICONDIRENTRY__Array__VTable {
};

struct ICONDIRENTRY__Array__StaticFields {
};

struct ICONDIRENTRY__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ICONDIRENTRY__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ICONDIRENTRY__Array__VTable vtable;
};

struct IEnumerable_1_System_Attribute_ {
    struct IEnumerable_1_System_Attribute___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_Attribute___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_Attribute___StaticFields {
};

struct IEnumerable_1_System_Attribute___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_Attribute___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_Attribute___VTable vtable;
};

struct AmbiguousMatchException__Fields {
    struct SystemException__Fields _;
};

struct AmbiguousMatchException {
    struct AmbiguousMatchException__Class *klass;
    MonitorData *monitor;
    struct AmbiguousMatchException__Fields fields;
};

struct AmbiguousMatchException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct AmbiguousMatchException__StaticFields {
};

struct AmbiguousMatchException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AmbiguousMatchException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AmbiguousMatchException__VTable vtable;
};

struct __declspec(align(8)) AssemblyCopyrightAttribute__Fields {
    struct String *m_copyright;
};

struct AssemblyCopyrightAttribute {
    struct AssemblyCopyrightAttribute__Class *klass;
    MonitorData *monitor;
    struct AssemblyCopyrightAttribute__Fields fields;
};

struct AssemblyCopyrightAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct AssemblyCopyrightAttribute__StaticFields {
};

struct AssemblyCopyrightAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyCopyrightAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyCopyrightAttribute__VTable vtable;
};

struct __declspec(align(8)) AssemblyTrademarkAttribute__Fields {
    struct String *m_trademark;
};

struct AssemblyTrademarkAttribute {
    struct AssemblyTrademarkAttribute__Class *klass;
    MonitorData *monitor;
    struct AssemblyTrademarkAttribute__Fields fields;
};

struct AssemblyTrademarkAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct AssemblyTrademarkAttribute__StaticFields {
};

struct AssemblyTrademarkAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyTrademarkAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyTrademarkAttribute__VTable vtable;
};

struct __declspec(align(8)) AssemblyProductAttribute__Fields {
    struct String *m_product;
};

struct AssemblyProductAttribute {
    struct AssemblyProductAttribute__Class *klass;
    MonitorData *monitor;
    struct AssemblyProductAttribute__Fields fields;
};

struct AssemblyProductAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct AssemblyProductAttribute__StaticFields {
};

struct AssemblyProductAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyProductAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyProductAttribute__VTable vtable;
};

struct __declspec(align(8)) AssemblyCompanyAttribute__Fields {
    struct String *m_company;
};

struct AssemblyCompanyAttribute {
    struct AssemblyCompanyAttribute__Class *klass;
    MonitorData *monitor;
    struct AssemblyCompanyAttribute__Fields fields;
};

struct AssemblyCompanyAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct AssemblyCompanyAttribute__StaticFields {
};

struct AssemblyCompanyAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyCompanyAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyCompanyAttribute__VTable vtable;
};

struct __declspec(align(8)) AssemblyDescriptionAttribute__Fields {
    struct String *m_description;
};

struct AssemblyDescriptionAttribute {
    struct AssemblyDescriptionAttribute__Class *klass;
    MonitorData *monitor;
    struct AssemblyDescriptionAttribute__Fields fields;
};

struct AssemblyDescriptionAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct AssemblyDescriptionAttribute__StaticFields {
};

struct AssemblyDescriptionAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyDescriptionAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyDescriptionAttribute__VTable vtable;
};

struct __declspec(align(8)) AssemblyTitleAttribute__Fields {
    struct String *m_title;
};

struct AssemblyTitleAttribute {
    struct AssemblyTitleAttribute__Class *klass;
    MonitorData *monitor;
    struct AssemblyTitleAttribute__Fields fields;
};

struct AssemblyTitleAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct AssemblyTitleAttribute__StaticFields {
};

struct AssemblyTitleAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyTitleAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyTitleAttribute__VTable vtable;
};

struct __declspec(align(8)) AssemblyConfigurationAttribute__Fields {
    struct String *m_configuration;
};

struct AssemblyConfigurationAttribute {
    struct AssemblyConfigurationAttribute__Class *klass;
    MonitorData *monitor;
    struct AssemblyConfigurationAttribute__Fields fields;
};

struct AssemblyConfigurationAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct AssemblyConfigurationAttribute__StaticFields {
};

struct AssemblyConfigurationAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyConfigurationAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyConfigurationAttribute__VTable vtable;
};

struct __declspec(align(8)) AssemblyDefaultAliasAttribute__Fields {
    struct String *m_defaultAlias;
};

struct AssemblyDefaultAliasAttribute {
    struct AssemblyDefaultAliasAttribute__Class *klass;
    MonitorData *monitor;
    struct AssemblyDefaultAliasAttribute__Fields fields;
};

struct AssemblyDefaultAliasAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct AssemblyDefaultAliasAttribute__StaticFields {
};

struct AssemblyDefaultAliasAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyDefaultAliasAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyDefaultAliasAttribute__VTable vtable;
};

struct __declspec(align(8)) AssemblyInformationalVersionAttribute__Fields {
    struct String *m_informationalVersion;
};

struct AssemblyInformationalVersionAttribute {
    struct AssemblyInformationalVersionAttribute__Class *klass;
    MonitorData *monitor;
    struct AssemblyInformationalVersionAttribute__Fields fields;
};

struct AssemblyInformationalVersionAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct AssemblyInformationalVersionAttribute__StaticFields {
};

struct AssemblyInformationalVersionAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyInformationalVersionAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyInformationalVersionAttribute__VTable vtable;
};

struct __declspec(align(8)) AssemblyFileVersionAttribute__Fields {
    struct String *_version;
};

struct AssemblyFileVersionAttribute {
    struct AssemblyFileVersionAttribute__Class *klass;
    MonitorData *monitor;
    struct AssemblyFileVersionAttribute__Fields fields;
};

struct AssemblyFileVersionAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct AssemblyFileVersionAttribute__StaticFields {
};

struct AssemblyFileVersionAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyFileVersionAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyFileVersionAttribute__VTable vtable;
};

struct __declspec(align(8)) AssemblyCultureAttribute__Fields {
    struct String *m_culture;
};

struct AssemblyCultureAttribute {
    struct AssemblyCultureAttribute__Class *klass;
    MonitorData *monitor;
    struct AssemblyCultureAttribute__Fields fields;
};

struct AssemblyCultureAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct AssemblyCultureAttribute__StaticFields {
};

struct AssemblyCultureAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyCultureAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyCultureAttribute__VTable vtable;
};

struct __declspec(align(8)) AssemblyVersionAttribute__Fields {
    struct String *m_version;
};

struct AssemblyVersionAttribute {
    struct AssemblyVersionAttribute__Class *klass;
    MonitorData *monitor;
    struct AssemblyVersionAttribute__Fields fields;
};

struct AssemblyVersionAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct AssemblyVersionAttribute__StaticFields {
};

struct AssemblyVersionAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyVersionAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyVersionAttribute__VTable vtable;
};

struct __declspec(align(8)) AssemblyKeyFileAttribute__Fields {
    struct String *m_keyFile;
};

struct AssemblyKeyFileAttribute {
    struct AssemblyKeyFileAttribute__Class *klass;
    MonitorData *monitor;
    struct AssemblyKeyFileAttribute__Fields fields;
};

struct AssemblyKeyFileAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct AssemblyKeyFileAttribute__StaticFields {
};

struct AssemblyKeyFileAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyKeyFileAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyKeyFileAttribute__VTable vtable;
};

struct __declspec(align(8)) AssemblyDelaySignAttribute__Fields {
    bool m_delaySign;
};

struct AssemblyDelaySignAttribute {
    struct AssemblyDelaySignAttribute__Class *klass;
    MonitorData *monitor;
    struct AssemblyDelaySignAttribute__Fields fields;
};

struct AssemblyDelaySignAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct AssemblyDelaySignAttribute__StaticFields {
};

struct AssemblyDelaySignAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyDelaySignAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyDelaySignAttribute__VTable vtable;
};

struct __declspec(align(8)) AssemblyAlgorithmIdAttribute__Fields {
    uint32_t m_algId;
};

struct AssemblyAlgorithmIdAttribute {
    struct AssemblyAlgorithmIdAttribute__Class *klass;
    MonitorData *monitor;
    struct AssemblyAlgorithmIdAttribute__Fields fields;
};

struct AssemblyAlgorithmIdAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct AssemblyAlgorithmIdAttribute__StaticFields {
};

struct AssemblyAlgorithmIdAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyAlgorithmIdAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyAlgorithmIdAttribute__VTable vtable;
};

struct __declspec(align(8)) AssemblyFlagsAttribute__Fields {
    #if defined(_CPLUSPLUS_)
    enum AssemblyNameFlags__Enum m_flags;
    #else
    uint32_t m_flags;
    #endif
};

struct AssemblyFlagsAttribute {
    struct AssemblyFlagsAttribute__Class *klass;
    MonitorData *monitor;
    struct AssemblyFlagsAttribute__Fields fields;
};

struct AssemblyFlagsAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct AssemblyFlagsAttribute__StaticFields {
};

struct AssemblyFlagsAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyFlagsAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyFlagsAttribute__VTable vtable;
};

struct __declspec(align(8)) AssemblyMetadataAttribute__Fields {
    struct String *m_key;
    struct String *m_value;
};

struct AssemblyMetadataAttribute {
    struct AssemblyMetadataAttribute__Class *klass;
    MonitorData *monitor;
    struct AssemblyMetadataAttribute__Fields fields;
};

struct AssemblyMetadataAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct AssemblyMetadataAttribute__StaticFields {
};

struct AssemblyMetadataAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyMetadataAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyMetadataAttribute__VTable vtable;
};

struct __declspec(align(8)) AssemblySignatureKeyAttribute__Fields {
    struct String *_publicKey;
    struct String *_countersignature;
};

struct AssemblySignatureKeyAttribute {
    struct AssemblySignatureKeyAttribute__Class *klass;
    MonitorData *monitor;
    struct AssemblySignatureKeyAttribute__Fields fields;
};

struct AssemblySignatureKeyAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct AssemblySignatureKeyAttribute__StaticFields {
};

struct AssemblySignatureKeyAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblySignatureKeyAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblySignatureKeyAttribute__VTable vtable;
};

struct __declspec(align(8)) AssemblyKeyNameAttribute__Fields {
    struct String *m_keyName;
};

struct AssemblyKeyNameAttribute {
    struct AssemblyKeyNameAttribute__Class *klass;
    MonitorData *monitor;
    struct AssemblyKeyNameAttribute__Fields fields;
};

struct AssemblyKeyNameAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct AssemblyKeyNameAttribute__StaticFields {
};

struct AssemblyKeyNameAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyKeyNameAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyKeyNameAttribute__VTable vtable;
};

struct AssemblyNameProxy__Fields {
    struct MarshalByRefObject__Fields _;
};

struct AssemblyNameProxy {
    struct AssemblyNameProxy__Class *klass;
    MonitorData *monitor;
    struct AssemblyNameProxy__Fields fields;
};

struct AssemblyNameProxy__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
};

struct AssemblyNameProxy__StaticFields {
};

struct AssemblyNameProxy__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AssemblyNameProxy__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AssemblyNameProxy__VTable vtable;
};

struct __declspec(align(8)) DefaultMemberAttribute__Fields {
    struct String *m_memberName;
};

struct DefaultMemberAttribute {
    struct DefaultMemberAttribute__Class *klass;
    MonitorData *monitor;
    struct DefaultMemberAttribute__Fields fields;
};

struct DefaultMemberAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct DefaultMemberAttribute__StaticFields {
};

struct DefaultMemberAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DefaultMemberAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DefaultMemberAttribute__VTable vtable;
};

struct InvalidFilterCriteriaException__Fields {
    struct ApplicationException__Fields _;
};

struct InvalidFilterCriteriaException {
    struct InvalidFilterCriteriaException__Class *klass;
    MonitorData *monitor;
    struct InvalidFilterCriteriaException__Fields fields;
};

struct InvalidFilterCriteriaException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct InvalidFilterCriteriaException__StaticFields {
};

struct InvalidFilterCriteriaException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct InvalidFilterCriteriaException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct InvalidFilterCriteriaException__VTable vtable;
};

struct __declspec(align(8)) MemberInfoSerializationHolder__Fields {
    struct String *m_memberName;
    struct RuntimeType *m_reflectedType;
    struct String *m_signature;
    struct String *m_signature2;
    #if defined(_CPLUSPLUS_)
    enum MemberTypes__Enum m_memberType;
    #else
    uint32_t m_memberType;
    #endif
    struct SerializationInfo *m_info;
};

struct MemberInfoSerializationHolder {
    struct MemberInfoSerializationHolder__Class *klass;
    MonitorData *monitor;
    struct MemberInfoSerializationHolder__Fields fields;
};

struct MemberInfoSerializationHolder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData GetRealObject;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetRealObject_1;
};

struct MemberInfoSerializationHolder__StaticFields {
};

struct MemberInfoSerializationHolder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MemberInfoSerializationHolder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MemberInfoSerializationHolder__VTable vtable;
};

struct __declspec(align(8)) ObfuscateAssemblyAttribute__Fields {
    bool m_assemblyIsPrivate;
    bool m_strip;
};

struct ObfuscateAssemblyAttribute {
    struct ObfuscateAssemblyAttribute__Class *klass;
    MonitorData *monitor;
    struct ObfuscateAssemblyAttribute__Fields fields;
};

struct ObfuscateAssemblyAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct ObfuscateAssemblyAttribute__StaticFields {
};

struct ObfuscateAssemblyAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ObfuscateAssemblyAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ObfuscateAssemblyAttribute__VTable vtable;
};

struct __declspec(align(8)) ObfuscationAttribute__Fields {
    bool m_strip;
    bool m_exclude;
    bool m_applyToMembers;
    struct String *m_feature;
};

struct ObfuscationAttribute {
    struct ObfuscationAttribute__Class *klass;
    MonitorData *monitor;
    struct ObfuscationAttribute__Fields fields;
};

struct ObfuscationAttribute__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Attribute_Invoke;
    VirtualInvokeData get_TypeId;
    VirtualInvokeData Match;
    VirtualInvokeData IsDefaultAttribute;
};

struct ObfuscationAttribute__StaticFields {
};

struct ObfuscationAttribute__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ObfuscationAttribute__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ObfuscationAttribute__VTable vtable;
};

struct __declspec(align(8)) Pointer_1__Fields {
    struct Void *_ptr;
    struct RuntimeType *_ptrType;
};

struct Pointer_1 {
    struct Pointer_1__Class *klass;
    MonitorData *monitor;
    struct Pointer_1__Fields fields;
};

struct Pointer_1__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_Serialization_ISerializable_GetObjectData;
};

struct Pointer_1__StaticFields {
};

struct Pointer_1__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Pointer_1__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Pointer_1__VTable vtable;
};

struct ReflectionContext {
    struct ReflectionContext__Class *klass;
    MonitorData *monitor;
};

struct ReflectionContext__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData GetTypeForObject;
};

struct ReflectionContext__StaticFields {
};

struct ReflectionContext__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ReflectionContext__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ReflectionContext__VTable vtable;
};

struct ReflectionTypeLoadException__Fields {
    struct SystemException__Fields _;
    struct Type__Array *_classes;
    struct Exception__Array *_exceptions;
};

struct ReflectionTypeLoadException {
    struct ReflectionTypeLoadException__Class *klass;
    MonitorData *monitor;
    struct ReflectionTypeLoadException__Fields fields;
};

struct ReflectionTypeLoadException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct ReflectionTypeLoadException__StaticFields {
};

struct ReflectionTypeLoadException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ReflectionTypeLoadException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ReflectionTypeLoadException__VTable vtable;
};

struct TargetException__Fields {
    struct ApplicationException__Fields _;
};

struct TargetException {
    struct TargetException__Class *klass;
    MonitorData *monitor;
    struct TargetException__Fields fields;
};

struct TargetException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct TargetException__StaticFields {
};

struct TargetException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TargetException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TargetException__VTable vtable;
};

struct TargetInvocationException__Fields {
    struct ApplicationException__Fields _;
};

struct TargetInvocationException {
    struct TargetInvocationException__Class *klass;
    MonitorData *monitor;
    struct TargetInvocationException__Fields fields;
};

struct TargetInvocationException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct TargetInvocationException__StaticFields {
};

struct TargetInvocationException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TargetInvocationException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TargetInvocationException__VTable vtable;
};

struct TargetParameterCountException__Fields {
    struct ApplicationException__Fields _;
};

struct TargetParameterCountException {
    struct TargetParameterCountException__Class *klass;
    MonitorData *monitor;
    struct TargetParameterCountException__Fields fields;
};

struct TargetParameterCountException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct TargetParameterCountException__StaticFields {
};

struct TargetParameterCountException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TargetParameterCountException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TargetParameterCountException__VTable vtable;
};

struct TypeDelegator__Fields {
    struct TypeInfo__Fields _;
    struct Type *typeImpl;
};

struct TypeDelegator {
    struct TypeDelegator__Class *klass;
    MonitorData *monitor;
    struct TypeDelegator__Fields fields;
};

struct TypeDelegator__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData Equals_2;
    VirtualInvokeData Equals_3;
    VirtualInvokeData FindInterfaces;
    VirtualInvokeData FindMembers;
    VirtualInvokeData GetArrayRank;
    VirtualInvokeData GetConstructor;
    VirtualInvokeData GetConstructor_1;
    VirtualInvokeData GetConstructor_2;
    VirtualInvokeData GetConstructors;
    VirtualInvokeData GetConstructors_1;
    VirtualInvokeData GetCustomAttributes_6;
    VirtualInvokeData GetCustomAttributes_7;
    VirtualInvokeData GetDefaultMembers;
    VirtualInvokeData GetElementType;
    VirtualInvokeData GetEvent;
    VirtualInvokeData GetEvent_1;
    VirtualInvokeData GetEvents;
    VirtualInvokeData GetEvents_1;
    VirtualInvokeData GetField;
    VirtualInvokeData GetField_1;
    VirtualInvokeData GetFields;
    VirtualInvokeData GetFields_1;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Type_Invoke;
    VirtualInvokeData GetInterface;
    VirtualInvokeData GetInterface_1;
    VirtualInvokeData GetInterfaceMap;
    VirtualInvokeData GetInterfaces;
    VirtualInvokeData GetMember;
    VirtualInvokeData GetMember_1;
    VirtualInvokeData GetMember_2;
    VirtualInvokeData GetMembers;
    VirtualInvokeData GetMembers_1;
    VirtualInvokeData GetMethod;
    VirtualInvokeData GetMethod_1;
    VirtualInvokeData GetMethod_2;
    VirtualInvokeData GetMethod_3;
    VirtualInvokeData GetMethod_4;
    VirtualInvokeData GetMethod_5;
    VirtualInvokeData GetMethods;
    VirtualInvokeData GetMethods_1;
    VirtualInvokeData GetNestedType;
    VirtualInvokeData GetNestedType_1;
    VirtualInvokeData GetNestedTypes;
    VirtualInvokeData GetNestedTypes_1;
    VirtualInvokeData GetProperties;
    VirtualInvokeData GetProperties_1;
    VirtualInvokeData GetProperty;
    VirtualInvokeData GetProperty_1;
    VirtualInvokeData GetProperty_2;
    VirtualInvokeData GetProperty_3;
    VirtualInvokeData GetProperty_4;
    VirtualInvokeData GetProperty_5;
    VirtualInvokeData GetProperty_6;
    VirtualInvokeData GetType;
    VirtualInvokeData InvokeMember;
    VirtualInvokeData InvokeMember_1;
    VirtualInvokeData InvokeMember_2;
    VirtualInvokeData IsAssignableFrom;
    VirtualInvokeData IsDefined_3;
    VirtualInvokeData IsInstanceOfType;
    VirtualInvokeData IsSubclassOf;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Assembly;
    VirtualInvokeData get_AssemblyQualifiedName;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_BaseType;
    VirtualInvokeData get_DeclaringType_2;
    VirtualInvokeData get_FullName;
    VirtualInvokeData get_GUID;
    VirtualInvokeData get_HasElementType;
    VirtualInvokeData get_IsAbstract;
    VirtualInvokeData get_IsAnsiClass;
    VirtualInvokeData get_IsArray;
    VirtualInvokeData get_IsAutoClass;
    VirtualInvokeData get_IsAutoLayout;
    VirtualInvokeData get_IsByRef;
    VirtualInvokeData get_IsClass;
    VirtualInvokeData get_IsCOMObject;
    VirtualInvokeData get_IsContextful;
    VirtualInvokeData get_IsEnum;
    VirtualInvokeData get_IsExplicitLayout;
    VirtualInvokeData get_IsImport;
    VirtualInvokeData get_IsInterface;
    VirtualInvokeData get_IsLayoutSequential;
    VirtualInvokeData get_IsMarshalByRef;
    VirtualInvokeData get_IsNestedAssembly;
    VirtualInvokeData get_IsNestedFamANDAssem;
    VirtualInvokeData get_IsNestedFamily;
    VirtualInvokeData get_IsNestedFamORAssem;
    VirtualInvokeData get_IsNestedPrivate;
    VirtualInvokeData get_IsNestedPublic;
    VirtualInvokeData get_IsNotPublic;
    VirtualInvokeData get_IsPointer;
    VirtualInvokeData get_IsPrimitive;
    VirtualInvokeData get_IsPublic;
    VirtualInvokeData get_IsSealed;
    VirtualInvokeData get_IsSerializable;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_IsUnicodeClass;
    VirtualInvokeData get_IsValueType;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_Module_1;
    VirtualInvokeData get_Name_2;
    VirtualInvokeData get_Namespace;
    VirtualInvokeData get_ReflectedType_2;
    VirtualInvokeData get_TypeHandle;
    VirtualInvokeData get_TypeInitializer;
    VirtualInvokeData get_UnderlyingSystemType;
    VirtualInvokeData GetMethod_6;
    VirtualInvokeData GetMethod_7;
    VirtualInvokeData GetMethods_2;
    VirtualInvokeData GetField_2;
    VirtualInvokeData GetFields_2;
    VirtualInvokeData GetProperty_7;
    VirtualInvokeData GetProperty_8;
    VirtualInvokeData GetProperties_2;
    VirtualInvokeData GetMember_3;
    VirtualInvokeData GetMembers_2;
    VirtualInvokeData InvokeMember_3;
    VirtualInvokeData get_UnderlyingSystemType_1;
    VirtualInvokeData get_DeclaringMethod;
    VirtualInvokeData MakePointerType;
    VirtualInvokeData get_StructLayoutAttribute;
    VirtualInvokeData MakeByRefType;
    VirtualInvokeData MakeArrayType;
    VirtualInvokeData MakeArrayType_1;
    VirtualInvokeData GetTypeCodeImpl;
    VirtualInvokeData get_GUID_1;
    VirtualInvokeData InvokeMember_4;
    VirtualInvokeData get_Assembly_1;
    VirtualInvokeData get_TypeHandle_1;
    VirtualInvokeData GetTypeHandleInternal;
    VirtualInvokeData get_FullName_1;
    VirtualInvokeData get_Namespace_1;
    VirtualInvokeData get_AssemblyQualifiedName_1;
    VirtualInvokeData GetArrayRank_1;
    VirtualInvokeData get_BaseType_1;
    VirtualInvokeData GetConstructorImpl;
    VirtualInvokeData GetConstructors_2;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetMethods_3;
    VirtualInvokeData GetField_3;
    VirtualInvokeData GetFields_3;
    VirtualInvokeData GetInterface_2;
    VirtualInvokeData GetInterfaces_1;
    VirtualInvokeData FindInterfaces_1;
    VirtualInvokeData GetEvent_2;
    VirtualInvokeData GetEvents_2;
    VirtualInvokeData GetEvents_3;
    VirtualInvokeData GetPropertyImpl;
    VirtualInvokeData GetProperties_3;
    VirtualInvokeData GetNestedTypes_2;
    VirtualInvokeData GetNestedType_2;
    VirtualInvokeData GetMember_4;
    VirtualInvokeData GetMember_5;
    VirtualInvokeData GetMembers_3;
    VirtualInvokeData GetDefaultMembers_1;
    VirtualInvokeData FindMembers_1;
    VirtualInvokeData get_GenericParameterAttributes;
    VirtualInvokeData get_IsEnum_1;
    VirtualInvokeData get_IsSerializable_1;
    VirtualInvokeData get_IsSzArray;
    VirtualInvokeData get_IsGenericType;
    VirtualInvokeData get_IsGenericTypeDefinition;
    VirtualInvokeData get_IsConstructedGenericType;
    VirtualInvokeData get_IsGenericParameter;
    VirtualInvokeData get_GenericParameterPosition;
    VirtualInvokeData get_ContainsGenericParameters;
    VirtualInvokeData GetGenericParameterConstraints;
    VirtualInvokeData IsValueTypeImpl;
    VirtualInvokeData GetAttributeFlagsImpl;
    VirtualInvokeData IsArrayImpl;
    VirtualInvokeData IsByRefImpl;
    VirtualInvokeData IsPointerImpl;
    VirtualInvokeData IsPrimitiveImpl;
    VirtualInvokeData IsCOMObjectImpl;
    VirtualInvokeData IsWindowsRuntimeObjectImpl;
    VirtualInvokeData IsExportedToWindowsRuntimeImpl;
    VirtualInvokeData MakeGenericType;
    VirtualInvokeData IsContextfulImpl;
    VirtualInvokeData IsMarshalByRefImpl;
    VirtualInvokeData HasProxyAttributeImpl;
    VirtualInvokeData GetElementType_1;
    VirtualInvokeData GetGenericArguments;
    VirtualInvokeData get_GenericTypeArguments;
    VirtualInvokeData GetGenericTypeDefinition;
    VirtualInvokeData HasElementTypeImpl;
    VirtualInvokeData GetEnumNames;
    VirtualInvokeData GetEnumValues;
    VirtualInvokeData GetEnumUnderlyingType;
    VirtualInvokeData IsEnumDefined;
    VirtualInvokeData GetEnumName;
    VirtualInvokeData get_IsSecurityCritical;
    VirtualInvokeData get_IsSecuritySafeCritical;
    VirtualInvokeData get_IsSecurityTransparent;
    VirtualInvokeData get_UnderlyingSystemType_2;
    VirtualInvokeData IsSubclassOf_1;
    VirtualInvokeData IsInstanceOfType_1;
    VirtualInvokeData IsAssignableFrom_1;
    VirtualInvokeData IsEquivalentTo;
    VirtualInvokeData FormatTypeName;
    VirtualInvokeData Equals_4;
    VirtualInvokeData GetInterfaceMap_1;
    VirtualInvokeData get_IsSZArray;
    VirtualInvokeData InternalResolve;
    VirtualInvokeData RuntimeResolve;
    VirtualInvokeData get_IsUserType;
    VirtualInvokeData GetMethod_8;
    VirtualInvokeData GetConstructor_3;
    VirtualInvokeData GetField_4;
    VirtualInvokeData System_Reflection_IReflectableType_GetTypeInfo;
    VirtualInvokeData AsType;
    VirtualInvokeData get_GenericTypeParameters;
    VirtualInvokeData IsAssignableFrom_2;
    VirtualInvokeData GetDeclaredEvent;
    VirtualInvokeData GetDeclaredField;
    VirtualInvokeData GetDeclaredMethod;
    VirtualInvokeData GetDeclaredMethods;
    VirtualInvokeData GetDeclaredNestedType;
    VirtualInvokeData GetDeclaredProperty;
    VirtualInvokeData get_DeclaredConstructors;
    VirtualInvokeData get_DeclaredEvents;
    VirtualInvokeData get_DeclaredFields;
    VirtualInvokeData get_DeclaredMembers;
    VirtualInvokeData get_DeclaredMethods;
    VirtualInvokeData get_DeclaredNestedTypes;
    VirtualInvokeData get_DeclaredProperties;
    VirtualInvokeData get_ImplementedInterfaces;
};

struct TypeDelegator__StaticFields {
};

struct TypeDelegator__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeDelegator__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeDelegator__VTable vtable;
};

struct __declspec(align(8)) TypeInfo_GetDeclaredMethods_d_9__Fields {
    int32_t __1__state;
    struct MethodInfo_1 *__2__current;
    int32_t __l__initialThreadId;
    struct TypeInfo *__4__this;
    struct String *name;
    struct String *__3__name;
    struct MethodInfo_1__Array *__7__wrap1;
    int32_t __7__wrap2;
};

struct TypeInfo_GetDeclaredMethods_d_9 {
    struct TypeInfo_GetDeclaredMethods_d_9__Class *klass;
    MonitorData *monitor;
    struct TypeInfo_GetDeclaredMethods_d_9__Fields fields;
};

struct IEnumerator_1_System_Reflection_MethodInfo_ {
    struct IEnumerator_1_System_Reflection_MethodInfo___Class *klass;
    MonitorData *monitor;
};

struct IEnumerator_1_System_Reflection_MethodInfo___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_System_Reflection_MethodInfo___StaticFields {
};

struct IEnumerator_1_System_Reflection_MethodInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_System_Reflection_MethodInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_System_Reflection_MethodInfo___VTable vtable;
};

struct TypeInfo_GetDeclaredMethods_d_9__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Collections_Generic_IEnumerable_System_Reflection_MethodInfo__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_Generic_IEnumerator_System_Reflection_MethodInfo__get_Current;
    VirtualInvokeData System_IDisposable_Dispose;
    VirtualInvokeData MoveNext;
    VirtualInvokeData System_Collections_IEnumerator_get_Current;
    VirtualInvokeData System_Collections_IEnumerator_Reset;
};

struct TypeInfo_GetDeclaredMethods_d_9__StaticFields {
};

struct TypeInfo_GetDeclaredMethods_d_9__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeInfo_GetDeclaredMethods_d_9__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeInfo_GetDeclaredMethods_d_9__VTable vtable;
};

struct __declspec(align(8)) TypeInfo_get_DeclaredNestedTypes_d_23__Fields {
    int32_t __1__state;
    struct TypeInfo *__2__current;
    int32_t __l__initialThreadId;
    struct TypeInfo *__4__this;
    struct Type__Array *__7__wrap1;
    int32_t __7__wrap2;
};

struct TypeInfo_get_DeclaredNestedTypes_d_23 {
    struct TypeInfo_get_DeclaredNestedTypes_d_23__Class *klass;
    MonitorData *monitor;
    struct TypeInfo_get_DeclaredNestedTypes_d_23__Fields fields;
};

struct IEnumerator_1_System_Reflection_TypeInfo_ {
    struct IEnumerator_1_System_Reflection_TypeInfo___Class *klass;
    MonitorData *monitor;
};

struct IEnumerator_1_System_Reflection_TypeInfo___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_System_Reflection_TypeInfo___StaticFields {
};

struct IEnumerator_1_System_Reflection_TypeInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_System_Reflection_TypeInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_System_Reflection_TypeInfo___VTable vtable;
};

struct TypeInfo_get_DeclaredNestedTypes_d_23__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Collections_Generic_IEnumerable_System_Reflection_TypeInfo__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_Generic_IEnumerator_System_Reflection_TypeInfo__get_Current;
    VirtualInvokeData System_IDisposable_Dispose;
    VirtualInvokeData MoveNext;
    VirtualInvokeData System_Collections_IEnumerator_get_Current;
    VirtualInvokeData System_Collections_IEnumerator_Reset;
};

struct TypeInfo_get_DeclaredNestedTypes_d_23__StaticFields {
};

struct TypeInfo_get_DeclaredNestedTypes_d_23__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeInfo_get_DeclaredNestedTypes_d_23__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeInfo_get_DeclaredNestedTypes_d_23__VTable vtable;
};

struct Module___VTable {
};

struct Module___StaticFields {
};

struct Module___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Module___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Module___VTable vtable;
};

struct Assembly_UnmanagedMemoryStreamForModule__Fields {
    struct UnmanagedMemoryStream__Fields _;
    struct Module *module;
};

struct Assembly_UnmanagedMemoryStreamForModule {
    struct Assembly_UnmanagedMemoryStreamForModule__Class *klass;
    MonitorData *monitor;
    struct Assembly_UnmanagedMemoryStreamForModule__Fields fields;
};

struct Assembly_UnmanagedMemoryStreamForModule__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_CanRead;
    VirtualInvokeData get_CanSeek;
    VirtualInvokeData get_CanTimeout;
    VirtualInvokeData get_CanWrite;
    VirtualInvokeData get_Length;
    VirtualInvokeData get_Position;
    VirtualInvokeData set_Position;
    VirtualInvokeData get_ReadTimeout;
    VirtualInvokeData set_ReadTimeout;
    VirtualInvokeData get_WriteTimeout;
    VirtualInvokeData set_WriteTimeout;
    VirtualInvokeData CopyToAsync;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Close;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData Flush;
    VirtualInvokeData FlushAsync;
    VirtualInvokeData CreateWaitHandle;
    VirtualInvokeData BeginRead;
    VirtualInvokeData EndRead;
    VirtualInvokeData ReadAsync;
    VirtualInvokeData BeginWrite;
    VirtualInvokeData EndWrite;
    VirtualInvokeData WriteAsync;
    VirtualInvokeData Seek;
    VirtualInvokeData SetLength;
    VirtualInvokeData Read;
    VirtualInvokeData ReadByte;
    VirtualInvokeData Write;
    VirtualInvokeData WriteByte;
    VirtualInvokeData ObjectInvariant;
    VirtualInvokeData Read_1;
    VirtualInvokeData Write_1;
    VirtualInvokeData ReadAsync_1;
    VirtualInvokeData WriteAsync_1;
};

struct Assembly_UnmanagedMemoryStreamForModule__StaticFields {
};

struct Assembly_UnmanagedMemoryStreamForModule__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Assembly_UnmanagedMemoryStreamForModule__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Assembly_UnmanagedMemoryStreamForModule__VTable vtable;
};

struct __declspec(align(8)) Assembly_get_DefinedTypes_d_140__Fields {
    int32_t __1__state;
    struct TypeInfo *__2__current;
    int32_t __l__initialThreadId;
    struct Assembly *__4__this;
    struct Type__Array *__7__wrap1;
    int32_t __7__wrap2;
};

struct Assembly_get_DefinedTypes_d_140 {
    struct Assembly_get_DefinedTypes_d_140__Class *klass;
    MonitorData *monitor;
    struct Assembly_get_DefinedTypes_d_140__Fields fields;
};

struct Assembly_get_DefinedTypes_d_140__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Collections_Generic_IEnumerable_System_Reflection_TypeInfo__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_Generic_IEnumerator_System_Reflection_TypeInfo__get_Current;
    VirtualInvokeData System_IDisposable_Dispose;
    VirtualInvokeData MoveNext;
    VirtualInvokeData System_Collections_IEnumerator_get_Current;
    VirtualInvokeData System_Collections_IEnumerator_Reset;
};

struct Assembly_get_DefinedTypes_d_140__StaticFields {
};

struct Assembly_get_DefinedTypes_d_140__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Assembly_get_DefinedTypes_d_140__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Assembly_get_DefinedTypes_d_140__VTable vtable;
};

struct MonoAssemblyNamePtr {
    struct MonoAssemblyNamePtr__Class *klass;
    MonitorData *monitor;
};

struct MonoAssemblyNamePtr__VTable {
};

struct MonoAssemblyNamePtr__StaticFields {
};

struct MonoAssemblyNamePtr__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoAssemblyNamePtr__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoAssemblyNamePtr__VTable vtable;
};

struct CustomAttributeFormatException__Fields {
    struct FormatException__Fields _;
};

struct CustomAttributeFormatException {
    struct CustomAttributeFormatException__Class *klass;
    MonitorData *monitor;
    struct CustomAttributeFormatException__Fields fields;
};

struct CustomAttributeFormatException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct CustomAttributeFormatException__StaticFields {
};

struct CustomAttributeFormatException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CustomAttributeFormatException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CustomAttributeFormatException__VTable vtable;
};

struct CustomAttributeTypedArgument {
    struct Type *argumentType;
    struct Object *value;
};

struct CustomAttributeTypedArgument__Boxed {
    struct CustomAttributeTypedArgument__Class *klass;
    MonitorData *monitor;
    struct CustomAttributeTypedArgument fields;
};

struct CustomAttributeNamedArgument {
    struct CustomAttributeTypedArgument typedArgument;
    struct MemberInfo_1 *memberInfo;
};

struct CustomAttributeNamedArgument__Boxed {
    struct CustomAttributeNamedArgument__Class *klass;
    MonitorData *monitor;
    struct CustomAttributeNamedArgument fields;
};

struct CustomAttributeTypedArgument__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct CustomAttributeTypedArgument__StaticFields {
};

struct CustomAttributeTypedArgument__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CustomAttributeTypedArgument__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CustomAttributeTypedArgument__VTable vtable;
};

struct CustomAttributeNamedArgument__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct CustomAttributeNamedArgument__StaticFields {
};

struct CustomAttributeNamedArgument__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CustomAttributeNamedArgument__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CustomAttributeNamedArgument__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum ResolveTokenError__Enum : int32_t {
    ResolveTokenError__Enum_OutOfRange = 0x00000000,
    ResolveTokenError__Enum_BadTable = 0x00000001,
    ResolveTokenError__Enum_Other = 0x00000002,
};

#else
enum ResolveTokenError__Enum {
    ResolveTokenError__Enum_OutOfRange = 0x00000000,
    ResolveTokenError__Enum_BadTable = 0x00000001,
    ResolveTokenError__Enum_Other = 0x00000002,
};

#endif
struct ResolveTokenError__Enum__Boxed {
    struct ResolveTokenError__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum ResolveTokenError__Enum value;
    #else
    uint32_t value;
    #endif
};

struct ResolveTokenError__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct ResolveTokenError__Enum__StaticFields {
};

struct ResolveTokenError__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ResolveTokenError__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ResolveTokenError__Enum__VTable vtable;
};

struct ResolveTokenError___VTable {
};

struct ResolveTokenError___StaticFields {
};

struct ResolveTokenError___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ResolveTokenError___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ResolveTokenError___VTable vtable;
};

struct RuntimeAssembly___VTable {
};

struct RuntimeAssembly___StaticFields {
};

struct RuntimeAssembly___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeAssembly___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeAssembly___VTable vtable;
};

struct MonoAssembly__Fields {
    struct RuntimeAssembly__Fields _;
};

struct MonoAssembly {
    struct MonoAssembly__Class *klass;
    MonitorData *monitor;
    struct MonoAssembly__Fields fields;
};

struct MonoAssembly__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData ToString_1;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__Assembly_GetType;
    VirtualInvokeData get_CodeBase;
    VirtualInvokeData get_EscapedCodeBase;
    VirtualInvokeData GetName;
    VirtualInvokeData GetName_1;
    VirtualInvokeData get_FullName;
    VirtualInvokeData get_EntryPoint;
    VirtualInvokeData GetType;
    VirtualInvokeData GetType_1;
    VirtualInvokeData GetExportedTypes;
    VirtualInvokeData GetTypes;
    VirtualInvokeData GetManifestResourceStream;
    VirtualInvokeData GetManifestResourceStream_1;
    VirtualInvokeData GetFile;
    VirtualInvokeData GetFiles;
    VirtualInvokeData GetFiles_1;
    VirtualInvokeData GetManifestResourceNames;
    VirtualInvokeData GetManifestResourceInfo;
    VirtualInvokeData get_Location;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType_2;
    VirtualInvokeData GetSatelliteAssembly;
    VirtualInvokeData GetSatelliteAssembly_1;
    VirtualInvokeData LoadModule;
    VirtualInvokeData LoadModule_1;
    VirtualInvokeData CreateInstance;
    VirtualInvokeData CreateInstance_1;
    VirtualInvokeData CreateInstance_2;
    VirtualInvokeData GetLoadedModules;
    VirtualInvokeData GetLoadedModules_1;
    VirtualInvokeData GetModules;
    VirtualInvokeData GetModules_1;
    VirtualInvokeData GetModule;
    VirtualInvokeData GetReferencedAssemblies;
    VirtualInvokeData add_ModuleResolve;
    VirtualInvokeData remove_ModuleResolve;
    VirtualInvokeData get_Evidence;
    VirtualInvokeData get_GlobalAssemblyCache;
    VirtualInvokeData get_Evidence_1;
    VirtualInvokeData add_ModuleResolve_1;
    VirtualInvokeData remove_ModuleResolve_1;
    VirtualInvokeData get_CodeBase_1;
    VirtualInvokeData get_EscapedCodeBase_1;
    VirtualInvokeData get_FullName_1;
    VirtualInvokeData get_EntryPoint_1;
    VirtualInvokeData get_Evidence_2;
    VirtualInvokeData get_Location_1;
    VirtualInvokeData get_ImageRuntimeVersion;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData GetFiles_2;
    VirtualInvokeData GetFiles_3;
    VirtualInvokeData GetFile_1;
    VirtualInvokeData GetManifestResourceStream_2;
    VirtualInvokeData GetManifestResourceStream_3;
    VirtualInvokeData GetTypes_1;
    VirtualInvokeData GetTypes_2;
    VirtualInvokeData GetExportedTypes_1;
    VirtualInvokeData GetType_3;
    VirtualInvokeData GetType_4;
    VirtualInvokeData GetName_2;
    VirtualInvokeData GetName_3;
    VirtualInvokeData LoadModule_2;
    VirtualInvokeData CreateInstance_3;
    VirtualInvokeData GetModulesInternal;
    VirtualInvokeData GetManifestResourceNames_1;
    VirtualInvokeData GetManifestResourceInfo_1;
    VirtualInvokeData get_HostContext;
    VirtualInvokeData GetManifestModule;
    VirtualInvokeData get_ReflectionOnly;
    VirtualInvokeData get_SecurityRuleSet;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData GetType_5;
    VirtualInvokeData GetModule_1;
    VirtualInvokeData GetReferencedAssemblies_1;
    VirtualInvokeData GetModules_2;
    VirtualInvokeData GetLoadedModules_2;
    VirtualInvokeData GetSatelliteAssembly_2;
    VirtualInvokeData GetSatelliteAssembly_3;
    VirtualInvokeData get_ManifestModule;
    VirtualInvokeData get_GlobalAssemblyCache_1;
    VirtualInvokeData get_IsDynamic;
    VirtualInvokeData get_DefinedTypes;
    VirtualInvokeData get_ExportedTypes;
    VirtualInvokeData get_Modules;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData get_PermissionSet;
};

struct MonoAssembly__StaticFields {
};

struct MonoAssembly__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoAssembly__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoAssembly__VTable vtable;
};

struct MonoEventInfo {
    struct Type *declaring_type;
    struct Type *reflected_type;
    struct String *name;
    struct MethodInfo_1 *add_method;
    struct MethodInfo_1 *remove_method;
    struct MethodInfo_1 *raise_method;
    #if defined(_CPLUSPLUS_)
    enum EventAttributes__Enum attrs;
    #else
    uint32_t attrs;
    #endif
    struct MethodInfo_1__Array *other_methods;
};

struct MonoEventInfo__Boxed {
    struct MonoEventInfo__Class *klass;
    MonitorData *monitor;
    struct MonoEventInfo fields;
};

struct MonoEventInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct MonoEventInfo__StaticFields {
};

struct MonoEventInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoEventInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoEventInfo__VTable vtable;
};

struct MonoEventInfo___VTable {
};

struct MonoEventInfo___StaticFields {
};

struct MonoEventInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoEventInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoEventInfo___VTable vtable;
};

struct MonoMethodInfo {
    struct Type *parent;
    struct Type *ret;
    #if defined(_CPLUSPLUS_)
    enum MethodAttributes__Enum attrs;
    #else
    uint32_t attrs;
    #endif
    #if defined(_CPLUSPLUS_)
    enum MethodImplAttributes__Enum iattrs;
    #else
    uint32_t iattrs;
    #endif
    #if defined(_CPLUSPLUS_)
    enum CallingConventions__Enum callconv;
    #else
    uint32_t callconv;
    #endif
};

struct MonoMethodInfo__Boxed {
    struct MonoMethodInfo__Class *klass;
    MonitorData *monitor;
    struct MonoMethodInfo fields;
};

struct MonoMethodInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct MonoMethodInfo__StaticFields {
};

struct MonoMethodInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoMethodInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoMethodInfo__VTable vtable;
};

struct MonoMethodInfo___VTable {
};

struct MonoMethodInfo___StaticFields {
};

struct MonoMethodInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoMethodInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoMethodInfo___VTable vtable;
};

struct Exception___VTable {
};

struct Exception___StaticFields {
};

struct Exception___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Exception___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Exception___VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum PInvokeAttributes__Enum : int32_t {
    PInvokeAttributes__Enum_NoMangle = 0x00000001,
    PInvokeAttributes__Enum_CharSetMask = 0x00000006,
    PInvokeAttributes__Enum_CharSetNotSpec = 0x00000000,
    PInvokeAttributes__Enum_CharSetAnsi = 0x00000002,
    PInvokeAttributes__Enum_CharSetUnicode = 0x00000004,
    PInvokeAttributes__Enum_CharSetAuto = 0x00000006,
    PInvokeAttributes__Enum_BestFitUseAssem = 0x00000000,
    PInvokeAttributes__Enum_BestFitEnabled = 0x00000010,
    PInvokeAttributes__Enum_BestFitDisabled = 0x00000020,
    PInvokeAttributes__Enum_BestFitMask = 0x00000030,
    PInvokeAttributes__Enum_ThrowOnUnmappableCharUseAssem = 0x00000000,
    PInvokeAttributes__Enum_ThrowOnUnmappableCharEnabled = 0x00001000,
    PInvokeAttributes__Enum_ThrowOnUnmappableCharDisabled = 0x00002000,
    PInvokeAttributes__Enum_ThrowOnUnmappableCharMask = 0x00003000,
    PInvokeAttributes__Enum_SupportsLastError = 0x00000040,
    PInvokeAttributes__Enum_CallConvMask = 0x00000700,
    PInvokeAttributes__Enum_CallConvWinapi = 0x00000100,
    PInvokeAttributes__Enum_CallConvCdecl = 0x00000200,
    PInvokeAttributes__Enum_CallConvStdcall = 0x00000300,
    PInvokeAttributes__Enum_CallConvThiscall = 0x00000400,
    PInvokeAttributes__Enum_CallConvFastcall = 0x00000500,
    PInvokeAttributes__Enum_MaxValue = 0x0000ffff,
};

#else
enum PInvokeAttributes__Enum {
    PInvokeAttributes__Enum_NoMangle = 0x00000001,
    PInvokeAttributes__Enum_CharSetMask = 0x00000006,
    PInvokeAttributes__Enum_CharSetNotSpec = 0x00000000,
    PInvokeAttributes__Enum_CharSetAnsi = 0x00000002,
    PInvokeAttributes__Enum_CharSetUnicode = 0x00000004,
    PInvokeAttributes__Enum_CharSetAuto = 0x00000006,
    PInvokeAttributes__Enum_BestFitUseAssem = 0x00000000,
    PInvokeAttributes__Enum_BestFitEnabled = 0x00000010,
    PInvokeAttributes__Enum_BestFitDisabled = 0x00000020,
    PInvokeAttributes__Enum_BestFitMask = 0x00000030,
    PInvokeAttributes__Enum_ThrowOnUnmappableCharUseAssem = 0x00000000,
    PInvokeAttributes__Enum_ThrowOnUnmappableCharEnabled = 0x00001000,
    PInvokeAttributes__Enum_ThrowOnUnmappableCharDisabled = 0x00002000,
    PInvokeAttributes__Enum_ThrowOnUnmappableCharMask = 0x00003000,
    PInvokeAttributes__Enum_SupportsLastError = 0x00000040,
    PInvokeAttributes__Enum_CallConvMask = 0x00000700,
    PInvokeAttributes__Enum_CallConvWinapi = 0x00000100,
    PInvokeAttributes__Enum_CallConvCdecl = 0x00000200,
    PInvokeAttributes__Enum_CallConvStdcall = 0x00000300,
    PInvokeAttributes__Enum_CallConvThiscall = 0x00000400,
    PInvokeAttributes__Enum_CallConvFastcall = 0x00000500,
    PInvokeAttributes__Enum_MaxValue = 0x0000ffff,
};

#endif
struct PInvokeAttributes__Enum__Boxed {
    struct PInvokeAttributes__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum PInvokeAttributes__Enum value;
    #else
    uint32_t value;
    #endif
};

struct PInvokeAttributes__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct PInvokeAttributes__Enum__StaticFields {
};

struct PInvokeAttributes__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PInvokeAttributes__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PInvokeAttributes__Enum__VTable vtable;
};

struct PInvokeAttributes___VTable {
};

struct PInvokeAttributes___StaticFields {
};

struct PInvokeAttributes___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PInvokeAttributes___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PInvokeAttributes___VTable vtable;
};

struct MonoModule__Fields {
    struct RuntimeModule__Fields _;
};

struct MonoModule {
    struct MonoModule__Class *klass;
    MonitorData *monitor;
    struct MonoModule__Fields fields;
};

struct MonoModule__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData System_Runtime_InteropServices__Module_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Module_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Module_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Module_Invoke;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData GetType_1;
    VirtualInvokeData GetModuleVersionId;
    VirtualInvokeData get_Assembly;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ScopeName;
    VirtualInvokeData get_MDStreamVersion;
    VirtualInvokeData get_ModuleVersionId;
    VirtualInvokeData get_FullyQualifiedName;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData IsResource;
    VirtualInvokeData FindTypes;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData GetField;
    VirtualInvokeData GetFields;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetMethods;
    VirtualInvokeData GetPEKind;
    VirtualInvokeData GetType_2;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ResolveField;
    VirtualInvokeData ResolveMember;
    VirtualInvokeData ResolveMethod;
    VirtualInvokeData ResolveSignature;
    VirtualInvokeData ResolveString;
    VirtualInvokeData ResolveType;
    VirtualInvokeData GetSignerCertificate;
    VirtualInvokeData GetTypes;
    VirtualInvokeData get_CustomAttributes;
};

struct MonoModule__StaticFields {
};

struct MonoModule__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoModule__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoModule__VTable vtable;
};

struct RuntimeParameterInfo__Fields {
    struct ParameterInfo_1__Fields _;
};

struct RuntimeParameterInfo {
    struct RuntimeParameterInfo__Class *klass;
    MonitorData *monitor;
    struct RuntimeParameterInfo__Fields fields;
};

struct RuntimeParameterInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData GetRealObject;
    VirtualInvokeData System_Runtime_InteropServices__ParameterInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__ParameterInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__ParameterInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__ParameterInfo_Invoke;
    VirtualInvokeData get_ParameterType;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_Member;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_Position;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData get_HasDefaultValue;
    VirtualInvokeData get_DefaultValue;
    VirtualInvokeData get_RawDefaultValue;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData GetRequiredCustomModifiers;
    VirtualInvokeData GetOptionalCustomModifiers;
    VirtualInvokeData GetCustomAttributesData;
};

struct RuntimeParameterInfo__StaticFields {
};

struct RuntimeParameterInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct RuntimeParameterInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct RuntimeParameterInfo__VTable vtable;
};

struct MonoParameterInfo__Fields {
    struct RuntimeParameterInfo__Fields _;
};

struct MonoParameterInfo {
    struct MonoParameterInfo__Class *klass;
    MonitorData *monitor;
    struct MonoParameterInfo__Fields fields;
};

struct MonoParameterInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData GetRealObject;
    VirtualInvokeData System_Runtime_InteropServices__ParameterInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__ParameterInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__ParameterInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__ParameterInfo_Invoke;
    VirtualInvokeData get_ParameterType;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_Member;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_Position;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData get_HasDefaultValue;
    VirtualInvokeData get_DefaultValue;
    VirtualInvokeData get_RawDefaultValue;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData GetRequiredCustomModifiers;
    VirtualInvokeData GetOptionalCustomModifiers;
    VirtualInvokeData GetCustomAttributesData;
};

struct MonoParameterInfo__StaticFields {
};

struct MonoParameterInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoParameterInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoParameterInfo__VTable vtable;
};

struct MonoPropertyInfo___VTable {
};

struct MonoPropertyInfo___StaticFields {
};

struct MonoPropertyInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoPropertyInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoPropertyInfo___VTable vtable;
};

struct GetterAdapter__Fields {
    struct MulticastDelegate__Fields _;
};

struct GetterAdapter {
    struct GetterAdapter__Class *klass;
    MonitorData *monitor;
    struct GetterAdapter__Fields fields;
};

struct GetterAdapter__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct GetterAdapter__StaticFields {
};

struct GetterAdapter__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct GetterAdapter__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct GetterAdapter__VTable vtable;
};

struct ExceptionHandler {
    int32_t m_exceptionClass;
    int32_t m_tryStartOffset;
    int32_t m_tryEndOffset;
    int32_t m_filterOffset;
    int32_t m_handlerStartOffset;
    int32_t m_handlerEndOffset;
    #if defined(_CPLUSPLUS_)
    enum ExceptionHandlingClauseOptions__Enum m_kind;
    #else
    uint32_t m_kind;
    #endif
};

struct ExceptionHandler__Boxed {
    struct ExceptionHandler__Class *klass;
    MonitorData *monitor;
    struct ExceptionHandler fields;
};

struct ExceptionHandler__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Equals_1;
};

struct ExceptionHandler__StaticFields {
};

struct ExceptionHandler__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ExceptionHandler__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ExceptionHandler__VTable vtable;
};

struct ModuleBuilder__Fields {
    struct Module__Fields _;
};

struct ModuleBuilder {
    struct ModuleBuilder__Class *klass;
    MonitorData *monitor;
    struct ModuleBuilder__Fields fields;
};

struct ModuleBuilder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData System_Runtime_InteropServices__Module_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Module_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Module_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Module_Invoke;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData GetType_1;
    VirtualInvokeData GetModuleVersionId;
    VirtualInvokeData get_Assembly;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ScopeName;
    VirtualInvokeData get_MDStreamVersion;
    VirtualInvokeData get_ModuleVersionId;
    VirtualInvokeData get_FullyQualifiedName;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData IsResource;
    VirtualInvokeData FindTypes;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData GetField;
    VirtualInvokeData GetFields;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetMethods;
    VirtualInvokeData GetPEKind;
    VirtualInvokeData GetType_2;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ResolveField;
    VirtualInvokeData ResolveMember;
    VirtualInvokeData ResolveMethod;
    VirtualInvokeData ResolveSignature;
    VirtualInvokeData ResolveString;
    VirtualInvokeData ResolveType;
    VirtualInvokeData GetSignerCertificate;
    VirtualInvokeData GetTypes;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData System_Runtime_InteropServices__ModuleBuilder_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__ModuleBuilder_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__ModuleBuilder_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__ModuleBuilder_Invoke;
};

struct ModuleBuilder__StaticFields {
};

struct ModuleBuilder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ModuleBuilder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ModuleBuilder__VTable vtable;
};

struct CustomAttributeBuilder {
    struct CustomAttributeBuilder__Class *klass;
    MonitorData *monitor;
};

struct CustomAttributeBuilder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__CustomAttributeBuilder_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__CustomAttributeBuilder_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__CustomAttributeBuilder_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__CustomAttributeBuilder_Invoke;
};

struct CustomAttributeBuilder__StaticFields {
};

struct CustomAttributeBuilder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CustomAttributeBuilder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CustomAttributeBuilder__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum ResourceAttributes__Enum : int32_t {
    ResourceAttributes__Enum_Public = 0x00000001,
    ResourceAttributes__Enum_Private = 0x00000002,
};

#else
enum ResourceAttributes__Enum {
    ResourceAttributes__Enum_Public = 0x00000001,
    ResourceAttributes__Enum_Private = 0x00000002,
};

#endif
struct ResourceAttributes__Enum__Boxed {
    struct ResourceAttributes__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum ResourceAttributes__Enum value;
    #else
    uint32_t value;
    #endif
};

struct ResourceAttributes__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct ResourceAttributes__Enum__StaticFields {
};

struct ResourceAttributes__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ResourceAttributes__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ResourceAttributes__Enum__VTable vtable;
};

struct IResourceWriter {
    struct IResourceWriter__Class *klass;
    MonitorData *monitor;
};

struct IResourceWriter__VTable {
    VirtualInvokeData AddResource;
    VirtualInvokeData AddResource_1;
    VirtualInvokeData AddResource_2;
    VirtualInvokeData Close;
    VirtualInvokeData Generate;
};

struct IResourceWriter__StaticFields {
};

struct IResourceWriter__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IResourceWriter__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IResourceWriter__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum PEFileKinds__Enum : int32_t {
    PEFileKinds__Enum_Dll = 0x00000001,
    PEFileKinds__Enum_ConsoleApplication = 0x00000002,
    PEFileKinds__Enum_WindowApplication = 0x00000003,
};

#else
enum PEFileKinds__Enum {
    PEFileKinds__Enum_Dll = 0x00000001,
    PEFileKinds__Enum_ConsoleApplication = 0x00000002,
    PEFileKinds__Enum_WindowApplication = 0x00000003,
};

#endif
struct PEFileKinds__Enum__Boxed {
    struct PEFileKinds__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum PEFileKinds__Enum value;
    #else
    uint32_t value;
    #endif
};

struct PEFileKinds__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct PEFileKinds__Enum__StaticFields {
};

struct PEFileKinds__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PEFileKinds__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PEFileKinds__Enum__VTable vtable;
};

struct __declspec(align(8)) ConstructorBuilder__Fields {
    bool _InitLocals_k__BackingField;
};

struct ConstructorBuilder {
    struct ConstructorBuilder__Class *klass;
    MonitorData *monitor;
    struct ConstructorBuilder__Fields fields;
};

struct ConstructorBuilder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData Equals_2;
    VirtualInvokeData GetCustomAttributes_6;
    VirtualInvokeData GetCustomAttributes_7;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData GetMethodImplementationFlags;
    VirtualInvokeData GetParameters;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_Invoke;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetType;
    VirtualInvokeData Invoke;
    VirtualInvokeData Invoke_1;
    VirtualInvokeData IsDefined_3;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_CallingConvention;
    VirtualInvokeData get_DeclaringType_2;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsAbstract;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsAssembly;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsConstructor;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFamily;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFamilyAndAssembly;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFamilyOrAssembly;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFinal;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsHideBySig;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsPrivate;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsPublic;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsSpecialName;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsStatic;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsVirtual;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_MethodHandle;
    VirtualInvokeData get_Name_2;
    VirtualInvokeData get_ReflectedType_2;
    VirtualInvokeData GetParametersNoCopy;
    VirtualInvokeData GetParameters_1;
    VirtualInvokeData get_MethodImplementationFlags;
    VirtualInvokeData GetMethodImplementationFlags_1;
    VirtualInvokeData get_MethodHandle_1;
    VirtualInvokeData get_Attributes_1;
    VirtualInvokeData Invoke_2;
    VirtualInvokeData get_CallingConvention_1;
    VirtualInvokeData GetGenericArguments;
    VirtualInvokeData get_IsGenericMethodDefinition;
    VirtualInvokeData get_ContainsGenericParameters;
    VirtualInvokeData get_IsGenericMethod;
    VirtualInvokeData get_IsSecurityCritical;
    VirtualInvokeData get_IsSecuritySafeCritical;
    VirtualInvokeData get_IsSecurityTransparent;
    VirtualInvokeData get_IsPublic;
    VirtualInvokeData get_IsPrivate;
    VirtualInvokeData get_IsFamily;
    VirtualInvokeData get_IsAssembly;
    VirtualInvokeData get_IsFamilyAndAssembly;
    VirtualInvokeData get_IsFamilyOrAssembly;
    VirtualInvokeData get_IsStatic;
    VirtualInvokeData get_IsFinal;
    VirtualInvokeData get_IsVirtual;
    VirtualInvokeData get_IsHideBySig;
    VirtualInvokeData get_IsAbstract;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_IsConstructor;
    VirtualInvokeData GetMethodBody;
    VirtualInvokeData FormatNameAndSig;
    VirtualInvokeData GetParameterTypes;
    VirtualInvokeData GetParametersInternal;
    VirtualInvokeData GetParametersCount;
    VirtualInvokeData GetParameterType;
    VirtualInvokeData get_next_table_index;
    VirtualInvokeData Equals_3;
    VirtualInvokeData GetCustomAttributes_8;
    VirtualInvokeData GetCustomAttributes_9;
    VirtualInvokeData GetHashCode_3;
    VirtualInvokeData GetMethodImplementationFlags_2;
    VirtualInvokeData GetParameters_2;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_Invoke;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_GetType;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_Invoke_5;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_Invoke_3;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_Invoke_4;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorInfo_Invoke_2;
    VirtualInvokeData IsDefined_4;
    VirtualInvokeData ToString_3;
    VirtualInvokeData get_Attributes_2;
    VirtualInvokeData get_CallingConvention_2;
    VirtualInvokeData get_DeclaringType_3;
    VirtualInvokeData get_IsAbstract_1;
    VirtualInvokeData get_IsAssembly_1;
    VirtualInvokeData get_IsConstructor_1;
    VirtualInvokeData get_IsFamily_1;
    VirtualInvokeData get_IsFamilyAndAssembly_1;
    VirtualInvokeData get_IsFamilyOrAssembly_1;
    VirtualInvokeData get_IsFinal_1;
    VirtualInvokeData get_IsHideBySig_1;
    VirtualInvokeData get_IsPrivate_1;
    VirtualInvokeData get_IsPublic_1;
    VirtualInvokeData get_IsSpecialName_1;
    VirtualInvokeData get_IsStatic_1;
    VirtualInvokeData get_IsVirtual_1;
    VirtualInvokeData get_MemberType_3;
    VirtualInvokeData get_MethodHandle_2;
    VirtualInvokeData get_Name_3;
    VirtualInvokeData get_ReflectedType_3;
    VirtualInvokeData Invoke_3;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorBuilder_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorBuilder_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorBuilder_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__ConstructorBuilder_Invoke;
};

struct ConstructorBuilder__StaticFields {
};

struct ConstructorBuilder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ConstructorBuilder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ConstructorBuilder__VTable vtable;
};

struct ParameterBuilder {
    struct ParameterBuilder__Class *klass;
    MonitorData *monitor;
};

struct ParameterToken {
};

struct ParameterToken__Boxed {
    struct ParameterToken__Class *klass;
    MonitorData *monitor;
    struct ParameterToken fields;
};

struct UnmanagedMarshal {
    struct UnmanagedMarshal__Class *klass;
    MonitorData *monitor;
};

struct ParameterToken__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct ParameterToken__StaticFields {
    struct ParameterToken Empty;
};

struct ParameterToken__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ParameterToken__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ParameterToken__VTable vtable;
};

struct UnmanagedMarshal__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct UnmanagedMarshal__StaticFields {
};

struct UnmanagedMarshal__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct UnmanagedMarshal__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct UnmanagedMarshal__VTable vtable;
};

struct ParameterBuilder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__ParameterBuilder_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__ParameterBuilder_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__ParameterBuilder_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__ParameterBuilder_Invoke;
    VirtualInvokeData SetConstant;
    VirtualInvokeData GetToken;
    VirtualInvokeData SetMarshal;
};

struct ParameterBuilder__StaticFields {
};

struct ParameterBuilder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ParameterBuilder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ParameterBuilder__VTable vtable;
};

struct ILGenerator {
    struct ILGenerator__Class *klass;
    MonitorData *monitor;
};

struct Label {
    int32_t label;
};

struct Label__Boxed {
    struct Label__Class *klass;
    MonitorData *monitor;
    struct Label fields;
};

struct LocalBuilder__Fields {
    struct LocalVariableInfo__Fields _;
    struct String *name;
    struct ILGenerator *ilgen;
    int32_t startOffset;
    int32_t endOffset;
};

struct LocalBuilder {
    struct LocalBuilder__Class *klass;
    MonitorData *monitor;
    struct LocalBuilder__Fields fields;
};

struct OpCode {
    uint8_t op1;
    uint8_t op2;
    uint8_t push;
    uint8_t pop;
    uint8_t size;
    uint8_t type;
    uint8_t args;
    uint8_t flow;
};

struct OpCode__Boxed {
    struct OpCode__Class *klass;
    MonitorData *monitor;
    struct OpCode fields;
};

struct Label__Array {
    struct Label__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Label vector[32];
};

struct SignatureHelper {
    struct SignatureHelper__Class *klass;
    MonitorData *monitor;
};

#if defined(_CPLUSPLUS_)
enum CallingConvention__Enum : int32_t {
    CallingConvention__Enum_Winapi = 0x00000001,
    CallingConvention__Enum_Cdecl = 0x00000002,
    CallingConvention__Enum_StdCall = 0x00000003,
    CallingConvention__Enum_ThisCall = 0x00000004,
    CallingConvention__Enum_FastCall = 0x00000005,
};

#else
enum CallingConvention__Enum {
    CallingConvention__Enum_Winapi = 0x00000001,
    CallingConvention__Enum_Cdecl = 0x00000002,
    CallingConvention__Enum_StdCall = 0x00000003,
    CallingConvention__Enum_ThisCall = 0x00000004,
    CallingConvention__Enum_FastCall = 0x00000005,
};

#endif
struct CallingConvention__Enum__Boxed {
    struct CallingConvention__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum CallingConvention__Enum value;
    #else
    uint32_t value;
    #endif
};

struct ISymbolDocumentWriter {
    struct ISymbolDocumentWriter__Class *klass;
    MonitorData *monitor;
};

struct Label__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Label__StaticFields {
};

struct Label__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Label__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Label__VTable vtable;
};

struct LocalBuilder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_IsPinned;
    VirtualInvokeData get_LocalIndex;
    VirtualInvokeData get_LocalType;
    VirtualInvokeData System_Runtime_InteropServices__LocalBuilder_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__LocalBuilder_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__LocalBuilder_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__LocalBuilder_Invoke;
};

struct LocalBuilder__StaticFields {
};

struct LocalBuilder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct LocalBuilder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct LocalBuilder__VTable vtable;
};

struct OpCode__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct OpCode__StaticFields {
};

struct OpCode__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct OpCode__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct OpCode__VTable vtable;
};

struct Label__Array__VTable {
};

struct Label__Array__StaticFields {
};

struct Label__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Label__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Label__Array__VTable vtable;
};

struct SignatureHelper__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__SignatureHelper_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__SignatureHelper_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__SignatureHelper_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__SignatureHelper_Invoke;
};

struct SignatureHelper__StaticFields {
};

struct SignatureHelper__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SignatureHelper__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SignatureHelper__VTable vtable;
};

struct CallingConvention__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct CallingConvention__Enum__StaticFields {
};

struct CallingConvention__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct CallingConvention__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct CallingConvention__Enum__VTable vtable;
};

struct ISymbolDocumentWriter__VTable {
    VirtualInvokeData SetCheckSum;
    VirtualInvokeData SetSource;
};

struct ISymbolDocumentWriter__StaticFields {
};

struct ISymbolDocumentWriter__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ISymbolDocumentWriter__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ISymbolDocumentWriter__VTable vtable;
};

struct ILGenerator__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__ILGenerator_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__ILGenerator_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__ILGenerator_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__ILGenerator_Invoke;
    VirtualInvokeData BeginCatchBlock;
    VirtualInvokeData BeginExceptFilterBlock;
    VirtualInvokeData BeginExceptionBlock;
    VirtualInvokeData BeginFaultBlock;
    VirtualInvokeData BeginFinallyBlock;
    VirtualInvokeData BeginScope;
    VirtualInvokeData DeclareLocal;
    VirtualInvokeData DeclareLocal_1;
    VirtualInvokeData DefineLabel;
    VirtualInvokeData Emit;
    VirtualInvokeData Emit_1;
    VirtualInvokeData Emit_2;
    VirtualInvokeData Emit_3;
    VirtualInvokeData Emit_4;
    VirtualInvokeData Emit_5;
    VirtualInvokeData Emit_6;
    VirtualInvokeData Emit_7;
    VirtualInvokeData Emit_8;
    VirtualInvokeData Emit_9;
    VirtualInvokeData Emit_10;
    VirtualInvokeData Emit_11;
    VirtualInvokeData Emit_12;
    VirtualInvokeData Emit_13;
    VirtualInvokeData Emit_14;
    VirtualInvokeData Emit_15;
    VirtualInvokeData EmitCall;
    VirtualInvokeData EmitCalli;
    VirtualInvokeData EmitWriteLine;
    VirtualInvokeData EmitWriteLine_1;
    VirtualInvokeData EmitWriteLine_2;
    VirtualInvokeData EndExceptionBlock;
    VirtualInvokeData EndScope;
    VirtualInvokeData MarkLabel;
    VirtualInvokeData ThrowException;
    VirtualInvokeData UsingNamespace;
    VirtualInvokeData EmitCalli_1;
    VirtualInvokeData MarkSequencePoint;
};

struct ILGenerator__StaticFields {
};

struct ILGenerator__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ILGenerator__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ILGenerator__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum SecurityAction__Enum : int32_t {
    SecurityAction__Enum_Demand = 0x00000002,
    SecurityAction__Enum_Assert = 0x00000003,
    SecurityAction__Enum_Deny = 0x00000004,
    SecurityAction__Enum_PermitOnly = 0x00000005,
    SecurityAction__Enum_LinkDemand = 0x00000006,
    SecurityAction__Enum_InheritanceDemand = 0x00000007,
    SecurityAction__Enum_RequestMinimum = 0x00000008,
    SecurityAction__Enum_RequestOptional = 0x00000009,
    SecurityAction__Enum_RequestRefuse = 0x0000000a,
};

#else
enum SecurityAction__Enum {
    SecurityAction__Enum_Demand = 0x00000002,
    SecurityAction__Enum_Assert = 0x00000003,
    SecurityAction__Enum_Deny = 0x00000004,
    SecurityAction__Enum_PermitOnly = 0x00000005,
    SecurityAction__Enum_LinkDemand = 0x00000006,
    SecurityAction__Enum_InheritanceDemand = 0x00000007,
    SecurityAction__Enum_RequestMinimum = 0x00000008,
    SecurityAction__Enum_RequestOptional = 0x00000009,
    SecurityAction__Enum_RequestRefuse = 0x0000000a,
};

#endif
struct SecurityAction__Enum__Boxed {
    struct SecurityAction__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum SecurityAction__Enum value;
    #else
    uint32_t value;
    #endif
};

struct SecurityAction__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct SecurityAction__Enum__StaticFields {
};

struct SecurityAction__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SecurityAction__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SecurityAction__Enum__VTable vtable;
};

struct MethodToken {
};

struct MethodToken__Boxed {
    struct MethodToken__Class *klass;
    MonitorData *monitor;
    struct MethodToken fields;
};

struct MethodToken__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct MethodToken__StaticFields {
    struct MethodToken Empty;
};

struct MethodToken__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MethodToken__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MethodToken__VTable vtable;
};

struct IEnumerable_1_System_Reflection_Emit_ExceptionHandler_ {
    struct IEnumerable_1_System_Reflection_Emit_ExceptionHandler___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_Reflection_Emit_ExceptionHandler___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_Reflection_Emit_ExceptionHandler___StaticFields {
};

struct IEnumerable_1_System_Reflection_Emit_ExceptionHandler___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_Reflection_Emit_ExceptionHandler___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_Reflection_Emit_ExceptionHandler___VTable vtable;
};

struct EnumBuilder__Fields {
    struct TypeInfo__Fields _;
};

struct EnumBuilder {
    struct EnumBuilder__Class *klass;
    MonitorData *monitor;
    struct EnumBuilder__Fields fields;
};

struct FieldBuilder {
    struct FieldBuilder__Class *klass;
    MonitorData *monitor;
};

struct EnumBuilder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData Equals_2;
    VirtualInvokeData Equals_3;
    VirtualInvokeData FindInterfaces;
    VirtualInvokeData FindMembers;
    VirtualInvokeData GetArrayRank;
    VirtualInvokeData GetConstructor;
    VirtualInvokeData GetConstructor_1;
    VirtualInvokeData GetConstructor_2;
    VirtualInvokeData GetConstructors;
    VirtualInvokeData GetConstructors_1;
    VirtualInvokeData GetCustomAttributes_6;
    VirtualInvokeData GetCustomAttributes_7;
    VirtualInvokeData GetDefaultMembers;
    VirtualInvokeData GetElementType;
    VirtualInvokeData GetEvent;
    VirtualInvokeData GetEvent_1;
    VirtualInvokeData GetEvents;
    VirtualInvokeData GetEvents_1;
    VirtualInvokeData GetField;
    VirtualInvokeData GetField_1;
    VirtualInvokeData GetFields;
    VirtualInvokeData GetFields_1;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Type_Invoke;
    VirtualInvokeData GetInterface;
    VirtualInvokeData GetInterface_1;
    VirtualInvokeData GetInterfaceMap;
    VirtualInvokeData GetInterfaces;
    VirtualInvokeData GetMember;
    VirtualInvokeData GetMember_1;
    VirtualInvokeData GetMember_2;
    VirtualInvokeData GetMembers;
    VirtualInvokeData GetMembers_1;
    VirtualInvokeData GetMethod;
    VirtualInvokeData GetMethod_1;
    VirtualInvokeData GetMethod_2;
    VirtualInvokeData GetMethod_3;
    VirtualInvokeData GetMethod_4;
    VirtualInvokeData GetMethod_5;
    VirtualInvokeData GetMethods;
    VirtualInvokeData GetMethods_1;
    VirtualInvokeData GetNestedType;
    VirtualInvokeData GetNestedType_1;
    VirtualInvokeData GetNestedTypes;
    VirtualInvokeData GetNestedTypes_1;
    VirtualInvokeData GetProperties;
    VirtualInvokeData GetProperties_1;
    VirtualInvokeData GetProperty;
    VirtualInvokeData GetProperty_1;
    VirtualInvokeData GetProperty_2;
    VirtualInvokeData GetProperty_3;
    VirtualInvokeData GetProperty_4;
    VirtualInvokeData GetProperty_5;
    VirtualInvokeData GetProperty_6;
    VirtualInvokeData GetType;
    VirtualInvokeData InvokeMember;
    VirtualInvokeData InvokeMember_1;
    VirtualInvokeData InvokeMember_2;
    VirtualInvokeData IsAssignableFrom;
    VirtualInvokeData IsDefined_3;
    VirtualInvokeData IsInstanceOfType;
    VirtualInvokeData IsSubclassOf;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Assembly;
    VirtualInvokeData get_AssemblyQualifiedName;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_BaseType;
    VirtualInvokeData get_DeclaringType_2;
    VirtualInvokeData get_FullName;
    VirtualInvokeData get_GUID;
    VirtualInvokeData get_HasElementType;
    VirtualInvokeData get_IsAbstract;
    VirtualInvokeData get_IsAnsiClass;
    VirtualInvokeData get_IsArray;
    VirtualInvokeData get_IsAutoClass;
    VirtualInvokeData get_IsAutoLayout;
    VirtualInvokeData get_IsByRef;
    VirtualInvokeData get_IsClass;
    VirtualInvokeData get_IsCOMObject;
    VirtualInvokeData get_IsContextful;
    VirtualInvokeData get_IsEnum;
    VirtualInvokeData get_IsExplicitLayout;
    VirtualInvokeData get_IsImport;
    VirtualInvokeData get_IsInterface;
    VirtualInvokeData get_IsLayoutSequential;
    VirtualInvokeData get_IsMarshalByRef;
    VirtualInvokeData get_IsNestedAssembly;
    VirtualInvokeData get_IsNestedFamANDAssem;
    VirtualInvokeData get_IsNestedFamily;
    VirtualInvokeData get_IsNestedFamORAssem;
    VirtualInvokeData get_IsNestedPrivate;
    VirtualInvokeData get_IsNestedPublic;
    VirtualInvokeData get_IsNotPublic;
    VirtualInvokeData get_IsPointer;
    VirtualInvokeData get_IsPrimitive;
    VirtualInvokeData get_IsPublic;
    VirtualInvokeData get_IsSealed;
    VirtualInvokeData get_IsSerializable;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_IsUnicodeClass;
    VirtualInvokeData get_IsValueType;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_Module_1;
    VirtualInvokeData get_Name_2;
    VirtualInvokeData get_Namespace;
    VirtualInvokeData get_ReflectedType_2;
    VirtualInvokeData get_TypeHandle;
    VirtualInvokeData get_TypeInitializer;
    VirtualInvokeData get_UnderlyingSystemType;
    VirtualInvokeData GetMethod_6;
    VirtualInvokeData GetMethod_7;
    VirtualInvokeData GetMethods_2;
    VirtualInvokeData GetField_2;
    VirtualInvokeData GetFields_2;
    VirtualInvokeData GetProperty_7;
    VirtualInvokeData GetProperty_8;
    VirtualInvokeData GetProperties_2;
    VirtualInvokeData GetMember_3;
    VirtualInvokeData GetMembers_2;
    VirtualInvokeData InvokeMember_3;
    VirtualInvokeData get_UnderlyingSystemType_1;
    VirtualInvokeData get_DeclaringMethod;
    VirtualInvokeData MakePointerType;
    VirtualInvokeData get_StructLayoutAttribute;
    VirtualInvokeData MakeByRefType;
    VirtualInvokeData MakeArrayType;
    VirtualInvokeData MakeArrayType_1;
    VirtualInvokeData GetTypeCodeImpl;
    VirtualInvokeData get_GUID_1;
    VirtualInvokeData InvokeMember_4;
    VirtualInvokeData get_Assembly_1;
    VirtualInvokeData get_TypeHandle_1;
    VirtualInvokeData GetTypeHandleInternal;
    VirtualInvokeData get_FullName_1;
    VirtualInvokeData get_Namespace_1;
    VirtualInvokeData get_AssemblyQualifiedName_1;
    VirtualInvokeData GetArrayRank_1;
    VirtualInvokeData get_BaseType_1;
    VirtualInvokeData GetConstructorImpl;
    VirtualInvokeData GetConstructors_2;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetMethods_3;
    VirtualInvokeData GetField_3;
    VirtualInvokeData GetFields_3;
    VirtualInvokeData GetInterface_2;
    VirtualInvokeData GetInterfaces_1;
    VirtualInvokeData FindInterfaces_1;
    VirtualInvokeData GetEvent_2;
    VirtualInvokeData GetEvents_2;
    VirtualInvokeData GetEvents_3;
    VirtualInvokeData GetPropertyImpl;
    VirtualInvokeData GetProperties_3;
    VirtualInvokeData GetNestedTypes_2;
    VirtualInvokeData GetNestedType_2;
    VirtualInvokeData GetMember_4;
    VirtualInvokeData GetMember_5;
    VirtualInvokeData GetMembers_3;
    VirtualInvokeData GetDefaultMembers_1;
    VirtualInvokeData FindMembers_1;
    VirtualInvokeData get_GenericParameterAttributes;
    VirtualInvokeData get_IsEnum_1;
    VirtualInvokeData get_IsSerializable_1;
    VirtualInvokeData get_IsSzArray;
    VirtualInvokeData get_IsGenericType;
    VirtualInvokeData get_IsGenericTypeDefinition;
    VirtualInvokeData get_IsConstructedGenericType;
    VirtualInvokeData get_IsGenericParameter;
    VirtualInvokeData get_GenericParameterPosition;
    VirtualInvokeData get_ContainsGenericParameters;
    VirtualInvokeData GetGenericParameterConstraints;
    VirtualInvokeData IsValueTypeImpl;
    VirtualInvokeData GetAttributeFlagsImpl;
    VirtualInvokeData IsArrayImpl;
    VirtualInvokeData IsByRefImpl;
    VirtualInvokeData IsPointerImpl;
    VirtualInvokeData IsPrimitiveImpl;
    VirtualInvokeData IsCOMObjectImpl;
    VirtualInvokeData IsWindowsRuntimeObjectImpl;
    VirtualInvokeData IsExportedToWindowsRuntimeImpl;
    VirtualInvokeData MakeGenericType;
    VirtualInvokeData IsContextfulImpl;
    VirtualInvokeData IsMarshalByRefImpl;
    VirtualInvokeData HasProxyAttributeImpl;
    VirtualInvokeData GetElementType_1;
    VirtualInvokeData GetGenericArguments;
    VirtualInvokeData get_GenericTypeArguments;
    VirtualInvokeData GetGenericTypeDefinition;
    VirtualInvokeData HasElementTypeImpl;
    VirtualInvokeData GetEnumNames;
    VirtualInvokeData GetEnumValues;
    VirtualInvokeData GetEnumUnderlyingType;
    VirtualInvokeData IsEnumDefined;
    VirtualInvokeData GetEnumName;
    VirtualInvokeData get_IsSecurityCritical;
    VirtualInvokeData get_IsSecuritySafeCritical;
    VirtualInvokeData get_IsSecurityTransparent;
    VirtualInvokeData get_UnderlyingSystemType_2;
    VirtualInvokeData IsSubclassOf_1;
    VirtualInvokeData IsInstanceOfType_1;
    VirtualInvokeData IsAssignableFrom_1;
    VirtualInvokeData IsEquivalentTo;
    VirtualInvokeData FormatTypeName;
    VirtualInvokeData Equals_4;
    VirtualInvokeData GetInterfaceMap_1;
    VirtualInvokeData get_IsSZArray;
    VirtualInvokeData InternalResolve;
    VirtualInvokeData RuntimeResolve;
    VirtualInvokeData get_IsUserType;
    VirtualInvokeData GetMethod_8;
    VirtualInvokeData GetConstructor_3;
    VirtualInvokeData GetField_4;
    VirtualInvokeData System_Reflection_IReflectableType_GetTypeInfo;
    VirtualInvokeData AsType;
    VirtualInvokeData get_GenericTypeParameters;
    VirtualInvokeData IsAssignableFrom_2;
    VirtualInvokeData GetDeclaredEvent;
    VirtualInvokeData GetDeclaredField;
    VirtualInvokeData GetDeclaredMethod;
    VirtualInvokeData GetDeclaredMethods;
    VirtualInvokeData GetDeclaredNestedType;
    VirtualInvokeData GetDeclaredProperty;
    VirtualInvokeData get_DeclaredConstructors;
    VirtualInvokeData get_DeclaredEvents;
    VirtualInvokeData get_DeclaredFields;
    VirtualInvokeData get_DeclaredMembers;
    VirtualInvokeData get_DeclaredMethods;
    VirtualInvokeData get_DeclaredNestedTypes;
    VirtualInvokeData get_DeclaredProperties;
    VirtualInvokeData get_ImplementedInterfaces;
    VirtualInvokeData System_Runtime_InteropServices__EnumBuilder_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__EnumBuilder_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__EnumBuilder_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__EnumBuilder_Invoke;
};

struct EnumBuilder__StaticFields {
};

struct EnumBuilder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EnumBuilder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EnumBuilder__VTable vtable;
};

struct FieldBuilder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData Equals_2;
    VirtualInvokeData GetCustomAttributes_6;
    VirtualInvokeData GetCustomAttributes_7;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData System_Runtime_InteropServices__FieldInfo_GetType;
    VirtualInvokeData System_Runtime_InteropServices__FieldInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__FieldInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__FieldInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__FieldInfo_Invoke;
    VirtualInvokeData GetValue;
    VirtualInvokeData GetValueDirect;
    VirtualInvokeData IsDefined_3;
    VirtualInvokeData SetValue;
    VirtualInvokeData SetValue_1;
    VirtualInvokeData SetValueDirect;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_DeclaringType_2;
    VirtualInvokeData get_FieldHandle;
    VirtualInvokeData get_FieldType;
    VirtualInvokeData get_IsAssembly;
    VirtualInvokeData get_IsFamily;
    VirtualInvokeData get_IsFamilyAndAssembly;
    VirtualInvokeData get_IsFamilyOrAssembly;
    VirtualInvokeData get_IsInitOnly;
    VirtualInvokeData get_IsLiteral;
    VirtualInvokeData get_IsNotSerialized;
    VirtualInvokeData get_IsPinvokeImpl;
    VirtualInvokeData get_IsPrivate;
    VirtualInvokeData get_IsPublic;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_IsStatic;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_Name_2;
    VirtualInvokeData get_ReflectedType_2;
    VirtualInvokeData get_Attributes_1;
    VirtualInvokeData get_FieldHandle_1;
    VirtualInvokeData get_FieldType_1;
    VirtualInvokeData GetValue_1;
    VirtualInvokeData SetValue_2;
    VirtualInvokeData GetFieldOffset;
    VirtualInvokeData GetValueDirect_1;
    VirtualInvokeData SetValueDirect_1;
    VirtualInvokeData GetOptionalCustomModifiers;
    VirtualInvokeData GetRequiredCustomModifiers;
    VirtualInvokeData GetRawConstantValue;
    VirtualInvokeData get_IsSecurityCritical;
    VirtualInvokeData get_IsSecuritySafeCritical;
    VirtualInvokeData get_IsSecurityTransparent;
    VirtualInvokeData System_Runtime_InteropServices__FieldBuilder_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__FieldBuilder_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__FieldBuilder_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__FieldBuilder_Invoke;
};

struct FieldBuilder__StaticFields {
};

struct FieldBuilder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FieldBuilder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FieldBuilder__VTable vtable;
};

struct TypeToken {
};

struct TypeToken__Boxed {
    struct TypeToken__Class *klass;
    MonitorData *monitor;
    struct TypeToken fields;
};

struct TypeToken__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct TypeToken__StaticFields {
    struct TypeToken Empty;
};

struct TypeToken__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeToken__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeToken__VTable vtable;
};

struct EventBuilder {
    struct EventBuilder__Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) MethodBuilder__Fields {
    bool _InitLocals_k__BackingField;
};

struct MethodBuilder {
    struct MethodBuilder__Class *klass;
    MonitorData *monitor;
    struct MethodBuilder__Fields fields;
};

struct EventBuilder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Runtime_InteropServices__EventBuilder_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__EventBuilder_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__EventBuilder_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__EventBuilder_Invoke;
};

struct EventBuilder__StaticFields {
};

struct EventBuilder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EventBuilder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EventBuilder__VTable vtable;
};

struct MethodBuilder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData Equals_2;
    VirtualInvokeData GetCustomAttributes_6;
    VirtualInvokeData GetCustomAttributes_7;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData GetMethodImplementationFlags;
    VirtualInvokeData GetParameters;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_Invoke;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_GetType;
    VirtualInvokeData Invoke;
    VirtualInvokeData Invoke_1;
    VirtualInvokeData IsDefined_3;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_CallingConvention;
    VirtualInvokeData get_DeclaringType_2;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsAbstract;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsAssembly;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsConstructor;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFamily;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFamilyAndAssembly;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFamilyOrAssembly;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsFinal;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsHideBySig;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsPrivate;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsPublic;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsSpecialName;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsStatic;
    VirtualInvokeData System_Runtime_InteropServices__MethodBase_get_IsVirtual;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_MethodHandle;
    VirtualInvokeData get_Name_2;
    VirtualInvokeData get_ReflectedType_2;
    VirtualInvokeData GetParametersNoCopy;
    VirtualInvokeData GetParameters_1;
    VirtualInvokeData get_MethodImplementationFlags;
    VirtualInvokeData GetMethodImplementationFlags_1;
    VirtualInvokeData get_MethodHandle_1;
    VirtualInvokeData get_Attributes_1;
    VirtualInvokeData Invoke_2;
    VirtualInvokeData get_CallingConvention_1;
    VirtualInvokeData GetGenericArguments;
    VirtualInvokeData get_IsGenericMethodDefinition;
    VirtualInvokeData get_ContainsGenericParameters;
    VirtualInvokeData get_IsGenericMethod;
    VirtualInvokeData get_IsSecurityCritical;
    VirtualInvokeData get_IsSecuritySafeCritical;
    VirtualInvokeData get_IsSecurityTransparent;
    VirtualInvokeData get_IsPublic;
    VirtualInvokeData get_IsPrivate;
    VirtualInvokeData get_IsFamily;
    VirtualInvokeData get_IsAssembly;
    VirtualInvokeData get_IsFamilyAndAssembly;
    VirtualInvokeData get_IsFamilyOrAssembly;
    VirtualInvokeData get_IsStatic;
    VirtualInvokeData get_IsFinal;
    VirtualInvokeData get_IsVirtual;
    VirtualInvokeData get_IsHideBySig;
    VirtualInvokeData get_IsAbstract;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_IsConstructor;
    VirtualInvokeData GetMethodBody;
    VirtualInvokeData FormatNameAndSig;
    VirtualInvokeData GetParameterTypes;
    VirtualInvokeData GetParametersInternal;
    VirtualInvokeData GetParametersCount;
    VirtualInvokeData GetParameterType;
    VirtualInvokeData get_next_table_index;
    VirtualInvokeData Equals_3;
    VirtualInvokeData GetBaseDefinition;
    VirtualInvokeData GetCustomAttributes_8;
    VirtualInvokeData GetCustomAttributes_9;
    VirtualInvokeData GetHashCode_3;
    VirtualInvokeData GetMethodImplementationFlags_2;
    VirtualInvokeData GetParameters_2;
    VirtualInvokeData System_Runtime_InteropServices__MethodInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MethodInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MethodInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MethodInfo_Invoke;
    VirtualInvokeData System_Runtime_InteropServices__MethodInfo_GetType;
    VirtualInvokeData Invoke_3;
    VirtualInvokeData Invoke_4;
    VirtualInvokeData IsDefined_4;
    VirtualInvokeData ToString_3;
    VirtualInvokeData get_Attributes_2;
    VirtualInvokeData get_CallingConvention_2;
    VirtualInvokeData get_DeclaringType_3;
    VirtualInvokeData get_IsAbstract_1;
    VirtualInvokeData get_IsAssembly_1;
    VirtualInvokeData get_IsConstructor_1;
    VirtualInvokeData get_IsFamily_1;
    VirtualInvokeData get_IsFamilyAndAssembly_1;
    VirtualInvokeData get_IsFamilyOrAssembly_1;
    VirtualInvokeData get_IsFinal_1;
    VirtualInvokeData get_IsHideBySig_1;
    VirtualInvokeData get_IsPrivate_1;
    VirtualInvokeData get_IsPublic_1;
    VirtualInvokeData get_IsSpecialName_1;
    VirtualInvokeData get_IsStatic_1;
    VirtualInvokeData get_IsVirtual_1;
    VirtualInvokeData get_MemberType_3;
    VirtualInvokeData get_MethodHandle_2;
    VirtualInvokeData get_Name_3;
    VirtualInvokeData get_ReflectedType_3;
    VirtualInvokeData get_ReturnType;
    VirtualInvokeData get_ReturnTypeCustomAttributes;
    VirtualInvokeData get_ReturnType_1;
    VirtualInvokeData get_ReturnParameter;
    VirtualInvokeData get_ReturnTypeCustomAttributes_1;
    VirtualInvokeData GetBaseDefinition_1;
    VirtualInvokeData GetGenericMethodDefinition;
    VirtualInvokeData MakeGenericMethod;
    VirtualInvokeData CreateDelegate;
    VirtualInvokeData CreateDelegate_1;
    VirtualInvokeData GetBaseMethod;
    VirtualInvokeData System_Runtime_InteropServices__MethodBuilder_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MethodBuilder_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MethodBuilder_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MethodBuilder_Invoke;
};

struct MethodBuilder__StaticFields {
};

struct MethodBuilder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MethodBuilder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MethodBuilder__VTable vtable;
};

struct EventToken {
};

struct EventToken__Boxed {
    struct EventToken__Class *klass;
    MonitorData *monitor;
    struct EventToken fields;
};

struct EventToken__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct EventToken__StaticFields {
    struct EventToken Empty;
};

struct EventToken__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EventToken__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EventToken__VTable vtable;
};

struct FieldToken {
};

struct FieldToken__Boxed {
    struct FieldToken__Class *klass;
    MonitorData *monitor;
    struct FieldToken fields;
};

struct FieldToken__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct FieldToken__StaticFields {
    struct FieldToken Empty;
};

struct FieldToken__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FieldToken__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FieldToken__VTable vtable;
};

struct GenericTypeParameterBuilder__Fields {
    struct TypeInfo__Fields _;
};

struct GenericTypeParameterBuilder {
    struct GenericTypeParameterBuilder__Class *klass;
    MonitorData *monitor;
    struct GenericTypeParameterBuilder__Fields fields;
};

struct GenericTypeParameterBuilder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData Equals_2;
    VirtualInvokeData Equals_3;
    VirtualInvokeData FindInterfaces;
    VirtualInvokeData FindMembers;
    VirtualInvokeData GetArrayRank;
    VirtualInvokeData GetConstructor;
    VirtualInvokeData GetConstructor_1;
    VirtualInvokeData GetConstructor_2;
    VirtualInvokeData GetConstructors;
    VirtualInvokeData GetConstructors_1;
    VirtualInvokeData GetCustomAttributes_6;
    VirtualInvokeData GetCustomAttributes_7;
    VirtualInvokeData GetDefaultMembers;
    VirtualInvokeData GetElementType;
    VirtualInvokeData GetEvent;
    VirtualInvokeData GetEvent_1;
    VirtualInvokeData GetEvents;
    VirtualInvokeData GetEvents_1;
    VirtualInvokeData GetField;
    VirtualInvokeData GetField_1;
    VirtualInvokeData GetFields;
    VirtualInvokeData GetFields_1;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Type_Invoke;
    VirtualInvokeData GetInterface;
    VirtualInvokeData GetInterface_1;
    VirtualInvokeData GetInterfaceMap;
    VirtualInvokeData GetInterfaces;
    VirtualInvokeData GetMember;
    VirtualInvokeData GetMember_1;
    VirtualInvokeData GetMember_2;
    VirtualInvokeData GetMembers;
    VirtualInvokeData GetMembers_1;
    VirtualInvokeData GetMethod;
    VirtualInvokeData GetMethod_1;
    VirtualInvokeData GetMethod_2;
    VirtualInvokeData GetMethod_3;
    VirtualInvokeData GetMethod_4;
    VirtualInvokeData GetMethod_5;
    VirtualInvokeData GetMethods;
    VirtualInvokeData GetMethods_1;
    VirtualInvokeData GetNestedType;
    VirtualInvokeData GetNestedType_1;
    VirtualInvokeData GetNestedTypes;
    VirtualInvokeData GetNestedTypes_1;
    VirtualInvokeData GetProperties;
    VirtualInvokeData GetProperties_1;
    VirtualInvokeData GetProperty;
    VirtualInvokeData GetProperty_1;
    VirtualInvokeData GetProperty_2;
    VirtualInvokeData GetProperty_3;
    VirtualInvokeData GetProperty_4;
    VirtualInvokeData GetProperty_5;
    VirtualInvokeData GetProperty_6;
    VirtualInvokeData GetType;
    VirtualInvokeData InvokeMember;
    VirtualInvokeData InvokeMember_1;
    VirtualInvokeData InvokeMember_2;
    VirtualInvokeData IsAssignableFrom;
    VirtualInvokeData IsDefined_3;
    VirtualInvokeData IsInstanceOfType;
    VirtualInvokeData IsSubclassOf;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Assembly;
    VirtualInvokeData get_AssemblyQualifiedName;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_BaseType;
    VirtualInvokeData get_DeclaringType_2;
    VirtualInvokeData get_FullName;
    VirtualInvokeData get_GUID;
    VirtualInvokeData get_HasElementType;
    VirtualInvokeData get_IsAbstract;
    VirtualInvokeData get_IsAnsiClass;
    VirtualInvokeData get_IsArray;
    VirtualInvokeData get_IsAutoClass;
    VirtualInvokeData get_IsAutoLayout;
    VirtualInvokeData get_IsByRef;
    VirtualInvokeData get_IsClass;
    VirtualInvokeData get_IsCOMObject;
    VirtualInvokeData get_IsContextful;
    VirtualInvokeData get_IsEnum;
    VirtualInvokeData get_IsExplicitLayout;
    VirtualInvokeData get_IsImport;
    VirtualInvokeData get_IsInterface;
    VirtualInvokeData get_IsLayoutSequential;
    VirtualInvokeData get_IsMarshalByRef;
    VirtualInvokeData get_IsNestedAssembly;
    VirtualInvokeData get_IsNestedFamANDAssem;
    VirtualInvokeData get_IsNestedFamily;
    VirtualInvokeData get_IsNestedFamORAssem;
    VirtualInvokeData get_IsNestedPrivate;
    VirtualInvokeData get_IsNestedPublic;
    VirtualInvokeData get_IsNotPublic;
    VirtualInvokeData get_IsPointer;
    VirtualInvokeData get_IsPrimitive;
    VirtualInvokeData get_IsPublic;
    VirtualInvokeData get_IsSealed;
    VirtualInvokeData get_IsSerializable;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_IsUnicodeClass;
    VirtualInvokeData get_IsValueType;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_Module_1;
    VirtualInvokeData get_Name_2;
    VirtualInvokeData get_Namespace;
    VirtualInvokeData get_ReflectedType_2;
    VirtualInvokeData get_TypeHandle;
    VirtualInvokeData get_TypeInitializer;
    VirtualInvokeData get_UnderlyingSystemType;
    VirtualInvokeData GetMethod_6;
    VirtualInvokeData GetMethod_7;
    VirtualInvokeData GetMethods_2;
    VirtualInvokeData GetField_2;
    VirtualInvokeData GetFields_2;
    VirtualInvokeData GetProperty_7;
    VirtualInvokeData GetProperty_8;
    VirtualInvokeData GetProperties_2;
    VirtualInvokeData GetMember_3;
    VirtualInvokeData GetMembers_2;
    VirtualInvokeData InvokeMember_3;
    VirtualInvokeData get_UnderlyingSystemType_1;
    VirtualInvokeData get_DeclaringMethod;
    VirtualInvokeData MakePointerType;
    VirtualInvokeData get_StructLayoutAttribute;
    VirtualInvokeData MakeByRefType;
    VirtualInvokeData MakeArrayType;
    VirtualInvokeData MakeArrayType_1;
    VirtualInvokeData GetTypeCodeImpl;
    VirtualInvokeData get_GUID_1;
    VirtualInvokeData InvokeMember_4;
    VirtualInvokeData get_Assembly_1;
    VirtualInvokeData get_TypeHandle_1;
    VirtualInvokeData GetTypeHandleInternal;
    VirtualInvokeData get_FullName_1;
    VirtualInvokeData get_Namespace_1;
    VirtualInvokeData get_AssemblyQualifiedName_1;
    VirtualInvokeData GetArrayRank_1;
    VirtualInvokeData get_BaseType_1;
    VirtualInvokeData GetConstructorImpl;
    VirtualInvokeData GetConstructors_2;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetMethods_3;
    VirtualInvokeData GetField_3;
    VirtualInvokeData GetFields_3;
    VirtualInvokeData GetInterface_2;
    VirtualInvokeData GetInterfaces_1;
    VirtualInvokeData FindInterfaces_1;
    VirtualInvokeData GetEvent_2;
    VirtualInvokeData GetEvents_2;
    VirtualInvokeData GetEvents_3;
    VirtualInvokeData GetPropertyImpl;
    VirtualInvokeData GetProperties_3;
    VirtualInvokeData GetNestedTypes_2;
    VirtualInvokeData GetNestedType_2;
    VirtualInvokeData GetMember_4;
    VirtualInvokeData GetMember_5;
    VirtualInvokeData GetMembers_3;
    VirtualInvokeData GetDefaultMembers_1;
    VirtualInvokeData FindMembers_1;
    VirtualInvokeData get_GenericParameterAttributes;
    VirtualInvokeData get_IsEnum_1;
    VirtualInvokeData get_IsSerializable_1;
    VirtualInvokeData get_IsSzArray;
    VirtualInvokeData get_IsGenericType;
    VirtualInvokeData get_IsGenericTypeDefinition;
    VirtualInvokeData get_IsConstructedGenericType;
    VirtualInvokeData get_IsGenericParameter;
    VirtualInvokeData get_GenericParameterPosition;
    VirtualInvokeData get_ContainsGenericParameters;
    VirtualInvokeData GetGenericParameterConstraints;
    VirtualInvokeData IsValueTypeImpl;
    VirtualInvokeData GetAttributeFlagsImpl;
    VirtualInvokeData IsArrayImpl;
    VirtualInvokeData IsByRefImpl;
    VirtualInvokeData IsPointerImpl;
    VirtualInvokeData IsPrimitiveImpl;
    VirtualInvokeData IsCOMObjectImpl;
    VirtualInvokeData IsWindowsRuntimeObjectImpl;
    VirtualInvokeData IsExportedToWindowsRuntimeImpl;
    VirtualInvokeData MakeGenericType;
    VirtualInvokeData IsContextfulImpl;
    VirtualInvokeData IsMarshalByRefImpl;
    VirtualInvokeData HasProxyAttributeImpl;
    VirtualInvokeData GetElementType_1;
    VirtualInvokeData GetGenericArguments;
    VirtualInvokeData get_GenericTypeArguments;
    VirtualInvokeData GetGenericTypeDefinition;
    VirtualInvokeData HasElementTypeImpl;
    VirtualInvokeData GetEnumNames;
    VirtualInvokeData GetEnumValues;
    VirtualInvokeData GetEnumUnderlyingType;
    VirtualInvokeData IsEnumDefined;
    VirtualInvokeData GetEnumName;
    VirtualInvokeData get_IsSecurityCritical;
    VirtualInvokeData get_IsSecuritySafeCritical;
    VirtualInvokeData get_IsSecurityTransparent;
    VirtualInvokeData get_UnderlyingSystemType_2;
    VirtualInvokeData IsSubclassOf_1;
    VirtualInvokeData IsInstanceOfType_1;
    VirtualInvokeData IsAssignableFrom_1;
    VirtualInvokeData IsEquivalentTo;
    VirtualInvokeData FormatTypeName;
    VirtualInvokeData Equals_4;
    VirtualInvokeData GetInterfaceMap_1;
    VirtualInvokeData get_IsSZArray;
    VirtualInvokeData InternalResolve;
    VirtualInvokeData RuntimeResolve;
    VirtualInvokeData get_IsUserType;
    VirtualInvokeData GetMethod_8;
    VirtualInvokeData GetConstructor_3;
    VirtualInvokeData GetField_4;
    VirtualInvokeData System_Reflection_IReflectableType_GetTypeInfo;
    VirtualInvokeData AsType;
    VirtualInvokeData get_GenericTypeParameters;
    VirtualInvokeData IsAssignableFrom_2;
    VirtualInvokeData GetDeclaredEvent;
    VirtualInvokeData GetDeclaredField;
    VirtualInvokeData GetDeclaredMethod;
    VirtualInvokeData GetDeclaredMethods;
    VirtualInvokeData GetDeclaredNestedType;
    VirtualInvokeData GetDeclaredProperty;
    VirtualInvokeData get_DeclaredConstructors;
    VirtualInvokeData get_DeclaredEvents;
    VirtualInvokeData get_DeclaredFields;
    VirtualInvokeData get_DeclaredMembers;
    VirtualInvokeData get_DeclaredMethods;
    VirtualInvokeData get_DeclaredNestedTypes;
    VirtualInvokeData get_DeclaredProperties;
    VirtualInvokeData get_ImplementedInterfaces;
};

struct GenericTypeParameterBuilder__StaticFields {
};

struct GenericTypeParameterBuilder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct GenericTypeParameterBuilder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct GenericTypeParameterBuilder__VTable vtable;
};

struct GenericTypeParameterBuilder__Array {
    struct GenericTypeParameterBuilder__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct GenericTypeParameterBuilder *vector[32];
};

struct GenericTypeParameterBuilder__Array__VTable {
};

struct GenericTypeParameterBuilder__Array__StaticFields {
};

struct GenericTypeParameterBuilder__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct GenericTypeParameterBuilder__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct GenericTypeParameterBuilder__Array__VTable vtable;
};

struct Type__Array__Array {
    struct Type__Array__Array__Class *klass;
    MonitorData *monitor;
    Il2CppArrayBounds *bounds;
    il2cpp_array_size_t max_length;
    struct Type__Array *vector[32];
};

struct Type__Array__Array__VTable {
};

struct Type__Array__Array__StaticFields {
};

struct Type__Array__Array__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Type__Array__Array__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Type__Array__Array__VTable vtable;
};

struct TypeBuilder__Fields {
    struct TypeInfo__Fields _;
};

struct TypeBuilder {
    struct TypeBuilder__Class *klass;
    MonitorData *monitor;
    struct TypeBuilder__Fields fields;
};

struct TypeBuilder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData Equals_2;
    VirtualInvokeData Equals_3;
    VirtualInvokeData FindInterfaces;
    VirtualInvokeData FindMembers;
    VirtualInvokeData GetArrayRank;
    VirtualInvokeData GetConstructor;
    VirtualInvokeData GetConstructor_1;
    VirtualInvokeData GetConstructor_2;
    VirtualInvokeData GetConstructors;
    VirtualInvokeData GetConstructors_1;
    VirtualInvokeData GetCustomAttributes_6;
    VirtualInvokeData GetCustomAttributes_7;
    VirtualInvokeData GetDefaultMembers;
    VirtualInvokeData GetElementType;
    VirtualInvokeData GetEvent;
    VirtualInvokeData GetEvent_1;
    VirtualInvokeData GetEvents;
    VirtualInvokeData GetEvents_1;
    VirtualInvokeData GetField;
    VirtualInvokeData GetField_1;
    VirtualInvokeData GetFields;
    VirtualInvokeData GetFields_1;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Type_Invoke;
    VirtualInvokeData GetInterface;
    VirtualInvokeData GetInterface_1;
    VirtualInvokeData GetInterfaceMap;
    VirtualInvokeData GetInterfaces;
    VirtualInvokeData GetMember;
    VirtualInvokeData GetMember_1;
    VirtualInvokeData GetMember_2;
    VirtualInvokeData GetMembers;
    VirtualInvokeData GetMembers_1;
    VirtualInvokeData GetMethod;
    VirtualInvokeData GetMethod_1;
    VirtualInvokeData GetMethod_2;
    VirtualInvokeData GetMethod_3;
    VirtualInvokeData GetMethod_4;
    VirtualInvokeData GetMethod_5;
    VirtualInvokeData GetMethods;
    VirtualInvokeData GetMethods_1;
    VirtualInvokeData GetNestedType;
    VirtualInvokeData GetNestedType_1;
    VirtualInvokeData GetNestedTypes;
    VirtualInvokeData GetNestedTypes_1;
    VirtualInvokeData GetProperties;
    VirtualInvokeData GetProperties_1;
    VirtualInvokeData GetProperty;
    VirtualInvokeData GetProperty_1;
    VirtualInvokeData GetProperty_2;
    VirtualInvokeData GetProperty_3;
    VirtualInvokeData GetProperty_4;
    VirtualInvokeData GetProperty_5;
    VirtualInvokeData GetProperty_6;
    VirtualInvokeData GetType;
    VirtualInvokeData InvokeMember;
    VirtualInvokeData InvokeMember_1;
    VirtualInvokeData InvokeMember_2;
    VirtualInvokeData IsAssignableFrom;
    VirtualInvokeData IsDefined_3;
    VirtualInvokeData IsInstanceOfType;
    VirtualInvokeData IsSubclassOf;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Assembly;
    VirtualInvokeData get_AssemblyQualifiedName;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_BaseType;
    VirtualInvokeData get_DeclaringType_2;
    VirtualInvokeData get_FullName;
    VirtualInvokeData get_GUID;
    VirtualInvokeData get_HasElementType;
    VirtualInvokeData get_IsAbstract;
    VirtualInvokeData get_IsAnsiClass;
    VirtualInvokeData get_IsArray;
    VirtualInvokeData get_IsAutoClass;
    VirtualInvokeData get_IsAutoLayout;
    VirtualInvokeData get_IsByRef;
    VirtualInvokeData get_IsClass;
    VirtualInvokeData get_IsCOMObject;
    VirtualInvokeData get_IsContextful;
    VirtualInvokeData get_IsEnum;
    VirtualInvokeData get_IsExplicitLayout;
    VirtualInvokeData get_IsImport;
    VirtualInvokeData get_IsInterface;
    VirtualInvokeData get_IsLayoutSequential;
    VirtualInvokeData get_IsMarshalByRef;
    VirtualInvokeData get_IsNestedAssembly;
    VirtualInvokeData get_IsNestedFamANDAssem;
    VirtualInvokeData get_IsNestedFamily;
    VirtualInvokeData get_IsNestedFamORAssem;
    VirtualInvokeData get_IsNestedPrivate;
    VirtualInvokeData get_IsNestedPublic;
    VirtualInvokeData get_IsNotPublic;
    VirtualInvokeData get_IsPointer;
    VirtualInvokeData get_IsPrimitive;
    VirtualInvokeData get_IsPublic;
    VirtualInvokeData get_IsSealed;
    VirtualInvokeData get_IsSerializable;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_IsUnicodeClass;
    VirtualInvokeData get_IsValueType;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_Module_1;
    VirtualInvokeData get_Name_2;
    VirtualInvokeData get_Namespace;
    VirtualInvokeData get_ReflectedType_2;
    VirtualInvokeData get_TypeHandle;
    VirtualInvokeData get_TypeInitializer;
    VirtualInvokeData get_UnderlyingSystemType;
    VirtualInvokeData GetMethod_6;
    VirtualInvokeData GetMethod_7;
    VirtualInvokeData GetMethods_2;
    VirtualInvokeData GetField_2;
    VirtualInvokeData GetFields_2;
    VirtualInvokeData GetProperty_7;
    VirtualInvokeData GetProperty_8;
    VirtualInvokeData GetProperties_2;
    VirtualInvokeData GetMember_3;
    VirtualInvokeData GetMembers_2;
    VirtualInvokeData InvokeMember_3;
    VirtualInvokeData get_UnderlyingSystemType_1;
    VirtualInvokeData get_DeclaringMethod;
    VirtualInvokeData MakePointerType;
    VirtualInvokeData get_StructLayoutAttribute;
    VirtualInvokeData MakeByRefType;
    VirtualInvokeData MakeArrayType;
    VirtualInvokeData MakeArrayType_1;
    VirtualInvokeData GetTypeCodeImpl;
    VirtualInvokeData get_GUID_1;
    VirtualInvokeData InvokeMember_4;
    VirtualInvokeData get_Assembly_1;
    VirtualInvokeData get_TypeHandle_1;
    VirtualInvokeData GetTypeHandleInternal;
    VirtualInvokeData get_FullName_1;
    VirtualInvokeData get_Namespace_1;
    VirtualInvokeData get_AssemblyQualifiedName_1;
    VirtualInvokeData GetArrayRank_1;
    VirtualInvokeData get_BaseType_1;
    VirtualInvokeData GetConstructorImpl;
    VirtualInvokeData GetConstructors_2;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetMethods_3;
    VirtualInvokeData GetField_3;
    VirtualInvokeData GetFields_3;
    VirtualInvokeData GetInterface_2;
    VirtualInvokeData GetInterfaces_1;
    VirtualInvokeData FindInterfaces_1;
    VirtualInvokeData GetEvent_2;
    VirtualInvokeData GetEvents_2;
    VirtualInvokeData GetEvents_3;
    VirtualInvokeData GetPropertyImpl;
    VirtualInvokeData GetProperties_3;
    VirtualInvokeData GetNestedTypes_2;
    VirtualInvokeData GetNestedType_2;
    VirtualInvokeData GetMember_4;
    VirtualInvokeData GetMember_5;
    VirtualInvokeData GetMembers_3;
    VirtualInvokeData GetDefaultMembers_1;
    VirtualInvokeData FindMembers_1;
    VirtualInvokeData get_GenericParameterAttributes;
    VirtualInvokeData get_IsEnum_1;
    VirtualInvokeData get_IsSerializable_1;
    VirtualInvokeData get_IsSzArray;
    VirtualInvokeData get_IsGenericType;
    VirtualInvokeData get_IsGenericTypeDefinition;
    VirtualInvokeData get_IsConstructedGenericType;
    VirtualInvokeData get_IsGenericParameter;
    VirtualInvokeData get_GenericParameterPosition;
    VirtualInvokeData get_ContainsGenericParameters;
    VirtualInvokeData GetGenericParameterConstraints;
    VirtualInvokeData IsValueTypeImpl;
    VirtualInvokeData GetAttributeFlagsImpl;
    VirtualInvokeData IsArrayImpl;
    VirtualInvokeData IsByRefImpl;
    VirtualInvokeData IsPointerImpl;
    VirtualInvokeData IsPrimitiveImpl;
    VirtualInvokeData IsCOMObjectImpl;
    VirtualInvokeData IsWindowsRuntimeObjectImpl;
    VirtualInvokeData IsExportedToWindowsRuntimeImpl;
    VirtualInvokeData MakeGenericType;
    VirtualInvokeData IsContextfulImpl;
    VirtualInvokeData IsMarshalByRefImpl;
    VirtualInvokeData HasProxyAttributeImpl;
    VirtualInvokeData GetElementType_1;
    VirtualInvokeData GetGenericArguments;
    VirtualInvokeData get_GenericTypeArguments;
    VirtualInvokeData GetGenericTypeDefinition;
    VirtualInvokeData HasElementTypeImpl;
    VirtualInvokeData GetEnumNames;
    VirtualInvokeData GetEnumValues;
    VirtualInvokeData GetEnumUnderlyingType;
    VirtualInvokeData IsEnumDefined;
    VirtualInvokeData GetEnumName;
    VirtualInvokeData get_IsSecurityCritical;
    VirtualInvokeData get_IsSecuritySafeCritical;
    VirtualInvokeData get_IsSecurityTransparent;
    VirtualInvokeData get_UnderlyingSystemType_2;
    VirtualInvokeData IsSubclassOf_1;
    VirtualInvokeData IsInstanceOfType_1;
    VirtualInvokeData IsAssignableFrom_1;
    VirtualInvokeData IsEquivalentTo;
    VirtualInvokeData FormatTypeName;
    VirtualInvokeData Equals_4;
    VirtualInvokeData GetInterfaceMap_1;
    VirtualInvokeData get_IsSZArray;
    VirtualInvokeData InternalResolve;
    VirtualInvokeData RuntimeResolve;
    VirtualInvokeData get_IsUserType;
    VirtualInvokeData GetMethod_8;
    VirtualInvokeData GetConstructor_3;
    VirtualInvokeData GetField_4;
    VirtualInvokeData System_Reflection_IReflectableType_GetTypeInfo;
    VirtualInvokeData AsType;
    VirtualInvokeData get_GenericTypeParameters;
    VirtualInvokeData IsAssignableFrom_2;
    VirtualInvokeData GetDeclaredEvent;
    VirtualInvokeData GetDeclaredField;
    VirtualInvokeData GetDeclaredMethod;
    VirtualInvokeData GetDeclaredMethods;
    VirtualInvokeData GetDeclaredNestedType;
    VirtualInvokeData GetDeclaredProperty;
    VirtualInvokeData get_DeclaredConstructors;
    VirtualInvokeData get_DeclaredEvents;
    VirtualInvokeData get_DeclaredFields;
    VirtualInvokeData get_DeclaredMembers;
    VirtualInvokeData get_DeclaredMethods;
    VirtualInvokeData get_DeclaredNestedTypes;
    VirtualInvokeData get_DeclaredProperties;
    VirtualInvokeData get_ImplementedInterfaces;
    VirtualInvokeData System_Runtime_InteropServices__TypeBuilder_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__TypeBuilder_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__TypeBuilder_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__TypeBuilder_Invoke;
};

struct TypeBuilder__StaticFields {
};

struct TypeBuilder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeBuilder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeBuilder__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum PackingSize__Enum : int32_t {
    PackingSize__Enum_Unspecified = 0x00000000,
    PackingSize__Enum_Size1 = 0x00000001,
    PackingSize__Enum_Size2 = 0x00000002,
    PackingSize__Enum_Size4 = 0x00000004,
    PackingSize__Enum_Size8 = 0x00000008,
    PackingSize__Enum_Size16 = 0x00000010,
    PackingSize__Enum_Size32 = 0x00000020,
    PackingSize__Enum_Size64 = 0x00000040,
    PackingSize__Enum_Size128 = 0x00000080,
};

#else
enum PackingSize__Enum {
    PackingSize__Enum_Unspecified = 0x00000000,
    PackingSize__Enum_Size1 = 0x00000001,
    PackingSize__Enum_Size2 = 0x00000002,
    PackingSize__Enum_Size4 = 0x00000004,
    PackingSize__Enum_Size8 = 0x00000008,
    PackingSize__Enum_Size16 = 0x00000010,
    PackingSize__Enum_Size32 = 0x00000020,
    PackingSize__Enum_Size64 = 0x00000040,
    PackingSize__Enum_Size128 = 0x00000080,
};

#endif
struct PackingSize__Enum__Boxed {
    struct PackingSize__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum PackingSize__Enum value;
    #else
    uint32_t value;
    #endif
};

struct PackingSize__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct PackingSize__Enum__StaticFields {
};

struct PackingSize__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PackingSize__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PackingSize__Enum__VTable vtable;
};

struct SignatureToken {
};

struct SignatureToken__Boxed {
    struct SignatureToken__Class *klass;
    MonitorData *monitor;
    struct SignatureToken fields;
};

struct SignatureToken__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct SignatureToken__StaticFields {
    struct SignatureToken Empty;
};

struct SignatureToken__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SignatureToken__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SignatureToken__VTable vtable;
};

struct StringToken {
    int32_t DummyAddedByUnityProfileStubber;
};

struct StringToken__Boxed {
    struct StringToken__Class *klass;
    MonitorData *monitor;
    struct StringToken fields;
};

struct StringToken__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct StringToken__StaticFields {
};

struct StringToken__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StringToken__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StringToken__VTable vtable;
};

struct ISymbolWriter {
    struct ISymbolWriter__Class *klass;
    MonitorData *monitor;
};

struct ISymbolWriter__VTable {
    VirtualInvokeData Close;
    VirtualInvokeData CloseMethod;
    VirtualInvokeData CloseNamespace;
    VirtualInvokeData CloseScope;
    VirtualInvokeData DefineDocument;
    VirtualInvokeData DefineField;
    VirtualInvokeData DefineGlobalVariable;
    VirtualInvokeData DefineLocalVariable;
    VirtualInvokeData DefineParameter;
    VirtualInvokeData DefineSequencePoints;
    VirtualInvokeData Initialize;
    VirtualInvokeData OpenMethod;
    VirtualInvokeData OpenNamespace;
    VirtualInvokeData OpenScope;
    VirtualInvokeData SetMethodSourceRange;
    VirtualInvokeData SetScopeRange;
    VirtualInvokeData SetSymAttribute;
    VirtualInvokeData SetUnderlyingWriter;
    VirtualInvokeData SetUserEntryPoint;
    VirtualInvokeData UsingNamespace;
};

struct ISymbolWriter__StaticFields {
};

struct ISymbolWriter__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ISymbolWriter__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ISymbolWriter__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum OpCodeType__Enum : int32_t {
    OpCodeType__Enum_Annotation = 0x00000000,
    OpCodeType__Enum_Macro = 0x00000001,
    OpCodeType__Enum_Nternal = 0x00000002,
    OpCodeType__Enum_Objmodel = 0x00000003,
    OpCodeType__Enum_Prefix = 0x00000004,
    OpCodeType__Enum_Primitive = 0x00000005,
};

#else
enum OpCodeType__Enum {
    OpCodeType__Enum_Annotation = 0x00000000,
    OpCodeType__Enum_Macro = 0x00000001,
    OpCodeType__Enum_Nternal = 0x00000002,
    OpCodeType__Enum_Objmodel = 0x00000003,
    OpCodeType__Enum_Prefix = 0x00000004,
    OpCodeType__Enum_Primitive = 0x00000005,
};

#endif
struct OpCodeType__Enum__Boxed {
    struct OpCodeType__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum OpCodeType__Enum value;
    #else
    uint32_t value;
    #endif
};

struct OpCodeType__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct OpCodeType__Enum__StaticFields {
};

struct OpCodeType__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct OpCodeType__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct OpCodeType__Enum__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum OperandType__Enum : int32_t {
    OperandType__Enum_InlineBrTarget = 0x00000000,
    OperandType__Enum_InlineField = 0x00000001,
    OperandType__Enum_InlineI = 0x00000002,
    OperandType__Enum_InlineI8 = 0x00000003,
    OperandType__Enum_InlineMethod = 0x00000004,
    OperandType__Enum_InlineNone = 0x00000005,
    OperandType__Enum_InlinePhi = 0x00000006,
    OperandType__Enum_InlineR = 0x00000007,
    OperandType__Enum_InlineSig = 0x00000009,
    OperandType__Enum_InlineString = 0x0000000a,
    OperandType__Enum_InlineSwitch = 0x0000000b,
    OperandType__Enum_InlineTok = 0x0000000c,
    OperandType__Enum_InlineType = 0x0000000d,
    OperandType__Enum_InlineVar = 0x0000000e,
    OperandType__Enum_ShortInlineBrTarget = 0x0000000f,
    OperandType__Enum_ShortInlineI = 0x00000010,
    OperandType__Enum_ShortInlineR = 0x00000011,
    OperandType__Enum_ShortInlineVar = 0x00000012,
};

#else
enum OperandType__Enum {
    OperandType__Enum_InlineBrTarget = 0x00000000,
    OperandType__Enum_InlineField = 0x00000001,
    OperandType__Enum_InlineI = 0x00000002,
    OperandType__Enum_InlineI8 = 0x00000003,
    OperandType__Enum_InlineMethod = 0x00000004,
    OperandType__Enum_InlineNone = 0x00000005,
    OperandType__Enum_InlinePhi = 0x00000006,
    OperandType__Enum_InlineR = 0x00000007,
    OperandType__Enum_InlineSig = 0x00000009,
    OperandType__Enum_InlineString = 0x0000000a,
    OperandType__Enum_InlineSwitch = 0x0000000b,
    OperandType__Enum_InlineTok = 0x0000000c,
    OperandType__Enum_InlineType = 0x0000000d,
    OperandType__Enum_InlineVar = 0x0000000e,
    OperandType__Enum_ShortInlineBrTarget = 0x0000000f,
    OperandType__Enum_ShortInlineI = 0x00000010,
    OperandType__Enum_ShortInlineR = 0x00000011,
    OperandType__Enum_ShortInlineVar = 0x00000012,
};

#endif
struct OperandType__Enum__Boxed {
    struct OperandType__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum OperandType__Enum value;
    #else
    uint32_t value;
    #endif
};

struct OperandType__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct OperandType__Enum__StaticFields {
};

struct OperandType__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct OperandType__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct OperandType__Enum__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum FlowControl__Enum : int32_t {
    FlowControl__Enum_Branch = 0x00000000,
    FlowControl__Enum_Break = 0x00000001,
    FlowControl__Enum_Call = 0x00000002,
    FlowControl__Enum_Cond_Branch = 0x00000003,
    FlowControl__Enum_Meta = 0x00000004,
    FlowControl__Enum_Next = 0x00000005,
    FlowControl__Enum_Phi = 0x00000006,
    FlowControl__Enum_Return = 0x00000007,
    FlowControl__Enum_Throw = 0x00000008,
};

#else
enum FlowControl__Enum {
    FlowControl__Enum_Branch = 0x00000000,
    FlowControl__Enum_Break = 0x00000001,
    FlowControl__Enum_Call = 0x00000002,
    FlowControl__Enum_Cond_Branch = 0x00000003,
    FlowControl__Enum_Meta = 0x00000004,
    FlowControl__Enum_Next = 0x00000005,
    FlowControl__Enum_Phi = 0x00000006,
    FlowControl__Enum_Return = 0x00000007,
    FlowControl__Enum_Throw = 0x00000008,
};

#endif
struct FlowControl__Enum__Boxed {
    struct FlowControl__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum FlowControl__Enum value;
    #else
    uint32_t value;
    #endif
};

struct FlowControl__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct FlowControl__Enum__StaticFields {
};

struct FlowControl__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FlowControl__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FlowControl__Enum__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum StackBehaviour__Enum : int32_t {
    StackBehaviour__Enum_Pop0 = 0x00000000,
    StackBehaviour__Enum_Pop1 = 0x00000001,
    StackBehaviour__Enum_Pop1_pop1 = 0x00000002,
    StackBehaviour__Enum_Popi = 0x00000003,
    StackBehaviour__Enum_Popi_pop1 = 0x00000004,
    StackBehaviour__Enum_Popi_popi = 0x00000005,
    StackBehaviour__Enum_Popi_popi8 = 0x00000006,
    StackBehaviour__Enum_Popi_popi_popi = 0x00000007,
    StackBehaviour__Enum_Popi_popr4 = 0x00000008,
    StackBehaviour__Enum_Popi_popr8 = 0x00000009,
    StackBehaviour__Enum_Popref = 0x0000000a,
    StackBehaviour__Enum_Popref_pop1 = 0x0000000b,
    StackBehaviour__Enum_Popref_popi = 0x0000000c,
    StackBehaviour__Enum_Popref_popi_popi = 0x0000000d,
    StackBehaviour__Enum_Popref_popi_popi8 = 0x0000000e,
    StackBehaviour__Enum_Popref_popi_popr4 = 0x0000000f,
    StackBehaviour__Enum_Popref_popi_popr8 = 0x00000010,
    StackBehaviour__Enum_Popref_popi_popref = 0x00000011,
    StackBehaviour__Enum_Push0 = 0x00000012,
    StackBehaviour__Enum_Push1 = 0x00000013,
    StackBehaviour__Enum_Push1_push1 = 0x00000014,
    StackBehaviour__Enum_Pushi = 0x00000015,
    StackBehaviour__Enum_Pushi8 = 0x00000016,
    StackBehaviour__Enum_Pushr4 = 0x00000017,
    StackBehaviour__Enum_Pushr8 = 0x00000018,
    StackBehaviour__Enum_Pushref = 0x00000019,
    StackBehaviour__Enum_Varpop = 0x0000001a,
    StackBehaviour__Enum_Varpush = 0x0000001b,
    StackBehaviour__Enum_Popref_popi_pop1 = 0x0000001c,
};

#else
enum StackBehaviour__Enum {
    StackBehaviour__Enum_Pop0 = 0x00000000,
    StackBehaviour__Enum_Pop1 = 0x00000001,
    StackBehaviour__Enum_Pop1_pop1 = 0x00000002,
    StackBehaviour__Enum_Popi = 0x00000003,
    StackBehaviour__Enum_Popi_pop1 = 0x00000004,
    StackBehaviour__Enum_Popi_popi = 0x00000005,
    StackBehaviour__Enum_Popi_popi8 = 0x00000006,
    StackBehaviour__Enum_Popi_popi_popi = 0x00000007,
    StackBehaviour__Enum_Popi_popr4 = 0x00000008,
    StackBehaviour__Enum_Popi_popr8 = 0x00000009,
    StackBehaviour__Enum_Popref = 0x0000000a,
    StackBehaviour__Enum_Popref_pop1 = 0x0000000b,
    StackBehaviour__Enum_Popref_popi = 0x0000000c,
    StackBehaviour__Enum_Popref_popi_popi = 0x0000000d,
    StackBehaviour__Enum_Popref_popi_popi8 = 0x0000000e,
    StackBehaviour__Enum_Popref_popi_popr4 = 0x0000000f,
    StackBehaviour__Enum_Popref_popi_popr8 = 0x00000010,
    StackBehaviour__Enum_Popref_popi_popref = 0x00000011,
    StackBehaviour__Enum_Push0 = 0x00000012,
    StackBehaviour__Enum_Push1 = 0x00000013,
    StackBehaviour__Enum_Push1_push1 = 0x00000014,
    StackBehaviour__Enum_Pushi = 0x00000015,
    StackBehaviour__Enum_Pushi8 = 0x00000016,
    StackBehaviour__Enum_Pushr4 = 0x00000017,
    StackBehaviour__Enum_Pushr8 = 0x00000018,
    StackBehaviour__Enum_Pushref = 0x00000019,
    StackBehaviour__Enum_Varpop = 0x0000001a,
    StackBehaviour__Enum_Varpush = 0x0000001b,
    StackBehaviour__Enum_Popref_popi_pop1 = 0x0000001c,
};

#endif
struct StackBehaviour__Enum__Boxed {
    struct StackBehaviour__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum StackBehaviour__Enum value;
    #else
    uint32_t value;
    #endif
};

struct StackBehaviour__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct StackBehaviour__Enum__StaticFields {
};

struct StackBehaviour__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StackBehaviour__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StackBehaviour__Enum__VTable vtable;
};

struct OpCodes {
    struct OpCodes__Class *klass;
    MonitorData *monitor;
};

struct OpCodes__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct OpCodes__StaticFields {
    struct OpCode Nop;
    struct OpCode Break;
    struct OpCode Ldarg_0;
    struct OpCode Ldarg_1;
    struct OpCode Ldarg_2;
    struct OpCode Ldarg_3;
    struct OpCode Ldloc_0;
    struct OpCode Ldloc_1;
    struct OpCode Ldloc_2;
    struct OpCode Ldloc_3;
    struct OpCode Stloc_0;
    struct OpCode Stloc_1;
    struct OpCode Stloc_2;
    struct OpCode Stloc_3;
    struct OpCode Ldarg_S;
    struct OpCode Ldarga_S;
    struct OpCode Starg_S;
    struct OpCode Ldloc_S;
    struct OpCode Ldloca_S;
    struct OpCode Stloc_S;
    struct OpCode Ldnull;
    struct OpCode Ldc_I4_M1;
    struct OpCode Ldc_I4_0;
    struct OpCode Ldc_I4_1;
    struct OpCode Ldc_I4_2;
    struct OpCode Ldc_I4_3;
    struct OpCode Ldc_I4_4;
    struct OpCode Ldc_I4_5;
    struct OpCode Ldc_I4_6;
    struct OpCode Ldc_I4_7;
    struct OpCode Ldc_I4_8;
    struct OpCode Ldc_I4_S;
    struct OpCode Ldc_I4;
    struct OpCode Ldc_I8;
    struct OpCode Ldc_R4;
    struct OpCode Ldc_R8;
    struct OpCode Dup;
    struct OpCode Pop;
    struct OpCode Jmp;
    struct OpCode Call;
    struct OpCode Calli;
    struct OpCode Ret;
    struct OpCode Br_S;
    struct OpCode Brfalse_S;
    struct OpCode Brtrue_S;
    struct OpCode Beq_S;
    struct OpCode Bge_S;
    struct OpCode Bgt_S;
    struct OpCode Ble_S;
    struct OpCode Blt_S;
    struct OpCode Bne_Un_S;
    struct OpCode Bge_Un_S;
    struct OpCode Bgt_Un_S;
    struct OpCode Ble_Un_S;
    struct OpCode Blt_Un_S;
    struct OpCode Br;
    struct OpCode Brfalse;
    struct OpCode Brtrue;
    struct OpCode Beq;
    struct OpCode Bge;
    struct OpCode Bgt;
    struct OpCode Ble;
    struct OpCode Blt;
    struct OpCode Bne_Un;
    struct OpCode Bge_Un;
    struct OpCode Bgt_Un;
    struct OpCode Ble_Un;
    struct OpCode Blt_Un;
    struct OpCode Switch;
    struct OpCode Ldind_I1;
    struct OpCode Ldind_U1;
    struct OpCode Ldind_I2;
    struct OpCode Ldind_U2;
    struct OpCode Ldind_I4;
    struct OpCode Ldind_U4;
    struct OpCode Ldind_I8;
    struct OpCode Ldind_I;
    struct OpCode Ldind_R4;
    struct OpCode Ldind_R8;
    struct OpCode Ldind_Ref;
    struct OpCode Stind_Ref;
    struct OpCode Stind_I1;
    struct OpCode Stind_I2;
    struct OpCode Stind_I4;
    struct OpCode Stind_I8;
    struct OpCode Stind_R4;
    struct OpCode Stind_R8;
    struct OpCode Add;
    struct OpCode Sub;
    struct OpCode Mul;
    struct OpCode Div;
    struct OpCode Div_Un;
    struct OpCode Rem;
    struct OpCode Rem_Un;
    struct OpCode And;
    struct OpCode Or;
    struct OpCode Xor;
    struct OpCode Shl;
    struct OpCode Shr;
    struct OpCode Shr_Un;
    struct OpCode Neg;
    struct OpCode Not;
    struct OpCode Conv_I1;
    struct OpCode Conv_I2;
    struct OpCode Conv_I4;
    struct OpCode Conv_I8;
    struct OpCode Conv_R4;
    struct OpCode Conv_R8;
    struct OpCode Conv_U4;
    struct OpCode Conv_U8;
    struct OpCode Callvirt;
    struct OpCode Cpobj;
    struct OpCode Ldobj;
    struct OpCode Ldstr;
    struct OpCode Newobj;
    struct OpCode Castclass;
    struct OpCode Isinst;
    struct OpCode Conv_R_Un;
    struct OpCode Unbox;
    struct OpCode Throw;
    struct OpCode Ldfld;
    struct OpCode Ldflda;
    struct OpCode Stfld;
    struct OpCode Ldsfld;
    struct OpCode Ldsflda;
    struct OpCode Stsfld;
    struct OpCode Stobj;
    struct OpCode Conv_Ovf_I1_Un;
    struct OpCode Conv_Ovf_I2_Un;
    struct OpCode Conv_Ovf_I4_Un;
    struct OpCode Conv_Ovf_I8_Un;
    struct OpCode Conv_Ovf_U1_Un;
    struct OpCode Conv_Ovf_U2_Un;
    struct OpCode Conv_Ovf_U4_Un;
    struct OpCode Conv_Ovf_U8_Un;
    struct OpCode Conv_Ovf_I_Un;
    struct OpCode Conv_Ovf_U_Un;
    struct OpCode Box;
    struct OpCode Newarr;
    struct OpCode Ldlen;
    struct OpCode Ldelema;
    struct OpCode Ldelem_I1;
    struct OpCode Ldelem_U1;
    struct OpCode Ldelem_I2;
    struct OpCode Ldelem_U2;
    struct OpCode Ldelem_I4;
    struct OpCode Ldelem_U4;
    struct OpCode Ldelem_I8;
    struct OpCode Ldelem_I;
    struct OpCode Ldelem_R4;
    struct OpCode Ldelem_R8;
    struct OpCode Ldelem_Ref;
    struct OpCode Stelem_I;
    struct OpCode Stelem_I1;
    struct OpCode Stelem_I2;
    struct OpCode Stelem_I4;
    struct OpCode Stelem_I8;
    struct OpCode Stelem_R4;
    struct OpCode Stelem_R8;
    struct OpCode Stelem_Ref;
    struct OpCode Ldelem;
    struct OpCode Stelem;
    struct OpCode Unbox_Any;
    struct OpCode Conv_Ovf_I1;
    struct OpCode Conv_Ovf_U1;
    struct OpCode Conv_Ovf_I2;
    struct OpCode Conv_Ovf_U2;
    struct OpCode Conv_Ovf_I4;
    struct OpCode Conv_Ovf_U4;
    struct OpCode Conv_Ovf_I8;
    struct OpCode Conv_Ovf_U8;
    struct OpCode Refanyval;
    struct OpCode Ckfinite;
    struct OpCode Mkrefany;
    struct OpCode Ldtoken;
    struct OpCode Conv_U2;
    struct OpCode Conv_U1;
    struct OpCode Conv_I;
    struct OpCode Conv_Ovf_I;
    struct OpCode Conv_Ovf_U;
    struct OpCode Add_Ovf;
    struct OpCode Add_Ovf_Un;
    struct OpCode Mul_Ovf;
    struct OpCode Mul_Ovf_Un;
    struct OpCode Sub_Ovf;
    struct OpCode Sub_Ovf_Un;
    struct OpCode Endfinally;
    struct OpCode Leave;
    struct OpCode Leave_S;
    struct OpCode Stind_I;
    struct OpCode Conv_U;
    struct OpCode Prefix7;
    struct OpCode Prefix6;
    struct OpCode Prefix5;
    struct OpCode Prefix4;
    struct OpCode Prefix3;
    struct OpCode Prefix2;
    struct OpCode Prefix1;
    struct OpCode Prefixref;
    struct OpCode Arglist;
    struct OpCode Ceq;
    struct OpCode Cgt;
    struct OpCode Cgt_Un;
    struct OpCode Clt;
    struct OpCode Clt_Un;
    struct OpCode Ldftn;
    struct OpCode Ldvirtftn;
    struct OpCode Ldarg;
    struct OpCode Ldarga;
    struct OpCode Starg;
    struct OpCode Ldloc;
    struct OpCode Ldloca;
    struct OpCode Stloc;
    struct OpCode Localloc;
    struct OpCode Endfilter;
    struct OpCode Unaligned;
    struct OpCode Volatile;
    struct OpCode Tailcall;
    struct OpCode Initobj;
    struct OpCode Constrained;
    struct OpCode Cpblk;
    struct OpCode Initblk;
    struct OpCode Rethrow;
    struct OpCode Sizeof;
    struct OpCode Refanytype;
    struct OpCode Readonly;
};

struct OpCodes__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct OpCodes__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct OpCodes__VTable vtable;
};

struct PropertyBuilder {
    struct PropertyBuilder__Class *klass;
    MonitorData *monitor;
};

struct PropertyBuilder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData get_Module;
    VirtualInvokeData Equals_2;
    VirtualInvokeData GetAccessors;
    VirtualInvokeData GetAccessors_1;
    VirtualInvokeData GetCustomAttributes_6;
    VirtualInvokeData GetCustomAttributes_7;
    VirtualInvokeData GetGetMethod;
    VirtualInvokeData GetGetMethod_1;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData GetIndexParameters;
    VirtualInvokeData GetSetMethod;
    VirtualInvokeData GetSetMethod_1;
    VirtualInvokeData System_Runtime_InteropServices__PropertyInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__PropertyInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__PropertyInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__PropertyInfo_Invoke;
    VirtualInvokeData System_Runtime_InteropServices__PropertyInfo_GetType;
    VirtualInvokeData GetValue;
    VirtualInvokeData GetValue_1;
    VirtualInvokeData IsDefined_3;
    VirtualInvokeData SetValue;
    VirtualInvokeData SetValue_1;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_CanRead;
    VirtualInvokeData get_CanWrite;
    VirtualInvokeData get_DeclaringType_2;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_Name_2;
    VirtualInvokeData get_PropertyType;
    VirtualInvokeData get_ReflectedType_2;
    VirtualInvokeData get_Attributes_1;
    VirtualInvokeData get_CanRead_1;
    VirtualInvokeData get_CanWrite_1;
    VirtualInvokeData get_GetMethod;
    VirtualInvokeData get_SetMethod;
    VirtualInvokeData get_PropertyType_1;
    VirtualInvokeData GetAccessors_2;
    VirtualInvokeData GetGetMethod_2;
    VirtualInvokeData GetIndexParameters_1;
    VirtualInvokeData GetSetMethod_2;
    VirtualInvokeData GetValue_2;
    VirtualInvokeData GetValue_3;
    VirtualInvokeData SetValue_2;
    VirtualInvokeData SetValue_3;
    VirtualInvokeData GetOptionalCustomModifiers;
    VirtualInvokeData GetRequiredCustomModifiers;
    VirtualInvokeData GetConstantValue;
    VirtualInvokeData GetRawConstantValue;
    VirtualInvokeData System_Runtime_InteropServices__PropertyBuilder_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__PropertyBuilder_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__PropertyBuilder_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__PropertyBuilder_Invoke;
};

struct PropertyBuilder__StaticFields {
};

struct PropertyBuilder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PropertyBuilder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PropertyBuilder__VTable vtable;
};

struct PropertyToken {
};

struct PropertyToken__Boxed {
    struct PropertyToken__Class *klass;
    MonitorData *monitor;
    struct PropertyToken fields;
};

struct PropertyToken__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct PropertyToken__StaticFields {
    struct PropertyToken Empty;
};

struct PropertyToken__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PropertyToken__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PropertyToken__VTable vtable;
};

struct TypeBuilderInstantiation__Fields {
    struct TypeInfo__Fields _;
};

struct TypeBuilderInstantiation {
    struct TypeBuilderInstantiation__Class *klass;
    MonitorData *monitor;
    struct TypeBuilderInstantiation__Fields fields;
};

struct TypeBuilderInstantiation__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetCustomAttributes;
    VirtualInvokeData GetCustomAttributes_1;
    VirtualInvokeData IsDefined;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetCustomAttributes_2;
    VirtualInvokeData GetCustomAttributes_3;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetType;
    VirtualInvokeData IsDefined_1;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_DeclaringType;
    VirtualInvokeData get_MemberType;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_ReflectedType;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__MemberInfo_Invoke;
    VirtualInvokeData CacheEquals;
    VirtualInvokeData get_MemberType_1;
    VirtualInvokeData __unknown;
    VirtualInvokeData get_DeclaringType_1;
    VirtualInvokeData get_ReflectedType_1;
    VirtualInvokeData get_CustomAttributes;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData __unknown_3;
    VirtualInvokeData GetCustomAttributesData;
    VirtualInvokeData get_MetadataToken;
    VirtualInvokeData __unknown_4;
    VirtualInvokeData Equals_2;
    VirtualInvokeData Equals_3;
    VirtualInvokeData FindInterfaces;
    VirtualInvokeData FindMembers;
    VirtualInvokeData GetArrayRank;
    VirtualInvokeData GetConstructor;
    VirtualInvokeData GetConstructor_1;
    VirtualInvokeData GetConstructor_2;
    VirtualInvokeData GetConstructors;
    VirtualInvokeData GetConstructors_1;
    VirtualInvokeData GetCustomAttributes_4;
    VirtualInvokeData GetCustomAttributes_5;
    VirtualInvokeData GetDefaultMembers;
    VirtualInvokeData GetElementType;
    VirtualInvokeData GetEvent;
    VirtualInvokeData GetEvent_1;
    VirtualInvokeData GetEvents;
    VirtualInvokeData GetEvents_1;
    VirtualInvokeData GetField;
    VirtualInvokeData GetField_1;
    VirtualInvokeData GetFields;
    VirtualInvokeData GetFields_1;
    VirtualInvokeData GetHashCode_2;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetIDsOfNames;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetTypeInfo;
    VirtualInvokeData System_Runtime_InteropServices__Type_GetTypeInfoCount;
    VirtualInvokeData System_Runtime_InteropServices__Type_Invoke;
    VirtualInvokeData GetInterface;
    VirtualInvokeData GetInterface_1;
    VirtualInvokeData GetInterfaceMap;
    VirtualInvokeData GetInterfaces;
    VirtualInvokeData GetMember;
    VirtualInvokeData GetMember_1;
    VirtualInvokeData GetMember_2;
    VirtualInvokeData GetMembers;
    VirtualInvokeData GetMembers_1;
    VirtualInvokeData GetMethod;
    VirtualInvokeData GetMethod_1;
    VirtualInvokeData GetMethod_2;
    VirtualInvokeData GetMethod_3;
    VirtualInvokeData GetMethod_4;
    VirtualInvokeData GetMethod_5;
    VirtualInvokeData GetMethods;
    VirtualInvokeData GetMethods_1;
    VirtualInvokeData GetNestedType;
    VirtualInvokeData GetNestedType_1;
    VirtualInvokeData GetNestedTypes;
    VirtualInvokeData GetNestedTypes_1;
    VirtualInvokeData GetProperties;
    VirtualInvokeData GetProperties_1;
    VirtualInvokeData GetProperty;
    VirtualInvokeData GetProperty_1;
    VirtualInvokeData GetProperty_2;
    VirtualInvokeData GetProperty_3;
    VirtualInvokeData GetProperty_4;
    VirtualInvokeData GetProperty_5;
    VirtualInvokeData GetProperty_6;
    VirtualInvokeData GetType;
    VirtualInvokeData InvokeMember;
    VirtualInvokeData InvokeMember_1;
    VirtualInvokeData InvokeMember_2;
    VirtualInvokeData IsAssignableFrom;
    VirtualInvokeData IsDefined_2;
    VirtualInvokeData IsInstanceOfType;
    VirtualInvokeData IsSubclassOf;
    VirtualInvokeData ToString_2;
    VirtualInvokeData get_Assembly;
    VirtualInvokeData get_AssemblyQualifiedName;
    VirtualInvokeData get_Attributes;
    VirtualInvokeData get_BaseType;
    VirtualInvokeData get_DeclaringType_2;
    VirtualInvokeData get_FullName;
    VirtualInvokeData get_GUID;
    VirtualInvokeData get_HasElementType;
    VirtualInvokeData get_IsAbstract;
    VirtualInvokeData get_IsAnsiClass;
    VirtualInvokeData get_IsArray;
    VirtualInvokeData get_IsAutoClass;
    VirtualInvokeData get_IsAutoLayout;
    VirtualInvokeData get_IsByRef;
    VirtualInvokeData get_IsClass;
    VirtualInvokeData get_IsCOMObject;
    VirtualInvokeData get_IsContextful;
    VirtualInvokeData get_IsEnum;
    VirtualInvokeData get_IsExplicitLayout;
    VirtualInvokeData get_IsImport;
    VirtualInvokeData get_IsInterface;
    VirtualInvokeData get_IsLayoutSequential;
    VirtualInvokeData get_IsMarshalByRef;
    VirtualInvokeData get_IsNestedAssembly;
    VirtualInvokeData get_IsNestedFamANDAssem;
    VirtualInvokeData get_IsNestedFamily;
    VirtualInvokeData get_IsNestedFamORAssem;
    VirtualInvokeData get_IsNestedPrivate;
    VirtualInvokeData get_IsNestedPublic;
    VirtualInvokeData get_IsNotPublic;
    VirtualInvokeData get_IsPointer;
    VirtualInvokeData get_IsPrimitive;
    VirtualInvokeData get_IsPublic;
    VirtualInvokeData get_IsSealed;
    VirtualInvokeData get_IsSerializable;
    VirtualInvokeData get_IsSpecialName;
    VirtualInvokeData get_IsUnicodeClass;
    VirtualInvokeData get_IsValueType;
    VirtualInvokeData get_MemberType_2;
    VirtualInvokeData get_Module;
    VirtualInvokeData get_Name_1;
    VirtualInvokeData get_Namespace;
    VirtualInvokeData get_ReflectedType_2;
    VirtualInvokeData get_TypeHandle;
    VirtualInvokeData get_TypeInitializer;
    VirtualInvokeData get_UnderlyingSystemType;
    VirtualInvokeData GetMethod_6;
    VirtualInvokeData GetMethod_7;
    VirtualInvokeData GetMethods_2;
    VirtualInvokeData GetField_2;
    VirtualInvokeData GetFields_2;
    VirtualInvokeData GetProperty_7;
    VirtualInvokeData GetProperty_8;
    VirtualInvokeData GetProperties_2;
    VirtualInvokeData GetMember_3;
    VirtualInvokeData GetMembers_2;
    VirtualInvokeData InvokeMember_3;
    VirtualInvokeData get_UnderlyingSystemType_1;
    VirtualInvokeData get_DeclaringMethod;
    VirtualInvokeData MakePointerType;
    VirtualInvokeData get_StructLayoutAttribute;
    VirtualInvokeData MakeByRefType;
    VirtualInvokeData MakeArrayType;
    VirtualInvokeData MakeArrayType_1;
    VirtualInvokeData GetTypeCodeImpl;
    VirtualInvokeData __unknown_5;
    VirtualInvokeData __unknown_6;
    VirtualInvokeData __unknown_7;
    VirtualInvokeData get_TypeHandle_1;
    VirtualInvokeData GetTypeHandleInternal;
    VirtualInvokeData __unknown_8;
    VirtualInvokeData __unknown_9;
    VirtualInvokeData __unknown_10;
    VirtualInvokeData GetArrayRank_1;
    VirtualInvokeData __unknown_11;
    VirtualInvokeData __unknown_12;
    VirtualInvokeData __unknown_13;
    VirtualInvokeData __unknown_14;
    VirtualInvokeData __unknown_15;
    VirtualInvokeData __unknown_16;
    VirtualInvokeData __unknown_17;
    VirtualInvokeData __unknown_18;
    VirtualInvokeData __unknown_19;
    VirtualInvokeData FindInterfaces_1;
    VirtualInvokeData __unknown_20;
    VirtualInvokeData GetEvents_2;
    VirtualInvokeData __unknown_21;
    VirtualInvokeData __unknown_22;
    VirtualInvokeData __unknown_23;
    VirtualInvokeData __unknown_24;
    VirtualInvokeData __unknown_25;
    VirtualInvokeData GetMember_4;
    VirtualInvokeData GetMember_5;
    VirtualInvokeData __unknown_26;
    VirtualInvokeData GetDefaultMembers_1;
    VirtualInvokeData FindMembers_1;
    VirtualInvokeData get_GenericParameterAttributes;
    VirtualInvokeData get_IsEnum_1;
    VirtualInvokeData get_IsSerializable_1;
    VirtualInvokeData get_IsSzArray;
    VirtualInvokeData get_IsGenericType;
    VirtualInvokeData get_IsGenericTypeDefinition;
    VirtualInvokeData get_IsConstructedGenericType;
    VirtualInvokeData get_IsGenericParameter;
    VirtualInvokeData get_GenericParameterPosition;
    VirtualInvokeData get_ContainsGenericParameters;
    VirtualInvokeData GetGenericParameterConstraints;
    VirtualInvokeData IsValueTypeImpl;
    VirtualInvokeData __unknown_27;
    VirtualInvokeData __unknown_28;
    VirtualInvokeData __unknown_29;
    VirtualInvokeData __unknown_30;
    VirtualInvokeData __unknown_31;
    VirtualInvokeData __unknown_32;
    VirtualInvokeData IsWindowsRuntimeObjectImpl;
    VirtualInvokeData IsExportedToWindowsRuntimeImpl;
    VirtualInvokeData MakeGenericType;
    VirtualInvokeData IsContextfulImpl;
    VirtualInvokeData IsMarshalByRefImpl;
    VirtualInvokeData HasProxyAttributeImpl;
    VirtualInvokeData __unknown_33;
    VirtualInvokeData GetGenericArguments;
    VirtualInvokeData get_GenericTypeArguments;
    VirtualInvokeData GetGenericTypeDefinition;
    VirtualInvokeData __unknown_34;
    VirtualInvokeData GetEnumNames;
    VirtualInvokeData GetEnumValues;
    VirtualInvokeData GetEnumUnderlyingType;
    VirtualInvokeData IsEnumDefined;
    VirtualInvokeData GetEnumName;
    VirtualInvokeData get_IsSecurityCritical;
    VirtualInvokeData get_IsSecuritySafeCritical;
    VirtualInvokeData get_IsSecurityTransparent;
    VirtualInvokeData __unknown_35;
    VirtualInvokeData IsSubclassOf_1;
    VirtualInvokeData IsInstanceOfType_1;
    VirtualInvokeData IsAssignableFrom_1;
    VirtualInvokeData IsEquivalentTo;
    VirtualInvokeData FormatTypeName;
    VirtualInvokeData Equals_4;
    VirtualInvokeData GetInterfaceMap_1;
    VirtualInvokeData get_IsSZArray;
    VirtualInvokeData InternalResolve;
    VirtualInvokeData RuntimeResolve;
    VirtualInvokeData get_IsUserType;
    VirtualInvokeData GetMethod_8;
    VirtualInvokeData GetConstructor_3;
    VirtualInvokeData GetField_3;
    VirtualInvokeData System_Reflection_IReflectableType_GetTypeInfo;
    VirtualInvokeData AsType;
    VirtualInvokeData get_GenericTypeParameters;
    VirtualInvokeData IsAssignableFrom_2;
    VirtualInvokeData GetDeclaredEvent;
    VirtualInvokeData GetDeclaredField;
    VirtualInvokeData GetDeclaredMethod;
    VirtualInvokeData GetDeclaredMethods;
    VirtualInvokeData GetDeclaredNestedType;
    VirtualInvokeData GetDeclaredProperty;
    VirtualInvokeData get_DeclaredConstructors;
    VirtualInvokeData get_DeclaredEvents;
    VirtualInvokeData get_DeclaredFields;
    VirtualInvokeData get_DeclaredMembers;
    VirtualInvokeData get_DeclaredMethods;
    VirtualInvokeData get_DeclaredNestedTypes;
    VirtualInvokeData get_DeclaredProperties;
    VirtualInvokeData get_ImplementedInterfaces;
};

struct TypeBuilderInstantiation__StaticFields {
};

struct TypeBuilderInstantiation__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TypeBuilderInstantiation__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TypeBuilderInstantiation__VTable vtable;
};

struct BufferedStream__Fields {
    struct Stream__Fields _;
    struct Stream *_stream;
    struct Byte__Array *_buffer;
    int32_t _bufferSize;
    int32_t _readPos;
    int32_t _readLen;
    int32_t _writePos;
    struct BeginEndAwaitableAdapter *_beginEndAwaitable;
    struct Task_1_System_Int32_ *_lastSyncCompletedReadTask;
};

struct BufferedStream {
    struct BufferedStream__Class *klass;
    MonitorData *monitor;
    struct BufferedStream__Fields fields;
};

struct __declspec(align(8)) BeginEndAwaitableAdapter__Fields {
    struct IAsyncResult *_asyncResult;
    struct Action *_continuation;
};

struct BeginEndAwaitableAdapter {
    struct BeginEndAwaitableAdapter__Class *klass;
    MonitorData *monitor;
    struct BeginEndAwaitableAdapter__Fields fields;
};

struct BeginEndAwaitableAdapter__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData UnsafeOnCompleted;
    VirtualInvokeData OnCompleted;
};

struct BeginEndAwaitableAdapter__StaticFields {
    struct Action *CALLBACK_RAN;
    struct AsyncCallback *Callback;
};

struct BeginEndAwaitableAdapter__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct BeginEndAwaitableAdapter__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct BeginEndAwaitableAdapter__VTable vtable;
};

struct BufferedStream__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_CanRead;
    VirtualInvokeData get_CanSeek;
    VirtualInvokeData get_CanTimeout;
    VirtualInvokeData get_CanWrite;
    VirtualInvokeData get_Length;
    VirtualInvokeData get_Position;
    VirtualInvokeData set_Position;
    VirtualInvokeData get_ReadTimeout;
    VirtualInvokeData set_ReadTimeout;
    VirtualInvokeData get_WriteTimeout;
    VirtualInvokeData set_WriteTimeout;
    VirtualInvokeData CopyToAsync;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Close;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData Flush;
    VirtualInvokeData FlushAsync;
    VirtualInvokeData CreateWaitHandle;
    VirtualInvokeData BeginRead;
    VirtualInvokeData EndRead;
    VirtualInvokeData ReadAsync;
    VirtualInvokeData BeginWrite;
    VirtualInvokeData EndWrite;
    VirtualInvokeData WriteAsync;
    VirtualInvokeData Seek;
    VirtualInvokeData SetLength;
    VirtualInvokeData Read;
    VirtualInvokeData ReadByte;
    VirtualInvokeData Write;
    VirtualInvokeData WriteByte;
    VirtualInvokeData ObjectInvariant;
    VirtualInvokeData Read_1;
    VirtualInvokeData Write_1;
    VirtualInvokeData ReadAsync_1;
    VirtualInvokeData WriteAsync_1;
};

struct BufferedStream__StaticFields {
};

struct BufferedStream__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct BufferedStream__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct BufferedStream__VTable vtable;
};

struct AsyncMethodBuilderCore {
    struct IAsyncStateMachine *m_stateMachine;
    struct Action *m_defaultContextAction;
};

struct AsyncMethodBuilderCore__Boxed {
    struct AsyncMethodBuilderCore__Class *klass;
    MonitorData *monitor;
    struct AsyncMethodBuilderCore fields;
};

struct AsyncTaskMethodBuilder_1_System_Threading_Tasks_VoidTaskResult_ {
    struct AsyncMethodBuilderCore m_coreState;
    struct Task_1_VoidTaskResult_ *m_task;
};

struct AsyncTaskMethodBuilder_1_System_Threading_Tasks_VoidTaskResult___Boxed {
    struct AsyncTaskMethodBuilder_1_System_Threading_Tasks_VoidTaskResult___Class *klass;
    MonitorData *monitor;
    struct AsyncTaskMethodBuilder_1_System_Threading_Tasks_VoidTaskResult_ fields;
};

struct AsyncTaskMethodBuilder {
    struct AsyncTaskMethodBuilder_1_System_Threading_Tasks_VoidTaskResult_ m_builder;
};

struct AsyncTaskMethodBuilder__Boxed {
    struct AsyncTaskMethodBuilder__Class *klass;
    MonitorData *monitor;
    struct AsyncTaskMethodBuilder fields;
};

struct ConfiguredTaskAwaitable_ConfiguredTaskAwaiter {
    struct Task *m_task;
    bool m_continueOnCapturedContext;
};

struct ConfiguredTaskAwaitable_ConfiguredTaskAwaiter__Boxed {
    struct ConfiguredTaskAwaitable_ConfiguredTaskAwaiter__Class *klass;
    MonitorData *monitor;
    struct ConfiguredTaskAwaitable_ConfiguredTaskAwaiter fields;
};

struct BufferedStream_FlushAsyncInternal_d_38 {
    int32_t __1__state;
    struct AsyncTaskMethodBuilder __t__builder;
    struct BufferedStream *_this;
    int32_t writePos;
    struct CancellationToken cancellationToken;
    int32_t readPos;
    int32_t readLen;
    struct Stream *stream;
    struct SemaphoreSlim *_sem_5__1;
    struct ConfiguredTaskAwaitable_ConfiguredTaskAwaiter __u__1;
};

struct BufferedStream_FlushAsyncInternal_d_38__Boxed {
    struct BufferedStream_FlushAsyncInternal_d_38__Class *klass;
    MonitorData *monitor;
    struct BufferedStream_FlushAsyncInternal_d_38 fields;
};

struct IAsyncStateMachine {
    struct IAsyncStateMachine__Class *klass;
    MonitorData *monitor;
};

struct IAsyncStateMachine__VTable {
    VirtualInvokeData MoveNext;
    VirtualInvokeData SetStateMachine;
};

struct IAsyncStateMachine__StaticFields {
};

struct IAsyncStateMachine__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IAsyncStateMachine__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IAsyncStateMachine__VTable vtable;
};

struct AsyncMethodBuilderCore__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct AsyncMethodBuilderCore__StaticFields {
};

struct AsyncMethodBuilderCore__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AsyncMethodBuilderCore__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AsyncMethodBuilderCore__VTable vtable;
};

struct AsyncTaskMethodBuilder_1_System_Threading_Tasks_VoidTaskResult___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct AsyncTaskMethodBuilder_1_System_Threading_Tasks_VoidTaskResult___StaticFields {
    struct Task_1_VoidTaskResult_ *s_defaultResultTask;
};

struct AsyncTaskMethodBuilder_1_System_Threading_Tasks_VoidTaskResult___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AsyncTaskMethodBuilder_1_System_Threading_Tasks_VoidTaskResult___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AsyncTaskMethodBuilder_1_System_Threading_Tasks_VoidTaskResult___VTable vtable;
};

struct AsyncTaskMethodBuilder__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct AsyncTaskMethodBuilder__StaticFields {
    struct Task_1_VoidTaskResult_ *s_cachedCompleted;
};

struct AsyncTaskMethodBuilder__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AsyncTaskMethodBuilder__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AsyncTaskMethodBuilder__VTable vtable;
};

struct ConfiguredTaskAwaitable_ConfiguredTaskAwaiter__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData UnsafeOnCompleted;
    VirtualInvokeData OnCompleted;
};

struct ConfiguredTaskAwaitable_ConfiguredTaskAwaiter__StaticFields {
};

struct ConfiguredTaskAwaitable_ConfiguredTaskAwaiter__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ConfiguredTaskAwaitable_ConfiguredTaskAwaiter__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ConfiguredTaskAwaitable_ConfiguredTaskAwaiter__VTable vtable;
};

struct BufferedStream_FlushAsyncInternal_d_38__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData MoveNext;
    VirtualInvokeData SetStateMachine;
};

struct BufferedStream_FlushAsyncInternal_d_38__StaticFields {
};

struct BufferedStream_FlushAsyncInternal_d_38__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct BufferedStream_FlushAsyncInternal_d_38__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct BufferedStream_FlushAsyncInternal_d_38__VTable vtable;
};

struct BufferedStream_FlushWriteAsync_d_42 {
    int32_t __1__state;
    struct AsyncTaskMethodBuilder __t__builder;
    struct BufferedStream *__4__this;
    struct CancellationToken cancellationToken;
    struct ConfiguredTaskAwaitable_ConfiguredTaskAwaiter __u__1;
};

struct BufferedStream_FlushWriteAsync_d_42__Boxed {
    struct BufferedStream_FlushWriteAsync_d_42__Class *klass;
    MonitorData *monitor;
    struct BufferedStream_FlushWriteAsync_d_42 fields;
};

struct BufferedStream_FlushWriteAsync_d_42__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData MoveNext;
    VirtualInvokeData SetStateMachine;
};

struct BufferedStream_FlushWriteAsync_d_42__StaticFields {
};

struct BufferedStream_FlushWriteAsync_d_42__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct BufferedStream_FlushWriteAsync_d_42__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct BufferedStream_FlushWriteAsync_d_42__VTable vtable;
};

struct AsyncTaskMethodBuilder_1_System_Int32_ {
    struct AsyncMethodBuilderCore m_coreState;
    struct Task_1_System_Int32_ *m_task;
};

struct AsyncTaskMethodBuilder_1_System_Int32___Boxed {
    struct AsyncTaskMethodBuilder_1_System_Int32___Class *klass;
    MonitorData *monitor;
    struct AsyncTaskMethodBuilder_1_System_Int32_ fields;
};

struct ConfiguredTaskAwaitable_1_TResult_ConfiguredTaskAwaiter_System_Int32_ {
    struct Task_1_System_Int32_ *m_task;
    bool m_continueOnCapturedContext;
};

struct ConfiguredTaskAwaitable_1_TResult_ConfiguredTaskAwaiter_System_Int32___Boxed {
    struct ConfiguredTaskAwaitable_1_TResult_ConfiguredTaskAwaiter_System_Int32___Class *klass;
    MonitorData *monitor;
    struct ConfiguredTaskAwaitable_1_TResult_ConfiguredTaskAwaiter_System_Int32_ fields;
};

struct BufferedStream_ReadFromUnderlyingStreamAsync_d_51 {
    int32_t __1__state;
    struct AsyncTaskMethodBuilder_1_System_Int32_ __t__builder;
    struct Task *semaphoreLockTask;
    struct BufferedStream *__4__this;
    struct Byte__Array *array;
    int32_t offset;
    int32_t count;
    int32_t bytesAlreadySatisfied;
    struct CancellationToken cancellationToken;
    bool useApmPattern;
    struct ConfiguredTaskAwaitable_ConfiguredTaskAwaiter __u__1;
    int32_t __7__wrap1;
    struct Stream *__7__wrap2;
    struct Object *__u__2;
    struct ConfiguredTaskAwaitable_1_TResult_ConfiguredTaskAwaiter_System_Int32_ __u__3;
};

struct BufferedStream_ReadFromUnderlyingStreamAsync_d_51__Boxed {
    struct BufferedStream_ReadFromUnderlyingStreamAsync_d_51__Class *klass;
    MonitorData *monitor;
    struct BufferedStream_ReadFromUnderlyingStreamAsync_d_51 fields;
};

struct AsyncTaskMethodBuilder_1_System_Int32___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct AsyncTaskMethodBuilder_1_System_Int32___StaticFields {
    struct Task_1_System_Int32_ *s_defaultResultTask;
};

struct AsyncTaskMethodBuilder_1_System_Int32___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AsyncTaskMethodBuilder_1_System_Int32___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AsyncTaskMethodBuilder_1_System_Int32___VTable vtable;
};

struct ConfiguredTaskAwaitable_1_TResult_ConfiguredTaskAwaiter_System_Int32___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData UnsafeOnCompleted;
    VirtualInvokeData OnCompleted;
};

struct ConfiguredTaskAwaitable_1_TResult_ConfiguredTaskAwaiter_System_Int32___StaticFields {
};

struct ConfiguredTaskAwaitable_1_TResult_ConfiguredTaskAwaiter_System_Int32___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ConfiguredTaskAwaitable_1_TResult_ConfiguredTaskAwaiter_System_Int32___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ConfiguredTaskAwaitable_1_TResult_ConfiguredTaskAwaiter_System_Int32___VTable vtable;
};

struct BufferedStream_ReadFromUnderlyingStreamAsync_d_51__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData MoveNext;
    VirtualInvokeData SetStateMachine;
};

struct BufferedStream_ReadFromUnderlyingStreamAsync_d_51__StaticFields {
};

struct BufferedStream_ReadFromUnderlyingStreamAsync_d_51__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct BufferedStream_ReadFromUnderlyingStreamAsync_d_51__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct BufferedStream_ReadFromUnderlyingStreamAsync_d_51__VTable vtable;
};

struct BufferedStream_WriteToUnderlyingStreamAsync_d_60 {
    int32_t __1__state;
    struct AsyncTaskMethodBuilder __t__builder;
    struct Task *semaphoreLockTask;
    struct BufferedStream *__4__this;
    int32_t count;
    struct Byte__Array *array;
    int32_t offset;
    bool useApmPattern;
    struct CancellationToken cancellationToken;
    int32_t _totalUserBytes_5__1;
    struct ConfiguredTaskAwaitable_ConfiguredTaskAwaiter __u__1;
    struct Stream *__7__wrap1;
    struct Object *__u__2;
};

struct BufferedStream_WriteToUnderlyingStreamAsync_d_60__Boxed {
    struct BufferedStream_WriteToUnderlyingStreamAsync_d_60__Class *klass;
    MonitorData *monitor;
    struct BufferedStream_WriteToUnderlyingStreamAsync_d_60 fields;
};

struct BufferedStream_WriteToUnderlyingStreamAsync_d_60__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData MoveNext;
    VirtualInvokeData SetStateMachine;
};

struct BufferedStream_WriteToUnderlyingStreamAsync_d_60__StaticFields {
};

struct BufferedStream_WriteToUnderlyingStreamAsync_d_60__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct BufferedStream_WriteToUnderlyingStreamAsync_d_60__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct BufferedStream_WriteToUnderlyingStreamAsync_d_60__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum SearchOption__Enum : int32_t {
    SearchOption__Enum_TopDirectoryOnly = 0x00000000,
    SearchOption__Enum_AllDirectories = 0x00000001,
};

#else
enum SearchOption__Enum {
    SearchOption__Enum_TopDirectoryOnly = 0x00000000,
    SearchOption__Enum_AllDirectories = 0x00000001,
};

#endif
struct SearchOption__Enum__Boxed {
    struct SearchOption__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum SearchOption__Enum value;
    #else
    uint32_t value;
    #endif
};

struct SearchOption__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct SearchOption__Enum__StaticFields {
};

struct SearchOption__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SearchOption__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SearchOption__Enum__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum FileAttributes__Enum : int32_t {
    FileAttributes__Enum_Archive = 0x00000020,
    FileAttributes__Enum_Compressed = 0x00000800,
    FileAttributes__Enum_Device = 0x00000040,
    FileAttributes__Enum_Directory = 0x00000010,
    FileAttributes__Enum_Encrypted = 0x00004000,
    FileAttributes__Enum_Hidden = 0x00000002,
    FileAttributes__Enum_Normal = 0x00000080,
    FileAttributes__Enum_NotContentIndexed = 0x00002000,
    FileAttributes__Enum_Offline = 0x00001000,
    FileAttributes__Enum_ReadOnly = 0x00000001,
    FileAttributes__Enum_ReparsePoint = 0x00000400,
    FileAttributes__Enum_SparseFile = 0x00000200,
    FileAttributes__Enum_System = 0x00000004,
    FileAttributes__Enum_Temporary = 0x00000100,
    FileAttributes__Enum_IntegrityStream = 0x00008000,
    FileAttributes__Enum_NoScrubData = 0x00020000,
};

#else
enum FileAttributes__Enum {
    FileAttributes__Enum_Archive = 0x00000020,
    FileAttributes__Enum_Compressed = 0x00000800,
    FileAttributes__Enum_Device = 0x00000040,
    FileAttributes__Enum_Directory = 0x00000010,
    FileAttributes__Enum_Encrypted = 0x00004000,
    FileAttributes__Enum_Hidden = 0x00000002,
    FileAttributes__Enum_Normal = 0x00000080,
    FileAttributes__Enum_NotContentIndexed = 0x00002000,
    FileAttributes__Enum_Offline = 0x00001000,
    FileAttributes__Enum_ReadOnly = 0x00000001,
    FileAttributes__Enum_ReparsePoint = 0x00000400,
    FileAttributes__Enum_SparseFile = 0x00000200,
    FileAttributes__Enum_System = 0x00000004,
    FileAttributes__Enum_Temporary = 0x00000100,
    FileAttributes__Enum_IntegrityStream = 0x00008000,
    FileAttributes__Enum_NoScrubData = 0x00020000,
};

#endif
struct FileAttributes__Enum__Boxed {
    struct FileAttributes__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum FileAttributes__Enum value;
    #else
    uint32_t value;
    #endif
};

struct MonoIOStat {
    #if defined(_CPLUSPLUS_)
    enum FileAttributes__Enum fileAttributes;
    #else
    uint32_t fileAttributes;
    #endif
    int64_t Length;
    int64_t CreationTime;
    int64_t LastAccessTime;
    int64_t LastWriteTime;
};

struct MonoIOStat__Boxed {
    struct MonoIOStat__Class *klass;
    MonitorData *monitor;
    struct MonoIOStat fields;
};

struct FileSystemInfo__Fields {
    struct MarshalByRefObject__Fields _;
    struct MonoIOStat _data;
    int32_t _dataInitialised;
    struct String *FullPath;
    struct String *OriginalPath;
    struct String *_displayPath;
};

struct FileSystemInfo {
    struct FileSystemInfo__Class *klass;
    MonitorData *monitor;
    struct FileSystemInfo__Fields fields;
};

struct DirectoryInfo__Fields {
    struct FileSystemInfo__Fields _;
    struct String *current;
    struct String *parent;
};

struct DirectoryInfo {
    struct DirectoryInfo__Class *klass;
    MonitorData *monitor;
    struct DirectoryInfo__Fields fields;
};

struct FileInfo__Fields {
    struct FileSystemInfo__Fields _;
    struct String *_name;
};

struct FileInfo {
    struct FileInfo__Class *klass;
    MonitorData *monitor;
    struct FileInfo__Fields fields;
};

struct FileAttributes__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct FileAttributes__Enum__StaticFields {
};

struct FileAttributes__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FileAttributes__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FileAttributes__Enum__VTable vtable;
};

struct MonoIOStat__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct MonoIOStat__StaticFields {
};

struct MonoIOStat__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MonoIOStat__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MonoIOStat__VTable vtable;
};

struct FileInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_FullName;
    VirtualInvokeData get_UnsafeGetFullName;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_Exists;
    VirtualInvokeData Delete;
    VirtualInvokeData GetObjectData_1;
};

struct FileInfo__StaticFields {
};

struct FileInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FileInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FileInfo__VTable vtable;
};

struct FileSystemInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_FullName;
    VirtualInvokeData get_UnsafeGetFullName;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
    VirtualInvokeData __unknown_2;
    VirtualInvokeData GetObjectData_1;
};

struct FileSystemInfo__StaticFields {
};

struct FileSystemInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FileSystemInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FileSystemInfo__VTable vtable;
};

struct DirectoryInfo__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_FullName;
    VirtualInvokeData get_UnsafeGetFullName;
    VirtualInvokeData get_Name;
    VirtualInvokeData get_Exists;
    VirtualInvokeData Delete;
    VirtualInvokeData GetObjectData_1;
};

struct DirectoryInfo__StaticFields {
};

struct DirectoryInfo__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DirectoryInfo__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DirectoryInfo__VTable vtable;
};

struct FileSystemSecurity__Fields {
    struct NativeObjectSecurity__Fields _;
};

struct FileSystemSecurity {
    struct FileSystemSecurity__Class *klass;
    MonitorData *monitor;
    struct FileSystemSecurity__Fields fields;
};

struct DirectorySecurity__Fields {
    struct FileSystemSecurity__Fields _;
};

struct DirectorySecurity {
    struct DirectorySecurity__Class *klass;
    MonitorData *monitor;
    struct DirectorySecurity__Fields fields;
};

struct FileSystemSecurity__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_AccessRightType;
    VirtualInvokeData get_AccessRuleType;
    VirtualInvokeData get_AuditRuleType;
    VirtualInvokeData AccessRuleFactory;
    VirtualInvokeData AuditRuleFactory;
    VirtualInvokeData ModifyAccessRule;
    VirtualInvokeData ModifyAuditRule;
    VirtualInvokeData PurgeAccessRules;
    VirtualInvokeData PurgeAuditRules;
    VirtualInvokeData ModifyAccess;
    VirtualInvokeData ModifyAudit;
    VirtualInvokeData Persist;
    VirtualInvokeData Persist_1;
    VirtualInvokeData Persist_2;
    VirtualInvokeData InternalAccessRuleFactory;
    VirtualInvokeData InternalAuditRuleFactory;
    VirtualInvokeData InternalGet;
    VirtualInvokeData InternalGet_1;
    VirtualInvokeData InternalSet;
    VirtualInvokeData InternalSet_1;
};

struct FileSystemSecurity__StaticFields {
};

struct FileSystemSecurity__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FileSystemSecurity__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FileSystemSecurity__VTable vtable;
};

struct DirectorySecurity__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_AccessRightType;
    VirtualInvokeData get_AccessRuleType;
    VirtualInvokeData get_AuditRuleType;
    VirtualInvokeData AccessRuleFactory;
    VirtualInvokeData AuditRuleFactory;
    VirtualInvokeData ModifyAccessRule;
    VirtualInvokeData ModifyAuditRule;
    VirtualInvokeData PurgeAccessRules;
    VirtualInvokeData PurgeAuditRules;
    VirtualInvokeData ModifyAccess;
    VirtualInvokeData ModifyAudit;
    VirtualInvokeData Persist;
    VirtualInvokeData Persist_1;
    VirtualInvokeData Persist_2;
    VirtualInvokeData InternalAccessRuleFactory;
    VirtualInvokeData InternalAuditRuleFactory;
    VirtualInvokeData InternalGet;
    VirtualInvokeData InternalGet_1;
    VirtualInvokeData InternalSet;
    VirtualInvokeData InternalSet_1;
};

struct DirectorySecurity__StaticFields {
};

struct DirectorySecurity__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DirectorySecurity__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DirectorySecurity__VTable vtable;
};

struct __declspec(align(8)) Directory_SearchData__Fields {
    struct String *fullPath;
    struct String *userPath;
    #if defined(_CPLUSPLUS_)
    enum SearchOption__Enum searchOption;
    #else
    uint32_t searchOption;
    #endif
};

struct Directory_SearchData {
    struct Directory_SearchData__Class *klass;
    MonitorData *monitor;
    struct Directory_SearchData__Fields fields;
};

struct Directory_SearchData__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Directory_SearchData__StaticFields {
};

struct Directory_SearchData__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Directory_SearchData__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Directory_SearchData__VTable vtable;
};

struct DirectoryNotFoundException__Fields {
    struct IOException__Fields _;
};

struct DirectoryNotFoundException {
    struct DirectoryNotFoundException__Class *klass;
    MonitorData *monitor;
    struct DirectoryNotFoundException__Fields fields;
};

struct DirectoryNotFoundException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct DirectoryNotFoundException__StaticFields {
};

struct DirectoryNotFoundException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DirectoryNotFoundException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DirectoryNotFoundException__VTable vtable;
};

struct DriveNotFoundException__Fields {
    struct IOException__Fields _;
};

struct DriveNotFoundException {
    struct DriveNotFoundException__Class *klass;
    MonitorData *monitor;
    struct DriveNotFoundException__Fields fields;
};

struct DriveNotFoundException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct DriveNotFoundException__StaticFields {
};

struct DriveNotFoundException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DriveNotFoundException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DriveNotFoundException__VTable vtable;
};

struct EndOfStreamException__Fields {
    struct IOException__Fields _;
};

struct EndOfStreamException {
    struct EndOfStreamException__Class *klass;
    MonitorData *monitor;
    struct EndOfStreamException__Fields fields;
};

struct EndOfStreamException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct EndOfStreamException__StaticFields {
};

struct EndOfStreamException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct EndOfStreamException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct EndOfStreamException__VTable vtable;
};

struct FileSecurity__Fields {
    struct FileSystemSecurity__Fields _;
};

struct FileSecurity {
    struct FileSecurity__Class *klass;
    MonitorData *monitor;
    struct FileSecurity__Fields fields;
};

struct FileSecurity__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_AccessRightType;
    VirtualInvokeData get_AccessRuleType;
    VirtualInvokeData get_AuditRuleType;
    VirtualInvokeData AccessRuleFactory;
    VirtualInvokeData AuditRuleFactory;
    VirtualInvokeData ModifyAccessRule;
    VirtualInvokeData ModifyAuditRule;
    VirtualInvokeData PurgeAccessRules;
    VirtualInvokeData PurgeAuditRules;
    VirtualInvokeData ModifyAccess;
    VirtualInvokeData ModifyAudit;
    VirtualInvokeData Persist;
    VirtualInvokeData Persist_1;
    VirtualInvokeData Persist_2;
    VirtualInvokeData InternalAccessRuleFactory;
    VirtualInvokeData InternalAuditRuleFactory;
    VirtualInvokeData InternalGet;
    VirtualInvokeData InternalGet_1;
    VirtualInvokeData InternalSet;
    VirtualInvokeData InternalSet_1;
};

struct FileSecurity__StaticFields {
};

struct FileSecurity__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FileSecurity__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FileSecurity__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum FileMode__Enum : int32_t {
    FileMode__Enum_CreateNew = 0x00000001,
    FileMode__Enum_Create = 0x00000002,
    FileMode__Enum_Open = 0x00000003,
    FileMode__Enum_OpenOrCreate = 0x00000004,
    FileMode__Enum_Truncate = 0x00000005,
    FileMode__Enum_Append = 0x00000006,
};

#else
enum FileMode__Enum {
    FileMode__Enum_CreateNew = 0x00000001,
    FileMode__Enum_Create = 0x00000002,
    FileMode__Enum_Open = 0x00000003,
    FileMode__Enum_OpenOrCreate = 0x00000004,
    FileMode__Enum_Truncate = 0x00000005,
    FileMode__Enum_Append = 0x00000006,
};

#endif
struct FileMode__Enum__Boxed {
    struct FileMode__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum FileMode__Enum value;
    #else
    uint32_t value;
    #endif
};

struct FileMode__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct FileMode__Enum__StaticFields {
};

struct FileMode__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FileMode__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FileMode__Enum__VTable vtable;
};

#if defined(_CPLUSPLUS_)
enum FileShare__Enum : int32_t {
    FileShare__Enum_None = 0x00000000,
    FileShare__Enum_Read = 0x00000001,
    FileShare__Enum_Write = 0x00000002,
    FileShare__Enum_ReadWrite = 0x00000003,
    FileShare__Enum_Delete = 0x00000004,
    FileShare__Enum_Inheritable = 0x00000010,
};

#else
enum FileShare__Enum {
    FileShare__Enum_None = 0x00000000,
    FileShare__Enum_Read = 0x00000001,
    FileShare__Enum_Write = 0x00000002,
    FileShare__Enum_ReadWrite = 0x00000003,
    FileShare__Enum_Delete = 0x00000004,
    FileShare__Enum_Inheritable = 0x00000010,
};

#endif
struct FileShare__Enum__Boxed {
    struct FileShare__Enum__Class *klass;
    MonitorData *monitor;
    #if defined(_CPLUSPLUS_)
    enum FileShare__Enum value;
    #else
    uint32_t value;
    #endif
};

struct FileShare__Enum__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CompareTo;
    VirtualInvokeData ToString_1;
    VirtualInvokeData GetTypeCode;
    VirtualInvokeData System_IConvertible_ToBoolean;
    VirtualInvokeData System_IConvertible_ToChar;
    VirtualInvokeData System_IConvertible_ToSByte;
    VirtualInvokeData System_IConvertible_ToByte;
    VirtualInvokeData System_IConvertible_ToInt16;
    VirtualInvokeData System_IConvertible_ToUInt16;
    VirtualInvokeData System_IConvertible_ToInt32;
    VirtualInvokeData System_IConvertible_ToUInt32;
    VirtualInvokeData System_IConvertible_ToInt64;
    VirtualInvokeData System_IConvertible_ToUInt64;
    VirtualInvokeData System_IConvertible_ToSingle;
    VirtualInvokeData System_IConvertible_ToDouble;
    VirtualInvokeData System_IConvertible_ToDecimal;
    VirtualInvokeData System_IConvertible_ToDateTime;
    VirtualInvokeData ToString_2;
    VirtualInvokeData System_IConvertible_ToType;
};

struct FileShare__Enum__StaticFields {
};

struct FileShare__Enum__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FileShare__Enum__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FileShare__Enum__VTable vtable;
};

struct FileLoadException__Fields {
    struct IOException__Fields _;
    struct String *_fileName;
    struct String *_fusionLog;
};

struct FileLoadException {
    struct FileLoadException__Class *klass;
    MonitorData *monitor;
    struct FileLoadException__Fields fields;
};

struct FileLoadException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct FileLoadException__StaticFields {
};

struct FileLoadException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FileLoadException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FileLoadException__VTable vtable;
};

struct FileNotFoundException__Fields {
    struct IOException__Fields _;
    struct String *_fileName;
    struct String *_fusionLog;
};

struct FileNotFoundException {
    struct FileNotFoundException__Class *klass;
    MonitorData *monitor;
    struct FileNotFoundException__Fields fields;
};

struct FileNotFoundException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct FileNotFoundException__StaticFields {
};

struct FileNotFoundException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FileNotFoundException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FileNotFoundException__VTable vtable;
};

struct IEnumerable_1_System_IO_FileInfo_ {
    struct IEnumerable_1_System_IO_FileInfo___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_IO_FileInfo___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_IO_FileInfo___StaticFields {
};

struct IEnumerable_1_System_IO_FileInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_IO_FileInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_IO_FileInfo___VTable vtable;
};

struct IEnumerable_1_System_IO_DirectoryInfo_ {
    struct IEnumerable_1_System_IO_DirectoryInfo___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_IO_DirectoryInfo___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_IO_DirectoryInfo___StaticFields {
};

struct IEnumerable_1_System_IO_DirectoryInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_IO_DirectoryInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_IO_DirectoryInfo___VTable vtable;
};

struct IEnumerable_1_System_IO_FileSystemInfo_ {
    struct IEnumerable_1_System_IO_FileSystemInfo___Class *klass;
    MonitorData *monitor;
};

struct IEnumerable_1_System_IO_FileSystemInfo___VTable {
    VirtualInvokeData GetEnumerator;
};

struct IEnumerable_1_System_IO_FileSystemInfo___StaticFields {
};

struct IEnumerable_1_System_IO_FileSystemInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerable_1_System_IO_FileSystemInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerable_1_System_IO_FileSystemInfo___VTable vtable;
};

struct SearchResultHandler_1_System_String_ {
    struct SearchResultHandler_1_System_String___Class *klass;
    MonitorData *monitor;
};

struct __declspec(align(8)) StringResultHandler__Fields {
    bool _includeFiles;
    bool _includeDirs;
};

struct StringResultHandler {
    struct StringResultHandler__Class *klass;
    MonitorData *monitor;
    struct StringResultHandler__Fields fields;
};

struct __declspec(align(8)) SearchResult__Fields {
    struct String *fullPath;
    struct String *userPath;
    struct Win32Native_WIN32_FIND_DATA *findData;
};

struct SearchResult {
    struct SearchResult__Class *klass;
    MonitorData *monitor;
    struct SearchResult__Fields fields;
};

struct SearchResult__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct SearchResult__StaticFields {
};

struct SearchResult__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SearchResult__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SearchResult__VTable vtable;
};

struct SearchResultHandler_1_System_String___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
};

struct SearchResultHandler_1_System_String___StaticFields {
};

struct SearchResultHandler_1_System_String___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SearchResultHandler_1_System_String___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SearchResultHandler_1_System_String___VTable vtable;
};

struct StringResultHandler__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData IsResultIncluded;
    VirtualInvokeData CreateObject;
};

struct StringResultHandler__StaticFields {
};

struct StringResultHandler__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StringResultHandler__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StringResultHandler__VTable vtable;
};

struct SearchResultHandler_1_FileInfo_ {
    struct SearchResultHandler_1_FileInfo___Class *klass;
    MonitorData *monitor;
};

struct FileInfoResultHandler {
    struct FileInfoResultHandler__Class *klass;
    MonitorData *monitor;
};

struct SearchResultHandler_1_FileInfo___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
};

struct SearchResultHandler_1_FileInfo___StaticFields {
};

struct SearchResultHandler_1_FileInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SearchResultHandler_1_FileInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SearchResultHandler_1_FileInfo___VTable vtable;
};

struct FileInfoResultHandler__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData IsResultIncluded;
    VirtualInvokeData CreateObject;
};

struct FileInfoResultHandler__StaticFields {
};

struct FileInfoResultHandler__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FileInfoResultHandler__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FileInfoResultHandler__VTable vtable;
};

struct SearchResultHandler_1_DirectoryInfo_ {
    struct SearchResultHandler_1_DirectoryInfo___Class *klass;
    MonitorData *monitor;
};

struct DirectoryInfoResultHandler {
    struct DirectoryInfoResultHandler__Class *klass;
    MonitorData *monitor;
};

struct SearchResultHandler_1_DirectoryInfo___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
};

struct SearchResultHandler_1_DirectoryInfo___StaticFields {
};

struct SearchResultHandler_1_DirectoryInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SearchResultHandler_1_DirectoryInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SearchResultHandler_1_DirectoryInfo___VTable vtable;
};

struct DirectoryInfoResultHandler__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData IsResultIncluded;
    VirtualInvokeData CreateObject;
};

struct DirectoryInfoResultHandler__StaticFields {
};

struct DirectoryInfoResultHandler__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct DirectoryInfoResultHandler__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct DirectoryInfoResultHandler__VTable vtable;
};

struct SearchResultHandler_1_FileSystemInfo_ {
    struct SearchResultHandler_1_FileSystemInfo___Class *klass;
    MonitorData *monitor;
};

struct FileSystemInfoResultHandler {
    struct FileSystemInfoResultHandler__Class *klass;
    MonitorData *monitor;
};

struct SearchResultHandler_1_FileSystemInfo___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData __unknown;
    VirtualInvokeData __unknown_1;
};

struct SearchResultHandler_1_FileSystemInfo___StaticFields {
};

struct SearchResultHandler_1_FileSystemInfo___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct SearchResultHandler_1_FileSystemInfo___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct SearchResultHandler_1_FileSystemInfo___VTable vtable;
};

struct FileSystemInfoResultHandler__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData IsResultIncluded;
    VirtualInvokeData CreateObject;
};

struct FileSystemInfoResultHandler__StaticFields {
};

struct FileSystemInfoResultHandler__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct FileSystemInfoResultHandler__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct FileSystemInfoResultHandler__VTable vtable;
};

struct MemoryStream__Fields {
    struct Stream__Fields _;
    struct Byte__Array *_buffer;
    int32_t _origin;
    int32_t _position;
    int32_t _length;
    int32_t _capacity;
    bool _expandable;
    bool _writable;
    bool _exposable;
    bool _isOpen;
    struct Task_1_System_Int32_ *_lastReadTask;
};

struct MemoryStream {
    struct MemoryStream__Class *klass;
    MonitorData *monitor;
    struct MemoryStream__Fields fields;
};

struct ArraySegment_1_Byte_ {
    struct Byte__Array *_array;
    int32_t _offset;
    int32_t _count;
};

struct ArraySegment_1_Byte___Boxed {
    struct ArraySegment_1_Byte___Class *klass;
    MonitorData *monitor;
    struct ArraySegment_1_Byte_ fields;
};

struct IEnumerator_1_System_Byte_ {
    struct IEnumerator_1_System_Byte___Class *klass;
    MonitorData *monitor;
};

struct IEnumerator_1_System_Byte___VTable {
    VirtualInvokeData get_Current;
};

struct IEnumerator_1_System_Byte___StaticFields {
};

struct IEnumerator_1_System_Byte___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct IEnumerator_1_System_Byte___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct IEnumerator_1_System_Byte___VTable vtable;
};

struct ArraySegment_1_Byte___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData System_Collections_Generic_IList_T__get_Item;
    VirtualInvokeData System_Collections_Generic_IList_T__set_Item;
    VirtualInvokeData System_Collections_Generic_IList_T__IndexOf;
    VirtualInvokeData System_Collections_Generic_IList_T__Insert;
    VirtualInvokeData System_Collections_Generic_IList_T__RemoveAt;
    VirtualInvokeData get_Count;
    VirtualInvokeData System_Collections_Generic_ICollection_T__get_IsReadOnly;
    VirtualInvokeData System_Collections_Generic_ICollection_T__Add;
    VirtualInvokeData System_Collections_Generic_ICollection_T__Clear;
    VirtualInvokeData System_Collections_Generic_ICollection_T__Contains;
    VirtualInvokeData System_Collections_Generic_ICollection_T__CopyTo;
    VirtualInvokeData System_Collections_Generic_ICollection_T__Remove;
    VirtualInvokeData System_Collections_Generic_IEnumerable_T__GetEnumerator;
    VirtualInvokeData System_Collections_IEnumerable_GetEnumerator;
    VirtualInvokeData System_Collections_Generic_IReadOnlyList_T__get_Item;
    VirtualInvokeData get_Count_1;
};

struct ArraySegment_1_Byte___StaticFields {
};

struct ArraySegment_1_Byte___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ArraySegment_1_Byte___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ArraySegment_1_Byte___VTable vtable;
};

struct ArraySegment_1_Byte__1__VTable {
};

struct ArraySegment_1_Byte__1__StaticFields {
};

struct ArraySegment_1_Byte__1__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct ArraySegment_1_Byte__1__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct ArraySegment_1_Byte__1__VTable vtable;
};

struct MemoryStream__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_CanRead;
    VirtualInvokeData get_CanSeek;
    VirtualInvokeData get_CanTimeout;
    VirtualInvokeData get_CanWrite;
    VirtualInvokeData get_Length;
    VirtualInvokeData get_Position;
    VirtualInvokeData set_Position;
    VirtualInvokeData get_ReadTimeout;
    VirtualInvokeData set_ReadTimeout;
    VirtualInvokeData get_WriteTimeout;
    VirtualInvokeData set_WriteTimeout;
    VirtualInvokeData CopyToAsync;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Close;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData Flush;
    VirtualInvokeData FlushAsync;
    VirtualInvokeData CreateWaitHandle;
    VirtualInvokeData BeginRead;
    VirtualInvokeData EndRead;
    VirtualInvokeData ReadAsync;
    VirtualInvokeData BeginWrite;
    VirtualInvokeData EndWrite;
    VirtualInvokeData WriteAsync;
    VirtualInvokeData Seek;
    VirtualInvokeData SetLength;
    VirtualInvokeData Read;
    VirtualInvokeData ReadByte;
    VirtualInvokeData Write;
    VirtualInvokeData WriteByte;
    VirtualInvokeData ObjectInvariant;
    VirtualInvokeData Read_1;
    VirtualInvokeData Write_1;
    VirtualInvokeData ReadAsync_1;
    VirtualInvokeData WriteAsync_1;
    VirtualInvokeData GetBuffer;
    VirtualInvokeData TryGetBuffer;
    VirtualInvokeData get_Capacity;
    VirtualInvokeData set_Capacity;
    VirtualInvokeData ToArray;
    VirtualInvokeData WriteTo;
};

struct MemoryStream__StaticFields {
};

struct MemoryStream__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct MemoryStream__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct MemoryStream__VTable vtable;
};

struct PathTooLongException__Fields {
    struct IOException__Fields _;
};

struct PathTooLongException {
    struct PathTooLongException__Class *klass;
    MonitorData *monitor;
    struct PathTooLongException__Fields fields;
};

struct PathTooLongException__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData get_HelpLink;
    VirtualInvokeData set_HelpLink;
    VirtualInvokeData get_InnerException;
    VirtualInvokeData get_Message;
    VirtualInvokeData get_Source;
    VirtualInvokeData set_Source;
    VirtualInvokeData get_StackTrace;
    VirtualInvokeData get_TargetSite;
    VirtualInvokeData Equals_1;
    VirtualInvokeData GetBaseException;
    VirtualInvokeData GetHashCode_1;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetType;
    VirtualInvokeData ToString_1;
    VirtualInvokeData get_Message_1;
    VirtualInvokeData get_Data;
    VirtualInvokeData GetBaseException_1;
    VirtualInvokeData get_StackTrace_1;
    VirtualInvokeData get_HelpLink_1;
    VirtualInvokeData set_HelpLink_1;
    VirtualInvokeData get_Source_1;
    VirtualInvokeData set_Source_1;
    VirtualInvokeData GetObjectData_2;
    VirtualInvokeData InternalToString;
};

struct PathTooLongException__StaticFields {
};

struct PathTooLongException__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PathTooLongException__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PathTooLongException__VTable vtable;
};

struct PinnedBufferMemoryStream__Fields {
    struct UnmanagedMemoryStream__Fields _;
    struct Byte__Array *_array;
    struct GCHandle _pinningHandle;
};

struct PinnedBufferMemoryStream {
    struct PinnedBufferMemoryStream__Class *klass;
    MonitorData *monitor;
    struct PinnedBufferMemoryStream__Fields fields;
};

struct PinnedBufferMemoryStream__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_CanRead;
    VirtualInvokeData get_CanSeek;
    VirtualInvokeData get_CanTimeout;
    VirtualInvokeData get_CanWrite;
    VirtualInvokeData get_Length;
    VirtualInvokeData get_Position;
    VirtualInvokeData set_Position;
    VirtualInvokeData get_ReadTimeout;
    VirtualInvokeData set_ReadTimeout;
    VirtualInvokeData get_WriteTimeout;
    VirtualInvokeData set_WriteTimeout;
    VirtualInvokeData CopyToAsync;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Close;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData Flush;
    VirtualInvokeData FlushAsync;
    VirtualInvokeData CreateWaitHandle;
    VirtualInvokeData BeginRead;
    VirtualInvokeData EndRead;
    VirtualInvokeData ReadAsync;
    VirtualInvokeData BeginWrite;
    VirtualInvokeData EndWrite;
    VirtualInvokeData WriteAsync;
    VirtualInvokeData Seek;
    VirtualInvokeData SetLength;
    VirtualInvokeData Read;
    VirtualInvokeData ReadByte;
    VirtualInvokeData Write;
    VirtualInvokeData WriteByte;
    VirtualInvokeData ObjectInvariant;
    VirtualInvokeData Read_1;
    VirtualInvokeData Write_1;
    VirtualInvokeData ReadAsync_1;
    VirtualInvokeData WriteAsync_1;
};

struct PinnedBufferMemoryStream__StaticFields {
};

struct PinnedBufferMemoryStream__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct PinnedBufferMemoryStream__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct PinnedBufferMemoryStream__VTable vtable;
};

struct Stream_NullStream__Fields {
    struct Stream__Fields _;
};

struct Stream_NullStream {
    struct Stream_NullStream__Class *klass;
    MonitorData *monitor;
    struct Stream_NullStream__Fields fields;
};

struct Stream_NullStream__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_CanRead;
    VirtualInvokeData get_CanSeek;
    VirtualInvokeData get_CanTimeout;
    VirtualInvokeData get_CanWrite;
    VirtualInvokeData get_Length;
    VirtualInvokeData get_Position;
    VirtualInvokeData set_Position;
    VirtualInvokeData get_ReadTimeout;
    VirtualInvokeData set_ReadTimeout;
    VirtualInvokeData get_WriteTimeout;
    VirtualInvokeData set_WriteTimeout;
    VirtualInvokeData CopyToAsync;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Close;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData Flush;
    VirtualInvokeData FlushAsync;
    VirtualInvokeData CreateWaitHandle;
    VirtualInvokeData BeginRead;
    VirtualInvokeData EndRead;
    VirtualInvokeData ReadAsync;
    VirtualInvokeData BeginWrite;
    VirtualInvokeData EndWrite;
    VirtualInvokeData WriteAsync;
    VirtualInvokeData Seek;
    VirtualInvokeData SetLength;
    VirtualInvokeData Read;
    VirtualInvokeData ReadByte;
    VirtualInvokeData Write;
    VirtualInvokeData WriteByte;
    VirtualInvokeData ObjectInvariant;
    VirtualInvokeData Read_1;
    VirtualInvokeData Write_1;
    VirtualInvokeData ReadAsync_1;
    VirtualInvokeData WriteAsync_1;
};

struct Stream_NullStream__StaticFields {
    struct Task_1_System_Int32_ *s_nullReadTask;
};

struct Stream_NullStream__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Stream_NullStream__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Stream_NullStream__VTable vtable;
};

struct __declspec(align(8)) Stream_SynchronousAsyncResult__Fields {
    struct Object *_stateObject;
    bool _isWrite;
    struct ManualResetEvent *_waitHandle;
    struct ExceptionDispatchInfo *_exceptionInfo;
    bool _endXxxCalled;
    int32_t _bytesRead;
};

struct Stream_SynchronousAsyncResult {
    struct Stream_SynchronousAsyncResult__Class *klass;
    MonitorData *monitor;
    struct Stream_SynchronousAsyncResult__Fields fields;
};

struct Stream_SynchronousAsyncResult__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData get_IsCompleted;
    VirtualInvokeData get_AsyncWaitHandle;
    VirtualInvokeData get_AsyncState;
    VirtualInvokeData get_CompletedSynchronously;
};

struct Stream_SynchronousAsyncResult__StaticFields {
};

struct Stream_SynchronousAsyncResult__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Stream_SynchronousAsyncResult__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Stream_SynchronousAsyncResult__VTable vtable;
};

struct Stream_SynchronousAsyncResult_c {
    struct Stream_SynchronousAsyncResult_c__Class *klass;
    MonitorData *monitor;
};

struct Func_1_System_Threading_ManualResetEvent___Fields {
    struct MulticastDelegate__Fields _;
};

struct Func_1_System_Threading_ManualResetEvent_ {
    struct Func_1_System_Threading_ManualResetEvent___Class *klass;
    MonitorData *monitor;
    struct Func_1_System_Threading_ManualResetEvent___Fields fields;
};

struct Func_1_System_Threading_ManualResetEvent___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Func_1_System_Threading_ManualResetEvent___StaticFields {
};

struct Func_1_System_Threading_ManualResetEvent___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Func_1_System_Threading_ManualResetEvent___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Func_1_System_Threading_ManualResetEvent___VTable vtable;
};

struct Stream_SynchronousAsyncResult_c__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Stream_SynchronousAsyncResult_c__StaticFields {
    struct Stream_SynchronousAsyncResult_c *__9;
    struct Func_1_System_Threading_ManualResetEvent_ *__9__12_0;
};

struct Stream_SynchronousAsyncResult_c__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Stream_SynchronousAsyncResult_c__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Stream_SynchronousAsyncResult_c__VTable vtable;
};

struct Stream_SyncStream__Fields {
    struct Stream__Fields _;
    struct Stream *_stream;
    struct Nullable_1_Boolean_ _overridesBeginRead;
    struct Nullable_1_Boolean_ _overridesBeginWrite;
};

struct Stream_SyncStream {
    struct Stream_SyncStream__Class *klass;
    MonitorData *monitor;
    struct Stream_SyncStream__Fields fields;
};

struct Stream_SyncStream__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_CanRead;
    VirtualInvokeData get_CanSeek;
    VirtualInvokeData get_CanTimeout;
    VirtualInvokeData get_CanWrite;
    VirtualInvokeData get_Length;
    VirtualInvokeData get_Position;
    VirtualInvokeData set_Position;
    VirtualInvokeData get_ReadTimeout;
    VirtualInvokeData set_ReadTimeout;
    VirtualInvokeData get_WriteTimeout;
    VirtualInvokeData set_WriteTimeout;
    VirtualInvokeData CopyToAsync;
    VirtualInvokeData CopyTo;
    VirtualInvokeData Close;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData Flush;
    VirtualInvokeData FlushAsync;
    VirtualInvokeData CreateWaitHandle;
    VirtualInvokeData BeginRead;
    VirtualInvokeData EndRead;
    VirtualInvokeData ReadAsync;
    VirtualInvokeData BeginWrite;
    VirtualInvokeData EndWrite;
    VirtualInvokeData WriteAsync;
    VirtualInvokeData Seek;
    VirtualInvokeData SetLength;
    VirtualInvokeData Read;
    VirtualInvokeData ReadByte;
    VirtualInvokeData Write;
    VirtualInvokeData WriteByte;
    VirtualInvokeData ObjectInvariant;
    VirtualInvokeData Read_1;
    VirtualInvokeData Write_1;
    VirtualInvokeData ReadAsync_1;
    VirtualInvokeData WriteAsync_1;
};

struct Stream_SyncStream__StaticFields {
};

struct Stream_SyncStream__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Stream_SyncStream__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Stream_SyncStream__VTable vtable;
};

struct Stream_c {
    struct Stream_c__Class *klass;
    MonitorData *monitor;
};

struct Func_1_System_Threading_SemaphoreSlim___Fields {
    struct MulticastDelegate__Fields _;
};

struct Func_1_System_Threading_SemaphoreSlim_ {
    struct Func_1_System_Threading_SemaphoreSlim___Class *klass;
    MonitorData *monitor;
    struct Func_1_System_Threading_SemaphoreSlim___Fields fields;
};

struct Func_5_System_IO_Stream_System_IO_Stream_ReadWriteParameters_AsyncCallback_Object_IAsyncResult___Fields {
    struct MulticastDelegate__Fields _;
};

struct Func_5_System_IO_Stream_System_IO_Stream_ReadWriteParameters_AsyncCallback_Object_IAsyncResult_ {
    struct Func_5_System_IO_Stream_System_IO_Stream_ReadWriteParameters_AsyncCallback_Object_IAsyncResult___Class *klass;
    MonitorData *monitor;
    struct Func_5_System_IO_Stream_System_IO_Stream_ReadWriteParameters_AsyncCallback_Object_IAsyncResult___Fields fields;
};

struct Stream_ReadWriteParameters {
    struct Byte__Array *Buffer;
    int32_t Offset;
    int32_t Count;
};

struct Stream_ReadWriteParameters__Boxed {
    struct Stream_ReadWriteParameters__Class *klass;
    MonitorData *monitor;
    struct Stream_ReadWriteParameters fields;
};

struct Func_3_System_IO_Stream_IAsyncResult_Int32___Fields {
    struct MulticastDelegate__Fields _;
};

struct Func_3_System_IO_Stream_IAsyncResult_Int32_ {
    struct Func_3_System_IO_Stream_IAsyncResult_Int32___Class *klass;
    MonitorData *monitor;
    struct Func_3_System_IO_Stream_IAsyncResult_Int32___Fields fields;
};

struct Action_2_System_Threading_Tasks_Task_Object___Fields {
    struct MulticastDelegate__Fields _;
};

struct Action_2_System_Threading_Tasks_Task_Object_ {
    struct Action_2_System_Threading_Tasks_Task_Object___Class *klass;
    MonitorData *monitor;
    struct Action_2_System_Threading_Tasks_Task_Object___Fields fields;
};

struct Func_3_System_IO_Stream_IAsyncResult_System_Threading_Tasks_VoidTaskResult___Fields {
    struct MulticastDelegate__Fields _;
};

struct Func_3_System_IO_Stream_IAsyncResult_System_Threading_Tasks_VoidTaskResult_ {
    struct Func_3_System_IO_Stream_IAsyncResult_System_Threading_Tasks_VoidTaskResult___Class *klass;
    MonitorData *monitor;
    struct Func_3_System_IO_Stream_IAsyncResult_System_Threading_Tasks_VoidTaskResult___Fields fields;
};

struct Func_1_System_Threading_SemaphoreSlim___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Func_1_System_Threading_SemaphoreSlim___StaticFields {
};

struct Func_1_System_Threading_SemaphoreSlim___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Func_1_System_Threading_SemaphoreSlim___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Func_1_System_Threading_SemaphoreSlim___VTable vtable;
};

struct Stream_ReadWriteParameters__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Stream_ReadWriteParameters__StaticFields {
};

struct Stream_ReadWriteParameters__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Stream_ReadWriteParameters__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Stream_ReadWriteParameters__VTable vtable;
};

struct Func_5_System_IO_Stream_System_IO_Stream_ReadWriteParameters_AsyncCallback_Object_IAsyncResult___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Func_5_System_IO_Stream_System_IO_Stream_ReadWriteParameters_AsyncCallback_Object_IAsyncResult___StaticFields {
};

struct Func_5_System_IO_Stream_System_IO_Stream_ReadWriteParameters_AsyncCallback_Object_IAsyncResult___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Func_5_System_IO_Stream_System_IO_Stream_ReadWriteParameters_AsyncCallback_Object_IAsyncResult___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Func_5_System_IO_Stream_System_IO_Stream_ReadWriteParameters_AsyncCallback_Object_IAsyncResult___VTable vtable;
};

struct Func_3_System_IO_Stream_IAsyncResult_Int32___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Func_3_System_IO_Stream_IAsyncResult_Int32___StaticFields {
};

struct Func_3_System_IO_Stream_IAsyncResult_Int32___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Func_3_System_IO_Stream_IAsyncResult_Int32___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Func_3_System_IO_Stream_IAsyncResult_Int32___VTable vtable;
};

struct Action_2_System_Threading_Tasks_Task_Object___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Action_2_System_Threading_Tasks_Task_Object___StaticFields {
};

struct Action_2_System_Threading_Tasks_Task_Object___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Action_2_System_Threading_Tasks_Task_Object___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Action_2_System_Threading_Tasks_Task_Object___VTable vtable;
};

struct Func_3_System_IO_Stream_IAsyncResult_System_Threading_Tasks_VoidTaskResult___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData Clone;
    VirtualInvokeData GetObjectData;
    VirtualInvokeData DynamicInvokeImpl;
    VirtualInvokeData Clone_1;
    VirtualInvokeData GetMethodImpl;
    VirtualInvokeData GetObjectData_1;
    VirtualInvokeData GetInvocationList;
    VirtualInvokeData CombineImpl;
    VirtualInvokeData RemoveImpl;
    VirtualInvokeData Invoke;
    VirtualInvokeData BeginInvoke;
    VirtualInvokeData EndInvoke;
};

struct Func_3_System_IO_Stream_IAsyncResult_System_Threading_Tasks_VoidTaskResult___StaticFields {
};

struct Func_3_System_IO_Stream_IAsyncResult_System_Threading_Tasks_VoidTaskResult___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Func_3_System_IO_Stream_IAsyncResult_System_Threading_Tasks_VoidTaskResult___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Func_3_System_IO_Stream_IAsyncResult_System_Threading_Tasks_VoidTaskResult___VTable vtable;
};

struct Stream_c__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct Stream_c__StaticFields {
    struct Stream_c *__9;
    struct Func_1_System_Threading_SemaphoreSlim_ *__9__4_0;
    struct Action_1_Object_ *__9__36_0;
    struct Func_2_Object_Int32_ *__9__39_0;
    struct Func_5_System_IO_Stream_System_IO_Stream_ReadWriteParameters_AsyncCallback_Object_IAsyncResult_ *__9__43_0;
    struct Func_3_System_IO_Stream_IAsyncResult_Int32_ *__9__43_1;
    struct Func_2_Object_Int32_ *__9__46_0;
    struct Action_2_System_Threading_Tasks_Task_Object_ *__9__47_0;
    struct Func_5_System_IO_Stream_System_IO_Stream_ReadWriteParameters_AsyncCallback_Object_IAsyncResult_ *__9__53_0;
    struct Func_3_System_IO_Stream_IAsyncResult_System_Threading_Tasks_VoidTaskResult_ *__9__53_1;
};

struct Stream_c__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Stream_c__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Stream_c__VTable vtable;
};

struct Stream_CopyToAsyncInternal_d_27 {
    int32_t __1__state;
    struct AsyncTaskMethodBuilder __t__builder;
    int32_t bufferSize;
    struct Stream *destination;
    struct Byte__Array *_buffer_5__1;
    int32_t _bytesRead_5__2;
    struct CancellationToken cancellationToken;
    struct Stream *__4__this;
    struct ConfiguredTaskAwaitable_ConfiguredTaskAwaiter __u__1;
    struct ConfiguredTaskAwaitable_1_TResult_ConfiguredTaskAwaiter_System_Int32_ __u__2;
};

struct Stream_CopyToAsyncInternal_d_27__Boxed {
    struct Stream_CopyToAsyncInternal_d_27__Class *klass;
    MonitorData *monitor;
    struct Stream_CopyToAsyncInternal_d_27 fields;
};

struct Stream_CopyToAsyncInternal_d_27__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData MoveNext;
    VirtualInvokeData SetStateMachine;
};

struct Stream_CopyToAsyncInternal_d_27__StaticFields {
};

struct Stream_CopyToAsyncInternal_d_27__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct Stream_CopyToAsyncInternal_d_27__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct Stream_CopyToAsyncInternal_d_27__VTable vtable;
};

struct StreamReader_NullStreamReader__Fields {
    struct StreamReader__Fields _;
};

struct StreamReader_NullStreamReader {
    struct StreamReader_NullStreamReader__Class *klass;
    MonitorData *monitor;
    struct StreamReader_NullStreamReader__Fields fields;
};

struct StreamReader_NullStreamReader__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData Dispose;
    VirtualInvokeData Close;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData Peek;
    VirtualInvokeData Read;
    VirtualInvokeData Read_1;
    VirtualInvokeData ReadToEnd;
    VirtualInvokeData ReadBlock;
    VirtualInvokeData ReadLine;
    VirtualInvokeData ReadLineAsync;
    VirtualInvokeData ReadToEndAsync;
    VirtualInvokeData ReadAsync;
    VirtualInvokeData ReadAsyncInternal;
    VirtualInvokeData ReadBlockAsync;
    VirtualInvokeData get_CurrentEncoding;
    VirtualInvokeData get_BaseStream;
    VirtualInvokeData ReadBuffer;
};

struct StreamReader_NullStreamReader__StaticFields {
};

struct StreamReader_NullStreamReader__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StreamReader_NullStreamReader__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StreamReader_NullStreamReader__VTable vtable;
};

struct AsyncTaskMethodBuilder_1_System_String_ {
    struct AsyncMethodBuilderCore m_coreState;
    struct Task_1_System_String_ *m_task;
};

struct AsyncTaskMethodBuilder_1_System_String___Boxed {
    struct AsyncTaskMethodBuilder_1_System_String___Class *klass;
    MonitorData *monitor;
    struct AsyncTaskMethodBuilder_1_System_String_ fields;
};

struct StreamReader_ReadLineAsyncInternal_d_61 {
    int32_t __1__state;
    struct AsyncTaskMethodBuilder_1_System_String_ __t__builder;
    struct StreamReader *__4__this;
    struct Char__Array *_tmpCharBuffer_5__1;
    struct StringBuilder *_sb_5__2;
    int32_t _tmpCharPos_5__3;
    int32_t _tmpCharLen_5__4;
    struct String *_s_5__5;
    int32_t _i_5__6;
    struct ConfiguredTaskAwaitable_1_TResult_ConfiguredTaskAwaiter_System_Int32_ __u__1;
};

struct StreamReader_ReadLineAsyncInternal_d_61__Boxed {
    struct StreamReader_ReadLineAsyncInternal_d_61__Class *klass;
    MonitorData *monitor;
    struct StreamReader_ReadLineAsyncInternal_d_61 fields;
};

struct AsyncTaskMethodBuilder_1_System_String___VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct AsyncTaskMethodBuilder_1_System_String___StaticFields {
    struct Task_1_System_String_ *s_defaultResultTask;
};

struct AsyncTaskMethodBuilder_1_System_String___Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct AsyncTaskMethodBuilder_1_System_String___StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct AsyncTaskMethodBuilder_1_System_String___VTable vtable;
};

struct StreamReader_ReadLineAsyncInternal_d_61__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData MoveNext;
    VirtualInvokeData SetStateMachine;
};

struct StreamReader_ReadLineAsyncInternal_d_61__StaticFields {
};

struct StreamReader_ReadLineAsyncInternal_d_61__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StreamReader_ReadLineAsyncInternal_d_61__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StreamReader_ReadLineAsyncInternal_d_61__VTable vtable;
};

struct StreamReader_ReadToEndAsyncInternal_d_63 {
    int32_t __1__state;
    struct AsyncTaskMethodBuilder_1_System_String_ __t__builder;
    struct StreamReader *__4__this;
    struct StringBuilder *_sb_5__1;
    struct ConfiguredTaskAwaitable_1_TResult_ConfiguredTaskAwaiter_System_Int32_ __u__1;
};

struct StreamReader_ReadToEndAsyncInternal_d_63__Boxed {
    struct StreamReader_ReadToEndAsyncInternal_d_63__Class *klass;
    MonitorData *monitor;
    struct StreamReader_ReadToEndAsyncInternal_d_63 fields;
};

struct StreamReader_ReadToEndAsyncInternal_d_63__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData MoveNext;
    VirtualInvokeData SetStateMachine;
};

struct StreamReader_ReadToEndAsyncInternal_d_63__StaticFields {
};

struct StreamReader_ReadToEndAsyncInternal_d_63__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StreamReader_ReadToEndAsyncInternal_d_63__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StreamReader_ReadToEndAsyncInternal_d_63__VTable vtable;
};

struct StreamReader_ReadAsyncInternal_d_65 {
    int32_t __1__state;
    struct AsyncTaskMethodBuilder_1_System_Int32_ __t__builder;
    struct StreamReader *__4__this;
    int32_t count;
    struct Stream *_tmpStream_5__1;
    struct Byte__Array *_tmpByteBuffer_5__2;
    bool _readToUserBuffer_5__3;
    struct Char__Array *buffer;
    int32_t index;
    int32_t _charsRead_5__4;
    int32_t _n_5__5;
    struct ConfiguredTaskAwaitable_1_TResult_ConfiguredTaskAwaiter_System_Int32_ __u__1;
};

struct StreamReader_ReadAsyncInternal_d_65__Boxed {
    struct StreamReader_ReadAsyncInternal_d_65__Class *klass;
    MonitorData *monitor;
    struct StreamReader_ReadAsyncInternal_d_65 fields;
};

struct StreamReader_ReadAsyncInternal_d_65__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData MoveNext;
    VirtualInvokeData SetStateMachine;
};

struct StreamReader_ReadAsyncInternal_d_65__StaticFields {
};

struct StreamReader_ReadAsyncInternal_d_65__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StreamReader_ReadAsyncInternal_d_65__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StreamReader_ReadAsyncInternal_d_65__VTable vtable;
};

struct StreamReader_ReadBufferAsync_d_98 {
    int32_t __1__state;
    struct AsyncTaskMethodBuilder_1_System_Int32_ __t__builder;
    struct StreamReader *__4__this;
    struct Stream *_tmpStream_5__1;
    struct Byte__Array *_tmpByteBuffer_5__2;
    struct ConfiguredTaskAwaitable_1_TResult_ConfiguredTaskAwaiter_System_Int32_ __u__1;
};

struct StreamReader_ReadBufferAsync_d_98__Boxed {
    struct StreamReader_ReadBufferAsync_d_98__Class *klass;
    MonitorData *monitor;
    struct StreamReader_ReadBufferAsync_d_98 fields;
};

struct StreamReader_ReadBufferAsync_d_98__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData MoveNext;
    VirtualInvokeData SetStateMachine;
};

struct StreamReader_ReadBufferAsync_d_98__StaticFields {
};

struct StreamReader_ReadBufferAsync_d_98__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StreamReader_ReadBufferAsync_d_98__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StreamReader_ReadBufferAsync_d_98__VTable vtable;
};

struct StreamWriter_WriteAsyncInternal_d_52 {
    int32_t __1__state;
    struct AsyncTaskMethodBuilder __t__builder;
    int32_t charPos;
    int32_t charLen;
    struct StreamWriter *_this;
    struct Char__Array *charBuffer;
    uint16_t value;
    bool appendNewLine;
    struct Char__Array *coreNewLine;
    int32_t _i_5__1;
    bool autoFlush;
    struct ConfiguredTaskAwaitable_ConfiguredTaskAwaiter __u__1;
};

struct StreamWriter_WriteAsyncInternal_d_52__Boxed {
    struct StreamWriter_WriteAsyncInternal_d_52__Class *klass;
    MonitorData *monitor;
    struct StreamWriter_WriteAsyncInternal_d_52 fields;
};

struct StreamWriter_WriteAsyncInternal_d_52__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData MoveNext;
    VirtualInvokeData SetStateMachine;
};

struct StreamWriter_WriteAsyncInternal_d_52__StaticFields {
};

struct StreamWriter_WriteAsyncInternal_d_52__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StreamWriter_WriteAsyncInternal_d_52__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StreamWriter_WriteAsyncInternal_d_52__VTable vtable;
};

struct StreamWriter_WriteAsyncInternal_d_54 {
    int32_t __1__state;
    struct AsyncTaskMethodBuilder __t__builder;
    struct String *value;
    int32_t charPos;
    int32_t charLen;
    struct StreamWriter *_this;
    struct Char__Array *charBuffer;
    int32_t _count_5__1;
    int32_t _index_5__2;
    bool appendNewLine;
    struct Char__Array *coreNewLine;
    int32_t _i_5__3;
    bool autoFlush;
    struct ConfiguredTaskAwaitable_ConfiguredTaskAwaiter __u__1;
};

struct StreamWriter_WriteAsyncInternal_d_54__Boxed {
    struct StreamWriter_WriteAsyncInternal_d_54__Class *klass;
    MonitorData *monitor;
    struct StreamWriter_WriteAsyncInternal_d_54 fields;
};

struct StreamWriter_WriteAsyncInternal_d_54__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData MoveNext;
    VirtualInvokeData SetStateMachine;
};

struct StreamWriter_WriteAsyncInternal_d_54__StaticFields {
};

struct StreamWriter_WriteAsyncInternal_d_54__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StreamWriter_WriteAsyncInternal_d_54__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StreamWriter_WriteAsyncInternal_d_54__VTable vtable;
};

struct StreamWriter_WriteAsyncInternal_d_56 {
    int32_t __1__state;
    struct AsyncTaskMethodBuilder __t__builder;
    int32_t charPos;
    int32_t charLen;
    struct StreamWriter *_this;
    struct Char__Array *charBuffer;
    int32_t count;
    struct Char__Array *buffer;
    int32_t index;
    bool appendNewLine;
    struct Char__Array *coreNewLine;
    int32_t _i_5__1;
    bool autoFlush;
    struct ConfiguredTaskAwaitable_ConfiguredTaskAwaiter __u__1;
};

struct StreamWriter_WriteAsyncInternal_d_56__Boxed {
    struct StreamWriter_WriteAsyncInternal_d_56__Class *klass;
    MonitorData *monitor;
    struct StreamWriter_WriteAsyncInternal_d_56 fields;
};

struct StreamWriter_WriteAsyncInternal_d_56__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData MoveNext;
    VirtualInvokeData SetStateMachine;
};

struct StreamWriter_WriteAsyncInternal_d_56__StaticFields {
};

struct StreamWriter_WriteAsyncInternal_d_56__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StreamWriter_WriteAsyncInternal_d_56__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StreamWriter_WriteAsyncInternal_d_56__VTable vtable;
};

struct StreamWriter_FlushAsyncInternal_d_67 {
    int32_t __1__state;
    struct AsyncTaskMethodBuilder __t__builder;
    bool haveWrittenPreamble;
    struct StreamWriter *_this;
    struct Encoding *encoding;
    struct Stream *stream;
    struct Encoder *encoder;
    struct Char__Array *charBuffer;
    int32_t charPos;
    struct Byte__Array *byteBuffer;
    bool flushEncoder;
    bool flushStream;
    struct ConfiguredTaskAwaitable_ConfiguredTaskAwaiter __u__1;
};

struct StreamWriter_FlushAsyncInternal_d_67__Boxed {
    struct StreamWriter_FlushAsyncInternal_d_67__Class *klass;
    MonitorData *monitor;
    struct StreamWriter_FlushAsyncInternal_d_67 fields;
};

struct StreamWriter_FlushAsyncInternal_d_67__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData MoveNext;
    VirtualInvokeData SetStateMachine;
};

struct StreamWriter_FlushAsyncInternal_d_67__StaticFields {
};

struct StreamWriter_FlushAsyncInternal_d_67__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StreamWriter_FlushAsyncInternal_d_67__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StreamWriter_FlushAsyncInternal_d_67__VTable vtable;
};

struct StringReader__Fields {
    struct TextReader__Fields _;
    struct String *_s;
    int32_t _pos;
    int32_t _length;
};

struct StringReader {
    struct StringReader__Class *klass;
    MonitorData *monitor;
    struct StringReader__Fields fields;
};

struct StringReader__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData Dispose;
    VirtualInvokeData Close;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData Peek;
    VirtualInvokeData Read;
    VirtualInvokeData Read_1;
    VirtualInvokeData ReadToEnd;
    VirtualInvokeData ReadBlock;
    VirtualInvokeData ReadLine;
    VirtualInvokeData ReadLineAsync;
    VirtualInvokeData ReadToEndAsync;
    VirtualInvokeData ReadAsync;
    VirtualInvokeData ReadAsyncInternal;
    VirtualInvokeData ReadBlockAsync;
};

struct StringReader__StaticFields {
};

struct StringReader__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StringReader__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StringReader__VTable vtable;
};

struct StringWriter__Fields {
    struct TextWriter__Fields _;
    struct StringBuilder *_sb;
    bool _isOpen;
};

struct StringWriter {
    struct StringWriter__Class *klass;
    MonitorData *monitor;
    struct StringWriter__Fields fields;
};

struct StringWriter__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_FormatProvider;
    VirtualInvokeData Close;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData Flush;
    VirtualInvokeData get_Encoding;
    VirtualInvokeData get_NewLine;
    VirtualInvokeData set_NewLine;
    VirtualInvokeData Write;
    VirtualInvokeData Write_1;
    VirtualInvokeData Write_2;
    VirtualInvokeData Write_3;
    VirtualInvokeData Write_4;
    VirtualInvokeData Write_5;
    VirtualInvokeData Write_6;
    VirtualInvokeData Write_7;
    VirtualInvokeData Write_8;
    VirtualInvokeData Write_9;
    VirtualInvokeData Write_10;
    VirtualInvokeData Write_11;
    VirtualInvokeData Write_12;
    VirtualInvokeData Write_13;
    VirtualInvokeData Write_14;
    VirtualInvokeData Write_15;
    VirtualInvokeData Write_16;
    VirtualInvokeData WriteLine;
    VirtualInvokeData WriteLine_1;
    VirtualInvokeData WriteLine_2;
    VirtualInvokeData WriteLine_3;
    VirtualInvokeData WriteLine_4;
    VirtualInvokeData WriteLine_5;
    VirtualInvokeData WriteLine_6;
    VirtualInvokeData WriteLine_7;
    VirtualInvokeData WriteLine_8;
    VirtualInvokeData WriteLine_9;
    VirtualInvokeData WriteLine_10;
    VirtualInvokeData WriteLine_11;
    VirtualInvokeData WriteLine_12;
    VirtualInvokeData WriteLine_13;
    VirtualInvokeData WriteLine_14;
    VirtualInvokeData WriteLine_15;
    VirtualInvokeData WriteLine_16;
    VirtualInvokeData WriteLine_17;
    VirtualInvokeData WriteAsync;
    VirtualInvokeData WriteAsync_1;
    VirtualInvokeData WriteAsync_2;
    VirtualInvokeData WriteLineAsync;
    VirtualInvokeData WriteLineAsync_1;
    VirtualInvokeData WriteLineAsync_2;
    VirtualInvokeData WriteLineAsync_3;
    VirtualInvokeData FlushAsync;
    VirtualInvokeData GetStringBuilder;
};

struct StringWriter__StaticFields {
    struct UnicodeEncoding *m_encoding;
};

struct StringWriter__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct StringWriter__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct StringWriter__VTable vtable;
};

struct TextReader_NullTextReader__Fields {
    struct TextReader__Fields _;
};

struct TextReader_NullTextReader {
    struct TextReader_NullTextReader__Class *klass;
    MonitorData *monitor;
    struct TextReader_NullTextReader__Fields fields;
};

struct TextReader_NullTextReader__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData Dispose;
    VirtualInvokeData Close;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData Peek;
    VirtualInvokeData Read;
    VirtualInvokeData Read_1;
    VirtualInvokeData ReadToEnd;
    VirtualInvokeData ReadBlock;
    VirtualInvokeData ReadLine;
    VirtualInvokeData ReadLineAsync;
    VirtualInvokeData ReadToEndAsync;
    VirtualInvokeData ReadAsync;
    VirtualInvokeData ReadAsyncInternal;
    VirtualInvokeData ReadBlockAsync;
};

struct TextReader_NullTextReader__StaticFields {
};

struct TextReader_NullTextReader__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TextReader_NullTextReader__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TextReader_NullTextReader__VTable vtable;
};

struct TextReader_SyncTextReader__Fields {
    struct TextReader__Fields _;
    struct TextReader *_in;
};

struct TextReader_SyncTextReader {
    struct TextReader_SyncTextReader__Class *klass;
    MonitorData *monitor;
    struct TextReader_SyncTextReader__Fields fields;
};

struct TextReader_SyncTextReader__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData Dispose;
    VirtualInvokeData Close;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData Peek;
    VirtualInvokeData Read;
    VirtualInvokeData Read_1;
    VirtualInvokeData ReadToEnd;
    VirtualInvokeData ReadBlock;
    VirtualInvokeData ReadLine;
    VirtualInvokeData ReadLineAsync;
    VirtualInvokeData ReadToEndAsync;
    VirtualInvokeData ReadAsync;
    VirtualInvokeData ReadAsyncInternal;
    VirtualInvokeData ReadBlockAsync;
};

struct TextReader_SyncTextReader__StaticFields {
};

struct TextReader_SyncTextReader__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TextReader_SyncTextReader__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TextReader_SyncTextReader__VTable vtable;
};

struct TextReader_ReadToEndAsync_d_14 {
    int32_t __1__state;
    struct AsyncTaskMethodBuilder_1_System_String_ __t__builder;
    struct StringBuilder *_sb_5__1;
    struct Char__Array *_chars_5__2;
    int32_t _len_5__3;
    struct TextReader *__4__this;
    struct ConfiguredTaskAwaitable_1_TResult_ConfiguredTaskAwaiter_System_Int32_ __u__1;
};

struct TextReader_ReadToEndAsync_d_14__Boxed {
    struct TextReader_ReadToEndAsync_d_14__Class *klass;
    MonitorData *monitor;
    struct TextReader_ReadToEndAsync_d_14 fields;
};

struct TextReader_ReadToEndAsync_d_14__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData MoveNext;
    VirtualInvokeData SetStateMachine;
};

struct TextReader_ReadToEndAsync_d_14__StaticFields {
};

struct TextReader_ReadToEndAsync_d_14__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TextReader_ReadToEndAsync_d_14__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TextReader_ReadToEndAsync_d_14__VTable vtable;
};

struct TextReader_ReadBlockAsyncInternal_d_18 {
    int32_t __1__state;
    struct AsyncTaskMethodBuilder_1_System_Int32_ __t__builder;
    struct TextReader *__4__this;
    struct Char__Array *buffer;
    int32_t index;
    int32_t count;
    int32_t _n_5__1;
    struct ConfiguredTaskAwaitable_1_TResult_ConfiguredTaskAwaiter_System_Int32_ __u__1;
};

struct TextReader_ReadBlockAsyncInternal_d_18__Boxed {
    struct TextReader_ReadBlockAsyncInternal_d_18__Class *klass;
    MonitorData *monitor;
    struct TextReader_ReadBlockAsyncInternal_d_18 fields;
};

struct TextReader_ReadBlockAsyncInternal_d_18__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData MoveNext;
    VirtualInvokeData SetStateMachine;
};

struct TextReader_ReadBlockAsyncInternal_d_18__StaticFields {
};

struct TextReader_ReadBlockAsyncInternal_d_18__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TextReader_ReadBlockAsyncInternal_d_18__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TextReader_ReadBlockAsyncInternal_d_18__VTable vtable;
};

struct TextReader_c {
    struct TextReader_c__Class *klass;
    MonitorData *monitor;
};

struct TextReader_c__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
};

struct TextReader_c__StaticFields {
    struct TextReader_c *__9;
};

struct TextReader_c__Class {
    Il2CppClass_0 _0;
    Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;
    struct TextReader_c__StaticFields *static_fields;
    const Il2CppRGCTXData *rgctx_data;
    Il2CppClass_1 _1;
    struct TextReader_c__VTable vtable;
};

struct TextWriter_NullTextWriter__Fields {
    struct TextWriter__Fields _;
};

struct TextWriter_NullTextWriter {
    struct TextWriter_NullTextWriter__Class *klass;
    MonitorData *monitor;
    struct TextWriter_NullTextWriter__Fields fields;
};

struct TextWriter_NullTextWriter__VTable {
    VirtualInvokeData Equals;
    VirtualInvokeData Finalize;
    VirtualInvokeData GetHashCode;
    VirtualInvokeData ToString;
    VirtualInvokeData CreateObjRef;
    VirtualInvokeData GetLifetimeService;
    VirtualInvokeData InitializeLifetimeService;
    VirtualInvokeData Dispose;
    VirtualInvokeData get_FormatProvider;
    VirtualInvokeData Close;
    VirtualInvokeData Dispose_1;
    VirtualInvokeData Flush;
    VirtualInvokeData get_Encoding;
    VirtualInvokeData get_NewLine;
    VirtualInvokeData set_NewLine;
    VirtualInvokeData Write;
    VirtualInvokeData Write_1;
    VirtualInvokeData Write_2;
    VirtualInvokeData Write_3;
    VirtualInvokeData Write_4;
    VirtualInvokeData Write_5;
    VirtualInvokeData Write_6;
    VirtualInvokeData Write_7;
    VirtualInvokeData Write_8;
    VirtualInvokeData Write_9;
    VirtualInvokeData Write_10;
    VirtualInvokeData Write_11;
    VirtualInvokeData Write_12;
    VirtualInvokeData Write_13;
    VirtualInvokeData Write_14;
    VirtualInvokeData Write_15;
    VirtualInvokeData Write_16;
    VirtualInvokeData WriteLine;
    VirtualInvokeData WriteLine_1;
    VirtualInvokeData WriteLine_2;
    VirtualInvokeData WriteLine_3;
    VirtualInvokeData WriteLine_4;
    VirtualInvokeData WriteLine_5;
    VirtualInvokeData WriteLine_6;
    VirtualInvokeData WriteLine_7;
    VirtualInvokeData WriteLine_8;
    VirtualInvokeData WriteLine_9;
    VirtualInvokeData WriteLine_10;
    VirtualInvokeData WriteLine_11;
    VirtualInvokeData WriteLine_12;
    VirtualInvokeData WriteLine_13;
    VirtualInvokeData WriteLine_14;
    Virtu