diff --git a/.vscode/settings.json b/.vscode/settings.json index 639f597b..c45b7300 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,6 +1,6 @@ { "rust-analyzer.cargo.features": [ - "unity2019", + "il2cpp_v31", "serde" ], "rust-analyzer.imports.granularity.group": "module" diff --git a/Cargo.toml b/Cargo.toml index de78e2a6..62656e65 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -21,9 +21,9 @@ tracing = { version = "0.1", features = [ "std", ], default-features = false, optional = true } tracing-subscriber = { version = "0.3", default-features = false, optional = true } -tracing-error = { version = "0.1", default-features = false, optional = true } -paranoid-android = { version = "0.1.2", optional = true } -thiserror = "1" +tracing-error = { version = "0.2", default-features = false, optional = true } +paranoid-android = { version = "0.2", optional = true } +thiserror = "2" [target.'cfg(not(target_os = "android"))'.dependencies] tracing-subscriber = { version = "0.3", features = [ @@ -34,7 +34,9 @@ tracing-subscriber = { version = "0.3", features = [ [features] default = ["util", "cache"] -unity2019 = ["libil2cpp/unity2019"] +il2cpp_v31 = ["libil2cpp/il2cpp_v31"] +il2cpp_v29 = ["libil2cpp/il2cpp_v29"] +il2cpp_v24 = ["libil2cpp/il2cpp_v24"] unity2018 = ["libil2cpp/unity2018"] util = ["tracing", "tracing-error", "tracing-subscriber", "paranoid-android"] cache = ["libil2cpp/cache"] diff --git a/inline_hook/Cargo.toml b/inline_hook/Cargo.toml index 3b9f2611..5896f6a7 100644 --- a/inline_hook/Cargo.toml +++ b/inline_hook/Cargo.toml @@ -8,7 +8,7 @@ edition = "2021" cfg-if = "1" [target.'cfg(not(target_os = "android"))'.dependencies] -detour = "0.8" +retour = "0.3" [build-dependencies] cc = "1" diff --git a/inline_hook/src/detour.rs b/inline_hook/src/detour.rs index b23fd00e..55b80508 100644 --- a/inline_hook/src/detour.rs +++ b/inline_hook/src/detour.rs @@ -1,6 +1,6 @@ use std::sync::OnceLock; -use detour::RawDetour; +use retour::RawDetour; /// A function hook that works across most platforms #[derive(Debug)] @@ -42,3 +42,9 @@ impl Hook { self.detour.get().map(|d| d.trampoline() as *const ()) } } + +impl Default for Hook { + fn default() -> Self { + Self::new() + } +} diff --git a/inline_hook/src/lib.rs b/inline_hook/src/lib.rs index da4cb87a..0da409cc 100644 --- a/inline_hook/src/lib.rs +++ b/inline_hook/src/lib.rs @@ -1,4 +1,3 @@ -#![cfg_attr(not(target_os = "android"), feature(once_cell))] #![doc(html_root_url = "https://stackdoubleflow.github.io/quest-hook-rs/inline_hook")] #![warn( clippy::all, diff --git a/libil2cpp/.gitignore b/libil2cpp/.gitignore new file mode 100644 index 00000000..7c363ef0 --- /dev/null +++ b/libil2cpp/.gitignore @@ -0,0 +1,3 @@ +extern/ +*.cmake +bindings.rs \ No newline at end of file diff --git a/libil2cpp/Cargo.toml b/libil2cpp/Cargo.toml index cf112a60..c26a34af 100644 --- a/libil2cpp/Cargo.toml +++ b/libil2cpp/Cargo.toml @@ -11,8 +11,8 @@ edition = "2021" [dependencies] quest_hook_proc_macros = { path = "../proc_macros" } -libloading = "0.7" -thiserror = "1" +libloading = "0.8" +thiserror = "2" paste = "1" serde = { version = "1", optional = true } @@ -24,7 +24,9 @@ optional = true [features] default = [] -unity2019 = [] +il2cpp_v31 = [] +il2cpp_v29 = [] +il2cpp_v24 = [] unity2018 = [] cache = [] trace = ["tracing"] diff --git a/libil2cpp/generate_bindings.ps1 b/libil2cpp/generate_bindings.ps1 new file mode 100644 index 00000000..3943933c --- /dev/null +++ b/libil2cpp/generate_bindings.ps1 @@ -0,0 +1,4 @@ +#!/bin/pwsh + + +bindgen wrapper.h -o bindings.rs --wrap-unsafe-ops --sort-semantically \ No newline at end of file diff --git a/libil2cpp/qpm.json b/libil2cpp/qpm.json new file mode 100644 index 00000000..db2bc9ac --- /dev/null +++ b/libil2cpp/qpm.json @@ -0,0 +1,27 @@ +{ + "version": "0.4.0", + "sharedDir": "shared", + "dependenciesDir": "extern", + "info": { + "name": "libil2cpp-rs", + "id": "libil2cpp-rs", + "version": "0.1.0", + "url": null, + "additionalData": { + "cmake": false + } + }, + "workspace": { + "scripts": {}, + "qmodIncludeDirs": [], + "qmodIncludeFiles": [], + "qmodOutput": null + }, + "dependencies": [ + { + "id": "libil2cpp", + "versionRange": "^0.4.0", + "additionalData": {} + } + ] +} \ No newline at end of file diff --git a/libil2cpp/qpm.shared.json b/libil2cpp/qpm.shared.json new file mode 100644 index 00000000..ca934f23 --- /dev/null +++ b/libil2cpp/qpm.shared.json @@ -0,0 +1,47 @@ +{ + "config": { + "version": "0.4.0", + "sharedDir": "shared", + "dependenciesDir": "extern", + "info": { + "name": "libil2cpp-rs", + "id": "libil2cpp-rs", + "version": "0.1.0", + "url": null, + "additionalData": { + "cmake": false + } + }, + "workspace": { + "scripts": {}, + "qmodIncludeDirs": [], + "qmodIncludeFiles": [], + "qmodOutput": null + }, + "dependencies": [ + { + "id": "libil2cpp", + "versionRange": "^0.4.0", + "additionalData": {} + } + ] + }, + "restoredDependencies": [ + { + "dependency": { + "id": "libil2cpp", + "versionRange": "=0.4.0", + "additionalData": { + "headersOnly": true, + "compileOptions": { + "systemIncludes": [ + "il2cpp/external/baselib/Include", + "il2cpp/external/baselib/Platforms/Android/Include" + ] + } + } + }, + "version": "0.4.0" + } + ] +} \ No newline at end of file diff --git a/libil2cpp/src/class.rs b/libil2cpp/src/class.rs index ae39315b..d9726f3a 100644 --- a/libil2cpp/src/class.rs +++ b/libil2cpp/src/class.rs @@ -8,7 +8,9 @@ use crate::{ Return, Returned, ThisParameter, Type, WrapRaw, }; -#[cfg(feature = "unity2019")] +#[cfg(feature = "il2cpp_v31")] +type FieldInfoSlice<'a> = &'a [FieldInfo]; +#[cfg(feature = "il2cpp_v24")] type FieldInfoSlice<'a> = &'a [FieldInfo]; #[cfg(feature = "unity2018")] type FieldInfoSlice<'a> = &'a [&'static FieldInfo]; diff --git a/libil2cpp/src/lib.rs b/libil2cpp/src/lib.rs index 38ca659a..3d16b348 100644 --- a/libil2cpp/src/lib.rs +++ b/libil2cpp/src/lib.rs @@ -74,7 +74,7 @@ //! Wrappers and raw bindings for Unity's libil2cpp -#[cfg(not(any(feature = "unity2019", feature = "unity2018")))] +#[cfg(not(any(feature = "il2cpp_v31", feature = "il2cpp_v29", feature = "il2cpp_v24", feature = "unity2018")))] compile_error!("No Unity version selected"); #[cfg(feature = "trace")] @@ -96,6 +96,12 @@ mod exception; mod field_info; mod method_info; mod object; + +#[cfg_attr( + any(feature = "unity2018", feature = "il2cpp_v24"), + path = "parameter_info.rs" +)] +#[cfg_attr(any(feature = "il2cpp_v31"), path = "parameter_info_stub.rs")] mod parameter_info; pub mod raw; mod string; @@ -119,3 +125,5 @@ pub use typecheck::callee::{Parameter, Parameters, Return, ThisParameter}; pub use typecheck::caller::{Argument, Arguments, Returned, ThisArgument}; pub use typecheck::generic::Generics; pub use typecheck::ty::Type; + +pub type Result<'a, T> = std::result::Result; \ No newline at end of file diff --git a/libil2cpp/src/method_info.rs b/libil2cpp/src/method_info.rs index 0fda69b3..f9d1f090 100644 --- a/libil2cpp/src/method_info.rs +++ b/libil2cpp/src/method_info.rs @@ -10,7 +10,9 @@ use crate::{ Returned, ThisArgument, WrapRaw, }; -#[cfg(feature = "unity2019")] +#[cfg(feature = "il2cpp_v31")] +type ParameterInfoSlice<'a> = &'a [ParameterInfo]; +#[cfg(feature = "il2cpp_v24")] type ParameterInfoSlice<'a> = &'a [ParameterInfo]; #[cfg(feature = "unity2018")] type ParameterInfoSlice<'a> = &'a [&'static ParameterInfo]; diff --git a/libil2cpp/src/parameter_info_stub.rs b/libil2cpp/src/parameter_info_stub.rs new file mode 100644 index 00000000..f3db914e --- /dev/null +++ b/libil2cpp/src/parameter_info_stub.rs @@ -0,0 +1,35 @@ +use std::fmt; + +use crate::{raw, Il2CppType, WrapRaw}; + +/// Information about a C# parameter +#[repr(transparent)] +pub struct ParameterInfo(&'static Il2CppType); + +unsafe impl Send for ParameterInfo {} +unsafe impl Sync for ParameterInfo {} + +impl ParameterInfo { + /// Type of the parameter + pub fn ty(&self) -> &Il2CppType { + self.0 + } +} + +impl fmt::Debug for ParameterInfo { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("ParameterInfo") + .field("ty", &self.ty()) + .finish() + } +} + +impl fmt::Display for ParameterInfo { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}", self.ty()) + } +} + +unsafe impl WrapRaw for ParameterInfo { + type Raw = raw::Il2CppType; +} diff --git a/libil2cpp/src/raw/functions.rs b/libil2cpp/src/raw/functions.rs index 1cc57980..481fb7b3 100644 --- a/libil2cpp/src/raw/functions.rs +++ b/libil2cpp/src/raw/functions.rs @@ -3,8 +3,8 @@ use libloading::{Library, Symbol}; use quest_hook_proc_macros::il2cpp_functions; use std::ffi::c_void; -use std::sync::{LazyLock, OnceLock}; use std::os::raw::c_char; +use std::sync::{LazyLock, OnceLock}; use super::{ FieldInfo, Il2CppArray, Il2CppAssembly, Il2CppClass, Il2CppDomain, Il2CppException, diff --git a/libil2cpp/src/raw/mod.rs b/libil2cpp/src/raw/mod.rs index a9271a03..854f6be8 100644 --- a/libil2cpp/src/raw/mod.rs +++ b/libil2cpp/src/raw/mod.rs @@ -5,7 +5,9 @@ mod functions; -#[cfg_attr(feature = "unity2019", path = "types_2019.rs")] +#[cfg_attr(feature = "il2cpp_v31", path = "types_v31.rs")] +#[cfg_attr(feature = "il2cpp_v29", path = "types_v29.rs")] +#[cfg_attr(feature = "il2cpp_v24", path = "types_v24.rs")] #[cfg_attr(feature = "unity2018", path = "types_2018.rs")] mod types; diff --git a/libil2cpp/src/raw/types_2019.rs b/libil2cpp/src/raw/types_v24.rs similarity index 100% rename from libil2cpp/src/raw/types_2019.rs rename to libil2cpp/src/raw/types_v24.rs diff --git a/libil2cpp/src/raw/types_v31.rs b/libil2cpp/src/raw/types_v31.rs new file mode 100644 index 00000000..16865503 --- /dev/null +++ b/libil2cpp/src/raw/types_v31.rs @@ -0,0 +1,8365 @@ +/* automatically generated by rust-bindgen 0.70.1 */ + +pub type va_list = *mut ::std::os::raw::c_char; +pub type __vcrt_bool = bool; +pub type wchar_t = ::std::os::raw::c_ushort; +pub type int_least8_t = ::std::os::raw::c_schar; +pub type int_least16_t = ::std::os::raw::c_short; +pub type int_least32_t = ::std::os::raw::c_int; +pub type int_least64_t = ::std::os::raw::c_longlong; +pub type uint_least8_t = ::std::os::raw::c_uchar; +pub type uint_least16_t = ::std::os::raw::c_ushort; +pub type uint_least32_t = ::std::os::raw::c_uint; +pub type uint_least64_t = ::std::os::raw::c_ulonglong; +pub type int_fast8_t = ::std::os::raw::c_schar; +pub type int_fast16_t = ::std::os::raw::c_int; +pub type int_fast32_t = ::std::os::raw::c_int; +pub type int_fast64_t = ::std::os::raw::c_longlong; +pub type uint_fast8_t = ::std::os::raw::c_uchar; +pub type uint_fast16_t = ::std::os::raw::c_uint; +pub type uint_fast32_t = ::std::os::raw::c_uint; +pub type uint_fast64_t = ::std::os::raw::c_ulonglong; +pub type intmax_t = ::std::os::raw::c_longlong; +pub type uintmax_t = ::std::os::raw::c_ulonglong; +pub type __crt_bool = bool; +pub type errno_t = ::std::os::raw::c_int; +pub type wint_t = ::std::os::raw::c_ushort; +pub type wctype_t = ::std::os::raw::c_ushort; +pub type __time32_t = ::std::os::raw::c_long; +pub type __time64_t = ::std::os::raw::c_longlong; +pub type _locale_t = *mut __crt_locale_pointers; +pub type mbstate_t = _Mbstatet; +pub type time_t = __time64_t; +pub type rsize_t = usize; +pub type _HEAPINFO = _heapinfo; +pub type Il2CppProfileFlags = ::std::os::raw::c_int; +pub type Il2CppProfileFileIOKind = ::std::os::raw::c_int; +pub type Il2CppGCEvent = ::std::os::raw::c_int; +pub type Il2CppGCMode = ::std::os::raw::c_int; +pub type Il2CppStat = ::std::os::raw::c_int; +pub type Il2CppRuntimeUnhandledExceptionPolicy = ::std::os::raw::c_int; +pub type Il2CppMethodPointer = ::std::option::Option; +pub type Il2CppChar = wchar_t; +pub type Il2CppNativeChar = wchar_t; +pub type il2cpp_register_object_callback = ::std::option::Option< + unsafe extern "C" fn( + arr: *mut *mut Il2CppObject, + size: ::std::os::raw::c_int, + userdata: *mut ::std::os::raw::c_void, + ), +>; +pub type il2cpp_liveness_reallocate_callback = ::std::option::Option< + unsafe extern "C" fn( + ptr: *mut ::std::os::raw::c_void, + size: usize, + userdata: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, +>; +pub type Il2CppFrameWalkFunc = ::std::option::Option< + unsafe extern "C" fn(info: *const Il2CppStackFrameInfo, user_data: *mut ::std::os::raw::c_void), +>; +pub type Il2CppProfileFunc = ::std::option::Option; +pub type Il2CppProfileMethodFunc = ::std::option::Option< + unsafe extern "C" fn(prof: *mut Il2CppProfiler, method: *const MethodInfo), +>; +pub type Il2CppProfileAllocFunc = ::std::option::Option< + unsafe extern "C" fn( + prof: *mut Il2CppProfiler, + obj: *mut Il2CppObject, + klass: *mut Il2CppClass, + ), +>; +pub type Il2CppProfileGCFunc = ::std::option::Option< + unsafe extern "C" fn( + prof: *mut Il2CppProfiler, + event: Il2CppGCEvent, + generation: ::std::os::raw::c_int, + ), +>; +pub type Il2CppProfileGCResizeFunc = + ::std::option::Option; +pub type Il2CppProfileFileIOFunc = ::std::option::Option< + unsafe extern "C" fn( + prof: *mut Il2CppProfiler, + kind: Il2CppProfileFileIOKind, + count: ::std::os::raw::c_int, + ), +>; +pub type Il2CppProfileThreadFunc = ::std::option::Option< + unsafe extern "C" fn(prof: *mut Il2CppProfiler, tid: ::std::os::raw::c_ulong), +>; +pub type Il2CppSetFindPlugInCallback = ::std::option::Option< + unsafe extern "C" fn(arg1: *const Il2CppNativeChar) -> *const Il2CppNativeChar, +>; +pub type Il2CppLogCallback = + ::std::option::Option; +pub type Il2CppBacktraceFunc = ::std::option::Option< + unsafe extern "C" fn(buffer: *mut Il2CppMethodPointer, maxSize: usize) -> usize, +>; +pub type il2cpp_array_size_t = usize; +pub type Il2CppAndroidUpStateFunc = ::std::option::Option< + unsafe extern "C" fn(ifName: *const ::std::os::raw::c_char, is_up: *mut u8) -> u8, +>; +pub type SynchronizationContextCallback = ::std::option::Option; +pub type CultureInfoChangedCallback = + ::std::option::Option; +pub type Il2CppMethodSlot = u16; +pub type il2cpp_hresult_t = i32; +pub type Il2CppTokenType = ::std::os::raw::c_int; +pub type TypeIndex = i32; +pub type TypeDefinitionIndex = i32; +pub type FieldIndex = i32; +pub type DefaultValueIndex = i32; +pub type DefaultValueDataIndex = i32; +pub type CustomAttributeIndex = i32; +pub type ParameterIndex = i32; +pub type MethodIndex = i32; +pub type GenericMethodIndex = i32; +pub type PropertyIndex = i32; +pub type EventIndex = i32; +pub type GenericContainerIndex = i32; +pub type GenericParameterIndex = i32; +pub type GenericParameterConstraintIndex = i16; +pub type NestedTypeIndex = i32; +pub type InterfacesIndex = i32; +pub type VTableIndex = i32; +pub type RGCTXIndex = i32; +pub type StringIndex = i32; +pub type StringLiteralIndex = i32; +pub type GenericInstIndex = i32; +pub type ImageIndex = i32; +pub type AssemblyIndex = i32; +pub type InteropDataIndex = i32; +pub type TypeFieldIndex = i32; +pub type TypeMethodIndex = i32; +pub type MethodParameterIndex = i32; +pub type TypePropertyIndex = i32; +pub type TypeEventIndex = i32; +pub type TypeInterfaceIndex = i32; +pub type TypeNestedTypeIndex = i32; +pub type TypeInterfaceOffsetIndex = i32; +pub type GenericContainerParameterIndex = i32; +pub type AssemblyTypeIndex = i32; +pub type AssemblyExportedTypeIndex = i32; +pub type Il2CppRGCTXDataType = ::std::os::raw::c_int; +pub type Il2CppMetadataImageHandle = *const ___Il2CppMetadataImageHandle; +pub type Il2CppMetadataCustomAttributeHandle = *const ___Il2CppMetadataCustomAttributeHandle; +pub type Il2CppMetadataTypeHandle = *const ___Il2CppMetadataTypeHandle; +pub type Il2CppMetadataMethodDefinitionHandle = *const ___Il2CppMetadataMethodHandle; +pub type Il2CppMetadataGenericContainerHandle = *const ___Il2CppMetadataGenericContainerHandle; +pub type Il2CppMetadataGenericParameterHandle = *const ___Il2CppMetadataGenericParameterHandle; +pub type Il2CppTypeEnum = ::std::os::raw::c_int; +pub type Il2CppCallConvention = ::std::os::raw::c_int; +pub type Il2CppCharSet = ::std::os::raw::c_int; +pub type Il2CppHString = *mut Il2CppHString__; +pub type IL2CPP_VARIANT_BOOL = i16; +pub type Il2CppVarType = ::std::os::raw::c_int; +pub type Il2CppWindowsRuntimeTypeKind = ::std::os::raw::c_int; +pub type PInvokeMarshalToNativeFunc = ::std::option::Option< + unsafe extern "C" fn( + managedStructure: *mut ::std::os::raw::c_void, + marshaledStructure: *mut ::std::os::raw::c_void, + ), +>; +pub type PInvokeMarshalFromNativeFunc = ::std::option::Option< + unsafe extern "C" fn( + marshaledStructure: *mut ::std::os::raw::c_void, + managedStructure: *mut ::std::os::raw::c_void, + ), +>; +pub type PInvokeMarshalCleanupFunc = + ::std::option::Option; +pub type CreateCCWFunc = + ::std::option::Option *mut Il2CppIUnknown>; +pub type Il2CppTypeNameFormat = ::std::os::raw::c_int; +pub type InvokerMethod = ::std::option::Option< + unsafe extern "C" fn( + arg1: Il2CppMethodPointer, + arg2: *const MethodInfo, + arg3: *mut ::std::os::raw::c_void, + arg4: *mut *mut ::std::os::raw::c_void, + arg5: *mut ::std::os::raw::c_void, + ), +>; +pub type MethodVariableKind = ::std::os::raw::c_int; +pub type SequencePointKind = ::std::os::raw::c_int; +pub type Il2CppVTable = Il2CppClass; +pub type il2cpp_array_lower_bound_t = i32; +pub type Il2CppCallType = ::std::os::raw::c_int; +pub type Il2CppFullySharedGenericAny = *mut ::std::os::raw::c_void; +pub type Il2CppFullySharedGenericStruct = *mut ::std::os::raw::c_void; +pub type Il2CppResourceLocation = ::std::os::raw::c_int; +pub type Il2CppDecimalCompareResult = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +#[repr(C)] +#[derive(Default)] +pub struct __IncompleteArrayField(::std::marker::PhantomData, [T; 0]); +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __crt_locale_data_public { + pub _locale_pctype: *const ::std::os::raw::c_ushort, + pub _locale_mb_cur_max: ::std::os::raw::c_int, + pub _locale_lc_codepage: ::std::os::raw::c_uint, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __crt_locale_pointers { + pub locinfo: *mut __crt_locale_data, + pub mbcinfo: *mut __crt_multibyte_data, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _Mbstatet { + pub _Wchar: ::std::os::raw::c_ulong, + pub _Byte: ::std::os::raw::c_ushort, + pub _State: ::std::os::raw::c_ushort, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _heapinfo { + pub _pentry: *mut ::std::os::raw::c_int, + pub _size: usize, + pub _useflag: ::std::os::raw::c_int, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppProfiler { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppManagedMemorySnapshot { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppCustomAttrInfo { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppStackFrameInfo { + pub method: *const MethodInfo, + pub raw_ip: usize, + pub sourceCodeLineNumber: ::std::os::raw::c_int, + pub ilOffset: ::std::os::raw::c_int, + pub filePath: *const ::std::os::raw::c_char, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppMethodDebugInfo { + pub methodPointer: Il2CppMethodPointer, + pub code_size: i32, + pub file: *const ::std::os::raw::c_char, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppMemoryCallbacks { + pub malloc_func: + ::std::option::Option *mut ::std::os::raw::c_void>, + pub aligned_malloc_func: ::std::option::Option< + unsafe extern "C" fn(size: usize, alignment: usize) -> *mut ::std::os::raw::c_void, + >, + pub free_func: ::std::option::Option, + pub aligned_free_func: + ::std::option::Option, + pub calloc_func: ::std::option::Option< + unsafe extern "C" fn(nmemb: usize, size: usize) -> *mut ::std::os::raw::c_void, + >, + pub realloc_func: ::std::option::Option< + unsafe extern "C" fn( + ptr: *mut ::std::os::raw::c_void, + size: usize, + ) -> *mut ::std::os::raw::c_void, + >, + pub aligned_realloc_func: ::std::option::Option< + unsafe extern "C" fn( + ptr: *mut ::std::os::raw::c_void, + size: usize, + alignment: usize, + ) -> *mut ::std::os::raw::c_void, + >, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppDebuggerTransport { + pub name: *const ::std::os::raw::c_char, + pub connect: + ::std::option::Option, + pub wait_for_attach: ::std::option::Option ::std::os::raw::c_int>, + pub close1: ::std::option::Option, + pub close2: ::std::option::Option, + pub send: ::std::option::Option< + unsafe extern "C" fn( + buf: *mut ::std::os::raw::c_void, + len: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub recv: ::std::option::Option< + unsafe extern "C" fn( + buf: *mut ::std::os::raw::c_void, + len: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppMethodSpec { + pub methodDefinitionIndex: MethodIndex, + pub classIndexIndex: GenericInstIndex, + pub methodIndexIndex: GenericInstIndex, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppRGCTXConstrainedData { + pub __typeIndex: TypeIndex, + pub __encodedMethodIndex: u32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppRGCTXDefinition { + pub type_: Il2CppRGCTXDataType, + pub data: *const ::std::os::raw::c_void, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppGenericMethodIndices { + pub methodIndex: MethodIndex, + pub invokerIndex: MethodIndex, + pub adjustorThunkIndex: MethodIndex, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppGenericMethodFunctionsDefinitions { + pub genericMethodIndex: GenericMethodIndex, + pub indices: Il2CppGenericMethodIndices, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ___Il2CppMetadataImageHandle { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ___Il2CppMetadataCustomAttributeHandle { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ___Il2CppMetadataTypeHandle { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ___Il2CppMetadataMethodHandle { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ___Il2CppMetadataGenericContainerHandle { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ___Il2CppMetadataGenericParameterHandle { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppArrayType { + pub etype: *const Il2CppType, + pub rank: u8, + pub numsizes: u8, + pub numlobounds: u8, + pub sizes: *mut ::std::os::raw::c_int, + pub lobounds: *mut ::std::os::raw::c_int, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppGenericInst { + pub type_argc: u32, + pub type_argv: *mut *const Il2CppType, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppGenericContext { + pub class_inst: *const Il2CppGenericInst, + pub method_inst: *const Il2CppGenericInst, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppGenericClass { + pub type_: *const Il2CppType, + pub context: Il2CppGenericContext, + pub cached_class: *mut Il2CppClass, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppGenericMethod { + pub methodDefinition: *const MethodInfo, + pub context: Il2CppGenericContext, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppType { + pub data: Il2CppType__bindgen_ty_1, + pub _bitfield_align_1: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + pub __bindgen_padding_0: u32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppMetadataFieldInfo { + pub type_: *const Il2CppType, + pub name: *const ::std::os::raw::c_char, + pub token: u32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppMetadataMethodInfo { + pub handle: Il2CppMetadataMethodDefinitionHandle, + pub name: *const ::std::os::raw::c_char, + pub return_type: *const Il2CppType, + pub token: u32, + pub flags: u16, + pub iflags: u16, + pub slot: u16, + pub parameterCount: u16, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppMetadataParameterInfo { + pub name: *const ::std::os::raw::c_char, + pub token: u32, + pub type_: *const Il2CppType, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppMetadataPropertyInfo { + pub name: *const ::std::os::raw::c_char, + pub get: *const MethodInfo, + pub set: *const MethodInfo, + pub attrs: u32, + pub token: u32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppMetadataEventInfo { + pub name: *const ::std::os::raw::c_char, + pub type_: *const Il2CppType, + pub add: *const MethodInfo, + pub remove: *const MethodInfo, + pub raise: *const MethodInfo, + pub token: u32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppInterfaceOffsetInfo { + pub interfaceType: *const Il2CppType, + pub offset: i32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppGenericParameterInfo { + pub containerHandle: Il2CppMetadataGenericContainerHandle, + pub name: *const ::std::os::raw::c_char, + pub num: u16, + pub flags: u16, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppHString__ { + pub unused: ::std::os::raw::c_int, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppHStringHeader { + pub Reserved: Il2CppHStringHeader__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppGuid { + pub data1: u32, + pub data2: u16, + pub data3: u16, + pub data4: [u8; 8usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppSafeArrayBound { + pub element_count: u32, + pub lower_bound: i32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppSafeArray { + pub dimension_count: u16, + pub features: u16, + pub element_size: u32, + pub lock_count: u32, + pub data: *mut ::std::os::raw::c_void, + pub bounds: [Il2CppSafeArrayBound; 1usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppWin32Decimal { + pub reserved: u16, + pub u: Il2CppWin32Decimal__bindgen_ty_1, + pub hi32: u32, + pub u2: Il2CppWin32Decimal__bindgen_ty_2, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppWin32Decimal__bindgen_ty_1__bindgen_ty_1 { + pub scale: u8, + pub sign: u8, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppWin32Decimal__bindgen_ty_2__bindgen_ty_1 { + pub lo32: u32, + pub mid32: u32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppIUnknown { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppVariant { + pub n1: Il2CppVariant__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppVariant__bindgen_ty_1___tagVARIANT { + pub type_: u16, + pub reserved1: u16, + pub reserved2: u16, + pub reserved3: u16, + pub n3: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1___tagBRECORD { + pub pvRecord: *mut ::std::os::raw::c_void, + pub pRecInfo: *mut ::std::os::raw::c_void, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppFileTime { + pub low: u32, + pub high: u32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppStatStg { + pub name: *mut Il2CppChar, + pub type_: u32, + pub size: u64, + pub mtime: Il2CppFileTime, + pub ctime: Il2CppFileTime, + pub atime: Il2CppFileTime, + pub mode: u32, + pub locks: u32, + pub clsid: Il2CppGuid, + pub state: u32, + pub reserved: u32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppWindowsRuntimeTypeName { + pub typeName: Il2CppHString, + pub typeKind: Il2CppWindowsRuntimeTypeKind, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppInteropData { + pub delegatePInvokeWrapperFunction: Il2CppMethodPointer, + pub pinvokeMarshalToNativeFunction: PInvokeMarshalToNativeFunc, + pub pinvokeMarshalFromNativeFunction: PInvokeMarshalFromNativeFunc, + pub pinvokeMarshalCleanupFunction: PInvokeMarshalCleanupFunc, + pub createCCWFunction: CreateCCWFunc, + pub guid: *const Il2CppGuid, + pub type_: *const Il2CppType, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppNameToTypeHandleHashTable { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VirtualInvokeData { + pub methodPtr: Il2CppMethodPointer, + pub method: *const MethodInfo, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppDefaults { + pub corlib: *mut Il2CppImage, + pub corlib_gen: *mut Il2CppImage, + pub object_class: *mut Il2CppClass, + pub byte_class: *mut Il2CppClass, + pub void_class: *mut Il2CppClass, + pub boolean_class: *mut Il2CppClass, + pub sbyte_class: *mut Il2CppClass, + pub int16_class: *mut Il2CppClass, + pub uint16_class: *mut Il2CppClass, + pub int32_class: *mut Il2CppClass, + pub uint32_class: *mut Il2CppClass, + pub int_class: *mut Il2CppClass, + pub uint_class: *mut Il2CppClass, + pub int64_class: *mut Il2CppClass, + pub uint64_class: *mut Il2CppClass, + pub single_class: *mut Il2CppClass, + pub double_class: *mut Il2CppClass, + pub char_class: *mut Il2CppClass, + pub string_class: *mut Il2CppClass, + pub enum_class: *mut Il2CppClass, + pub array_class: *mut Il2CppClass, + pub delegate_class: *mut Il2CppClass, + pub multicastdelegate_class: *mut Il2CppClass, + pub asyncresult_class: *mut Il2CppClass, + pub manualresetevent_class: *mut Il2CppClass, + pub typehandle_class: *mut Il2CppClass, + pub fieldhandle_class: *mut Il2CppClass, + pub methodhandle_class: *mut Il2CppClass, + pub systemtype_class: *mut Il2CppClass, + pub monotype_class: *mut Il2CppClass, + pub exception_class: *mut Il2CppClass, + pub threadabortexception_class: *mut Il2CppClass, + pub thread_class: *mut Il2CppClass, + pub internal_thread_class: *mut Il2CppClass, + pub appdomain_class: *mut Il2CppClass, + pub appdomain_setup_class: *mut Il2CppClass, + pub member_info_class: *mut Il2CppClass, + pub field_info_class: *mut Il2CppClass, + pub method_info_class: *mut Il2CppClass, + pub property_info_class: *mut Il2CppClass, + pub event_info_class: *mut Il2CppClass, + pub stringbuilder_class: *mut Il2CppClass, + pub stack_frame_class: *mut Il2CppClass, + pub stack_trace_class: *mut Il2CppClass, + pub marshal_class: *mut Il2CppClass, + pub typed_reference_class: *mut Il2CppClass, + pub marshalbyrefobject_class: *mut Il2CppClass, + pub generic_ilist_class: *mut Il2CppClass, + pub generic_icollection_class: *mut Il2CppClass, + pub generic_ienumerable_class: *mut Il2CppClass, + pub generic_ireadonlylist_class: *mut Il2CppClass, + pub generic_ireadonlycollection_class: *mut Il2CppClass, + pub runtimetype_class: *mut Il2CppClass, + pub generic_nullable_class: *mut Il2CppClass, + pub il2cpp_com_object_class: *mut Il2CppClass, + pub attribute_class: *mut Il2CppClass, + pub customattribute_data_class: *mut Il2CppClass, + pub customattribute_typed_argument_class: *mut Il2CppClass, + pub customattribute_named_argument_class: *mut Il2CppClass, + pub version: *mut Il2CppClass, + pub culture_info: *mut Il2CppClass, + pub async_call_class: *mut Il2CppClass, + pub assembly_class: *mut Il2CppClass, + pub assembly_name_class: *mut Il2CppClass, + pub parameter_info_class: *mut Il2CppClass, + pub module_class: *mut Il2CppClass, + pub system_exception_class: *mut Il2CppClass, + pub argument_exception_class: *mut Il2CppClass, + pub wait_handle_class: *mut Il2CppClass, + pub safe_handle_class: *mut Il2CppClass, + pub sort_key_class: *mut Il2CppClass, + pub dbnull_class: *mut Il2CppClass, + pub error_wrapper_class: *mut Il2CppClass, + pub missing_class: *mut Il2CppClass, + pub value_type_class: *mut Il2CppClass, + pub threadpool_wait_callback_class: *mut Il2CppClass, + pub threadpool_perform_wait_callback_method: *mut MethodInfo, + pub mono_method_message_class: *mut Il2CppClass, + pub ireference_class: *mut Il2CppClass, + pub ireferencearray_class: *mut Il2CppClass, + pub ikey_value_pair_class: *mut Il2CppClass, + pub key_value_pair_class: *mut Il2CppClass, + pub windows_foundation_uri_class: *mut Il2CppClass, + pub windows_foundation_iuri_runtime_class_class: *mut Il2CppClass, + pub system_uri_class: *mut Il2CppClass, + pub system_guid_class: *mut Il2CppClass, + pub sbyte_shared_enum: *mut Il2CppClass, + pub int16_shared_enum: *mut Il2CppClass, + pub int32_shared_enum: *mut Il2CppClass, + pub int64_shared_enum: *mut Il2CppClass, + pub byte_shared_enum: *mut Il2CppClass, + pub uint16_shared_enum: *mut Il2CppClass, + pub uint32_shared_enum: *mut Il2CppClass, + pub uint64_shared_enum: *mut Il2CppClass, + pub il2cpp_fully_shared_type: *mut Il2CppClass, + pub il2cpp_fully_shared_struct_type: *mut Il2CppClass, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct MemberInfo { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct FieldInfo { + pub name: *const ::std::os::raw::c_char, + pub type_: *const Il2CppType, + pub parent: *mut Il2CppClass, + pub offset: i32, + pub token: u32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct PropertyInfo { + pub parent: *mut Il2CppClass, + pub name: *const ::std::os::raw::c_char, + pub get: *const MethodInfo, + pub set: *const MethodInfo, + pub attrs: u32, + pub token: u32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct EventInfo { + pub name: *const ::std::os::raw::c_char, + pub eventType: *const Il2CppType, + pub parent: *mut Il2CppClass, + pub add: *const MethodInfo, + pub remove: *const MethodInfo, + pub raise: *const MethodInfo, + pub token: u32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppMethodExecutionContextInfo { + pub typeIndex: TypeIndex, + pub nameIndex: i32, + pub scopeIndex: i32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppMethodExecutionContextInfoIndex { + pub startIndex: i32, + pub count: i32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppMethodScope { + pub startOffset: i32, + pub endOffset: i32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppMethodHeaderInfo { + pub code_size: i32, + pub startScope: i32, + pub numScopes: i32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppSequencePointSourceFile { + pub file: *const ::std::os::raw::c_char, + pub hash: [u8; 16usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppTypeSourceFilePair { + pub __klassIndex: TypeDefinitionIndex, + pub sourceFileIndex: i32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppSequencePoint { + pub __methodDefinitionIndex: MethodIndex, + pub sourceFileIndex: i32, + pub lineStart: i32, + pub lineEnd: i32, + pub columnStart: i32, + pub columnEnd: i32, + pub ilOffset: i32, + pub kind: SequencePointKind, + pub isActive: i32, + pub id: i32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppCatchPoint { + pub __methodDefinitionIndex: MethodIndex, + pub catchTypeIndex: TypeIndex, + pub ilOffset: i32, + pub tryId: i32, + pub parentTryId: i32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppDebuggerMetadataRegistration { + pub methodExecutionContextInfos: *mut Il2CppMethodExecutionContextInfo, + pub methodExecutionContextInfoIndexes: *mut Il2CppMethodExecutionContextInfoIndex, + pub methodScopes: *mut Il2CppMethodScope, + pub methodHeaderInfos: *mut Il2CppMethodHeaderInfo, + pub sequencePointSourceFiles: *mut Il2CppSequencePointSourceFile, + pub numSequencePoints: i32, + pub sequencePoints: *mut Il2CppSequencePoint, + pub numCatchPoints: i32, + pub catchPoints: *mut Il2CppCatchPoint, + pub numTypeSourceFileEntries: i32, + pub typeSourceFiles: *mut Il2CppTypeSourceFilePair, + pub methodExecutionContextInfoStrings: *mut *const ::std::os::raw::c_char, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct MethodInfo { + pub methodPointer: Il2CppMethodPointer, + pub virtualMethodPointer: Il2CppMethodPointer, + pub invoker_method: InvokerMethod, + pub name: *const ::std::os::raw::c_char, + pub klass: *mut Il2CppClass, + pub return_type: *const Il2CppType, + pub parameters: *mut *const Il2CppType, + pub __bindgen_anon_1: MethodInfo__bindgen_ty_1, + pub __bindgen_anon_2: MethodInfo__bindgen_ty_2, + pub token: u32, + pub flags: u16, + pub iflags: u16, + pub slot: u16, + pub parameters_count: u8, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: u32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppRuntimeInterfaceOffsetPair { + pub interfaceType: *mut Il2CppClass, + pub offset: i32, +} +#[repr(C)] +pub struct Il2CppClass { + pub image: *const Il2CppImage, + pub gc_desc: *mut ::std::os::raw::c_void, + pub name: *const ::std::os::raw::c_char, + pub namespaze: *const ::std::os::raw::c_char, + pub byval_arg: Il2CppType, + pub this_arg: Il2CppType, + pub element_class: *mut Il2CppClass, + pub castClass: *mut Il2CppClass, + pub declaringType: *mut Il2CppClass, + pub parent: *mut Il2CppClass, + pub generic_class: *mut Il2CppGenericClass, + pub typeMetadataHandle: Il2CppMetadataTypeHandle, + pub interopData: *const Il2CppInteropData, + pub klass: *mut Il2CppClass, + pub fields: *mut FieldInfo, + pub events: *const EventInfo, + pub properties: *const PropertyInfo, + pub methods: *mut *const MethodInfo, + pub nestedTypes: *mut *mut Il2CppClass, + pub implementedInterfaces: *mut *mut Il2CppClass, + pub interfaceOffsets: *mut Il2CppRuntimeInterfaceOffsetPair, + pub static_fields: *mut ::std::os::raw::c_void, + pub rgctx_data: *const Il2CppRGCTXData, + pub typeHierarchy: *mut *mut Il2CppClass, + pub unity_user_data: *mut ::std::os::raw::c_void, + pub initializationExceptionGCHandle: u32, + pub cctor_started: u32, + pub cctor_finished_or_no_cctor: u32, + pub cctor_thread: usize, + pub genericContainerHandle: Il2CppMetadataGenericContainerHandle, + pub instance_size: u32, + pub stack_slot_size: u32, + pub actualSize: u32, + pub element_size: u32, + pub native_size: i32, + pub static_fields_size: u32, + pub thread_static_fields_size: u32, + pub thread_static_fields_offset: i32, + pub flags: u32, + pub token: u32, + pub method_count: u16, + pub property_count: u16, + pub field_count: u16, + pub event_count: u16, + pub nested_type_count: u16, + pub vtable_count: u16, + pub interfaces_count: u16, + pub interface_offsets_count: u16, + pub typeHierarchyDepth: u8, + pub genericRecursionDepth: u8, + pub rank: u8, + pub minimumAlignment: u8, + pub packingSize: u8, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, + pub vtable: __IncompleteArrayField, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppTypeDefinitionSizes { + pub instance_size: u32, + pub native_size: i32, + pub static_fields_size: u32, + pub thread_static_fields_size: u32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppDomain { + pub domain: *mut Il2CppAppDomain, + pub setup: *mut Il2CppAppDomainSetup, + pub default_context: *mut Il2CppAppContext, + pub ephemeron_tombstone: *mut Il2CppObject, + pub friendly_name: *const ::std::os::raw::c_char, + pub domain_id: u32, + pub threadpool_jobs: ::std::os::raw::c_int, + pub agent_info: *mut ::std::os::raw::c_void, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppAssemblyName { + pub name: *const ::std::os::raw::c_char, + pub culture: *const ::std::os::raw::c_char, + pub public_key: *const u8, + pub hash_alg: u32, + pub hash_len: i32, + pub flags: u32, + pub major: i32, + pub minor: i32, + pub build: i32, + pub revision: i32, + pub public_key_token: [u8; 8usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppImage { + pub name: *const ::std::os::raw::c_char, + pub nameNoExt: *const ::std::os::raw::c_char, + pub assembly: *mut Il2CppAssembly, + pub typeCount: u32, + pub exportedTypeCount: u32, + pub customAttributeCount: u32, + pub metadataHandle: Il2CppMetadataImageHandle, + pub nameToClassHashTable: *mut Il2CppNameToTypeHandleHashTable, + pub codeGenModule: *const Il2CppCodeGenModule, + pub token: u32, + pub dynamic: u8, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppAssembly { + pub image: *mut Il2CppImage, + pub token: u32, + pub referencedAssemblyStart: i32, + pub referencedAssemblyCount: i32, + pub aname: Il2CppAssemblyName, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppCodeGenOptions { + pub enablePrimitiveValueTypeGenericSharing: u8, + pub maximumRuntimeGenericDepth: ::std::os::raw::c_int, + pub recursiveGenericIterations: ::std::os::raw::c_int, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppRange { + pub start: i32, + pub length: i32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppTokenRangePair { + pub token: u32, + pub range: Il2CppRange, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppTokenIndexMethodTuple { + pub token: u32, + pub index: i32, + pub method: *mut *mut ::std::os::raw::c_void, + pub __genericMethodIndex: u32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppTokenAdjustorThunkPair { + pub token: u32, + pub adjustorThunk: Il2CppMethodPointer, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppWindowsRuntimeFactoryTableEntry { + pub type_: *const Il2CppType, + pub createFactoryFunction: Il2CppMethodPointer, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppCodeGenModule { + pub moduleName: *const ::std::os::raw::c_char, + pub methodPointerCount: u32, + pub methodPointers: *const Il2CppMethodPointer, + pub adjustorThunkCount: u32, + pub adjustorThunks: *const Il2CppTokenAdjustorThunkPair, + pub invokerIndices: *const i32, + pub reversePInvokeWrapperCount: u32, + pub reversePInvokeWrapperIndices: *const Il2CppTokenIndexMethodTuple, + pub rgctxRangesCount: u32, + pub rgctxRanges: *const Il2CppTokenRangePair, + pub rgctxsCount: u32, + pub rgctxs: *const Il2CppRGCTXDefinition, + pub debuggerMetadata: *const Il2CppDebuggerMetadataRegistration, + pub moduleInitializer: Il2CppMethodPointer, + pub staticConstructorTypeIndices: *mut TypeDefinitionIndex, + pub metadataRegistration: *const Il2CppMetadataRegistration, + pub codeRegistaration: *const Il2CppCodeRegistration, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppCodeRegistration { + pub reversePInvokeWrapperCount: u32, + pub reversePInvokeWrappers: *const Il2CppMethodPointer, + pub genericMethodPointersCount: u32, + pub genericMethodPointers: *const Il2CppMethodPointer, + pub genericAdjustorThunks: *const Il2CppMethodPointer, + pub invokerPointersCount: u32, + pub invokerPointers: *const InvokerMethod, + pub unresolvedIndirectCallCount: u32, + pub unresolvedVirtualCallPointers: *const Il2CppMethodPointer, + pub unresolvedInstanceCallPointers: *const Il2CppMethodPointer, + pub unresolvedStaticCallPointers: *const Il2CppMethodPointer, + pub interopDataCount: u32, + pub interopData: *mut Il2CppInteropData, + pub windowsRuntimeFactoryCount: u32, + pub windowsRuntimeFactoryTable: *mut Il2CppWindowsRuntimeFactoryTableEntry, + pub codeGenModulesCount: u32, + pub codeGenModules: *mut *const Il2CppCodeGenModule, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppMetadataRegistration { + pub genericClassesCount: i32, + pub genericClasses: *const *mut Il2CppGenericClass, + pub genericInstsCount: i32, + pub genericInsts: *const *const Il2CppGenericInst, + pub genericMethodTableCount: i32, + pub genericMethodTable: *const Il2CppGenericMethodFunctionsDefinitions, + pub typesCount: i32, + pub types: *const *const Il2CppType, + pub methodSpecsCount: i32, + pub methodSpecs: *const Il2CppMethodSpec, + pub fieldOffsetsCount: FieldIndex, + pub fieldOffsets: *mut *const i32, + pub typeDefinitionsSizesCount: TypeDefinitionIndex, + pub typeDefinitionsSizes: *mut *const Il2CppTypeDefinitionSizes, + pub metadataUsagesCount: usize, + pub metadataUsages: *const *mut *mut ::std::os::raw::c_void, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppPerfCounters { + pub jit_methods: u32, + pub jit_bytes: u32, + pub jit_time: u32, + pub jit_failures: u32, + pub exceptions_thrown: u32, + pub exceptions_filters: u32, + pub exceptions_finallys: u32, + pub exceptions_depth: u32, + pub aspnet_requests_queued: u32, + pub aspnet_requests: u32, + pub gc_collections0: u32, + pub gc_collections1: u32, + pub gc_collections2: u32, + pub gc_promotions0: u32, + pub gc_promotions1: u32, + pub gc_promotion_finalizers: u32, + pub gc_gen0size: u32, + pub gc_gen1size: u32, + pub gc_gen2size: u32, + pub gc_lossize: u32, + pub gc_fin_survivors: u32, + pub gc_num_handles: u32, + pub gc_allocated: u32, + pub gc_induced: u32, + pub gc_time: u32, + pub gc_total_bytes: u32, + pub gc_committed_bytes: u32, + pub gc_reserved_bytes: u32, + pub gc_num_pinned: u32, + pub gc_sync_blocks: u32, + pub remoting_calls: u32, + pub remoting_channels: u32, + pub remoting_proxies: u32, + pub remoting_classes: u32, + pub remoting_objects: u32, + pub remoting_contexts: u32, + pub loader_classes: u32, + pub loader_total_classes: u32, + pub loader_appdomains: u32, + pub loader_total_appdomains: u32, + pub loader_assemblies: u32, + pub loader_total_assemblies: u32, + pub loader_failures: u32, + pub loader_bytes: u32, + pub loader_appdomains_uloaded: u32, + pub thread_contentions: u32, + pub thread_queue_len: u32, + pub thread_queue_max: u32, + pub thread_num_logical: u32, + pub thread_num_physical: u32, + pub thread_cur_recognized: u32, + pub thread_num_recognized: u32, + pub interop_num_ccw: u32, + pub interop_num_stubs: u32, + pub interop_num_marshals: u32, + pub security_num_checks: u32, + pub security_num_link_checks: u32, + pub security_time: u32, + pub security_depth: u32, + pub unused: u32, + pub threadpool_workitems: u64, + pub threadpool_ioworkitems: u64, + pub threadpool_threads: ::std::os::raw::c_uint, + pub threadpool_iothreads: ::std::os::raw::c_uint, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppWaitHandle { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct MonitorData { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppObject { + pub __bindgen_anon_1: Il2CppObject__bindgen_ty_1, + pub monitor: *mut MonitorData, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppArrayBounds { + pub length: il2cpp_array_size_t, + pub lower_bound: il2cpp_array_lower_bound_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppArray { + pub obj: Il2CppObject, + pub bounds: *mut Il2CppArrayBounds, + pub max_length: il2cpp_array_size_t, +} +#[repr(C)] +pub struct Il2CppArraySize { + pub obj: Il2CppObject, + pub bounds: *mut Il2CppArrayBounds, + pub max_length: il2cpp_array_size_t, + pub vector: __IncompleteArrayField<*mut ::std::os::raw::c_void>, +} +#[repr(C)] +pub struct Il2CppString { + pub object: Il2CppObject, + #[doc = "< Length of string *excluding* the trailing null (which is included in 'chars')."] + pub length: i32, + pub chars: __IncompleteArrayField, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppReflectionType { + pub object: Il2CppObject, + pub type_: *const Il2CppType, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppReflectionRuntimeType { + pub type_: Il2CppReflectionType, + pub type_info: *mut Il2CppObject, + pub genericCache: *mut Il2CppObject, + pub serializationCtor: *mut Il2CppObject, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppReflectionMonoType { + pub type_: Il2CppReflectionRuntimeType, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppReflectionEvent { + pub object: Il2CppObject, + pub cached_add_event: *mut Il2CppObject, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppReflectionMonoEvent { + pub event: Il2CppReflectionEvent, + pub reflectedType: *mut Il2CppReflectionType, + pub eventInfo: *const EventInfo, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppReflectionMonoEventInfo { + pub declaringType: *mut Il2CppReflectionType, + pub reflectedType: *mut Il2CppReflectionType, + pub name: *mut Il2CppString, + pub addMethod: *mut Il2CppReflectionMethod, + pub removeMethod: *mut Il2CppReflectionMethod, + pub raiseMethod: *mut Il2CppReflectionMethod, + pub eventAttributes: u32, + pub otherMethods: *mut Il2CppArray, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppReflectionField { + pub object: Il2CppObject, + pub klass: *mut Il2CppClass, + pub field: *mut FieldInfo, + pub name: *mut Il2CppString, + pub type_: *mut Il2CppReflectionType, + pub attrs: u32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppReflectionProperty { + pub object: Il2CppObject, + pub klass: *mut Il2CppClass, + pub property: *const PropertyInfo, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppReflectionMethod { + pub object: Il2CppObject, + pub method: *const MethodInfo, + pub name: *mut Il2CppString, + pub reftype: *mut Il2CppReflectionType, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppReflectionGenericMethod { + pub base: Il2CppReflectionMethod, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppMethodInfo { + pub parent: *mut Il2CppReflectionType, + pub ret: *mut Il2CppReflectionType, + pub attrs: u32, + pub implattrs: u32, + pub callconv: u32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppPropertyInfo { + pub parent: *mut Il2CppReflectionType, + pub declaringType: *mut Il2CppReflectionType, + pub name: *mut Il2CppString, + pub get: *mut Il2CppReflectionMethod, + pub set: *mut Il2CppReflectionMethod, + pub attrs: u32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppReflectionParameter { + pub object: Il2CppObject, + pub AttrsImpl: u32, + pub ClassImpl: *mut Il2CppReflectionType, + pub DefaultValueImpl: *mut Il2CppObject, + pub MemberImpl: *mut Il2CppObject, + pub NameImpl: *mut Il2CppString, + pub PositionImpl: i32, + pub MarshalAs: *mut Il2CppObject, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppReflectionModule { + pub obj: Il2CppObject, + pub image: *const Il2CppImage, + pub assembly: *mut Il2CppReflectionAssembly, + pub fqname: *mut Il2CppString, + pub name: *mut Il2CppString, + pub scopename: *mut Il2CppString, + pub is_resource: u8, + pub token: u32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppReflectionAssemblyName { + pub obj: Il2CppObject, + pub name: *mut Il2CppString, + pub codebase: *mut Il2CppString, + pub major: i32, + pub minor: i32, + pub build: i32, + pub revision: i32, + pub cultureInfo: *mut Il2CppObject, + pub flags: u32, + pub hashalg: u32, + pub keypair: *mut Il2CppObject, + pub publicKey: *mut Il2CppArray, + pub keyToken: *mut Il2CppArray, + pub versioncompat: u32, + pub version: *mut Il2CppObject, + pub processor_architecture: u32, + pub contentType: u32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppReflectionAssembly { + pub object: Il2CppObject, + pub assembly: *const Il2CppAssembly, + pub evidence: *mut Il2CppObject, + pub resolve_event_holder: *mut Il2CppObject, + pub minimum: *mut Il2CppObject, + pub optional: *mut Il2CppObject, + pub refuse: *mut Il2CppObject, + pub granted: *mut Il2CppObject, + pub denied: *mut Il2CppObject, + pub from_byte_array: u8, + pub name: *mut Il2CppString, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppReflectionMarshal { + pub object: Il2CppObject, + pub count: i32, + pub type_: i32, + pub eltype: i32, + pub guid: *mut Il2CppString, + pub mcookie: *mut Il2CppString, + pub marshaltype: *mut Il2CppString, + pub marshaltyperef: *mut Il2CppObject, + pub param_num: i32, + pub has_size: u8, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppReflectionPointer { + pub object: Il2CppObject, + pub data: *mut ::std::os::raw::c_void, + pub type_: *mut Il2CppReflectionType, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppThreadName { + pub chars: *mut Il2CppChar, + pub unused: i32, + pub length: i32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppRefCount { + pub ref_: u32, + pub destructor: ::std::option::Option, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppLongLivedThreadData { + pub ref_: Il2CppRefCount, + pub synch_cs: *mut ::std::os::raw::c_void, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppInternalThread { + pub obj: Il2CppObject, + pub lock_thread_id: ::std::os::raw::c_int, + pub handle: *mut ::std::os::raw::c_void, + pub native_handle: *mut ::std::os::raw::c_void, + pub name: Il2CppThreadName, + pub state: u32, + pub abort_exc: *mut Il2CppObject, + pub abort_state_handle: ::std::os::raw::c_int, + pub tid: u64, + pub debugger_thread: isize, + pub static_data: *mut ::std::os::raw::c_void, + pub runtime_thread_info: *mut ::std::os::raw::c_void, + pub current_appcontext: *mut Il2CppObject, + pub root_domain_thread: *mut Il2CppObject, + pub _serialized_principal: *mut Il2CppArray, + pub _serialized_principal_version: ::std::os::raw::c_int, + pub appdomain_refs: *mut ::std::os::raw::c_void, + pub interruption_requested: i32, + pub longlived: *mut ::std::os::raw::c_void, + pub threadpool_thread: u8, + pub thread_interrupt_requested: u8, + pub stack_size: ::std::os::raw::c_int, + pub apartment_state: u8, + pub critical_region_level: ::std::os::raw::c_int, + pub managed_id: ::std::os::raw::c_int, + pub small_id: u32, + pub manage_callback: *mut ::std::os::raw::c_void, + pub flags: isize, + pub thread_pinning_ref: *mut ::std::os::raw::c_void, + pub abort_protected_block_count: *mut ::std::os::raw::c_void, + pub priority: i32, + pub owned_mutexes: *mut ::std::os::raw::c_void, + pub suspended: *mut ::std::os::raw::c_void, + pub self_suspended: i32, + pub thread_state: usize, + pub unused: [*mut ::std::os::raw::c_void; 3usize], + pub last: *mut ::std::os::raw::c_void, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppIOSelectorJob { + pub object: Il2CppObject, + pub operation: i32, + pub callback: *mut Il2CppObject, + pub state: *mut Il2CppObject, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppMethodMessage { + pub obj: Il2CppObject, + pub method: *mut Il2CppReflectionMethod, + pub args: *mut Il2CppArray, + pub names: *mut Il2CppArray, + pub arg_types: *mut Il2CppArray, + pub ctx: *mut Il2CppObject, + pub rval: *mut Il2CppObject, + pub exc: *mut Il2CppObject, + pub async_result: *mut Il2CppAsyncResult, + pub call_type: u32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppAppDomainSetup { + pub object: Il2CppObject, + pub application_base: *mut Il2CppString, + pub application_name: *mut Il2CppString, + pub cache_path: *mut Il2CppString, + pub configuration_file: *mut Il2CppString, + pub dynamic_base: *mut Il2CppString, + pub license_file: *mut Il2CppString, + pub private_bin_path: *mut Il2CppString, + pub private_bin_path_probe: *mut Il2CppString, + pub shadow_copy_directories: *mut Il2CppString, + pub shadow_copy_files: *mut Il2CppString, + pub publisher_policy: u8, + pub path_changed: u8, + pub loader_optimization: ::std::os::raw::c_int, + pub disallow_binding_redirects: u8, + pub disallow_code_downloads: u8, + pub activation_arguments: *mut Il2CppObject, + pub domain_initializer: *mut Il2CppObject, + pub application_trust: *mut Il2CppObject, + pub domain_initializer_args: *mut Il2CppArray, + pub disallow_appbase_probe: u8, + pub configuration_bytes: *mut Il2CppArray, + pub serialized_non_primitives: *mut Il2CppArray, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppThread { + pub obj: Il2CppObject, + pub internal_thread: *mut Il2CppInternalThread, + pub start_obj: *mut Il2CppObject, + pub pending_exception: *mut Il2CppException, + pub principal: *mut Il2CppObject, + pub principal_version: i32, + pub delegate: *mut Il2CppDelegate, + pub executionContext: *mut Il2CppObject, + pub executionContextBelongsToOuterScope: u8, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppException { + pub object: Il2CppObject, + pub className: *mut Il2CppString, + pub message: *mut Il2CppString, + pub _data: *mut Il2CppObject, + pub inner_ex: *mut Il2CppException, + pub _helpURL: *mut Il2CppString, + pub trace_ips: *mut Il2CppArray, + pub stack_trace: *mut Il2CppString, + pub remote_stack_trace: *mut Il2CppString, + pub remote_stack_index: ::std::os::raw::c_int, + pub _dynamicMethods: *mut Il2CppObject, + pub hresult: il2cpp_hresult_t, + pub source: *mut Il2CppString, + pub safeSerializationManager: *mut Il2CppObject, + pub captured_traces: *mut Il2CppArray, + pub native_trace_ips: *mut Il2CppArray, + pub caught_in_unmanaged: i32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppSystemException { + pub base: Il2CppException, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppArgumentException { + pub base: Il2CppException, + pub argName: *mut Il2CppString, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppTypedRef { + pub type_: *const Il2CppType, + pub value: *mut ::std::os::raw::c_void, + pub klass: *mut Il2CppClass, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppDelegate { + pub object: Il2CppObject, + pub method_ptr: Il2CppMethodPointer, + pub invoke_impl: Il2CppMethodPointer, + pub target: *mut Il2CppObject, + pub method: *const MethodInfo, + pub delegate_trampoline: *mut ::std::os::raw::c_void, + pub extraArg: isize, + pub invoke_impl_this: *mut Il2CppObject, + pub interp_method: *mut ::std::os::raw::c_void, + pub interp_invoke_impl: *mut ::std::os::raw::c_void, + pub method_info: *mut Il2CppReflectionMethod, + pub original_method_info: *mut Il2CppReflectionMethod, + pub data: *mut Il2CppObject, + pub method_is_virtual: u8, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppMulticastDelegate { + pub delegate: Il2CppDelegate, + pub delegates: *mut Il2CppArray, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppMarshalByRefObject { + pub obj: Il2CppObject, + pub identity: *mut Il2CppObject, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppAppDomain { + pub mbr: Il2CppMarshalByRefObject, + pub data: *mut Il2CppDomain, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppStackFrame { + pub obj: Il2CppObject, + pub il_offset: i32, + pub native_offset: i32, + pub methodAddress: u64, + pub methodIndex: u32, + pub method: *mut Il2CppReflectionMethod, + pub filename: *mut Il2CppString, + pub line: i32, + pub column: i32, + pub internal_method_name: *mut Il2CppString, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppDateTimeFormatInfo { + pub obj: Il2CppObject, + pub CultureData: *mut Il2CppObject, + pub Name: *mut Il2CppString, + pub LangName: *mut Il2CppString, + pub CompareInfo: *mut Il2CppObject, + pub CultureInfo: *mut Il2CppObject, + pub AMDesignator: *mut Il2CppString, + pub PMDesignator: *mut Il2CppString, + pub DateSeparator: *mut Il2CppString, + pub GeneralShortTimePattern: *mut Il2CppString, + pub GeneralLongTimePattern: *mut Il2CppString, + pub TimeSeparator: *mut Il2CppString, + pub MonthDayPattern: *mut Il2CppString, + pub DateTimeOffsetPattern: *mut Il2CppString, + pub Calendar: *mut Il2CppObject, + pub FirstDayOfWeek: u32, + pub CalendarWeekRule: u32, + pub FullDateTimePattern: *mut Il2CppString, + pub AbbreviatedDayNames: *mut Il2CppArray, + pub ShortDayNames: *mut Il2CppArray, + pub DayNames: *mut Il2CppArray, + pub AbbreviatedMonthNames: *mut Il2CppArray, + pub MonthNames: *mut Il2CppArray, + pub GenitiveMonthNames: *mut Il2CppArray, + pub GenitiveAbbreviatedMonthNames: *mut Il2CppArray, + pub LeapYearMonthNames: *mut Il2CppArray, + pub LongDatePattern: *mut Il2CppString, + pub ShortDatePattern: *mut Il2CppString, + pub YearMonthPattern: *mut Il2CppString, + pub LongTimePattern: *mut Il2CppString, + pub ShortTimePattern: *mut Il2CppString, + pub YearMonthPatterns: *mut Il2CppArray, + pub ShortDatePatterns: *mut Il2CppArray, + pub LongDatePatterns: *mut Il2CppArray, + pub ShortTimePatterns: *mut Il2CppArray, + pub LongTimePatterns: *mut Il2CppArray, + pub EraNames: *mut Il2CppArray, + pub AbbrevEraNames: *mut Il2CppArray, + pub AbbrevEnglishEraNames: *mut Il2CppArray, + pub OptionalCalendars: *mut Il2CppArray, + pub readOnly: u8, + pub FormatFlags: i32, + pub CultureID: i32, + pub UseUserOverride: u8, + pub UseCalendarInfo: u8, + pub DataItem: i32, + pub IsDefaultCalendar: u8, + pub DateWords: *mut Il2CppArray, + pub FullTimeSpanPositivePattern: *mut Il2CppString, + pub FullTimeSpanNegativePattern: *mut Il2CppString, + pub dtfiTokenHash: *mut Il2CppArray, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppNumberFormatInfo { + pub obj: Il2CppObject, + pub numberGroupSizes: *mut Il2CppArray, + pub currencyGroupSizes: *mut Il2CppArray, + pub percentGroupSizes: *mut Il2CppArray, + pub positiveSign: *mut Il2CppString, + pub negativeSign: *mut Il2CppString, + pub numberDecimalSeparator: *mut Il2CppString, + pub numberGroupSeparator: *mut Il2CppString, + pub currencyGroupSeparator: *mut Il2CppString, + pub currencyDecimalSeparator: *mut Il2CppString, + pub currencySymbol: *mut Il2CppString, + pub ansiCurrencySymbol: *mut Il2CppString, + pub naNSymbol: *mut Il2CppString, + pub positiveInfinitySymbol: *mut Il2CppString, + pub negativeInfinitySymbol: *mut Il2CppString, + pub percentDecimalSeparator: *mut Il2CppString, + pub percentGroupSeparator: *mut Il2CppString, + pub percentSymbol: *mut Il2CppString, + pub perMilleSymbol: *mut Il2CppString, + pub nativeDigits: *mut Il2CppArray, + pub dataItem: ::std::os::raw::c_int, + pub numberDecimalDigits: ::std::os::raw::c_int, + pub currencyDecimalDigits: ::std::os::raw::c_int, + pub currencyPositivePattern: ::std::os::raw::c_int, + pub currencyNegativePattern: ::std::os::raw::c_int, + pub numberNegativePattern: ::std::os::raw::c_int, + pub percentPositivePattern: ::std::os::raw::c_int, + pub percentNegativePattern: ::std::os::raw::c_int, + pub percentDecimalDigits: ::std::os::raw::c_int, + pub digitSubstitution: ::std::os::raw::c_int, + pub readOnly: u8, + pub useUserOverride: u8, + pub isInvariant: u8, + pub validForParseAsNumber: u8, + pub validForParseAsCurrency: u8, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NumberFormatEntryManaged { + pub currency_decimal_digits: i32, + pub currency_decimal_separator: i32, + pub currency_group_separator: i32, + pub currency_group_sizes0: i32, + pub currency_group_sizes1: i32, + pub currency_negative_pattern: i32, + pub currency_positive_pattern: i32, + pub currency_symbol: i32, + pub nan_symbol: i32, + pub negative_infinity_symbol: i32, + pub negative_sign: i32, + pub number_decimal_digits: i32, + pub number_decimal_separator: i32, + pub number_group_separator: i32, + pub number_group_sizes0: i32, + pub number_group_sizes1: i32, + pub number_negative_pattern: i32, + pub per_mille_symbol: i32, + pub percent_negative_pattern: i32, + pub percent_positive_pattern: i32, + pub percent_symbol: i32, + pub positive_infinity_symbol: i32, + pub positive_sign: i32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppCultureData { + pub obj: Il2CppObject, + pub AMDesignator: *mut Il2CppString, + pub PMDesignator: *mut Il2CppString, + pub TimeSeparator: *mut Il2CppString, + pub LongTimePatterns: *mut Il2CppArray, + pub ShortTimePatterns: *mut Il2CppArray, + pub FirstDayOfWeek: u32, + pub CalendarWeekRule: u32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppCalendarData { + pub obj: Il2CppObject, + pub NativeName: *mut Il2CppString, + pub ShortDatePatterns: *mut Il2CppArray, + pub YearMonthPatterns: *mut Il2CppArray, + pub LongDatePatterns: *mut Il2CppArray, + pub MonthDayPattern: *mut Il2CppString, + pub EraNames: *mut Il2CppArray, + pub AbbreviatedEraNames: *mut Il2CppArray, + pub AbbreviatedEnglishEraNames: *mut Il2CppArray, + pub DayNames: *mut Il2CppArray, + pub AbbreviatedDayNames: *mut Il2CppArray, + pub SuperShortDayNames: *mut Il2CppArray, + pub MonthNames: *mut Il2CppArray, + pub AbbreviatedMonthNames: *mut Il2CppArray, + pub GenitiveMonthNames: *mut Il2CppArray, + pub GenitiveAbbreviatedMonthNames: *mut Il2CppArray, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppCultureInfo { + pub obj: Il2CppObject, + pub is_read_only: u8, + pub lcid: i32, + pub parent_lcid: i32, + pub datetime_index: i32, + pub number_index: i32, + pub default_calendar_type: i32, + pub use_user_override: u8, + pub number_format: *mut Il2CppNumberFormatInfo, + pub datetime_format: *mut Il2CppDateTimeFormatInfo, + pub textinfo: *mut Il2CppObject, + pub name: *mut Il2CppString, + pub englishname: *mut Il2CppString, + pub nativename: *mut Il2CppString, + pub iso3lang: *mut Il2CppString, + pub iso2lang: *mut Il2CppString, + pub win3lang: *mut Il2CppString, + pub territory: *mut Il2CppString, + pub native_calendar_names: *mut Il2CppArray, + pub compareinfo: *mut Il2CppString, + pub text_info_data: *const ::std::os::raw::c_void, + pub dataItem: ::std::os::raw::c_int, + pub calendar: *mut Il2CppObject, + pub parent_culture: *mut Il2CppObject, + pub constructed: u8, + pub cached_serialized_form: *mut Il2CppArray, + pub cultureData: *mut Il2CppObject, + pub isInherited: u8, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppRegionInfo { + pub obj: Il2CppObject, + pub geo_id: i32, + pub iso2name: *mut Il2CppString, + pub iso3name: *mut Il2CppString, + pub win3name: *mut Il2CppString, + pub english_name: *mut Il2CppString, + pub native_name: *mut Il2CppString, + pub currency_symbol: *mut Il2CppString, + pub iso_currency_symbol: *mut Il2CppString, + pub currency_english_name: *mut Il2CppString, + pub currency_native_name: *mut Il2CppString, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppSafeHandle { + pub base: Il2CppObject, + pub handle: *mut ::std::os::raw::c_void, + pub state: ::std::os::raw::c_int, + pub owns_handle: u8, + pub fullyInitialized: u8, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppStringBuilder { + pub object: Il2CppObject, + pub chunkChars: *mut Il2CppArray, + pub chunkPrevious: *mut Il2CppStringBuilder, + pub chunkLength: ::std::os::raw::c_int, + pub chunkOffset: ::std::os::raw::c_int, + pub maxCapacity: ::std::os::raw::c_int, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppSocketAddress { + pub base: Il2CppObject, + pub m_Size: ::std::os::raw::c_int, + pub data: *mut Il2CppArray, + pub m_changed: u8, + pub m_hash: ::std::os::raw::c_int, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppSortKey { + pub base: Il2CppObject, + pub str_: *mut Il2CppString, + pub key: *mut Il2CppArray, + pub options: i32, + pub lcid: i32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppErrorWrapper { + pub base: Il2CppObject, + pub errorCode: i32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppAsyncResult { + pub base: Il2CppObject, + pub async_state: *mut Il2CppObject, + pub handle: *mut Il2CppWaitHandle, + pub async_delegate: *mut Il2CppDelegate, + pub data: *mut ::std::os::raw::c_void, + pub object_data: *mut Il2CppAsyncCall, + pub sync_completed: u8, + pub completed: u8, + pub endinvoke_called: u8, + pub async_callback: *mut Il2CppObject, + pub execution_context: *mut Il2CppObject, + pub original_context: *mut Il2CppObject, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppAsyncCall { + pub base: Il2CppObject, + pub msg: *mut Il2CppMethodMessage, + pub cb_method: *mut MethodInfo, + pub cb_target: *mut Il2CppDelegate, + pub state: *mut Il2CppObject, + pub res: *mut Il2CppObject, + pub out_args: *mut Il2CppArray, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppExceptionWrapper { + pub ex: *mut Il2CppException, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppIOAsyncResult { + pub base: Il2CppObject, + pub callback: *mut Il2CppDelegate, + pub state: *mut Il2CppObject, + pub wait_handle: *mut Il2CppWaitHandle, + pub completed_synchronously: u8, + pub completed: u8, +} +#[doc = " Corresponds to Mono's internal System.Net.Sockets.Socket.SocketAsyncResult\n class. Has no relation to Il2CppAsyncResult."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppSocketAsyncResult { + pub base: Il2CppIOAsyncResult, + pub socket: *mut Il2CppObject, + pub operation: i32, + pub delayedException: *mut Il2CppException, + pub endPoint: *mut Il2CppObject, + pub buffer: *mut Il2CppArray, + pub offset: i32, + pub size: i32, + pub socket_flags: i32, + pub acceptSocket: *mut Il2CppObject, + pub addresses: *mut Il2CppArray, + pub port: i32, + pub buffers: *mut Il2CppObject, + pub reuseSocket: u8, + pub currentAddress: i32, + pub acceptedSocket: *mut Il2CppObject, + pub total: i32, + pub error: i32, + pub endCalled: i32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppManifestResourceInfo { + pub object: Il2CppObject, + pub assembly: *mut Il2CppReflectionAssembly, + pub filename: *mut Il2CppString, + pub location: u32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppAppContext { + pub obj: Il2CppObject, + pub domain_id: i32, + pub context_id: i32, + pub static_data: *mut ::std::os::raw::c_void, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppDecimal { + pub reserved: u16, + pub u: Il2CppDecimal__bindgen_ty_1, + pub Hi32: u32, + pub v: Il2CppDecimal__bindgen_ty_2, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppDecimal__bindgen_ty_1__bindgen_ty_1 { + pub scale: u8, + pub sign: u8, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppDecimal__bindgen_ty_2__bindgen_ty_1 { + pub Lo32: u32, + pub Mid32: u32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppDouble { + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppSingle { + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppByReference { + pub value: isize, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __crt_locale_data { + pub _address: u8, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __crt_multibyte_data { + pub _address: u8, +} +pub const _VCRT_COMPILER_PREPROCESSOR: u32 = 1; +pub const _SAL_VERSION: u32 = 20; +pub const __SAL_H_VERSION: u32 = 180000000; +pub const _USE_DECLSPECS_FOR_SAL: u32 = 0; +pub const _USE_ATTRIBUTES_FOR_SAL: u32 = 0; +pub const _CRT_PACKING: u32 = 8; +pub const _HAS_EXCEPTIONS: u32 = 1; +pub const _STL_LANG: u32 = 0; +pub const _HAS_CXX17: u32 = 0; +pub const _HAS_CXX20: u32 = 0; +pub const _HAS_CXX23: u32 = 0; +pub const _HAS_NODISCARD: u32 = 0; +pub const WCHAR_MIN: u32 = 0; +pub const WCHAR_MAX: u32 = 65535; +pub const WINT_MIN: u32 = 0; +pub const WINT_MAX: u32 = 65535; +pub const _ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE: u32 = 1; +pub const _CRT_BUILD_DESKTOP_APP: u32 = 1; +pub const _ARGMAX: u32 = 100; +pub const _CRT_INT_MAX: u32 = 2147483647; +pub const _CRT_FUNCTIONS_REQUIRED: u32 = 1; +pub const _CRT_HAS_CXX17: u32 = 0; +pub const _CRT_HAS_C11: u32 = 1; +pub const _CRT_INTERNAL_NONSTDC_NAMES: u32 = 1; +pub const __STDC_SECURE_LIB__: u32 = 200411; +pub const __GOT_SECURE_LIB__: u32 = 200411; +pub const __STDC_WANT_SECURE_LIB__: u32 = 1; +pub const _SECURECRT_FILL_BUFFER_PATTERN: u32 = 254; +pub const _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES: u32 = 0; +pub const _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT: u32 = 0; +pub const _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES: u32 = 1; +pub const _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_MEMORY: u32 = 0; +pub const _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_MEMORY: u32 = 0; +pub const IL2CPP_TARGET_ARM64: u32 = 0; +pub const IL2CPP_TARGET_ARMV7: u32 = 0; +pub const IL2CPP_TARGET_ARM64E: u32 = 0; +pub const IL2CPP_TARGET_X64: u32 = 1; +pub const IL2CPP_TARGET_X86: u32 = 0; +pub const IL2CPP_BINARY_SECTION_NAME: &[u8; 7] = b"il2cpp\0"; +pub const IL2CPP_TARGET_WINDOWS: u32 = 1; +pub const IL2CPP_PLATFORM_SUPPORTS_DEBUGGER_PRESENT: u32 = 1; +pub const IL2CPP_TARGET_WINDOWS_DESKTOP: u32 = 1; +pub const IL2CPP_PLATFORM_SUPPORTS_SYSTEM_CERTIFICATES: u32 = 1; +pub const IL2CPP_PLATFORM_SUPPORTS_CPU_INFO: u32 = 1; +pub const NTDDI_VERSION: u32 = 100728832; +pub const _WIN32_WINNT: u32 = 1537; +pub const WINVER: u32 = 1537; +pub const _UNICODE: u32 = 1; +pub const UNICODE: u32 = 1; +pub const STRICT: u32 = 1; +pub const IL2CPP_TARGET_WINDOWS_GAMES: u32 = 0; +pub const IL2CPP_TARGET_GAMECORE_XBOX: u32 = 0; +pub const IL2CPP_TARGET_WINRT: u32 = 0; +pub const IL2CPP_TARGET_XBOXONE: u32 = 0; +pub const IL2CPP_TARGET_DARWIN: u32 = 0; +pub const IL2CPP_TARGET_IOS: u32 = 0; +pub const IL2CPP_TARGET_OSX: u32 = 0; +pub const IL2CPP_TARGET_ANDROID: u32 = 0; +pub const IL2CPP_TARGET_JAVASCRIPT: u32 = 0; +pub const IL2CPP_TARGET_LINUX: u32 = 0; +pub const IL2CPP_TARGET_QNX: u32 = 0; +pub const IL2CPP_TARGET_N3DS: u32 = 0; +pub const IL2CPP_TARGET_PS4: u32 = 0; +pub const IL2CPP_TARGET_PSP2: u32 = 0; +pub const IL2CPP_TARGET_SWITCH: u32 = 0; +pub const IL2CPP_TARGET_EMBEDDED_LINUX: u32 = 0; +pub const IL2CPP_PLATFORM_OVERRIDES_STD_FILE_HANDLES: u32 = 0; +pub const IL2CPP_PLATFORM_SUPPORTS_TIMEZONEINFO: u32 = 0; +pub const IL2CPP_DEBUG: u32 = 0; +pub const IL2CPP_PLATFORM_DISABLE_LIBC_PINVOKE: u32 = 0; +pub const IL2CPP_SUPPORT_SOCKETS_POSIX_API: u32 = 0; +pub const IL2CPP_USE_STD_THREAD: u32 = 0; +pub const IL2CPP_THREADS_STD: u32 = 0; +pub const IL2CPP_USE_BASELIB_FAST_READER_RWL: u32 = 0; +pub const IL2CPP_SIZEOF_VOID_P: u32 = 8; +pub const IL2CPP_SUPPORTS_CONSOLE_EXTENSION: u32 = 0; +pub const _HEAP_MAXREQ: i32 = -32; +pub const _HEAPEMPTY: i32 = -1; +pub const _HEAPOK: i32 = -2; +pub const _HEAPBADBEGIN: i32 = -3; +pub const _HEAPBADNODE: i32 = -4; +pub const _HEAPEND: i32 = -5; +pub const _HEAPBADPTR: i32 = -6; +pub const _FREEENTRY: u32 = 0; +pub const _USEDENTRY: u32 = 1; +pub const _ALLOCA_S_THRESHOLD: u32 = 1024; +pub const _ALLOCA_S_STACK_MARKER: u32 = 52428; +pub const _ALLOCA_S_HEAP_MARKER: u32 = 56797; +pub const _ALLOCA_S_MARKER_SIZE: u32 = 16; +pub const IL2CPP_API_DYNAMIC_NO_DLSYM: u32 = 0; +pub const IL2CPP_POINTER_SPARE_BITS: u32 = 0; +pub const EPERM: u32 = 1; +pub const ENOENT: u32 = 2; +pub const ESRCH: u32 = 3; +pub const EINTR: u32 = 4; +pub const EIO: u32 = 5; +pub const ENXIO: u32 = 6; +pub const E2BIG: u32 = 7; +pub const ENOEXEC: u32 = 8; +pub const EBADF: u32 = 9; +pub const ECHILD: u32 = 10; +pub const EAGAIN: u32 = 11; +pub const ENOMEM: u32 = 12; +pub const EACCES: u32 = 13; +pub const EFAULT: u32 = 14; +pub const EBUSY: u32 = 16; +pub const EEXIST: u32 = 17; +pub const EXDEV: u32 = 18; +pub const ENODEV: u32 = 19; +pub const ENOTDIR: u32 = 20; +pub const EISDIR: u32 = 21; +pub const ENFILE: u32 = 23; +pub const EMFILE: u32 = 24; +pub const ENOTTY: u32 = 25; +pub const EFBIG: u32 = 27; +pub const ENOSPC: u32 = 28; +pub const ESPIPE: u32 = 29; +pub const EROFS: u32 = 30; +pub const EMLINK: u32 = 31; +pub const EPIPE: u32 = 32; +pub const EDOM: u32 = 33; +pub const EDEADLK: u32 = 36; +pub const ENAMETOOLONG: u32 = 38; +pub const ENOLCK: u32 = 39; +pub const ENOSYS: u32 = 40; +pub const ENOTEMPTY: u32 = 41; +pub const EINVAL: u32 = 22; +pub const ERANGE: u32 = 34; +pub const EILSEQ: u32 = 42; +pub const STRUNCATE: u32 = 80; +pub const EDEADLOCK: u32 = 36; +pub const EADDRINUSE: u32 = 100; +pub const EADDRNOTAVAIL: u32 = 101; +pub const EAFNOSUPPORT: u32 = 102; +pub const EALREADY: u32 = 103; +pub const EBADMSG: u32 = 104; +pub const ECANCELED: u32 = 105; +pub const ECONNABORTED: u32 = 106; +pub const ECONNREFUSED: u32 = 107; +pub const ECONNRESET: u32 = 108; +pub const EDESTADDRREQ: u32 = 109; +pub const EHOSTUNREACH: u32 = 110; +pub const EIDRM: u32 = 111; +pub const EINPROGRESS: u32 = 112; +pub const EISCONN: u32 = 113; +pub const ELOOP: u32 = 114; +pub const EMSGSIZE: u32 = 115; +pub const ENETDOWN: u32 = 116; +pub const ENETRESET: u32 = 117; +pub const ENETUNREACH: u32 = 118; +pub const ENOBUFS: u32 = 119; +pub const ENODATA: u32 = 120; +pub const ENOLINK: u32 = 121; +pub const ENOMSG: u32 = 122; +pub const ENOPROTOOPT: u32 = 123; +pub const ENOSR: u32 = 124; +pub const ENOSTR: u32 = 125; +pub const ENOTCONN: u32 = 126; +pub const ENOTRECOVERABLE: u32 = 127; +pub const ENOTSOCK: u32 = 128; +pub const ENOTSUP: u32 = 129; +pub const EOPNOTSUPP: u32 = 130; +pub const EOTHER: u32 = 131; +pub const EOVERFLOW: u32 = 132; +pub const EOWNERDEAD: u32 = 133; +pub const EPROTO: u32 = 134; +pub const EPROTONOSUPPORT: u32 = 135; +pub const EPROTOTYPE: u32 = 136; +pub const ETIME: u32 = 137; +pub const ETIMEDOUT: u32 = 138; +pub const ETXTBSY: u32 = 139; +pub const EWOULDBLOCK: u32 = 140; +pub const _NLSCMPERROR: u32 = 2147483647; +pub const IL2CPP_CXX_ABI_MSVC: u32 = 1; +pub const IL2CPP_ENABLE_MONO_BUG_EMULATION: u32 = 1; +pub const IL2CPP_PAGE_SIZE: u32 = 4096; +pub const IL2CPP_DEVELOPMENT: u32 = 0; +pub const IL2CPP_THREAD_IMPL_HAS_COM_APARTMENTS: u32 = 1; +pub const IL2CPP_CAN_USE_MULTIPLE_SYMBOL_MAPS: u32 = 0; +pub const IL2CPP_GC_BOEHM: u32 = 1; +pub const IL2CPP_ENABLE_DEFERRED_GC: u32 = 0; +pub const NEED_TO_ZERO_PTRFREE: u32 = 1; +pub const IL2CPP_HAS_GC_DESCRIPTORS: u32 = 1; +pub const IL2CPP_ZERO_LEN_ARRAY: u32 = 0; +pub const FIXME: &[u8; 8] = b"FIXME: \0"; +pub const IL2CPP_DIR_SEPARATOR: u8 = 92u8; +pub const IL2CPP_DISABLE_FULL_MESSAGES: u32 = 1; +pub const IL2CPP_USE_GENERIC_SOCKET_IMPL: u32 = 0; +pub const IL2CPP_USE_SEND_NOSIGNAL: u32 = 0; +pub const IL2CPP_USE_GENERIC_PROCESS: u32 = 1; +pub const IL2CPP_SIZEOF_STRUCT_WITH_NO_INSTANCE_FIELDS: u32 = 1; +pub const IL2CPP_VALIDATE_FIELD_LAYOUT: u32 = 0; +pub const IL2CPP_USE_NETWORK_ACCESS_HANDLER: u32 = 0; +pub const IL2CPP_LITTLE_ENDIAN: u32 = 1; +pub const IL2CPP_BIG_ENDIAN: u32 = 2; +pub const IL2CPP_BYTE_ORDER: u32 = 1; +pub const IL2CPP_HAS_DELETED_FUNCTIONS: u32 = 1; +pub const MAXIMUM_NESTED_GENERICS_EXCEPTION_MESSAGE : & [u8 ; 248] = b"IL2CPP encountered a managed type which it cannot convert ahead-of-time. The type uses generic or array types which are nested beyond the maximum depth which can be converted. Consider increasing the --maximum-recursive-generic-depth=%d argument\0" ; +pub const IL2CPP_USE_GENERIC_CPU_INFO: u32 = 0; +pub const IL2CPP_SUPPORTS_BROKERED_FILESYSTEM: u32 = 0; +pub const PUBLIC_KEY_BYTE_LENGTH: u32 = 8; +pub const THREAD_STATIC_FIELD_OFFSET: i32 = -1; +pub const FIELD_ATTRIBUTE_FIELD_ACCESS_MASK: u32 = 7; +pub const FIELD_ATTRIBUTE_COMPILER_CONTROLLED: u32 = 0; +pub const FIELD_ATTRIBUTE_PRIVATE: u32 = 1; +pub const FIELD_ATTRIBUTE_FAM_AND_ASSEM: u32 = 2; +pub const FIELD_ATTRIBUTE_ASSEMBLY: u32 = 3; +pub const FIELD_ATTRIBUTE_FAMILY: u32 = 4; +pub const FIELD_ATTRIBUTE_FAM_OR_ASSEM: u32 = 5; +pub const FIELD_ATTRIBUTE_PUBLIC: u32 = 6; +pub const FIELD_ATTRIBUTE_STATIC: u32 = 16; +pub const FIELD_ATTRIBUTE_INIT_ONLY: u32 = 32; +pub const FIELD_ATTRIBUTE_LITERAL: u32 = 64; +pub const FIELD_ATTRIBUTE_NOT_SERIALIZED: u32 = 128; +pub const FIELD_ATTRIBUTE_SPECIAL_NAME: u32 = 512; +pub const FIELD_ATTRIBUTE_PINVOKE_IMPL: u32 = 8192; +pub const FIELD_ATTRIBUTE_RESERVED_MASK: u32 = 38144; +pub const FIELD_ATTRIBUTE_RT_SPECIAL_NAME: u32 = 1024; +pub const FIELD_ATTRIBUTE_HAS_FIELD_MARSHAL: u32 = 4096; +pub const FIELD_ATTRIBUTE_HAS_DEFAULT: u32 = 32768; +pub const FIELD_ATTRIBUTE_HAS_FIELD_RVA: u32 = 256; +pub const METHOD_IMPL_ATTRIBUTE_CODE_TYPE_MASK: u32 = 3; +pub const METHOD_IMPL_ATTRIBUTE_IL: u32 = 0; +pub const METHOD_IMPL_ATTRIBUTE_NATIVE: u32 = 1; +pub const METHOD_IMPL_ATTRIBUTE_OPTIL: u32 = 2; +pub const METHOD_IMPL_ATTRIBUTE_RUNTIME: u32 = 3; +pub const METHOD_IMPL_ATTRIBUTE_MANAGED_MASK: u32 = 4; +pub const METHOD_IMPL_ATTRIBUTE_UNMANAGED: u32 = 4; +pub const METHOD_IMPL_ATTRIBUTE_MANAGED: u32 = 0; +pub const METHOD_IMPL_ATTRIBUTE_FORWARD_REF: u32 = 16; +pub const METHOD_IMPL_ATTRIBUTE_PRESERVE_SIG: u32 = 128; +pub const METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL: u32 = 4096; +pub const METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED: u32 = 32; +pub const METHOD_IMPL_ATTRIBUTE_NOINLINING: u32 = 8; +pub const METHOD_IMPL_ATTRIBUTE_MAX_METHOD_IMPL_VAL: u32 = 65535; +pub const METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK: u32 = 7; +pub const METHOD_ATTRIBUTE_COMPILER_CONTROLLED: u32 = 0; +pub const METHOD_ATTRIBUTE_PRIVATE: u32 = 1; +pub const METHOD_ATTRIBUTE_FAM_AND_ASSEM: u32 = 2; +pub const METHOD_ATTRIBUTE_ASSEM: u32 = 3; +pub const METHOD_ATTRIBUTE_FAMILY: u32 = 4; +pub const METHOD_ATTRIBUTE_FAM_OR_ASSEM: u32 = 5; +pub const METHOD_ATTRIBUTE_PUBLIC: u32 = 6; +pub const METHOD_ATTRIBUTE_STATIC: u32 = 16; +pub const METHOD_ATTRIBUTE_FINAL: u32 = 32; +pub const METHOD_ATTRIBUTE_VIRTUAL: u32 = 64; +pub const METHOD_ATTRIBUTE_HIDE_BY_SIG: u32 = 128; +pub const METHOD_ATTRIBUTE_VTABLE_LAYOUT_MASK: u32 = 256; +pub const METHOD_ATTRIBUTE_REUSE_SLOT: u32 = 0; +pub const METHOD_ATTRIBUTE_NEW_SLOT: u32 = 256; +pub const METHOD_ATTRIBUTE_STRICT: u32 = 512; +pub const METHOD_ATTRIBUTE_ABSTRACT: u32 = 1024; +pub const METHOD_ATTRIBUTE_SPECIAL_NAME: u32 = 2048; +pub const METHOD_ATTRIBUTE_PINVOKE_IMPL: u32 = 8192; +pub const METHOD_ATTRIBUTE_UNMANAGED_EXPORT: u32 = 8; +pub const METHOD_ATTRIBUTE_RESERVED_MASK: u32 = 53248; +pub const METHOD_ATTRIBUTE_RT_SPECIAL_NAME: u32 = 4096; +pub const METHOD_ATTRIBUTE_HAS_SECURITY: u32 = 16384; +pub const METHOD_ATTRIBUTE_REQUIRE_SEC_OBJECT: u32 = 32768; +pub const TYPE_ATTRIBUTE_VISIBILITY_MASK: u32 = 7; +pub const TYPE_ATTRIBUTE_NOT_PUBLIC: u32 = 0; +pub const TYPE_ATTRIBUTE_PUBLIC: u32 = 1; +pub const TYPE_ATTRIBUTE_NESTED_PUBLIC: u32 = 2; +pub const TYPE_ATTRIBUTE_NESTED_PRIVATE: u32 = 3; +pub const TYPE_ATTRIBUTE_NESTED_FAMILY: u32 = 4; +pub const TYPE_ATTRIBUTE_NESTED_ASSEMBLY: u32 = 5; +pub const TYPE_ATTRIBUTE_NESTED_FAM_AND_ASSEM: u32 = 6; +pub const TYPE_ATTRIBUTE_NESTED_FAM_OR_ASSEM: u32 = 7; +pub const TYPE_ATTRIBUTE_LAYOUT_MASK: u32 = 24; +pub const TYPE_ATTRIBUTE_AUTO_LAYOUT: u32 = 0; +pub const TYPE_ATTRIBUTE_SEQUENTIAL_LAYOUT: u32 = 8; +pub const TYPE_ATTRIBUTE_EXPLICIT_LAYOUT: u32 = 16; +pub const TYPE_ATTRIBUTE_CLASS_SEMANTIC_MASK: u32 = 32; +pub const TYPE_ATTRIBUTE_CLASS: u32 = 0; +pub const TYPE_ATTRIBUTE_INTERFACE: u32 = 32; +pub const TYPE_ATTRIBUTE_ABSTRACT: u32 = 128; +pub const TYPE_ATTRIBUTE_SEALED: u32 = 256; +pub const TYPE_ATTRIBUTE_SPECIAL_NAME: u32 = 1024; +pub const TYPE_ATTRIBUTE_IMPORT: u32 = 4096; +pub const TYPE_ATTRIBUTE_SERIALIZABLE: u32 = 8192; +pub const TYPE_ATTRIBUTE_STRING_FORMAT_MASK: u32 = 196608; +pub const TYPE_ATTRIBUTE_ANSI_CLASS: u32 = 0; +pub const TYPE_ATTRIBUTE_UNICODE_CLASS: u32 = 65536; +pub const TYPE_ATTRIBUTE_AUTO_CLASS: u32 = 131072; +pub const TYPE_ATTRIBUTE_BEFORE_FIELD_INIT: u32 = 1048576; +pub const TYPE_ATTRIBUTE_FORWARDER: u32 = 2097152; +pub const TYPE_ATTRIBUTE_RESERVED_MASK: u32 = 264192; +pub const TYPE_ATTRIBUTE_RT_SPECIAL_NAME: u32 = 2048; +pub const TYPE_ATTRIBUTE_HAS_SECURITY: u32 = 262144; +pub const PARAM_ATTRIBUTE_IN: u32 = 1; +pub const PARAM_ATTRIBUTE_OUT: u32 = 2; +pub const PARAM_ATTRIBUTE_OPTIONAL: u32 = 16; +pub const PARAM_ATTRIBUTE_RESERVED_MASK: u32 = 61440; +pub const PARAM_ATTRIBUTE_HAS_DEFAULT: u32 = 4096; +pub const PARAM_ATTRIBUTE_HAS_FIELD_MARSHAL: u32 = 8192; +pub const PARAM_ATTRIBUTE_UNUSED: u32 = 53216; +pub const IL2CPP_GENERIC_PARAMETER_ATTRIBUTE_NON_VARIANT: u32 = 0; +pub const IL2CPP_GENERIC_PARAMETER_ATTRIBUTE_COVARIANT: u32 = 1; +pub const IL2CPP_GENERIC_PARAMETER_ATTRIBUTE_CONTRAVARIANT: u32 = 2; +pub const IL2CPP_GENERIC_PARAMETER_ATTRIBUTE_VARIANCE_MASK: u32 = 3; +pub const IL2CPP_GENERIC_PARAMETER_ATTRIBUTE_REFERENCE_TYPE_CONSTRAINT: u32 = 4; +pub const IL2CPP_GENERIC_PARAMETER_ATTRIBUTE_NOT_NULLABLE_VALUE_TYPE_CONSTRAINT: u32 = 8; +pub const IL2CPP_GENERIC_PARAMETER_ATTRIBUTE_DEFAULT_CONSTRUCTOR_CONSTRAINT: u32 = 16; +pub const IL2CPP_GENERIC_PARAMETER_ATTRIBUTE_SPECIAL_CONSTRAINT_MASK: u32 = 28; +pub const ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG: u32 = 1; +pub const ASSEMBLYREF_RETARGETABLE_FLAG: u32 = 256; +pub const ASSEMBLYREF_ENABLEJITCOMPILE_TRACKING_FLAG: u32 = 32768; +pub const ASSEMBLYREF_DISABLEJITCOMPILE_OPTIMIZER_FLAG: u32 = 16384; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of __crt_locale_data_public"] + [::std::mem::size_of::<__crt_locale_data_public>() - 16usize]; + ["Alignment of __crt_locale_data_public"] + [::std::mem::align_of::<__crt_locale_data_public>() - 8usize]; + ["Offset of field: __crt_locale_data_public::_locale_pctype"] + [::std::mem::offset_of!(__crt_locale_data_public, _locale_pctype) - 0usize]; + ["Offset of field: __crt_locale_data_public::_locale_mb_cur_max"] + [::std::mem::offset_of!(__crt_locale_data_public, _locale_mb_cur_max) - 8usize]; + ["Offset of field: __crt_locale_data_public::_locale_lc_codepage"] + [::std::mem::offset_of!(__crt_locale_data_public, _locale_lc_codepage) - 12usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of __crt_locale_pointers"][::std::mem::size_of::<__crt_locale_pointers>() - 16usize]; + ["Alignment of __crt_locale_pointers"] + [::std::mem::align_of::<__crt_locale_pointers>() - 8usize]; + ["Offset of field: __crt_locale_pointers::locinfo"] + [::std::mem::offset_of!(__crt_locale_pointers, locinfo) - 0usize]; + ["Offset of field: __crt_locale_pointers::mbcinfo"] + [::std::mem::offset_of!(__crt_locale_pointers, mbcinfo) - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _Mbstatet"][::std::mem::size_of::<_Mbstatet>() - 8usize]; + ["Alignment of _Mbstatet"][::std::mem::align_of::<_Mbstatet>() - 4usize]; + ["Offset of field: _Mbstatet::_Wchar"][::std::mem::offset_of!(_Mbstatet, _Wchar) - 0usize]; + ["Offset of field: _Mbstatet::_Byte"][::std::mem::offset_of!(_Mbstatet, _Byte) - 4usize]; + ["Offset of field: _Mbstatet::_State"][::std::mem::offset_of!(_Mbstatet, _State) - 6usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _heapinfo"][::std::mem::size_of::<_heapinfo>() - 24usize]; + ["Alignment of _heapinfo"][::std::mem::align_of::<_heapinfo>() - 8usize]; + ["Offset of field: _heapinfo::_pentry"][::std::mem::offset_of!(_heapinfo, _pentry) - 0usize]; + ["Offset of field: _heapinfo::_size"][::std::mem::offset_of!(_heapinfo, _size) - 8usize]; + ["Offset of field: _heapinfo::_useflag"][::std::mem::offset_of!(_heapinfo, _useflag) - 16usize]; +}; +pub const Il2CppProfileFlags_IL2CPP_PROFILE_NONE: Il2CppProfileFlags = 0; +pub const Il2CppProfileFlags_IL2CPP_PROFILE_APPDOMAIN_EVENTS: Il2CppProfileFlags = 1; +pub const Il2CppProfileFlags_IL2CPP_PROFILE_ASSEMBLY_EVENTS: Il2CppProfileFlags = 2; +pub const Il2CppProfileFlags_IL2CPP_PROFILE_MODULE_EVENTS: Il2CppProfileFlags = 4; +pub const Il2CppProfileFlags_IL2CPP_PROFILE_CLASS_EVENTS: Il2CppProfileFlags = 8; +pub const Il2CppProfileFlags_IL2CPP_PROFILE_JIT_COMPILATION: Il2CppProfileFlags = 16; +pub const Il2CppProfileFlags_IL2CPP_PROFILE_INLINING: Il2CppProfileFlags = 32; +pub const Il2CppProfileFlags_IL2CPP_PROFILE_EXCEPTIONS: Il2CppProfileFlags = 64; +pub const Il2CppProfileFlags_IL2CPP_PROFILE_ALLOCATIONS: Il2CppProfileFlags = 128; +pub const Il2CppProfileFlags_IL2CPP_PROFILE_GC: Il2CppProfileFlags = 256; +pub const Il2CppProfileFlags_IL2CPP_PROFILE_THREADS: Il2CppProfileFlags = 512; +pub const Il2CppProfileFlags_IL2CPP_PROFILE_REMOTING: Il2CppProfileFlags = 1024; +pub const Il2CppProfileFlags_IL2CPP_PROFILE_TRANSITIONS: Il2CppProfileFlags = 2048; +pub const Il2CppProfileFlags_IL2CPP_PROFILE_ENTER_LEAVE: Il2CppProfileFlags = 4096; +pub const Il2CppProfileFlags_IL2CPP_PROFILE_COVERAGE: Il2CppProfileFlags = 8192; +pub const Il2CppProfileFlags_IL2CPP_PROFILE_INS_COVERAGE: Il2CppProfileFlags = 16384; +pub const Il2CppProfileFlags_IL2CPP_PROFILE_STATISTICAL: Il2CppProfileFlags = 32768; +pub const Il2CppProfileFlags_IL2CPP_PROFILE_METHOD_EVENTS: Il2CppProfileFlags = 65536; +pub const Il2CppProfileFlags_IL2CPP_PROFILE_MONITOR_EVENTS: Il2CppProfileFlags = 131072; +pub const Il2CppProfileFlags_IL2CPP_PROFILE_IOMAP_EVENTS: Il2CppProfileFlags = 262144; +pub const Il2CppProfileFlags_IL2CPP_PROFILE_GC_MOVES: Il2CppProfileFlags = 524288; +pub const Il2CppProfileFlags_IL2CPP_PROFILE_FILEIO: Il2CppProfileFlags = 1048576; +pub const Il2CppProfileFileIOKind_IL2CPP_PROFILE_FILEIO_WRITE: Il2CppProfileFileIOKind = 0; +pub const Il2CppProfileFileIOKind_IL2CPP_PROFILE_FILEIO_READ: Il2CppProfileFileIOKind = 1; +pub const Il2CppGCEvent_IL2CPP_GC_EVENT_START: Il2CppGCEvent = 0; +pub const Il2CppGCEvent_IL2CPP_GC_EVENT_MARK_START: Il2CppGCEvent = 1; +pub const Il2CppGCEvent_IL2CPP_GC_EVENT_MARK_END: Il2CppGCEvent = 2; +pub const Il2CppGCEvent_IL2CPP_GC_EVENT_RECLAIM_START: Il2CppGCEvent = 3; +pub const Il2CppGCEvent_IL2CPP_GC_EVENT_RECLAIM_END: Il2CppGCEvent = 4; +pub const Il2CppGCEvent_IL2CPP_GC_EVENT_END: Il2CppGCEvent = 5; +pub const Il2CppGCEvent_IL2CPP_GC_EVENT_PRE_STOP_WORLD: Il2CppGCEvent = 6; +pub const Il2CppGCEvent_IL2CPP_GC_EVENT_POST_STOP_WORLD: Il2CppGCEvent = 7; +pub const Il2CppGCEvent_IL2CPP_GC_EVENT_PRE_START_WORLD: Il2CppGCEvent = 8; +pub const Il2CppGCEvent_IL2CPP_GC_EVENT_POST_START_WORLD: Il2CppGCEvent = 9; +pub const Il2CppGCMode_IL2CPP_GC_MODE_DISABLED: Il2CppGCMode = 0; +pub const Il2CppGCMode_IL2CPP_GC_MODE_ENABLED: Il2CppGCMode = 1; +pub const Il2CppGCMode_IL2CPP_GC_MODE_MANUAL: Il2CppGCMode = 2; +pub const Il2CppStat_IL2CPP_STAT_NEW_OBJECT_COUNT: Il2CppStat = 0; +pub const Il2CppStat_IL2CPP_STAT_INITIALIZED_CLASS_COUNT: Il2CppStat = 1; +pub const Il2CppStat_IL2CPP_STAT_METHOD_COUNT: Il2CppStat = 2; +pub const Il2CppStat_IL2CPP_STAT_CLASS_STATIC_DATA_SIZE: Il2CppStat = 3; +pub const Il2CppStat_IL2CPP_STAT_GENERIC_INSTANCE_COUNT: Il2CppStat = 4; +pub const Il2CppStat_IL2CPP_STAT_GENERIC_CLASS_COUNT: Il2CppStat = 5; +pub const Il2CppStat_IL2CPP_STAT_INFLATED_METHOD_COUNT: Il2CppStat = 6; +pub const Il2CppStat_IL2CPP_STAT_INFLATED_TYPE_COUNT: Il2CppStat = 7; +pub const Il2CppRuntimeUnhandledExceptionPolicy_IL2CPP_UNHANDLED_POLICY_LEGACY: + Il2CppRuntimeUnhandledExceptionPolicy = 0; +pub const Il2CppRuntimeUnhandledExceptionPolicy_IL2CPP_UNHANDLED_POLICY_CURRENT: + Il2CppRuntimeUnhandledExceptionPolicy = 1; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppStackFrameInfo"][::std::mem::size_of::() - 32usize]; + ["Alignment of Il2CppStackFrameInfo"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppStackFrameInfo::method"] + [::std::mem::offset_of!(Il2CppStackFrameInfo, method) - 0usize]; + ["Offset of field: Il2CppStackFrameInfo::raw_ip"] + [::std::mem::offset_of!(Il2CppStackFrameInfo, raw_ip) - 8usize]; + ["Offset of field: Il2CppStackFrameInfo::sourceCodeLineNumber"] + [::std::mem::offset_of!(Il2CppStackFrameInfo, sourceCodeLineNumber) - 16usize]; + ["Offset of field: Il2CppStackFrameInfo::ilOffset"] + [::std::mem::offset_of!(Il2CppStackFrameInfo, ilOffset) - 20usize]; + ["Offset of field: Il2CppStackFrameInfo::filePath"] + [::std::mem::offset_of!(Il2CppStackFrameInfo, filePath) - 24usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppMethodDebugInfo"][::std::mem::size_of::() - 24usize]; + ["Alignment of Il2CppMethodDebugInfo"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppMethodDebugInfo::methodPointer"] + [::std::mem::offset_of!(Il2CppMethodDebugInfo, methodPointer) - 0usize]; + ["Offset of field: Il2CppMethodDebugInfo::code_size"] + [::std::mem::offset_of!(Il2CppMethodDebugInfo, code_size) - 8usize]; + ["Offset of field: Il2CppMethodDebugInfo::file"] + [::std::mem::offset_of!(Il2CppMethodDebugInfo, file) - 16usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppMemoryCallbacks"][::std::mem::size_of::() - 56usize]; + ["Alignment of Il2CppMemoryCallbacks"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppMemoryCallbacks::malloc_func"] + [::std::mem::offset_of!(Il2CppMemoryCallbacks, malloc_func) - 0usize]; + ["Offset of field: Il2CppMemoryCallbacks::aligned_malloc_func"] + [::std::mem::offset_of!(Il2CppMemoryCallbacks, aligned_malloc_func) - 8usize]; + ["Offset of field: Il2CppMemoryCallbacks::free_func"] + [::std::mem::offset_of!(Il2CppMemoryCallbacks, free_func) - 16usize]; + ["Offset of field: Il2CppMemoryCallbacks::aligned_free_func"] + [::std::mem::offset_of!(Il2CppMemoryCallbacks, aligned_free_func) - 24usize]; + ["Offset of field: Il2CppMemoryCallbacks::calloc_func"] + [::std::mem::offset_of!(Il2CppMemoryCallbacks, calloc_func) - 32usize]; + ["Offset of field: Il2CppMemoryCallbacks::realloc_func"] + [::std::mem::offset_of!(Il2CppMemoryCallbacks, realloc_func) - 40usize]; + ["Offset of field: Il2CppMemoryCallbacks::aligned_realloc_func"] + [::std::mem::offset_of!(Il2CppMemoryCallbacks, aligned_realloc_func) - 48usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppDebuggerTransport"][::std::mem::size_of::() - 56usize]; + ["Alignment of Il2CppDebuggerTransport"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppDebuggerTransport::name"] + [::std::mem::offset_of!(Il2CppDebuggerTransport, name) - 0usize]; + ["Offset of field: Il2CppDebuggerTransport::connect"] + [::std::mem::offset_of!(Il2CppDebuggerTransport, connect) - 8usize]; + ["Offset of field: Il2CppDebuggerTransport::wait_for_attach"] + [::std::mem::offset_of!(Il2CppDebuggerTransport, wait_for_attach) - 16usize]; + ["Offset of field: Il2CppDebuggerTransport::close1"] + [::std::mem::offset_of!(Il2CppDebuggerTransport, close1) - 24usize]; + ["Offset of field: Il2CppDebuggerTransport::close2"] + [::std::mem::offset_of!(Il2CppDebuggerTransport, close2) - 32usize]; + ["Offset of field: Il2CppDebuggerTransport::send"] + [::std::mem::offset_of!(Il2CppDebuggerTransport, send) - 40usize]; + ["Offset of field: Il2CppDebuggerTransport::recv"] + [::std::mem::offset_of!(Il2CppDebuggerTransport, recv) - 48usize]; +}; +pub const kInvalidIl2CppMethodSlot: u16 = 65535; +pub const kIl2CppInt32Min: i32 = -2147483648; +pub const kIl2CppInt32Max: i32 = 2147483647; +pub const kIl2CppUInt32Max: u32 = 4294967295; +pub const kIl2CppInt64Min: i64 = -9223372036854775808; +pub const kIl2CppInt64Max: i64 = 9223372036854775807; +pub const kIl2CppIntPtrMin: isize = -9223372036854775808; +pub const kIl2CppIntPtrMax: isize = 9223372036854775807; +pub const ipv6AddressSize: ::std::os::raw::c_int = 16; +pub const Il2CppTokenType_IL2CPP_TOKEN_MODULE: Il2CppTokenType = 0; +pub const Il2CppTokenType_IL2CPP_TOKEN_TYPE_REF: Il2CppTokenType = 16777216; +pub const Il2CppTokenType_IL2CPP_TOKEN_TYPE_DEF: Il2CppTokenType = 33554432; +pub const Il2CppTokenType_IL2CPP_TOKEN_FIELD_DEF: Il2CppTokenType = 67108864; +pub const Il2CppTokenType_IL2CPP_TOKEN_METHOD_DEF: Il2CppTokenType = 100663296; +pub const Il2CppTokenType_IL2CPP_TOKEN_PARAM_DEF: Il2CppTokenType = 134217728; +pub const Il2CppTokenType_IL2CPP_TOKEN_INTERFACE_IMPL: Il2CppTokenType = 150994944; +pub const Il2CppTokenType_IL2CPP_TOKEN_MEMBER_REF: Il2CppTokenType = 167772160; +pub const Il2CppTokenType_IL2CPP_TOKEN_CUSTOM_ATTRIBUTE: Il2CppTokenType = 201326592; +pub const Il2CppTokenType_IL2CPP_TOKEN_PERMISSION: Il2CppTokenType = 234881024; +pub const Il2CppTokenType_IL2CPP_TOKEN_SIGNATURE: Il2CppTokenType = 285212672; +pub const Il2CppTokenType_IL2CPP_TOKEN_EVENT: Il2CppTokenType = 335544320; +pub const Il2CppTokenType_IL2CPP_TOKEN_PROPERTY: Il2CppTokenType = 385875968; +pub const Il2CppTokenType_IL2CPP_TOKEN_MODULE_REF: Il2CppTokenType = 436207616; +pub const Il2CppTokenType_IL2CPP_TOKEN_TYPE_SPEC: Il2CppTokenType = 452984832; +pub const Il2CppTokenType_IL2CPP_TOKEN_ASSEMBLY: Il2CppTokenType = 536870912; +pub const Il2CppTokenType_IL2CPP_TOKEN_ASSEMBLY_REF: Il2CppTokenType = 587202560; +pub const Il2CppTokenType_IL2CPP_TOKEN_FILE: Il2CppTokenType = 637534208; +pub const Il2CppTokenType_IL2CPP_TOKEN_EXPORTED_TYPE: Il2CppTokenType = 654311424; +pub const Il2CppTokenType_IL2CPP_TOKEN_MANIFEST_RESOURCE: Il2CppTokenType = 671088640; +pub const Il2CppTokenType_IL2CPP_TOKEN_GENERIC_PARAM: Il2CppTokenType = 704643072; +pub const Il2CppTokenType_IL2CPP_TOKEN_METHOD_SPEC: Il2CppTokenType = 721420288; +pub const kTypeIndexInvalid: TypeIndex = -1; +pub const kTypeDefinitionIndexInvalid: TypeDefinitionIndex = -1; +pub const kDefaultValueIndexNull: DefaultValueDataIndex = -1; +pub const kCustomAttributeIndexInvalid: CustomAttributeIndex = -1; +pub const kEventIndexInvalid: EventIndex = -1; +pub const kFieldIndexInvalid: FieldIndex = -1; +pub const kMethodIndexInvalid: MethodIndex = -1; +pub const kPropertyIndexInvalid: PropertyIndex = -1; +pub const kGenericContainerIndexInvalid: GenericContainerIndex = -1; +pub const kGenericParameterIndexInvalid: GenericParameterIndex = -1; +pub const kRGCTXIndexInvalid: RGCTXIndex = -1; +pub const kStringLiteralIndexInvalid: StringLiteralIndex = -1; +pub const kInteropDataIndexInvalid: InteropDataIndex = -1; +pub const kPublicKeyByteLength: ::std::os::raw::c_int = 8; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppMethodSpec"][::std::mem::size_of::() - 12usize]; + ["Alignment of Il2CppMethodSpec"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Il2CppMethodSpec::methodDefinitionIndex"] + [::std::mem::offset_of!(Il2CppMethodSpec, methodDefinitionIndex) - 0usize]; + ["Offset of field: Il2CppMethodSpec::classIndexIndex"] + [::std::mem::offset_of!(Il2CppMethodSpec, classIndexIndex) - 4usize]; + ["Offset of field: Il2CppMethodSpec::methodIndexIndex"] + [::std::mem::offset_of!(Il2CppMethodSpec, methodIndexIndex) - 8usize]; +}; +pub const Il2CppRGCTXDataType_IL2CPP_RGCTX_DATA_INVALID: Il2CppRGCTXDataType = 0; +pub const Il2CppRGCTXDataType_IL2CPP_RGCTX_DATA_TYPE: Il2CppRGCTXDataType = 1; +pub const Il2CppRGCTXDataType_IL2CPP_RGCTX_DATA_CLASS: Il2CppRGCTXDataType = 2; +pub const Il2CppRGCTXDataType_IL2CPP_RGCTX_DATA_METHOD: Il2CppRGCTXDataType = 3; +pub const Il2CppRGCTXDataType_IL2CPP_RGCTX_DATA_ARRAY: Il2CppRGCTXDataType = 4; +pub const Il2CppRGCTXDataType_IL2CPP_RGCTX_DATA_CONSTRAINED: Il2CppRGCTXDataType = 5; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppRGCTXDefinitionData"] + [::std::mem::size_of::() - 4usize]; + ["Alignment of Il2CppRGCTXDefinitionData"] + [::std::mem::align_of::() - 4usize]; + ["Offset of field: Il2CppRGCTXDefinitionData::rgctxDataDummy"] + [::std::mem::offset_of!(Il2CppRGCTXDefinitionData, rgctxDataDummy) - 0usize]; + ["Offset of field: Il2CppRGCTXDefinitionData::__methodIndex"] + [::std::mem::offset_of!(Il2CppRGCTXDefinitionData, __methodIndex) - 0usize]; + ["Offset of field: Il2CppRGCTXDefinitionData::__typeIndex"] + [::std::mem::offset_of!(Il2CppRGCTXDefinitionData, __typeIndex) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppRGCTXConstrainedData"] + [::std::mem::size_of::() - 8usize]; + ["Alignment of Il2CppRGCTXConstrainedData"] + [::std::mem::align_of::() - 4usize]; + ["Offset of field: Il2CppRGCTXConstrainedData::__typeIndex"] + [::std::mem::offset_of!(Il2CppRGCTXConstrainedData, __typeIndex) - 0usize]; + ["Offset of field: Il2CppRGCTXConstrainedData::__encodedMethodIndex"] + [::std::mem::offset_of!(Il2CppRGCTXConstrainedData, __encodedMethodIndex) - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppRGCTXDefinition"][::std::mem::size_of::() - 16usize]; + ["Alignment of Il2CppRGCTXDefinition"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppRGCTXDefinition::type_"] + [::std::mem::offset_of!(Il2CppRGCTXDefinition, type_) - 0usize]; + ["Offset of field: Il2CppRGCTXDefinition::data"] + [::std::mem::offset_of!(Il2CppRGCTXDefinition, data) - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppGenericMethodIndices"] + [::std::mem::size_of::() - 12usize]; + ["Alignment of Il2CppGenericMethodIndices"] + [::std::mem::align_of::() - 4usize]; + ["Offset of field: Il2CppGenericMethodIndices::methodIndex"] + [::std::mem::offset_of!(Il2CppGenericMethodIndices, methodIndex) - 0usize]; + ["Offset of field: Il2CppGenericMethodIndices::invokerIndex"] + [::std::mem::offset_of!(Il2CppGenericMethodIndices, invokerIndex) - 4usize]; + ["Offset of field: Il2CppGenericMethodIndices::adjustorThunkIndex"] + [::std::mem::offset_of!(Il2CppGenericMethodIndices, adjustorThunkIndex) - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppGenericMethodFunctionsDefinitions"] + [::std::mem::size_of::() - 16usize]; + ["Alignment of Il2CppGenericMethodFunctionsDefinitions"] + [::std::mem::align_of::() - 4usize]; + ["Offset of field: Il2CppGenericMethodFunctionsDefinitions::genericMethodIndex"][::std::mem::offset_of!( + Il2CppGenericMethodFunctionsDefinitions, + genericMethodIndex + ) - 0usize]; + ["Offset of field: Il2CppGenericMethodFunctionsDefinitions::indices"] + [::std::mem::offset_of!(Il2CppGenericMethodFunctionsDefinitions, indices) - 4usize]; +}; +pub const Il2CppTypeEnum_IL2CPP_TYPE_END: Il2CppTypeEnum = 0; +pub const Il2CppTypeEnum_IL2CPP_TYPE_VOID: Il2CppTypeEnum = 1; +pub const Il2CppTypeEnum_IL2CPP_TYPE_BOOLEAN: Il2CppTypeEnum = 2; +pub const Il2CppTypeEnum_IL2CPP_TYPE_CHAR: Il2CppTypeEnum = 3; +pub const Il2CppTypeEnum_IL2CPP_TYPE_I1: Il2CppTypeEnum = 4; +pub const Il2CppTypeEnum_IL2CPP_TYPE_U1: Il2CppTypeEnum = 5; +pub const Il2CppTypeEnum_IL2CPP_TYPE_I2: Il2CppTypeEnum = 6; +pub const Il2CppTypeEnum_IL2CPP_TYPE_U2: Il2CppTypeEnum = 7; +pub const Il2CppTypeEnum_IL2CPP_TYPE_I4: Il2CppTypeEnum = 8; +pub const Il2CppTypeEnum_IL2CPP_TYPE_U4: Il2CppTypeEnum = 9; +pub const Il2CppTypeEnum_IL2CPP_TYPE_I8: Il2CppTypeEnum = 10; +pub const Il2CppTypeEnum_IL2CPP_TYPE_U8: Il2CppTypeEnum = 11; +pub const Il2CppTypeEnum_IL2CPP_TYPE_R4: Il2CppTypeEnum = 12; +pub const Il2CppTypeEnum_IL2CPP_TYPE_R8: Il2CppTypeEnum = 13; +pub const Il2CppTypeEnum_IL2CPP_TYPE_STRING: Il2CppTypeEnum = 14; +pub const Il2CppTypeEnum_IL2CPP_TYPE_PTR: Il2CppTypeEnum = 15; +pub const Il2CppTypeEnum_IL2CPP_TYPE_BYREF: Il2CppTypeEnum = 16; +pub const Il2CppTypeEnum_IL2CPP_TYPE_VALUETYPE: Il2CppTypeEnum = 17; +pub const Il2CppTypeEnum_IL2CPP_TYPE_CLASS: Il2CppTypeEnum = 18; +pub const Il2CppTypeEnum_IL2CPP_TYPE_VAR: Il2CppTypeEnum = 19; +pub const Il2CppTypeEnum_IL2CPP_TYPE_ARRAY: Il2CppTypeEnum = 20; +pub const Il2CppTypeEnum_IL2CPP_TYPE_GENERICINST: Il2CppTypeEnum = 21; +pub const Il2CppTypeEnum_IL2CPP_TYPE_TYPEDBYREF: Il2CppTypeEnum = 22; +pub const Il2CppTypeEnum_IL2CPP_TYPE_I: Il2CppTypeEnum = 24; +pub const Il2CppTypeEnum_IL2CPP_TYPE_U: Il2CppTypeEnum = 25; +pub const Il2CppTypeEnum_IL2CPP_TYPE_FNPTR: Il2CppTypeEnum = 27; +pub const Il2CppTypeEnum_IL2CPP_TYPE_OBJECT: Il2CppTypeEnum = 28; +pub const Il2CppTypeEnum_IL2CPP_TYPE_SZARRAY: Il2CppTypeEnum = 29; +pub const Il2CppTypeEnum_IL2CPP_TYPE_MVAR: Il2CppTypeEnum = 30; +pub const Il2CppTypeEnum_IL2CPP_TYPE_CMOD_REQD: Il2CppTypeEnum = 31; +pub const Il2CppTypeEnum_IL2CPP_TYPE_CMOD_OPT: Il2CppTypeEnum = 32; +pub const Il2CppTypeEnum_IL2CPP_TYPE_INTERNAL: Il2CppTypeEnum = 33; +pub const Il2CppTypeEnum_IL2CPP_TYPE_MODIFIER: Il2CppTypeEnum = 64; +pub const Il2CppTypeEnum_IL2CPP_TYPE_SENTINEL: Il2CppTypeEnum = 65; +pub const Il2CppTypeEnum_IL2CPP_TYPE_PINNED: Il2CppTypeEnum = 69; +pub const Il2CppTypeEnum_IL2CPP_TYPE_ENUM: Il2CppTypeEnum = 85; +pub const Il2CppTypeEnum_IL2CPP_TYPE_IL2CPP_TYPE_INDEX: Il2CppTypeEnum = 255; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppArrayType"][::std::mem::size_of::() - 32usize]; + ["Alignment of Il2CppArrayType"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppArrayType::etype"] + [::std::mem::offset_of!(Il2CppArrayType, etype) - 0usize]; + ["Offset of field: Il2CppArrayType::rank"] + [::std::mem::offset_of!(Il2CppArrayType, rank) - 8usize]; + ["Offset of field: Il2CppArrayType::numsizes"] + [::std::mem::offset_of!(Il2CppArrayType, numsizes) - 9usize]; + ["Offset of field: Il2CppArrayType::numlobounds"] + [::std::mem::offset_of!(Il2CppArrayType, numlobounds) - 10usize]; + ["Offset of field: Il2CppArrayType::sizes"] + [::std::mem::offset_of!(Il2CppArrayType, sizes) - 16usize]; + ["Offset of field: Il2CppArrayType::lobounds"] + [::std::mem::offset_of!(Il2CppArrayType, lobounds) - 24usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppGenericInst"][::std::mem::size_of::() - 16usize]; + ["Alignment of Il2CppGenericInst"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppGenericInst::type_argc"] + [::std::mem::offset_of!(Il2CppGenericInst, type_argc) - 0usize]; + ["Offset of field: Il2CppGenericInst::type_argv"] + [::std::mem::offset_of!(Il2CppGenericInst, type_argv) - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppGenericContext"][::std::mem::size_of::() - 16usize]; + ["Alignment of Il2CppGenericContext"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppGenericContext::class_inst"] + [::std::mem::offset_of!(Il2CppGenericContext, class_inst) - 0usize]; + ["Offset of field: Il2CppGenericContext::method_inst"] + [::std::mem::offset_of!(Il2CppGenericContext, method_inst) - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppGenericClass"][::std::mem::size_of::() - 32usize]; + ["Alignment of Il2CppGenericClass"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppGenericClass::type_"] + [::std::mem::offset_of!(Il2CppGenericClass, type_) - 0usize]; + ["Offset of field: Il2CppGenericClass::context"] + [::std::mem::offset_of!(Il2CppGenericClass, context) - 8usize]; + ["Offset of field: Il2CppGenericClass::cached_class"] + [::std::mem::offset_of!(Il2CppGenericClass, cached_class) - 24usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppGenericMethod"][::std::mem::size_of::() - 24usize]; + ["Alignment of Il2CppGenericMethod"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppGenericMethod::methodDefinition"] + [::std::mem::offset_of!(Il2CppGenericMethod, methodDefinition) - 0usize]; + ["Offset of field: Il2CppGenericMethod::context"] + [::std::mem::offset_of!(Il2CppGenericMethod, context) - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppType__bindgen_ty_1"] + [::std::mem::size_of::() - 8usize]; + ["Alignment of Il2CppType__bindgen_ty_1"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppType__bindgen_ty_1::dummy"] + [::std::mem::offset_of!(Il2CppType__bindgen_ty_1, dummy) - 0usize]; + ["Offset of field: Il2CppType__bindgen_ty_1::__klassIndex"] + [::std::mem::offset_of!(Il2CppType__bindgen_ty_1, __klassIndex) - 0usize]; + ["Offset of field: Il2CppType__bindgen_ty_1::typeHandle"] + [::std::mem::offset_of!(Il2CppType__bindgen_ty_1, typeHandle) - 0usize]; + ["Offset of field: Il2CppType__bindgen_ty_1::type_"] + [::std::mem::offset_of!(Il2CppType__bindgen_ty_1, type_) - 0usize]; + ["Offset of field: Il2CppType__bindgen_ty_1::array"] + [::std::mem::offset_of!(Il2CppType__bindgen_ty_1, array) - 0usize]; + ["Offset of field: Il2CppType__bindgen_ty_1::__genericParameterIndex"] + [::std::mem::offset_of!(Il2CppType__bindgen_ty_1, __genericParameterIndex) - 0usize]; + ["Offset of field: Il2CppType__bindgen_ty_1::genericParameterHandle"] + [::std::mem::offset_of!(Il2CppType__bindgen_ty_1, genericParameterHandle) - 0usize]; + ["Offset of field: Il2CppType__bindgen_ty_1::generic_class"] + [::std::mem::offset_of!(Il2CppType__bindgen_ty_1, generic_class) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppType"][::std::mem::size_of::() - 16usize]; + ["Alignment of Il2CppType"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppType::data"][::std::mem::offset_of!(Il2CppType, data) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppMetadataFieldInfo"][::std::mem::size_of::() - 24usize]; + ["Alignment of Il2CppMetadataFieldInfo"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppMetadataFieldInfo::type_"] + [::std::mem::offset_of!(Il2CppMetadataFieldInfo, type_) - 0usize]; + ["Offset of field: Il2CppMetadataFieldInfo::name"] + [::std::mem::offset_of!(Il2CppMetadataFieldInfo, name) - 8usize]; + ["Offset of field: Il2CppMetadataFieldInfo::token"] + [::std::mem::offset_of!(Il2CppMetadataFieldInfo, token) - 16usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppMetadataMethodInfo"] + [::std::mem::size_of::() - 40usize]; + ["Alignment of Il2CppMetadataMethodInfo"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppMetadataMethodInfo::handle"] + [::std::mem::offset_of!(Il2CppMetadataMethodInfo, handle) - 0usize]; + ["Offset of field: Il2CppMetadataMethodInfo::name"] + [::std::mem::offset_of!(Il2CppMetadataMethodInfo, name) - 8usize]; + ["Offset of field: Il2CppMetadataMethodInfo::return_type"] + [::std::mem::offset_of!(Il2CppMetadataMethodInfo, return_type) - 16usize]; + ["Offset of field: Il2CppMetadataMethodInfo::token"] + [::std::mem::offset_of!(Il2CppMetadataMethodInfo, token) - 24usize]; + ["Offset of field: Il2CppMetadataMethodInfo::flags"] + [::std::mem::offset_of!(Il2CppMetadataMethodInfo, flags) - 28usize]; + ["Offset of field: Il2CppMetadataMethodInfo::iflags"] + [::std::mem::offset_of!(Il2CppMetadataMethodInfo, iflags) - 30usize]; + ["Offset of field: Il2CppMetadataMethodInfo::slot"] + [::std::mem::offset_of!(Il2CppMetadataMethodInfo, slot) - 32usize]; + ["Offset of field: Il2CppMetadataMethodInfo::parameterCount"] + [::std::mem::offset_of!(Il2CppMetadataMethodInfo, parameterCount) - 34usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppMetadataParameterInfo"] + [::std::mem::size_of::() - 24usize]; + ["Alignment of Il2CppMetadataParameterInfo"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppMetadataParameterInfo::name"] + [::std::mem::offset_of!(Il2CppMetadataParameterInfo, name) - 0usize]; + ["Offset of field: Il2CppMetadataParameterInfo::token"] + [::std::mem::offset_of!(Il2CppMetadataParameterInfo, token) - 8usize]; + ["Offset of field: Il2CppMetadataParameterInfo::type_"] + [::std::mem::offset_of!(Il2CppMetadataParameterInfo, type_) - 16usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppMetadataPropertyInfo"] + [::std::mem::size_of::() - 32usize]; + ["Alignment of Il2CppMetadataPropertyInfo"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppMetadataPropertyInfo::name"] + [::std::mem::offset_of!(Il2CppMetadataPropertyInfo, name) - 0usize]; + ["Offset of field: Il2CppMetadataPropertyInfo::get"] + [::std::mem::offset_of!(Il2CppMetadataPropertyInfo, get) - 8usize]; + ["Offset of field: Il2CppMetadataPropertyInfo::set"] + [::std::mem::offset_of!(Il2CppMetadataPropertyInfo, set) - 16usize]; + ["Offset of field: Il2CppMetadataPropertyInfo::attrs"] + [::std::mem::offset_of!(Il2CppMetadataPropertyInfo, attrs) - 24usize]; + ["Offset of field: Il2CppMetadataPropertyInfo::token"] + [::std::mem::offset_of!(Il2CppMetadataPropertyInfo, token) - 28usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppMetadataEventInfo"][::std::mem::size_of::() - 48usize]; + ["Alignment of Il2CppMetadataEventInfo"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppMetadataEventInfo::name"] + [::std::mem::offset_of!(Il2CppMetadataEventInfo, name) - 0usize]; + ["Offset of field: Il2CppMetadataEventInfo::type_"] + [::std::mem::offset_of!(Il2CppMetadataEventInfo, type_) - 8usize]; + ["Offset of field: Il2CppMetadataEventInfo::add"] + [::std::mem::offset_of!(Il2CppMetadataEventInfo, add) - 16usize]; + ["Offset of field: Il2CppMetadataEventInfo::remove"] + [::std::mem::offset_of!(Il2CppMetadataEventInfo, remove) - 24usize]; + ["Offset of field: Il2CppMetadataEventInfo::raise"] + [::std::mem::offset_of!(Il2CppMetadataEventInfo, raise) - 32usize]; + ["Offset of field: Il2CppMetadataEventInfo::token"] + [::std::mem::offset_of!(Il2CppMetadataEventInfo, token) - 40usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppInterfaceOffsetInfo"] + [::std::mem::size_of::() - 16usize]; + ["Alignment of Il2CppInterfaceOffsetInfo"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppInterfaceOffsetInfo::interfaceType"] + [::std::mem::offset_of!(Il2CppInterfaceOffsetInfo, interfaceType) - 0usize]; + ["Offset of field: Il2CppInterfaceOffsetInfo::offset"] + [::std::mem::offset_of!(Il2CppInterfaceOffsetInfo, offset) - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppGenericParameterInfo"] + [::std::mem::size_of::() - 24usize]; + ["Alignment of Il2CppGenericParameterInfo"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppGenericParameterInfo::containerHandle"] + [::std::mem::offset_of!(Il2CppGenericParameterInfo, containerHandle) - 0usize]; + ["Offset of field: Il2CppGenericParameterInfo::name"] + [::std::mem::offset_of!(Il2CppGenericParameterInfo, name) - 8usize]; + ["Offset of field: Il2CppGenericParameterInfo::num"] + [::std::mem::offset_of!(Il2CppGenericParameterInfo, num) - 16usize]; + ["Offset of field: Il2CppGenericParameterInfo::flags"] + [::std::mem::offset_of!(Il2CppGenericParameterInfo, flags) - 18usize]; +}; +pub const Il2CppCallConvention_IL2CPP_CALL_DEFAULT: Il2CppCallConvention = 0; +pub const Il2CppCallConvention_IL2CPP_CALL_C: Il2CppCallConvention = 1; +pub const Il2CppCallConvention_IL2CPP_CALL_STDCALL: Il2CppCallConvention = 2; +pub const Il2CppCallConvention_IL2CPP_CALL_THISCALL: Il2CppCallConvention = 3; +pub const Il2CppCallConvention_IL2CPP_CALL_FASTCALL: Il2CppCallConvention = 4; +pub const Il2CppCallConvention_IL2CPP_CALL_VARARG: Il2CppCallConvention = 5; +pub const Il2CppCharSet_CHARSET_ANSI: Il2CppCharSet = 0; +pub const Il2CppCharSet_CHARSET_UNICODE: Il2CppCharSet = 1; +pub const Il2CppCharSet_CHARSET_NOT_SPECIFIED: Il2CppCharSet = 2; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppHString__"][::std::mem::size_of::() - 4usize]; + ["Alignment of Il2CppHString__"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Il2CppHString__::unused"] + [::std::mem::offset_of!(Il2CppHString__, unused) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppHStringHeader__bindgen_ty_1"] + [::std::mem::size_of::() - 24usize]; + ["Alignment of Il2CppHStringHeader__bindgen_ty_1"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppHStringHeader__bindgen_ty_1::Reserved1"] + [::std::mem::offset_of!(Il2CppHStringHeader__bindgen_ty_1, Reserved1) - 0usize]; + ["Offset of field: Il2CppHStringHeader__bindgen_ty_1::Reserved2"] + [::std::mem::offset_of!(Il2CppHStringHeader__bindgen_ty_1, Reserved2) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppHStringHeader"][::std::mem::size_of::() - 24usize]; + ["Alignment of Il2CppHStringHeader"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppHStringHeader::Reserved"] + [::std::mem::offset_of!(Il2CppHStringHeader, Reserved) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppGuid"][::std::mem::size_of::() - 16usize]; + ["Alignment of Il2CppGuid"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Il2CppGuid::data1"][::std::mem::offset_of!(Il2CppGuid, data1) - 0usize]; + ["Offset of field: Il2CppGuid::data2"][::std::mem::offset_of!(Il2CppGuid, data2) - 4usize]; + ["Offset of field: Il2CppGuid::data3"][::std::mem::offset_of!(Il2CppGuid, data3) - 6usize]; + ["Offset of field: Il2CppGuid::data4"][::std::mem::offset_of!(Il2CppGuid, data4) - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppSafeArrayBound"][::std::mem::size_of::() - 8usize]; + ["Alignment of Il2CppSafeArrayBound"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Il2CppSafeArrayBound::element_count"] + [::std::mem::offset_of!(Il2CppSafeArrayBound, element_count) - 0usize]; + ["Offset of field: Il2CppSafeArrayBound::lower_bound"] + [::std::mem::offset_of!(Il2CppSafeArrayBound, lower_bound) - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppSafeArray"][::std::mem::size_of::() - 32usize]; + ["Alignment of Il2CppSafeArray"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppSafeArray::dimension_count"] + [::std::mem::offset_of!(Il2CppSafeArray, dimension_count) - 0usize]; + ["Offset of field: Il2CppSafeArray::features"] + [::std::mem::offset_of!(Il2CppSafeArray, features) - 2usize]; + ["Offset of field: Il2CppSafeArray::element_size"] + [::std::mem::offset_of!(Il2CppSafeArray, element_size) - 4usize]; + ["Offset of field: Il2CppSafeArray::lock_count"] + [::std::mem::offset_of!(Il2CppSafeArray, lock_count) - 8usize]; + ["Offset of field: Il2CppSafeArray::data"] + [::std::mem::offset_of!(Il2CppSafeArray, data) - 16usize]; + ["Offset of field: Il2CppSafeArray::bounds"] + [::std::mem::offset_of!(Il2CppSafeArray, bounds) - 24usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppWin32Decimal__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::size_of::() - 2usize]; + ["Alignment of Il2CppWin32Decimal__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::align_of::() - 1usize]; + ["Offset of field: Il2CppWin32Decimal__bindgen_ty_1__bindgen_ty_1::scale"] + [::std::mem::offset_of!(Il2CppWin32Decimal__bindgen_ty_1__bindgen_ty_1, scale) - 0usize]; + ["Offset of field: Il2CppWin32Decimal__bindgen_ty_1__bindgen_ty_1::sign"] + [::std::mem::offset_of!(Il2CppWin32Decimal__bindgen_ty_1__bindgen_ty_1, sign) - 1usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppWin32Decimal__bindgen_ty_1"] + [::std::mem::size_of::() - 2usize]; + ["Alignment of Il2CppWin32Decimal__bindgen_ty_1"] + [::std::mem::align_of::() - 2usize]; + ["Offset of field: Il2CppWin32Decimal__bindgen_ty_1::s"] + [::std::mem::offset_of!(Il2CppWin32Decimal__bindgen_ty_1, s) - 0usize]; + ["Offset of field: Il2CppWin32Decimal__bindgen_ty_1::signscale"] + [::std::mem::offset_of!(Il2CppWin32Decimal__bindgen_ty_1, signscale) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppWin32Decimal__bindgen_ty_2__bindgen_ty_1"] + [::std::mem::size_of::() - 8usize]; + ["Alignment of Il2CppWin32Decimal__bindgen_ty_2__bindgen_ty_1"] + [::std::mem::align_of::() - 4usize]; + ["Offset of field: Il2CppWin32Decimal__bindgen_ty_2__bindgen_ty_1::lo32"] + [::std::mem::offset_of!(Il2CppWin32Decimal__bindgen_ty_2__bindgen_ty_1, lo32) - 0usize]; + ["Offset of field: Il2CppWin32Decimal__bindgen_ty_2__bindgen_ty_1::mid32"] + [::std::mem::offset_of!(Il2CppWin32Decimal__bindgen_ty_2__bindgen_ty_1, mid32) - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppWin32Decimal__bindgen_ty_2"] + [::std::mem::size_of::() - 8usize]; + ["Alignment of Il2CppWin32Decimal__bindgen_ty_2"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppWin32Decimal__bindgen_ty_2::s2"] + [::std::mem::offset_of!(Il2CppWin32Decimal__bindgen_ty_2, s2) - 0usize]; + ["Offset of field: Il2CppWin32Decimal__bindgen_ty_2::lo64"] + [::std::mem::offset_of!(Il2CppWin32Decimal__bindgen_ty_2, lo64) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppWin32Decimal"][::std::mem::size_of::() - 16usize]; + ["Alignment of Il2CppWin32Decimal"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppWin32Decimal::reserved"] + [::std::mem::offset_of!(Il2CppWin32Decimal, reserved) - 0usize]; + ["Offset of field: Il2CppWin32Decimal::u"] + [::std::mem::offset_of!(Il2CppWin32Decimal, u) - 2usize]; + ["Offset of field: Il2CppWin32Decimal::hi32"] + [::std::mem::offset_of!(Il2CppWin32Decimal, hi32) - 4usize]; + ["Offset of field: Il2CppWin32Decimal::u2"] + [::std::mem::offset_of!(Il2CppWin32Decimal, u2) - 8usize]; +}; +pub const Il2CppVarType_IL2CPP_VT_EMPTY: Il2CppVarType = 0; +pub const Il2CppVarType_IL2CPP_VT_NULL: Il2CppVarType = 1; +pub const Il2CppVarType_IL2CPP_VT_I2: Il2CppVarType = 2; +pub const Il2CppVarType_IL2CPP_VT_I4: Il2CppVarType = 3; +pub const Il2CppVarType_IL2CPP_VT_R4: Il2CppVarType = 4; +pub const Il2CppVarType_IL2CPP_VT_R8: Il2CppVarType = 5; +pub const Il2CppVarType_IL2CPP_VT_CY: Il2CppVarType = 6; +pub const Il2CppVarType_IL2CPP_VT_DATE: Il2CppVarType = 7; +pub const Il2CppVarType_IL2CPP_VT_BSTR: Il2CppVarType = 8; +pub const Il2CppVarType_IL2CPP_VT_DISPATCH: Il2CppVarType = 9; +pub const Il2CppVarType_IL2CPP_VT_ERROR: Il2CppVarType = 10; +pub const Il2CppVarType_IL2CPP_VT_BOOL: Il2CppVarType = 11; +pub const Il2CppVarType_IL2CPP_VT_VARIANT: Il2CppVarType = 12; +pub const Il2CppVarType_IL2CPP_VT_UNKNOWN: Il2CppVarType = 13; +pub const Il2CppVarType_IL2CPP_VT_DECIMAL: Il2CppVarType = 14; +pub const Il2CppVarType_IL2CPP_VT_I1: Il2CppVarType = 16; +pub const Il2CppVarType_IL2CPP_VT_UI1: Il2CppVarType = 17; +pub const Il2CppVarType_IL2CPP_VT_UI2: Il2CppVarType = 18; +pub const Il2CppVarType_IL2CPP_VT_UI4: Il2CppVarType = 19; +pub const Il2CppVarType_IL2CPP_VT_I8: Il2CppVarType = 20; +pub const Il2CppVarType_IL2CPP_VT_UI8: Il2CppVarType = 21; +pub const Il2CppVarType_IL2CPP_VT_INT: Il2CppVarType = 22; +pub const Il2CppVarType_IL2CPP_VT_UINT: Il2CppVarType = 23; +pub const Il2CppVarType_IL2CPP_VT_VOID: Il2CppVarType = 24; +pub const Il2CppVarType_IL2CPP_VT_HRESULT: Il2CppVarType = 25; +pub const Il2CppVarType_IL2CPP_VT_PTR: Il2CppVarType = 26; +pub const Il2CppVarType_IL2CPP_VT_SAFEARRAY: Il2CppVarType = 27; +pub const Il2CppVarType_IL2CPP_VT_CARRAY: Il2CppVarType = 28; +pub const Il2CppVarType_IL2CPP_VT_USERDEFINED: Il2CppVarType = 29; +pub const Il2CppVarType_IL2CPP_VT_LPSTR: Il2CppVarType = 30; +pub const Il2CppVarType_IL2CPP_VT_LPWSTR: Il2CppVarType = 31; +pub const Il2CppVarType_IL2CPP_VT_RECORD: Il2CppVarType = 36; +pub const Il2CppVarType_IL2CPP_VT_INT_PTR: Il2CppVarType = 37; +pub const Il2CppVarType_IL2CPP_VT_UINT_PTR: Il2CppVarType = 38; +pub const Il2CppVarType_IL2CPP_VT_FILETIME: Il2CppVarType = 64; +pub const Il2CppVarType_IL2CPP_VT_BLOB: Il2CppVarType = 65; +pub const Il2CppVarType_IL2CPP_VT_STREAM: Il2CppVarType = 66; +pub const Il2CppVarType_IL2CPP_VT_STORAGE: Il2CppVarType = 67; +pub const Il2CppVarType_IL2CPP_VT_STREAMED_OBJECT: Il2CppVarType = 68; +pub const Il2CppVarType_IL2CPP_VT_STORED_OBJECT: Il2CppVarType = 69; +pub const Il2CppVarType_IL2CPP_VT_BLOB_OBJECT: Il2CppVarType = 70; +pub const Il2CppVarType_IL2CPP_VT_CF: Il2CppVarType = 71; +pub const Il2CppVarType_IL2CPP_VT_CLSID: Il2CppVarType = 72; +pub const Il2CppVarType_IL2CPP_VT_VERSIONED_STREAM: Il2CppVarType = 73; +pub const Il2CppVarType_IL2CPP_VT_BSTR_BLOB: Il2CppVarType = 4095; +pub const Il2CppVarType_IL2CPP_VT_VECTOR: Il2CppVarType = 4096; +pub const Il2CppVarType_IL2CPP_VT_ARRAY: Il2CppVarType = 8192; +pub const Il2CppVarType_IL2CPP_VT_BYREF: Il2CppVarType = 16384; +pub const Il2CppVarType_IL2CPP_VT_RESERVED: Il2CppVarType = 32768; +pub const Il2CppVarType_IL2CPP_VT_ILLEGAL: Il2CppVarType = 65535; +pub const Il2CppVarType_IL2CPP_VT_ILLEGALMASKED: Il2CppVarType = 4095; +pub const Il2CppVarType_IL2CPP_VT_TYPEMASK: Il2CppVarType = 4095; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1___tagBRECORD"] + [::std::mem::size_of::( + ) - 16usize]; + ["Alignment of Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1___tagBRECORD"] + [::std::mem::align_of::( + ) - 8usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1___tagBRECORD::pvRecord"] [:: std :: mem :: offset_of ! (Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1___tagBRECORD , pvRecord) - 0usize] ; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1___tagBRECORD::pRecInfo"] [:: std :: mem :: offset_of ! (Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1___tagBRECORD , pRecInfo) - 8usize] ; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1"] + [::std::mem::size_of::() - 16usize]; + ["Alignment of Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::llVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + llVal + ) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::lVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + lVal + ) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::bVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + bVal + ) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::iVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + iVal + ) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::fltVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + fltVal + ) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::dblVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + dblVal + ) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::boolVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + boolVal + ) + - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::scode"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + scode + ) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::cyVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + cyVal + ) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::date"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + date + ) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::bstrVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + bstrVal + ) + - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::punkVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + punkVal + ) + - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::pdispVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + pdispVal + ) + - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::parray"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + parray + ) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::pbVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + pbVal + ) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::piVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + piVal + ) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::plVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + plVal + ) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::pllVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + pllVal + ) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::pfltVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + pfltVal + ) + - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::pdblVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + pdblVal + ) + - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::pboolVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + pboolVal + ) + - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::pscode"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + pscode + ) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::pcyVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + pcyVal + ) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::pdate"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + pdate + ) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::pbstrVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + pbstrVal + ) + - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::ppunkVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + ppunkVal + ) + - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::ppdispVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + ppdispVal + ) + - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::pparray"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + pparray + ) + - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::pvarVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + pvarVal + ) + - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::byref"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + byref + ) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::cVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + cVal + ) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::uiVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + uiVal + ) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::ulVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + ulVal + ) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::ullVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + ullVal + ) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::intVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + intVal + ) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::uintVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + uintVal + ) + - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::pdecVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + pdecVal + ) + - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::pcVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + pcVal + ) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::puiVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + puiVal + ) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::pulVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + pulVal + ) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::pullVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + pullVal + ) + - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::pintVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + pintVal + ) + - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::puintVal"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + puintVal + ) + - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1::n4"][::std::mem::offset_of!( + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1, + n4 + ) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppVariant__bindgen_ty_1___tagVARIANT"] + [::std::mem::size_of::() - 24usize]; + ["Alignment of Il2CppVariant__bindgen_ty_1___tagVARIANT"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT::type_"] + [::std::mem::offset_of!(Il2CppVariant__bindgen_ty_1___tagVARIANT, type_) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT::reserved1"] + [::std::mem::offset_of!(Il2CppVariant__bindgen_ty_1___tagVARIANT, reserved1) - 2usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT::reserved2"] + [::std::mem::offset_of!(Il2CppVariant__bindgen_ty_1___tagVARIANT, reserved2) - 4usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT::reserved3"] + [::std::mem::offset_of!(Il2CppVariant__bindgen_ty_1___tagVARIANT, reserved3) - 6usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1___tagVARIANT::n3"] + [::std::mem::offset_of!(Il2CppVariant__bindgen_ty_1___tagVARIANT, n3) - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppVariant__bindgen_ty_1"] + [::std::mem::size_of::() - 24usize]; + ["Alignment of Il2CppVariant__bindgen_ty_1"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1::n2"] + [::std::mem::offset_of!(Il2CppVariant__bindgen_ty_1, n2) - 0usize]; + ["Offset of field: Il2CppVariant__bindgen_ty_1::decVal"] + [::std::mem::offset_of!(Il2CppVariant__bindgen_ty_1, decVal) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppVariant"][::std::mem::size_of::() - 24usize]; + ["Alignment of Il2CppVariant"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppVariant::n1"][::std::mem::offset_of!(Il2CppVariant, n1) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppFileTime"][::std::mem::size_of::() - 8usize]; + ["Alignment of Il2CppFileTime"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Il2CppFileTime::low"][::std::mem::offset_of!(Il2CppFileTime, low) - 0usize]; + ["Offset of field: Il2CppFileTime::high"] + [::std::mem::offset_of!(Il2CppFileTime, high) - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppStatStg"][::std::mem::size_of::() - 80usize]; + ["Alignment of Il2CppStatStg"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppStatStg::name"][::std::mem::offset_of!(Il2CppStatStg, name) - 0usize]; + ["Offset of field: Il2CppStatStg::type_"] + [::std::mem::offset_of!(Il2CppStatStg, type_) - 8usize]; + ["Offset of field: Il2CppStatStg::size"][::std::mem::offset_of!(Il2CppStatStg, size) - 16usize]; + ["Offset of field: Il2CppStatStg::mtime"] + [::std::mem::offset_of!(Il2CppStatStg, mtime) - 24usize]; + ["Offset of field: Il2CppStatStg::ctime"] + [::std::mem::offset_of!(Il2CppStatStg, ctime) - 32usize]; + ["Offset of field: Il2CppStatStg::atime"] + [::std::mem::offset_of!(Il2CppStatStg, atime) - 40usize]; + ["Offset of field: Il2CppStatStg::mode"][::std::mem::offset_of!(Il2CppStatStg, mode) - 48usize]; + ["Offset of field: Il2CppStatStg::locks"] + [::std::mem::offset_of!(Il2CppStatStg, locks) - 52usize]; + ["Offset of field: Il2CppStatStg::clsid"] + [::std::mem::offset_of!(Il2CppStatStg, clsid) - 56usize]; + ["Offset of field: Il2CppStatStg::state"] + [::std::mem::offset_of!(Il2CppStatStg, state) - 72usize]; + ["Offset of field: Il2CppStatStg::reserved"] + [::std::mem::offset_of!(Il2CppStatStg, reserved) - 76usize]; +}; +pub const Il2CppWindowsRuntimeTypeKind_kTypeKindPrimitive: Il2CppWindowsRuntimeTypeKind = 0; +pub const Il2CppWindowsRuntimeTypeKind_kTypeKindMetadata: Il2CppWindowsRuntimeTypeKind = 1; +pub const Il2CppWindowsRuntimeTypeKind_kTypeKindCustom: Il2CppWindowsRuntimeTypeKind = 2; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppWindowsRuntimeTypeName"] + [::std::mem::size_of::() - 16usize]; + ["Alignment of Il2CppWindowsRuntimeTypeName"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppWindowsRuntimeTypeName::typeName"] + [::std::mem::offset_of!(Il2CppWindowsRuntimeTypeName, typeName) - 0usize]; + ["Offset of field: Il2CppWindowsRuntimeTypeName::typeKind"] + [::std::mem::offset_of!(Il2CppWindowsRuntimeTypeName, typeKind) - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppInteropData"][::std::mem::size_of::() - 56usize]; + ["Alignment of Il2CppInteropData"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppInteropData::delegatePInvokeWrapperFunction"] + [::std::mem::offset_of!(Il2CppInteropData, delegatePInvokeWrapperFunction) - 0usize]; + ["Offset of field: Il2CppInteropData::pinvokeMarshalToNativeFunction"] + [::std::mem::offset_of!(Il2CppInteropData, pinvokeMarshalToNativeFunction) - 8usize]; + ["Offset of field: Il2CppInteropData::pinvokeMarshalFromNativeFunction"] + [::std::mem::offset_of!(Il2CppInteropData, pinvokeMarshalFromNativeFunction) - 16usize]; + ["Offset of field: Il2CppInteropData::pinvokeMarshalCleanupFunction"] + [::std::mem::offset_of!(Il2CppInteropData, pinvokeMarshalCleanupFunction) - 24usize]; + ["Offset of field: Il2CppInteropData::createCCWFunction"] + [::std::mem::offset_of!(Il2CppInteropData, createCCWFunction) - 32usize]; + ["Offset of field: Il2CppInteropData::guid"] + [::std::mem::offset_of!(Il2CppInteropData, guid) - 40usize]; + ["Offset of field: Il2CppInteropData::type_"] + [::std::mem::offset_of!(Il2CppInteropData, type_) - 48usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of VirtualInvokeData"][::std::mem::size_of::() - 16usize]; + ["Alignment of VirtualInvokeData"][::std::mem::align_of::() - 8usize]; + ["Offset of field: VirtualInvokeData::methodPtr"] + [::std::mem::offset_of!(VirtualInvokeData, methodPtr) - 0usize]; + ["Offset of field: VirtualInvokeData::method"] + [::std::mem::offset_of!(VirtualInvokeData, method) - 8usize]; +}; +pub const Il2CppTypeNameFormat_IL2CPP_TYPE_NAME_FORMAT_IL: Il2CppTypeNameFormat = 0; +pub const Il2CppTypeNameFormat_IL2CPP_TYPE_NAME_FORMAT_REFLECTION: Il2CppTypeNameFormat = 1; +pub const Il2CppTypeNameFormat_IL2CPP_TYPE_NAME_FORMAT_FULL_NAME: Il2CppTypeNameFormat = 2; +pub const Il2CppTypeNameFormat_IL2CPP_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED: Il2CppTypeNameFormat = 3; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppDefaults"][::std::mem::size_of::() - 768usize]; + ["Alignment of Il2CppDefaults"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppDefaults::corlib"] + [::std::mem::offset_of!(Il2CppDefaults, corlib) - 0usize]; + ["Offset of field: Il2CppDefaults::corlib_gen"] + [::std::mem::offset_of!(Il2CppDefaults, corlib_gen) - 8usize]; + ["Offset of field: Il2CppDefaults::object_class"] + [::std::mem::offset_of!(Il2CppDefaults, object_class) - 16usize]; + ["Offset of field: Il2CppDefaults::byte_class"] + [::std::mem::offset_of!(Il2CppDefaults, byte_class) - 24usize]; + ["Offset of field: Il2CppDefaults::void_class"] + [::std::mem::offset_of!(Il2CppDefaults, void_class) - 32usize]; + ["Offset of field: Il2CppDefaults::boolean_class"] + [::std::mem::offset_of!(Il2CppDefaults, boolean_class) - 40usize]; + ["Offset of field: Il2CppDefaults::sbyte_class"] + [::std::mem::offset_of!(Il2CppDefaults, sbyte_class) - 48usize]; + ["Offset of field: Il2CppDefaults::int16_class"] + [::std::mem::offset_of!(Il2CppDefaults, int16_class) - 56usize]; + ["Offset of field: Il2CppDefaults::uint16_class"] + [::std::mem::offset_of!(Il2CppDefaults, uint16_class) - 64usize]; + ["Offset of field: Il2CppDefaults::int32_class"] + [::std::mem::offset_of!(Il2CppDefaults, int32_class) - 72usize]; + ["Offset of field: Il2CppDefaults::uint32_class"] + [::std::mem::offset_of!(Il2CppDefaults, uint32_class) - 80usize]; + ["Offset of field: Il2CppDefaults::int_class"] + [::std::mem::offset_of!(Il2CppDefaults, int_class) - 88usize]; + ["Offset of field: Il2CppDefaults::uint_class"] + [::std::mem::offset_of!(Il2CppDefaults, uint_class) - 96usize]; + ["Offset of field: Il2CppDefaults::int64_class"] + [::std::mem::offset_of!(Il2CppDefaults, int64_class) - 104usize]; + ["Offset of field: Il2CppDefaults::uint64_class"] + [::std::mem::offset_of!(Il2CppDefaults, uint64_class) - 112usize]; + ["Offset of field: Il2CppDefaults::single_class"] + [::std::mem::offset_of!(Il2CppDefaults, single_class) - 120usize]; + ["Offset of field: Il2CppDefaults::double_class"] + [::std::mem::offset_of!(Il2CppDefaults, double_class) - 128usize]; + ["Offset of field: Il2CppDefaults::char_class"] + [::std::mem::offset_of!(Il2CppDefaults, char_class) - 136usize]; + ["Offset of field: Il2CppDefaults::string_class"] + [::std::mem::offset_of!(Il2CppDefaults, string_class) - 144usize]; + ["Offset of field: Il2CppDefaults::enum_class"] + [::std::mem::offset_of!(Il2CppDefaults, enum_class) - 152usize]; + ["Offset of field: Il2CppDefaults::array_class"] + [::std::mem::offset_of!(Il2CppDefaults, array_class) - 160usize]; + ["Offset of field: Il2CppDefaults::delegate_class"] + [::std::mem::offset_of!(Il2CppDefaults, delegate_class) - 168usize]; + ["Offset of field: Il2CppDefaults::multicastdelegate_class"] + [::std::mem::offset_of!(Il2CppDefaults, multicastdelegate_class) - 176usize]; + ["Offset of field: Il2CppDefaults::asyncresult_class"] + [::std::mem::offset_of!(Il2CppDefaults, asyncresult_class) - 184usize]; + ["Offset of field: Il2CppDefaults::manualresetevent_class"] + [::std::mem::offset_of!(Il2CppDefaults, manualresetevent_class) - 192usize]; + ["Offset of field: Il2CppDefaults::typehandle_class"] + [::std::mem::offset_of!(Il2CppDefaults, typehandle_class) - 200usize]; + ["Offset of field: Il2CppDefaults::fieldhandle_class"] + [::std::mem::offset_of!(Il2CppDefaults, fieldhandle_class) - 208usize]; + ["Offset of field: Il2CppDefaults::methodhandle_class"] + [::std::mem::offset_of!(Il2CppDefaults, methodhandle_class) - 216usize]; + ["Offset of field: Il2CppDefaults::systemtype_class"] + [::std::mem::offset_of!(Il2CppDefaults, systemtype_class) - 224usize]; + ["Offset of field: Il2CppDefaults::monotype_class"] + [::std::mem::offset_of!(Il2CppDefaults, monotype_class) - 232usize]; + ["Offset of field: Il2CppDefaults::exception_class"] + [::std::mem::offset_of!(Il2CppDefaults, exception_class) - 240usize]; + ["Offset of field: Il2CppDefaults::threadabortexception_class"] + [::std::mem::offset_of!(Il2CppDefaults, threadabortexception_class) - 248usize]; + ["Offset of field: Il2CppDefaults::thread_class"] + [::std::mem::offset_of!(Il2CppDefaults, thread_class) - 256usize]; + ["Offset of field: Il2CppDefaults::internal_thread_class"] + [::std::mem::offset_of!(Il2CppDefaults, internal_thread_class) - 264usize]; + ["Offset of field: Il2CppDefaults::appdomain_class"] + [::std::mem::offset_of!(Il2CppDefaults, appdomain_class) - 272usize]; + ["Offset of field: Il2CppDefaults::appdomain_setup_class"] + [::std::mem::offset_of!(Il2CppDefaults, appdomain_setup_class) - 280usize]; + ["Offset of field: Il2CppDefaults::member_info_class"] + [::std::mem::offset_of!(Il2CppDefaults, member_info_class) - 288usize]; + ["Offset of field: Il2CppDefaults::field_info_class"] + [::std::mem::offset_of!(Il2CppDefaults, field_info_class) - 296usize]; + ["Offset of field: Il2CppDefaults::method_info_class"] + [::std::mem::offset_of!(Il2CppDefaults, method_info_class) - 304usize]; + ["Offset of field: Il2CppDefaults::property_info_class"] + [::std::mem::offset_of!(Il2CppDefaults, property_info_class) - 312usize]; + ["Offset of field: Il2CppDefaults::event_info_class"] + [::std::mem::offset_of!(Il2CppDefaults, event_info_class) - 320usize]; + ["Offset of field: Il2CppDefaults::stringbuilder_class"] + [::std::mem::offset_of!(Il2CppDefaults, stringbuilder_class) - 328usize]; + ["Offset of field: Il2CppDefaults::stack_frame_class"] + [::std::mem::offset_of!(Il2CppDefaults, stack_frame_class) - 336usize]; + ["Offset of field: Il2CppDefaults::stack_trace_class"] + [::std::mem::offset_of!(Il2CppDefaults, stack_trace_class) - 344usize]; + ["Offset of field: Il2CppDefaults::marshal_class"] + [::std::mem::offset_of!(Il2CppDefaults, marshal_class) - 352usize]; + ["Offset of field: Il2CppDefaults::typed_reference_class"] + [::std::mem::offset_of!(Il2CppDefaults, typed_reference_class) - 360usize]; + ["Offset of field: Il2CppDefaults::marshalbyrefobject_class"] + [::std::mem::offset_of!(Il2CppDefaults, marshalbyrefobject_class) - 368usize]; + ["Offset of field: Il2CppDefaults::generic_ilist_class"] + [::std::mem::offset_of!(Il2CppDefaults, generic_ilist_class) - 376usize]; + ["Offset of field: Il2CppDefaults::generic_icollection_class"] + [::std::mem::offset_of!(Il2CppDefaults, generic_icollection_class) - 384usize]; + ["Offset of field: Il2CppDefaults::generic_ienumerable_class"] + [::std::mem::offset_of!(Il2CppDefaults, generic_ienumerable_class) - 392usize]; + ["Offset of field: Il2CppDefaults::generic_ireadonlylist_class"] + [::std::mem::offset_of!(Il2CppDefaults, generic_ireadonlylist_class) - 400usize]; + ["Offset of field: Il2CppDefaults::generic_ireadonlycollection_class"] + [::std::mem::offset_of!(Il2CppDefaults, generic_ireadonlycollection_class) - 408usize]; + ["Offset of field: Il2CppDefaults::runtimetype_class"] + [::std::mem::offset_of!(Il2CppDefaults, runtimetype_class) - 416usize]; + ["Offset of field: Il2CppDefaults::generic_nullable_class"] + [::std::mem::offset_of!(Il2CppDefaults, generic_nullable_class) - 424usize]; + ["Offset of field: Il2CppDefaults::il2cpp_com_object_class"] + [::std::mem::offset_of!(Il2CppDefaults, il2cpp_com_object_class) - 432usize]; + ["Offset of field: Il2CppDefaults::attribute_class"] + [::std::mem::offset_of!(Il2CppDefaults, attribute_class) - 440usize]; + ["Offset of field: Il2CppDefaults::customattribute_data_class"] + [::std::mem::offset_of!(Il2CppDefaults, customattribute_data_class) - 448usize]; + ["Offset of field: Il2CppDefaults::customattribute_typed_argument_class"] + [::std::mem::offset_of!(Il2CppDefaults, customattribute_typed_argument_class) - 456usize]; + ["Offset of field: Il2CppDefaults::customattribute_named_argument_class"] + [::std::mem::offset_of!(Il2CppDefaults, customattribute_named_argument_class) - 464usize]; + ["Offset of field: Il2CppDefaults::version"] + [::std::mem::offset_of!(Il2CppDefaults, version) - 472usize]; + ["Offset of field: Il2CppDefaults::culture_info"] + [::std::mem::offset_of!(Il2CppDefaults, culture_info) - 480usize]; + ["Offset of field: Il2CppDefaults::async_call_class"] + [::std::mem::offset_of!(Il2CppDefaults, async_call_class) - 488usize]; + ["Offset of field: Il2CppDefaults::assembly_class"] + [::std::mem::offset_of!(Il2CppDefaults, assembly_class) - 496usize]; + ["Offset of field: Il2CppDefaults::assembly_name_class"] + [::std::mem::offset_of!(Il2CppDefaults, assembly_name_class) - 504usize]; + ["Offset of field: Il2CppDefaults::parameter_info_class"] + [::std::mem::offset_of!(Il2CppDefaults, parameter_info_class) - 512usize]; + ["Offset of field: Il2CppDefaults::module_class"] + [::std::mem::offset_of!(Il2CppDefaults, module_class) - 520usize]; + ["Offset of field: Il2CppDefaults::system_exception_class"] + [::std::mem::offset_of!(Il2CppDefaults, system_exception_class) - 528usize]; + ["Offset of field: Il2CppDefaults::argument_exception_class"] + [::std::mem::offset_of!(Il2CppDefaults, argument_exception_class) - 536usize]; + ["Offset of field: Il2CppDefaults::wait_handle_class"] + [::std::mem::offset_of!(Il2CppDefaults, wait_handle_class) - 544usize]; + ["Offset of field: Il2CppDefaults::safe_handle_class"] + [::std::mem::offset_of!(Il2CppDefaults, safe_handle_class) - 552usize]; + ["Offset of field: Il2CppDefaults::sort_key_class"] + [::std::mem::offset_of!(Il2CppDefaults, sort_key_class) - 560usize]; + ["Offset of field: Il2CppDefaults::dbnull_class"] + [::std::mem::offset_of!(Il2CppDefaults, dbnull_class) - 568usize]; + ["Offset of field: Il2CppDefaults::error_wrapper_class"] + [::std::mem::offset_of!(Il2CppDefaults, error_wrapper_class) - 576usize]; + ["Offset of field: Il2CppDefaults::missing_class"] + [::std::mem::offset_of!(Il2CppDefaults, missing_class) - 584usize]; + ["Offset of field: Il2CppDefaults::value_type_class"] + [::std::mem::offset_of!(Il2CppDefaults, value_type_class) - 592usize]; + ["Offset of field: Il2CppDefaults::threadpool_wait_callback_class"] + [::std::mem::offset_of!(Il2CppDefaults, threadpool_wait_callback_class) - 600usize]; + ["Offset of field: Il2CppDefaults::threadpool_perform_wait_callback_method"][::std::mem::offset_of!( + Il2CppDefaults, + threadpool_perform_wait_callback_method + ) - 608usize]; + ["Offset of field: Il2CppDefaults::mono_method_message_class"] + [::std::mem::offset_of!(Il2CppDefaults, mono_method_message_class) - 616usize]; + ["Offset of field: Il2CppDefaults::ireference_class"] + [::std::mem::offset_of!(Il2CppDefaults, ireference_class) - 624usize]; + ["Offset of field: Il2CppDefaults::ireferencearray_class"] + [::std::mem::offset_of!(Il2CppDefaults, ireferencearray_class) - 632usize]; + ["Offset of field: Il2CppDefaults::ikey_value_pair_class"] + [::std::mem::offset_of!(Il2CppDefaults, ikey_value_pair_class) - 640usize]; + ["Offset of field: Il2CppDefaults::key_value_pair_class"] + [::std::mem::offset_of!(Il2CppDefaults, key_value_pair_class) - 648usize]; + ["Offset of field: Il2CppDefaults::windows_foundation_uri_class"] + [::std::mem::offset_of!(Il2CppDefaults, windows_foundation_uri_class) - 656usize]; + ["Offset of field: Il2CppDefaults::windows_foundation_iuri_runtime_class_class"][::std::mem::offset_of!( + Il2CppDefaults, + windows_foundation_iuri_runtime_class_class + ) - 664usize]; + ["Offset of field: Il2CppDefaults::system_uri_class"] + [::std::mem::offset_of!(Il2CppDefaults, system_uri_class) - 672usize]; + ["Offset of field: Il2CppDefaults::system_guid_class"] + [::std::mem::offset_of!(Il2CppDefaults, system_guid_class) - 680usize]; + ["Offset of field: Il2CppDefaults::sbyte_shared_enum"] + [::std::mem::offset_of!(Il2CppDefaults, sbyte_shared_enum) - 688usize]; + ["Offset of field: Il2CppDefaults::int16_shared_enum"] + [::std::mem::offset_of!(Il2CppDefaults, int16_shared_enum) - 696usize]; + ["Offset of field: Il2CppDefaults::int32_shared_enum"] + [::std::mem::offset_of!(Il2CppDefaults, int32_shared_enum) - 704usize]; + ["Offset of field: Il2CppDefaults::int64_shared_enum"] + [::std::mem::offset_of!(Il2CppDefaults, int64_shared_enum) - 712usize]; + ["Offset of field: Il2CppDefaults::byte_shared_enum"] + [::std::mem::offset_of!(Il2CppDefaults, byte_shared_enum) - 720usize]; + ["Offset of field: Il2CppDefaults::uint16_shared_enum"] + [::std::mem::offset_of!(Il2CppDefaults, uint16_shared_enum) - 728usize]; + ["Offset of field: Il2CppDefaults::uint32_shared_enum"] + [::std::mem::offset_of!(Il2CppDefaults, uint32_shared_enum) - 736usize]; + ["Offset of field: Il2CppDefaults::uint64_shared_enum"] + [::std::mem::offset_of!(Il2CppDefaults, uint64_shared_enum) - 744usize]; + ["Offset of field: Il2CppDefaults::il2cpp_fully_shared_type"] + [::std::mem::offset_of!(Il2CppDefaults, il2cpp_fully_shared_type) - 752usize]; + ["Offset of field: Il2CppDefaults::il2cpp_fully_shared_struct_type"] + [::std::mem::offset_of!(Il2CppDefaults, il2cpp_fully_shared_struct_type) - 760usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of FieldInfo"][::std::mem::size_of::() - 32usize]; + ["Alignment of FieldInfo"][::std::mem::align_of::() - 8usize]; + ["Offset of field: FieldInfo::name"][::std::mem::offset_of!(FieldInfo, name) - 0usize]; + ["Offset of field: FieldInfo::type_"][::std::mem::offset_of!(FieldInfo, type_) - 8usize]; + ["Offset of field: FieldInfo::parent"][::std::mem::offset_of!(FieldInfo, parent) - 16usize]; + ["Offset of field: FieldInfo::offset"][::std::mem::offset_of!(FieldInfo, offset) - 24usize]; + ["Offset of field: FieldInfo::token"][::std::mem::offset_of!(FieldInfo, token) - 28usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of PropertyInfo"][::std::mem::size_of::() - 40usize]; + ["Alignment of PropertyInfo"][::std::mem::align_of::() - 8usize]; + ["Offset of field: PropertyInfo::parent"] + [::std::mem::offset_of!(PropertyInfo, parent) - 0usize]; + ["Offset of field: PropertyInfo::name"][::std::mem::offset_of!(PropertyInfo, name) - 8usize]; + ["Offset of field: PropertyInfo::get"][::std::mem::offset_of!(PropertyInfo, get) - 16usize]; + ["Offset of field: PropertyInfo::set"][::std::mem::offset_of!(PropertyInfo, set) - 24usize]; + ["Offset of field: PropertyInfo::attrs"][::std::mem::offset_of!(PropertyInfo, attrs) - 32usize]; + ["Offset of field: PropertyInfo::token"][::std::mem::offset_of!(PropertyInfo, token) - 36usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of EventInfo"][::std::mem::size_of::() - 56usize]; + ["Alignment of EventInfo"][::std::mem::align_of::() - 8usize]; + ["Offset of field: EventInfo::name"][::std::mem::offset_of!(EventInfo, name) - 0usize]; + ["Offset of field: EventInfo::eventType"] + [::std::mem::offset_of!(EventInfo, eventType) - 8usize]; + ["Offset of field: EventInfo::parent"][::std::mem::offset_of!(EventInfo, parent) - 16usize]; + ["Offset of field: EventInfo::add"][::std::mem::offset_of!(EventInfo, add) - 24usize]; + ["Offset of field: EventInfo::remove"][::std::mem::offset_of!(EventInfo, remove) - 32usize]; + ["Offset of field: EventInfo::raise"][::std::mem::offset_of!(EventInfo, raise) - 40usize]; + ["Offset of field: EventInfo::token"][::std::mem::offset_of!(EventInfo, token) - 48usize]; +}; +pub const MethodVariableKind_kMethodVariableKind_This: MethodVariableKind = 0; +pub const MethodVariableKind_kMethodVariableKind_Parameter: MethodVariableKind = 1; +pub const MethodVariableKind_kMethodVariableKind_LocalVariable: MethodVariableKind = 2; +pub const SequencePointKind_kSequencePointKind_Normal: SequencePointKind = 0; +pub const SequencePointKind_kSequencePointKind_StepOut: SequencePointKind = 1; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppMethodExecutionContextInfo"] + [::std::mem::size_of::() - 12usize]; + ["Alignment of Il2CppMethodExecutionContextInfo"] + [::std::mem::align_of::() - 4usize]; + ["Offset of field: Il2CppMethodExecutionContextInfo::typeIndex"] + [::std::mem::offset_of!(Il2CppMethodExecutionContextInfo, typeIndex) - 0usize]; + ["Offset of field: Il2CppMethodExecutionContextInfo::nameIndex"] + [::std::mem::offset_of!(Il2CppMethodExecutionContextInfo, nameIndex) - 4usize]; + ["Offset of field: Il2CppMethodExecutionContextInfo::scopeIndex"] + [::std::mem::offset_of!(Il2CppMethodExecutionContextInfo, scopeIndex) - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppMethodExecutionContextInfoIndex"] + [::std::mem::size_of::() - 8usize]; + ["Alignment of Il2CppMethodExecutionContextInfoIndex"] + [::std::mem::align_of::() - 4usize]; + ["Offset of field: Il2CppMethodExecutionContextInfoIndex::startIndex"] + [::std::mem::offset_of!(Il2CppMethodExecutionContextInfoIndex, startIndex) - 0usize]; + ["Offset of field: Il2CppMethodExecutionContextInfoIndex::count"] + [::std::mem::offset_of!(Il2CppMethodExecutionContextInfoIndex, count) - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppMethodScope"][::std::mem::size_of::() - 8usize]; + ["Alignment of Il2CppMethodScope"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Il2CppMethodScope::startOffset"] + [::std::mem::offset_of!(Il2CppMethodScope, startOffset) - 0usize]; + ["Offset of field: Il2CppMethodScope::endOffset"] + [::std::mem::offset_of!(Il2CppMethodScope, endOffset) - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppMethodHeaderInfo"][::std::mem::size_of::() - 12usize]; + ["Alignment of Il2CppMethodHeaderInfo"] + [::std::mem::align_of::() - 4usize]; + ["Offset of field: Il2CppMethodHeaderInfo::code_size"] + [::std::mem::offset_of!(Il2CppMethodHeaderInfo, code_size) - 0usize]; + ["Offset of field: Il2CppMethodHeaderInfo::startScope"] + [::std::mem::offset_of!(Il2CppMethodHeaderInfo, startScope) - 4usize]; + ["Offset of field: Il2CppMethodHeaderInfo::numScopes"] + [::std::mem::offset_of!(Il2CppMethodHeaderInfo, numScopes) - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppSequencePointSourceFile"] + [::std::mem::size_of::() - 24usize]; + ["Alignment of Il2CppSequencePointSourceFile"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppSequencePointSourceFile::file"] + [::std::mem::offset_of!(Il2CppSequencePointSourceFile, file) - 0usize]; + ["Offset of field: Il2CppSequencePointSourceFile::hash"] + [::std::mem::offset_of!(Il2CppSequencePointSourceFile, hash) - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppTypeSourceFilePair"] + [::std::mem::size_of::() - 8usize]; + ["Alignment of Il2CppTypeSourceFilePair"] + [::std::mem::align_of::() - 4usize]; + ["Offset of field: Il2CppTypeSourceFilePair::__klassIndex"] + [::std::mem::offset_of!(Il2CppTypeSourceFilePair, __klassIndex) - 0usize]; + ["Offset of field: Il2CppTypeSourceFilePair::sourceFileIndex"] + [::std::mem::offset_of!(Il2CppTypeSourceFilePair, sourceFileIndex) - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppSequencePoint"][::std::mem::size_of::() - 40usize]; + ["Alignment of Il2CppSequencePoint"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Il2CppSequencePoint::__methodDefinitionIndex"] + [::std::mem::offset_of!(Il2CppSequencePoint, __methodDefinitionIndex) - 0usize]; + ["Offset of field: Il2CppSequencePoint::sourceFileIndex"] + [::std::mem::offset_of!(Il2CppSequencePoint, sourceFileIndex) - 4usize]; + ["Offset of field: Il2CppSequencePoint::lineStart"] + [::std::mem::offset_of!(Il2CppSequencePoint, lineStart) - 8usize]; + ["Offset of field: Il2CppSequencePoint::lineEnd"] + [::std::mem::offset_of!(Il2CppSequencePoint, lineEnd) - 12usize]; + ["Offset of field: Il2CppSequencePoint::columnStart"] + [::std::mem::offset_of!(Il2CppSequencePoint, columnStart) - 16usize]; + ["Offset of field: Il2CppSequencePoint::columnEnd"] + [::std::mem::offset_of!(Il2CppSequencePoint, columnEnd) - 20usize]; + ["Offset of field: Il2CppSequencePoint::ilOffset"] + [::std::mem::offset_of!(Il2CppSequencePoint, ilOffset) - 24usize]; + ["Offset of field: Il2CppSequencePoint::kind"] + [::std::mem::offset_of!(Il2CppSequencePoint, kind) - 28usize]; + ["Offset of field: Il2CppSequencePoint::isActive"] + [::std::mem::offset_of!(Il2CppSequencePoint, isActive) - 32usize]; + ["Offset of field: Il2CppSequencePoint::id"] + [::std::mem::offset_of!(Il2CppSequencePoint, id) - 36usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppCatchPoint"][::std::mem::size_of::() - 20usize]; + ["Alignment of Il2CppCatchPoint"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Il2CppCatchPoint::__methodDefinitionIndex"] + [::std::mem::offset_of!(Il2CppCatchPoint, __methodDefinitionIndex) - 0usize]; + ["Offset of field: Il2CppCatchPoint::catchTypeIndex"] + [::std::mem::offset_of!(Il2CppCatchPoint, catchTypeIndex) - 4usize]; + ["Offset of field: Il2CppCatchPoint::ilOffset"] + [::std::mem::offset_of!(Il2CppCatchPoint, ilOffset) - 8usize]; + ["Offset of field: Il2CppCatchPoint::tryId"] + [::std::mem::offset_of!(Il2CppCatchPoint, tryId) - 12usize]; + ["Offset of field: Il2CppCatchPoint::parentTryId"] + [::std::mem::offset_of!(Il2CppCatchPoint, parentTryId) - 16usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppDebuggerMetadataRegistration"] + [::std::mem::size_of::() - 96usize]; + ["Alignment of Il2CppDebuggerMetadataRegistration"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppDebuggerMetadataRegistration::methodExecutionContextInfos"][::std::mem::offset_of!( + Il2CppDebuggerMetadataRegistration, + methodExecutionContextInfos + ) + - 0usize]; + ["Offset of field: Il2CppDebuggerMetadataRegistration::methodExecutionContextInfoIndexes"][::std::mem::offset_of!( + Il2CppDebuggerMetadataRegistration, + methodExecutionContextInfoIndexes + ) + - 8usize]; + ["Offset of field: Il2CppDebuggerMetadataRegistration::methodScopes"] + [::std::mem::offset_of!(Il2CppDebuggerMetadataRegistration, methodScopes) - 16usize]; + ["Offset of field: Il2CppDebuggerMetadataRegistration::methodHeaderInfos"] + [::std::mem::offset_of!(Il2CppDebuggerMetadataRegistration, methodHeaderInfos) - 24usize]; + ["Offset of field: Il2CppDebuggerMetadataRegistration::sequencePointSourceFiles"][::std::mem::offset_of!( + Il2CppDebuggerMetadataRegistration, + sequencePointSourceFiles + ) - 32usize]; + ["Offset of field: Il2CppDebuggerMetadataRegistration::numSequencePoints"] + [::std::mem::offset_of!(Il2CppDebuggerMetadataRegistration, numSequencePoints) - 40usize]; + ["Offset of field: Il2CppDebuggerMetadataRegistration::sequencePoints"] + [::std::mem::offset_of!(Il2CppDebuggerMetadataRegistration, sequencePoints) - 48usize]; + ["Offset of field: Il2CppDebuggerMetadataRegistration::numCatchPoints"] + [::std::mem::offset_of!(Il2CppDebuggerMetadataRegistration, numCatchPoints) - 56usize]; + ["Offset of field: Il2CppDebuggerMetadataRegistration::catchPoints"] + [::std::mem::offset_of!(Il2CppDebuggerMetadataRegistration, catchPoints) - 64usize]; + ["Offset of field: Il2CppDebuggerMetadataRegistration::numTypeSourceFileEntries"][::std::mem::offset_of!( + Il2CppDebuggerMetadataRegistration, + numTypeSourceFileEntries + ) - 72usize]; + ["Offset of field: Il2CppDebuggerMetadataRegistration::typeSourceFiles"] + [::std::mem::offset_of!(Il2CppDebuggerMetadataRegistration, typeSourceFiles) - 80usize]; + ["Offset of field: Il2CppDebuggerMetadataRegistration::methodExecutionContextInfoStrings"][::std::mem::offset_of!( + Il2CppDebuggerMetadataRegistration, + methodExecutionContextInfoStrings + ) + - 88usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppRGCTXData"][::std::mem::size_of::() - 8usize]; + ["Alignment of Il2CppRGCTXData"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppRGCTXData::rgctxDataDummy"] + [::std::mem::offset_of!(Il2CppRGCTXData, rgctxDataDummy) - 0usize]; + ["Offset of field: Il2CppRGCTXData::method"] + [::std::mem::offset_of!(Il2CppRGCTXData, method) - 0usize]; + ["Offset of field: Il2CppRGCTXData::type_"] + [::std::mem::offset_of!(Il2CppRGCTXData, type_) - 0usize]; + ["Offset of field: Il2CppRGCTXData::klass"] + [::std::mem::offset_of!(Il2CppRGCTXData, klass) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of MethodInfo__bindgen_ty_1"] + [::std::mem::size_of::() - 8usize]; + ["Alignment of MethodInfo__bindgen_ty_1"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: MethodInfo__bindgen_ty_1::rgctx_data"] + [::std::mem::offset_of!(MethodInfo__bindgen_ty_1, rgctx_data) - 0usize]; + ["Offset of field: MethodInfo__bindgen_ty_1::methodMetadataHandle"] + [::std::mem::offset_of!(MethodInfo__bindgen_ty_1, methodMetadataHandle) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of MethodInfo__bindgen_ty_2"] + [::std::mem::size_of::() - 8usize]; + ["Alignment of MethodInfo__bindgen_ty_2"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: MethodInfo__bindgen_ty_2::genericMethod"] + [::std::mem::offset_of!(MethodInfo__bindgen_ty_2, genericMethod) - 0usize]; + ["Offset of field: MethodInfo__bindgen_ty_2::genericContainerHandle"] + [::std::mem::offset_of!(MethodInfo__bindgen_ty_2, genericContainerHandle) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of MethodInfo"][::std::mem::size_of::() - 88usize]; + ["Alignment of MethodInfo"][::std::mem::align_of::() - 8usize]; + ["Offset of field: MethodInfo::methodPointer"] + [::std::mem::offset_of!(MethodInfo, methodPointer) - 0usize]; + ["Offset of field: MethodInfo::virtualMethodPointer"] + [::std::mem::offset_of!(MethodInfo, virtualMethodPointer) - 8usize]; + ["Offset of field: MethodInfo::invoker_method"] + [::std::mem::offset_of!(MethodInfo, invoker_method) - 16usize]; + ["Offset of field: MethodInfo::name"][::std::mem::offset_of!(MethodInfo, name) - 24usize]; + ["Offset of field: MethodInfo::klass"][::std::mem::offset_of!(MethodInfo, klass) - 32usize]; + ["Offset of field: MethodInfo::return_type"] + [::std::mem::offset_of!(MethodInfo, return_type) - 40usize]; + ["Offset of field: MethodInfo::parameters"] + [::std::mem::offset_of!(MethodInfo, parameters) - 48usize]; + ["Offset of field: MethodInfo::token"][::std::mem::offset_of!(MethodInfo, token) - 72usize]; + ["Offset of field: MethodInfo::flags"][::std::mem::offset_of!(MethodInfo, flags) - 76usize]; + ["Offset of field: MethodInfo::iflags"][::std::mem::offset_of!(MethodInfo, iflags) - 78usize]; + ["Offset of field: MethodInfo::slot"][::std::mem::offset_of!(MethodInfo, slot) - 80usize]; + ["Offset of field: MethodInfo::parameters_count"] + [::std::mem::offset_of!(MethodInfo, parameters_count) - 82usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppRuntimeInterfaceOffsetPair"] + [::std::mem::size_of::() - 16usize]; + ["Alignment of Il2CppRuntimeInterfaceOffsetPair"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppRuntimeInterfaceOffsetPair::interfaceType"] + [::std::mem::offset_of!(Il2CppRuntimeInterfaceOffsetPair, interfaceType) - 0usize]; + ["Offset of field: Il2CppRuntimeInterfaceOffsetPair::offset"] + [::std::mem::offset_of!(Il2CppRuntimeInterfaceOffsetPair, offset) - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppClass"][::std::mem::size_of::() - 312usize]; + ["Alignment of Il2CppClass"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppClass::image"][::std::mem::offset_of!(Il2CppClass, image) - 0usize]; + ["Offset of field: Il2CppClass::gc_desc"] + [::std::mem::offset_of!(Il2CppClass, gc_desc) - 8usize]; + ["Offset of field: Il2CppClass::name"][::std::mem::offset_of!(Il2CppClass, name) - 16usize]; + ["Offset of field: Il2CppClass::namespaze"] + [::std::mem::offset_of!(Il2CppClass, namespaze) - 24usize]; + ["Offset of field: Il2CppClass::byval_arg"] + [::std::mem::offset_of!(Il2CppClass, byval_arg) - 32usize]; + ["Offset of field: Il2CppClass::this_arg"] + [::std::mem::offset_of!(Il2CppClass, this_arg) - 48usize]; + ["Offset of field: Il2CppClass::element_class"] + [::std::mem::offset_of!(Il2CppClass, element_class) - 64usize]; + ["Offset of field: Il2CppClass::castClass"] + [::std::mem::offset_of!(Il2CppClass, castClass) - 72usize]; + ["Offset of field: Il2CppClass::declaringType"] + [::std::mem::offset_of!(Il2CppClass, declaringType) - 80usize]; + ["Offset of field: Il2CppClass::parent"][::std::mem::offset_of!(Il2CppClass, parent) - 88usize]; + ["Offset of field: Il2CppClass::generic_class"] + [::std::mem::offset_of!(Il2CppClass, generic_class) - 96usize]; + ["Offset of field: Il2CppClass::typeMetadataHandle"] + [::std::mem::offset_of!(Il2CppClass, typeMetadataHandle) - 104usize]; + ["Offset of field: Il2CppClass::interopData"] + [::std::mem::offset_of!(Il2CppClass, interopData) - 112usize]; + ["Offset of field: Il2CppClass::klass"][::std::mem::offset_of!(Il2CppClass, klass) - 120usize]; + ["Offset of field: Il2CppClass::fields"] + [::std::mem::offset_of!(Il2CppClass, fields) - 128usize]; + ["Offset of field: Il2CppClass::events"] + [::std::mem::offset_of!(Il2CppClass, events) - 136usize]; + ["Offset of field: Il2CppClass::properties"] + [::std::mem::offset_of!(Il2CppClass, properties) - 144usize]; + ["Offset of field: Il2CppClass::methods"] + [::std::mem::offset_of!(Il2CppClass, methods) - 152usize]; + ["Offset of field: Il2CppClass::nestedTypes"] + [::std::mem::offset_of!(Il2CppClass, nestedTypes) - 160usize]; + ["Offset of field: Il2CppClass::implementedInterfaces"] + [::std::mem::offset_of!(Il2CppClass, implementedInterfaces) - 168usize]; + ["Offset of field: Il2CppClass::interfaceOffsets"] + [::std::mem::offset_of!(Il2CppClass, interfaceOffsets) - 176usize]; + ["Offset of field: Il2CppClass::static_fields"] + [::std::mem::offset_of!(Il2CppClass, static_fields) - 184usize]; + ["Offset of field: Il2CppClass::rgctx_data"] + [::std::mem::offset_of!(Il2CppClass, rgctx_data) - 192usize]; + ["Offset of field: Il2CppClass::typeHierarchy"] + [::std::mem::offset_of!(Il2CppClass, typeHierarchy) - 200usize]; + ["Offset of field: Il2CppClass::unity_user_data"] + [::std::mem::offset_of!(Il2CppClass, unity_user_data) - 208usize]; + ["Offset of field: Il2CppClass::initializationExceptionGCHandle"] + [::std::mem::offset_of!(Il2CppClass, initializationExceptionGCHandle) - 216usize]; + ["Offset of field: Il2CppClass::cctor_started"] + [::std::mem::offset_of!(Il2CppClass, cctor_started) - 220usize]; + ["Offset of field: Il2CppClass::cctor_finished_or_no_cctor"] + [::std::mem::offset_of!(Il2CppClass, cctor_finished_or_no_cctor) - 224usize]; + ["Offset of field: Il2CppClass::cctor_thread"] + [::std::mem::offset_of!(Il2CppClass, cctor_thread) - 232usize]; + ["Offset of field: Il2CppClass::genericContainerHandle"] + [::std::mem::offset_of!(Il2CppClass, genericContainerHandle) - 240usize]; + ["Offset of field: Il2CppClass::instance_size"] + [::std::mem::offset_of!(Il2CppClass, instance_size) - 248usize]; + ["Offset of field: Il2CppClass::stack_slot_size"] + [::std::mem::offset_of!(Il2CppClass, stack_slot_size) - 252usize]; + ["Offset of field: Il2CppClass::actualSize"] + [::std::mem::offset_of!(Il2CppClass, actualSize) - 256usize]; + ["Offset of field: Il2CppClass::element_size"] + [::std::mem::offset_of!(Il2CppClass, element_size) - 260usize]; + ["Offset of field: Il2CppClass::native_size"] + [::std::mem::offset_of!(Il2CppClass, native_size) - 264usize]; + ["Offset of field: Il2CppClass::static_fields_size"] + [::std::mem::offset_of!(Il2CppClass, static_fields_size) - 268usize]; + ["Offset of field: Il2CppClass::thread_static_fields_size"] + [::std::mem::offset_of!(Il2CppClass, thread_static_fields_size) - 272usize]; + ["Offset of field: Il2CppClass::thread_static_fields_offset"] + [::std::mem::offset_of!(Il2CppClass, thread_static_fields_offset) - 276usize]; + ["Offset of field: Il2CppClass::flags"][::std::mem::offset_of!(Il2CppClass, flags) - 280usize]; + ["Offset of field: Il2CppClass::token"][::std::mem::offset_of!(Il2CppClass, token) - 284usize]; + ["Offset of field: Il2CppClass::method_count"] + [::std::mem::offset_of!(Il2CppClass, method_count) - 288usize]; + ["Offset of field: Il2CppClass::property_count"] + [::std::mem::offset_of!(Il2CppClass, property_count) - 290usize]; + ["Offset of field: Il2CppClass::field_count"] + [::std::mem::offset_of!(Il2CppClass, field_count) - 292usize]; + ["Offset of field: Il2CppClass::event_count"] + [::std::mem::offset_of!(Il2CppClass, event_count) - 294usize]; + ["Offset of field: Il2CppClass::nested_type_count"] + [::std::mem::offset_of!(Il2CppClass, nested_type_count) - 296usize]; + ["Offset of field: Il2CppClass::vtable_count"] + [::std::mem::offset_of!(Il2CppClass, vtable_count) - 298usize]; + ["Offset of field: Il2CppClass::interfaces_count"] + [::std::mem::offset_of!(Il2CppClass, interfaces_count) - 300usize]; + ["Offset of field: Il2CppClass::interface_offsets_count"] + [::std::mem::offset_of!(Il2CppClass, interface_offsets_count) - 302usize]; + ["Offset of field: Il2CppClass::typeHierarchyDepth"] + [::std::mem::offset_of!(Il2CppClass, typeHierarchyDepth) - 304usize]; + ["Offset of field: Il2CppClass::genericRecursionDepth"] + [::std::mem::offset_of!(Il2CppClass, genericRecursionDepth) - 305usize]; + ["Offset of field: Il2CppClass::rank"][::std::mem::offset_of!(Il2CppClass, rank) - 306usize]; + ["Offset of field: Il2CppClass::minimumAlignment"] + [::std::mem::offset_of!(Il2CppClass, minimumAlignment) - 307usize]; + ["Offset of field: Il2CppClass::packingSize"] + [::std::mem::offset_of!(Il2CppClass, packingSize) - 308usize]; + ["Offset of field: Il2CppClass::vtable"] + [::std::mem::offset_of!(Il2CppClass, vtable) - 312usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppTypeDefinitionSizes"] + [::std::mem::size_of::() - 16usize]; + ["Alignment of Il2CppTypeDefinitionSizes"] + [::std::mem::align_of::() - 4usize]; + ["Offset of field: Il2CppTypeDefinitionSizes::instance_size"] + [::std::mem::offset_of!(Il2CppTypeDefinitionSizes, instance_size) - 0usize]; + ["Offset of field: Il2CppTypeDefinitionSizes::native_size"] + [::std::mem::offset_of!(Il2CppTypeDefinitionSizes, native_size) - 4usize]; + ["Offset of field: Il2CppTypeDefinitionSizes::static_fields_size"] + [::std::mem::offset_of!(Il2CppTypeDefinitionSizes, static_fields_size) - 8usize]; + ["Offset of field: Il2CppTypeDefinitionSizes::thread_static_fields_size"] + [::std::mem::offset_of!(Il2CppTypeDefinitionSizes, thread_static_fields_size) - 12usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppDomain"][::std::mem::size_of::() - 56usize]; + ["Alignment of Il2CppDomain"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppDomain::domain"] + [::std::mem::offset_of!(Il2CppDomain, domain) - 0usize]; + ["Offset of field: Il2CppDomain::setup"][::std::mem::offset_of!(Il2CppDomain, setup) - 8usize]; + ["Offset of field: Il2CppDomain::default_context"] + [::std::mem::offset_of!(Il2CppDomain, default_context) - 16usize]; + ["Offset of field: Il2CppDomain::ephemeron_tombstone"] + [::std::mem::offset_of!(Il2CppDomain, ephemeron_tombstone) - 24usize]; + ["Offset of field: Il2CppDomain::friendly_name"] + [::std::mem::offset_of!(Il2CppDomain, friendly_name) - 32usize]; + ["Offset of field: Il2CppDomain::domain_id"] + [::std::mem::offset_of!(Il2CppDomain, domain_id) - 40usize]; + ["Offset of field: Il2CppDomain::threadpool_jobs"] + [::std::mem::offset_of!(Il2CppDomain, threadpool_jobs) - 44usize]; + ["Offset of field: Il2CppDomain::agent_info"] + [::std::mem::offset_of!(Il2CppDomain, agent_info) - 48usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppAssemblyName"][::std::mem::size_of::() - 64usize]; + ["Alignment of Il2CppAssemblyName"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppAssemblyName::name"] + [::std::mem::offset_of!(Il2CppAssemblyName, name) - 0usize]; + ["Offset of field: Il2CppAssemblyName::culture"] + [::std::mem::offset_of!(Il2CppAssemblyName, culture) - 8usize]; + ["Offset of field: Il2CppAssemblyName::public_key"] + [::std::mem::offset_of!(Il2CppAssemblyName, public_key) - 16usize]; + ["Offset of field: Il2CppAssemblyName::hash_alg"] + [::std::mem::offset_of!(Il2CppAssemblyName, hash_alg) - 24usize]; + ["Offset of field: Il2CppAssemblyName::hash_len"] + [::std::mem::offset_of!(Il2CppAssemblyName, hash_len) - 28usize]; + ["Offset of field: Il2CppAssemblyName::flags"] + [::std::mem::offset_of!(Il2CppAssemblyName, flags) - 32usize]; + ["Offset of field: Il2CppAssemblyName::major"] + [::std::mem::offset_of!(Il2CppAssemblyName, major) - 36usize]; + ["Offset of field: Il2CppAssemblyName::minor"] + [::std::mem::offset_of!(Il2CppAssemblyName, minor) - 40usize]; + ["Offset of field: Il2CppAssemblyName::build"] + [::std::mem::offset_of!(Il2CppAssemblyName, build) - 44usize]; + ["Offset of field: Il2CppAssemblyName::revision"] + [::std::mem::offset_of!(Il2CppAssemblyName, revision) - 48usize]; + ["Offset of field: Il2CppAssemblyName::public_key_token"] + [::std::mem::offset_of!(Il2CppAssemblyName, public_key_token) - 52usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppImage"][::std::mem::size_of::() - 72usize]; + ["Alignment of Il2CppImage"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppImage::name"][::std::mem::offset_of!(Il2CppImage, name) - 0usize]; + ["Offset of field: Il2CppImage::nameNoExt"] + [::std::mem::offset_of!(Il2CppImage, nameNoExt) - 8usize]; + ["Offset of field: Il2CppImage::assembly"] + [::std::mem::offset_of!(Il2CppImage, assembly) - 16usize]; + ["Offset of field: Il2CppImage::typeCount"] + [::std::mem::offset_of!(Il2CppImage, typeCount) - 24usize]; + ["Offset of field: Il2CppImage::exportedTypeCount"] + [::std::mem::offset_of!(Il2CppImage, exportedTypeCount) - 28usize]; + ["Offset of field: Il2CppImage::customAttributeCount"] + [::std::mem::offset_of!(Il2CppImage, customAttributeCount) - 32usize]; + ["Offset of field: Il2CppImage::metadataHandle"] + [::std::mem::offset_of!(Il2CppImage, metadataHandle) - 40usize]; + ["Offset of field: Il2CppImage::nameToClassHashTable"] + [::std::mem::offset_of!(Il2CppImage, nameToClassHashTable) - 48usize]; + ["Offset of field: Il2CppImage::codeGenModule"] + [::std::mem::offset_of!(Il2CppImage, codeGenModule) - 56usize]; + ["Offset of field: Il2CppImage::token"][::std::mem::offset_of!(Il2CppImage, token) - 64usize]; + ["Offset of field: Il2CppImage::dynamic"] + [::std::mem::offset_of!(Il2CppImage, dynamic) - 68usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppAssembly"][::std::mem::size_of::() - 88usize]; + ["Alignment of Il2CppAssembly"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppAssembly::image"] + [::std::mem::offset_of!(Il2CppAssembly, image) - 0usize]; + ["Offset of field: Il2CppAssembly::token"] + [::std::mem::offset_of!(Il2CppAssembly, token) - 8usize]; + ["Offset of field: Il2CppAssembly::referencedAssemblyStart"] + [::std::mem::offset_of!(Il2CppAssembly, referencedAssemblyStart) - 12usize]; + ["Offset of field: Il2CppAssembly::referencedAssemblyCount"] + [::std::mem::offset_of!(Il2CppAssembly, referencedAssemblyCount) - 16usize]; + ["Offset of field: Il2CppAssembly::aname"] + [::std::mem::offset_of!(Il2CppAssembly, aname) - 24usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppCodeGenOptions"][::std::mem::size_of::() - 12usize]; + ["Alignment of Il2CppCodeGenOptions"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Il2CppCodeGenOptions::enablePrimitiveValueTypeGenericSharing"][::std::mem::offset_of!( + Il2CppCodeGenOptions, + enablePrimitiveValueTypeGenericSharing + ) - 0usize]; + ["Offset of field: Il2CppCodeGenOptions::maximumRuntimeGenericDepth"] + [::std::mem::offset_of!(Il2CppCodeGenOptions, maximumRuntimeGenericDepth) - 4usize]; + ["Offset of field: Il2CppCodeGenOptions::recursiveGenericIterations"] + [::std::mem::offset_of!(Il2CppCodeGenOptions, recursiveGenericIterations) - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppRange"][::std::mem::size_of::() - 8usize]; + ["Alignment of Il2CppRange"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Il2CppRange::start"][::std::mem::offset_of!(Il2CppRange, start) - 0usize]; + ["Offset of field: Il2CppRange::length"][::std::mem::offset_of!(Il2CppRange, length) - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppTokenRangePair"][::std::mem::size_of::() - 12usize]; + ["Alignment of Il2CppTokenRangePair"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Il2CppTokenRangePair::token"] + [::std::mem::offset_of!(Il2CppTokenRangePair, token) - 0usize]; + ["Offset of field: Il2CppTokenRangePair::range"] + [::std::mem::offset_of!(Il2CppTokenRangePair, range) - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppTokenIndexMethodTuple"] + [::std::mem::size_of::() - 24usize]; + ["Alignment of Il2CppTokenIndexMethodTuple"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppTokenIndexMethodTuple::token"] + [::std::mem::offset_of!(Il2CppTokenIndexMethodTuple, token) - 0usize]; + ["Offset of field: Il2CppTokenIndexMethodTuple::index"] + [::std::mem::offset_of!(Il2CppTokenIndexMethodTuple, index) - 4usize]; + ["Offset of field: Il2CppTokenIndexMethodTuple::method"] + [::std::mem::offset_of!(Il2CppTokenIndexMethodTuple, method) - 8usize]; + ["Offset of field: Il2CppTokenIndexMethodTuple::__genericMethodIndex"] + [::std::mem::offset_of!(Il2CppTokenIndexMethodTuple, __genericMethodIndex) - 16usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppTokenAdjustorThunkPair"] + [::std::mem::size_of::() - 16usize]; + ["Alignment of Il2CppTokenAdjustorThunkPair"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppTokenAdjustorThunkPair::token"] + [::std::mem::offset_of!(Il2CppTokenAdjustorThunkPair, token) - 0usize]; + ["Offset of field: Il2CppTokenAdjustorThunkPair::adjustorThunk"] + [::std::mem::offset_of!(Il2CppTokenAdjustorThunkPair, adjustorThunk) - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppWindowsRuntimeFactoryTableEntry"] + [::std::mem::size_of::() - 16usize]; + ["Alignment of Il2CppWindowsRuntimeFactoryTableEntry"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppWindowsRuntimeFactoryTableEntry::type_"] + [::std::mem::offset_of!(Il2CppWindowsRuntimeFactoryTableEntry, type_) - 0usize]; + ["Offset of field: Il2CppWindowsRuntimeFactoryTableEntry::createFactoryFunction"][::std::mem::offset_of!( + Il2CppWindowsRuntimeFactoryTableEntry, + createFactoryFunction + ) - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppCodeGenModule"][::std::mem::size_of::() - 136usize]; + ["Alignment of Il2CppCodeGenModule"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppCodeGenModule::moduleName"] + [::std::mem::offset_of!(Il2CppCodeGenModule, moduleName) - 0usize]; + ["Offset of field: Il2CppCodeGenModule::methodPointerCount"] + [::std::mem::offset_of!(Il2CppCodeGenModule, methodPointerCount) - 8usize]; + ["Offset of field: Il2CppCodeGenModule::methodPointers"] + [::std::mem::offset_of!(Il2CppCodeGenModule, methodPointers) - 16usize]; + ["Offset of field: Il2CppCodeGenModule::adjustorThunkCount"] + [::std::mem::offset_of!(Il2CppCodeGenModule, adjustorThunkCount) - 24usize]; + ["Offset of field: Il2CppCodeGenModule::adjustorThunks"] + [::std::mem::offset_of!(Il2CppCodeGenModule, adjustorThunks) - 32usize]; + ["Offset of field: Il2CppCodeGenModule::invokerIndices"] + [::std::mem::offset_of!(Il2CppCodeGenModule, invokerIndices) - 40usize]; + ["Offset of field: Il2CppCodeGenModule::reversePInvokeWrapperCount"] + [::std::mem::offset_of!(Il2CppCodeGenModule, reversePInvokeWrapperCount) - 48usize]; + ["Offset of field: Il2CppCodeGenModule::reversePInvokeWrapperIndices"] + [::std::mem::offset_of!(Il2CppCodeGenModule, reversePInvokeWrapperIndices) - 56usize]; + ["Offset of field: Il2CppCodeGenModule::rgctxRangesCount"] + [::std::mem::offset_of!(Il2CppCodeGenModule, rgctxRangesCount) - 64usize]; + ["Offset of field: Il2CppCodeGenModule::rgctxRanges"] + [::std::mem::offset_of!(Il2CppCodeGenModule, rgctxRanges) - 72usize]; + ["Offset of field: Il2CppCodeGenModule::rgctxsCount"] + [::std::mem::offset_of!(Il2CppCodeGenModule, rgctxsCount) - 80usize]; + ["Offset of field: Il2CppCodeGenModule::rgctxs"] + [::std::mem::offset_of!(Il2CppCodeGenModule, rgctxs) - 88usize]; + ["Offset of field: Il2CppCodeGenModule::debuggerMetadata"] + [::std::mem::offset_of!(Il2CppCodeGenModule, debuggerMetadata) - 96usize]; + ["Offset of field: Il2CppCodeGenModule::moduleInitializer"] + [::std::mem::offset_of!(Il2CppCodeGenModule, moduleInitializer) - 104usize]; + ["Offset of field: Il2CppCodeGenModule::staticConstructorTypeIndices"] + [::std::mem::offset_of!(Il2CppCodeGenModule, staticConstructorTypeIndices) - 112usize]; + ["Offset of field: Il2CppCodeGenModule::metadataRegistration"] + [::std::mem::offset_of!(Il2CppCodeGenModule, metadataRegistration) - 120usize]; + ["Offset of field: Il2CppCodeGenModule::codeRegistaration"] + [::std::mem::offset_of!(Il2CppCodeGenModule, codeRegistaration) - 128usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppCodeRegistration"][::std::mem::size_of::() - 136usize]; + ["Alignment of Il2CppCodeRegistration"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppCodeRegistration::reversePInvokeWrapperCount"] + [::std::mem::offset_of!(Il2CppCodeRegistration, reversePInvokeWrapperCount) - 0usize]; + ["Offset of field: Il2CppCodeRegistration::reversePInvokeWrappers"] + [::std::mem::offset_of!(Il2CppCodeRegistration, reversePInvokeWrappers) - 8usize]; + ["Offset of field: Il2CppCodeRegistration::genericMethodPointersCount"] + [::std::mem::offset_of!(Il2CppCodeRegistration, genericMethodPointersCount) - 16usize]; + ["Offset of field: Il2CppCodeRegistration::genericMethodPointers"] + [::std::mem::offset_of!(Il2CppCodeRegistration, genericMethodPointers) - 24usize]; + ["Offset of field: Il2CppCodeRegistration::genericAdjustorThunks"] + [::std::mem::offset_of!(Il2CppCodeRegistration, genericAdjustorThunks) - 32usize]; + ["Offset of field: Il2CppCodeRegistration::invokerPointersCount"] + [::std::mem::offset_of!(Il2CppCodeRegistration, invokerPointersCount) - 40usize]; + ["Offset of field: Il2CppCodeRegistration::invokerPointers"] + [::std::mem::offset_of!(Il2CppCodeRegistration, invokerPointers) - 48usize]; + ["Offset of field: Il2CppCodeRegistration::unresolvedIndirectCallCount"] + [::std::mem::offset_of!(Il2CppCodeRegistration, unresolvedIndirectCallCount) - 56usize]; + ["Offset of field: Il2CppCodeRegistration::unresolvedVirtualCallPointers"] + [::std::mem::offset_of!(Il2CppCodeRegistration, unresolvedVirtualCallPointers) - 64usize]; + ["Offset of field: Il2CppCodeRegistration::unresolvedInstanceCallPointers"] + [::std::mem::offset_of!(Il2CppCodeRegistration, unresolvedInstanceCallPointers) - 72usize]; + ["Offset of field: Il2CppCodeRegistration::unresolvedStaticCallPointers"] + [::std::mem::offset_of!(Il2CppCodeRegistration, unresolvedStaticCallPointers) - 80usize]; + ["Offset of field: Il2CppCodeRegistration::interopDataCount"] + [::std::mem::offset_of!(Il2CppCodeRegistration, interopDataCount) - 88usize]; + ["Offset of field: Il2CppCodeRegistration::interopData"] + [::std::mem::offset_of!(Il2CppCodeRegistration, interopData) - 96usize]; + ["Offset of field: Il2CppCodeRegistration::windowsRuntimeFactoryCount"] + [::std::mem::offset_of!(Il2CppCodeRegistration, windowsRuntimeFactoryCount) - 104usize]; + ["Offset of field: Il2CppCodeRegistration::windowsRuntimeFactoryTable"] + [::std::mem::offset_of!(Il2CppCodeRegistration, windowsRuntimeFactoryTable) - 112usize]; + ["Offset of field: Il2CppCodeRegistration::codeGenModulesCount"] + [::std::mem::offset_of!(Il2CppCodeRegistration, codeGenModulesCount) - 120usize]; + ["Offset of field: Il2CppCodeRegistration::codeGenModules"] + [::std::mem::offset_of!(Il2CppCodeRegistration, codeGenModules) - 128usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppMetadataRegistration"] + [::std::mem::size_of::() - 128usize]; + ["Alignment of Il2CppMetadataRegistration"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppMetadataRegistration::genericClassesCount"] + [::std::mem::offset_of!(Il2CppMetadataRegistration, genericClassesCount) - 0usize]; + ["Offset of field: Il2CppMetadataRegistration::genericClasses"] + [::std::mem::offset_of!(Il2CppMetadataRegistration, genericClasses) - 8usize]; + ["Offset of field: Il2CppMetadataRegistration::genericInstsCount"] + [::std::mem::offset_of!(Il2CppMetadataRegistration, genericInstsCount) - 16usize]; + ["Offset of field: Il2CppMetadataRegistration::genericInsts"] + [::std::mem::offset_of!(Il2CppMetadataRegistration, genericInsts) - 24usize]; + ["Offset of field: Il2CppMetadataRegistration::genericMethodTableCount"] + [::std::mem::offset_of!(Il2CppMetadataRegistration, genericMethodTableCount) - 32usize]; + ["Offset of field: Il2CppMetadataRegistration::genericMethodTable"] + [::std::mem::offset_of!(Il2CppMetadataRegistration, genericMethodTable) - 40usize]; + ["Offset of field: Il2CppMetadataRegistration::typesCount"] + [::std::mem::offset_of!(Il2CppMetadataRegistration, typesCount) - 48usize]; + ["Offset of field: Il2CppMetadataRegistration::types"] + [::std::mem::offset_of!(Il2CppMetadataRegistration, types) - 56usize]; + ["Offset of field: Il2CppMetadataRegistration::methodSpecsCount"] + [::std::mem::offset_of!(Il2CppMetadataRegistration, methodSpecsCount) - 64usize]; + ["Offset of field: Il2CppMetadataRegistration::methodSpecs"] + [::std::mem::offset_of!(Il2CppMetadataRegistration, methodSpecs) - 72usize]; + ["Offset of field: Il2CppMetadataRegistration::fieldOffsetsCount"] + [::std::mem::offset_of!(Il2CppMetadataRegistration, fieldOffsetsCount) - 80usize]; + ["Offset of field: Il2CppMetadataRegistration::fieldOffsets"] + [::std::mem::offset_of!(Il2CppMetadataRegistration, fieldOffsets) - 88usize]; + ["Offset of field: Il2CppMetadataRegistration::typeDefinitionsSizesCount"] + [::std::mem::offset_of!(Il2CppMetadataRegistration, typeDefinitionsSizesCount) - 96usize]; + ["Offset of field: Il2CppMetadataRegistration::typeDefinitionsSizes"] + [::std::mem::offset_of!(Il2CppMetadataRegistration, typeDefinitionsSizes) - 104usize]; + ["Offset of field: Il2CppMetadataRegistration::metadataUsagesCount"] + [::std::mem::offset_of!(Il2CppMetadataRegistration, metadataUsagesCount) - 112usize]; + ["Offset of field: Il2CppMetadataRegistration::metadataUsages"] + [::std::mem::offset_of!(Il2CppMetadataRegistration, metadataUsages) - 120usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppPerfCounters"][::std::mem::size_of::() - 264usize]; + ["Alignment of Il2CppPerfCounters"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppPerfCounters::jit_methods"] + [::std::mem::offset_of!(Il2CppPerfCounters, jit_methods) - 0usize]; + ["Offset of field: Il2CppPerfCounters::jit_bytes"] + [::std::mem::offset_of!(Il2CppPerfCounters, jit_bytes) - 4usize]; + ["Offset of field: Il2CppPerfCounters::jit_time"] + [::std::mem::offset_of!(Il2CppPerfCounters, jit_time) - 8usize]; + ["Offset of field: Il2CppPerfCounters::jit_failures"] + [::std::mem::offset_of!(Il2CppPerfCounters, jit_failures) - 12usize]; + ["Offset of field: Il2CppPerfCounters::exceptions_thrown"] + [::std::mem::offset_of!(Il2CppPerfCounters, exceptions_thrown) - 16usize]; + ["Offset of field: Il2CppPerfCounters::exceptions_filters"] + [::std::mem::offset_of!(Il2CppPerfCounters, exceptions_filters) - 20usize]; + ["Offset of field: Il2CppPerfCounters::exceptions_finallys"] + [::std::mem::offset_of!(Il2CppPerfCounters, exceptions_finallys) - 24usize]; + ["Offset of field: Il2CppPerfCounters::exceptions_depth"] + [::std::mem::offset_of!(Il2CppPerfCounters, exceptions_depth) - 28usize]; + ["Offset of field: Il2CppPerfCounters::aspnet_requests_queued"] + [::std::mem::offset_of!(Il2CppPerfCounters, aspnet_requests_queued) - 32usize]; + ["Offset of field: Il2CppPerfCounters::aspnet_requests"] + [::std::mem::offset_of!(Il2CppPerfCounters, aspnet_requests) - 36usize]; + ["Offset of field: Il2CppPerfCounters::gc_collections0"] + [::std::mem::offset_of!(Il2CppPerfCounters, gc_collections0) - 40usize]; + ["Offset of field: Il2CppPerfCounters::gc_collections1"] + [::std::mem::offset_of!(Il2CppPerfCounters, gc_collections1) - 44usize]; + ["Offset of field: Il2CppPerfCounters::gc_collections2"] + [::std::mem::offset_of!(Il2CppPerfCounters, gc_collections2) - 48usize]; + ["Offset of field: Il2CppPerfCounters::gc_promotions0"] + [::std::mem::offset_of!(Il2CppPerfCounters, gc_promotions0) - 52usize]; + ["Offset of field: Il2CppPerfCounters::gc_promotions1"] + [::std::mem::offset_of!(Il2CppPerfCounters, gc_promotions1) - 56usize]; + ["Offset of field: Il2CppPerfCounters::gc_promotion_finalizers"] + [::std::mem::offset_of!(Il2CppPerfCounters, gc_promotion_finalizers) - 60usize]; + ["Offset of field: Il2CppPerfCounters::gc_gen0size"] + [::std::mem::offset_of!(Il2CppPerfCounters, gc_gen0size) - 64usize]; + ["Offset of field: Il2CppPerfCounters::gc_gen1size"] + [::std::mem::offset_of!(Il2CppPerfCounters, gc_gen1size) - 68usize]; + ["Offset of field: Il2CppPerfCounters::gc_gen2size"] + [::std::mem::offset_of!(Il2CppPerfCounters, gc_gen2size) - 72usize]; + ["Offset of field: Il2CppPerfCounters::gc_lossize"] + [::std::mem::offset_of!(Il2CppPerfCounters, gc_lossize) - 76usize]; + ["Offset of field: Il2CppPerfCounters::gc_fin_survivors"] + [::std::mem::offset_of!(Il2CppPerfCounters, gc_fin_survivors) - 80usize]; + ["Offset of field: Il2CppPerfCounters::gc_num_handles"] + [::std::mem::offset_of!(Il2CppPerfCounters, gc_num_handles) - 84usize]; + ["Offset of field: Il2CppPerfCounters::gc_allocated"] + [::std::mem::offset_of!(Il2CppPerfCounters, gc_allocated) - 88usize]; + ["Offset of field: Il2CppPerfCounters::gc_induced"] + [::std::mem::offset_of!(Il2CppPerfCounters, gc_induced) - 92usize]; + ["Offset of field: Il2CppPerfCounters::gc_time"] + [::std::mem::offset_of!(Il2CppPerfCounters, gc_time) - 96usize]; + ["Offset of field: Il2CppPerfCounters::gc_total_bytes"] + [::std::mem::offset_of!(Il2CppPerfCounters, gc_total_bytes) - 100usize]; + ["Offset of field: Il2CppPerfCounters::gc_committed_bytes"] + [::std::mem::offset_of!(Il2CppPerfCounters, gc_committed_bytes) - 104usize]; + ["Offset of field: Il2CppPerfCounters::gc_reserved_bytes"] + [::std::mem::offset_of!(Il2CppPerfCounters, gc_reserved_bytes) - 108usize]; + ["Offset of field: Il2CppPerfCounters::gc_num_pinned"] + [::std::mem::offset_of!(Il2CppPerfCounters, gc_num_pinned) - 112usize]; + ["Offset of field: Il2CppPerfCounters::gc_sync_blocks"] + [::std::mem::offset_of!(Il2CppPerfCounters, gc_sync_blocks) - 116usize]; + ["Offset of field: Il2CppPerfCounters::remoting_calls"] + [::std::mem::offset_of!(Il2CppPerfCounters, remoting_calls) - 120usize]; + ["Offset of field: Il2CppPerfCounters::remoting_channels"] + [::std::mem::offset_of!(Il2CppPerfCounters, remoting_channels) - 124usize]; + ["Offset of field: Il2CppPerfCounters::remoting_proxies"] + [::std::mem::offset_of!(Il2CppPerfCounters, remoting_proxies) - 128usize]; + ["Offset of field: Il2CppPerfCounters::remoting_classes"] + [::std::mem::offset_of!(Il2CppPerfCounters, remoting_classes) - 132usize]; + ["Offset of field: Il2CppPerfCounters::remoting_objects"] + [::std::mem::offset_of!(Il2CppPerfCounters, remoting_objects) - 136usize]; + ["Offset of field: Il2CppPerfCounters::remoting_contexts"] + [::std::mem::offset_of!(Il2CppPerfCounters, remoting_contexts) - 140usize]; + ["Offset of field: Il2CppPerfCounters::loader_classes"] + [::std::mem::offset_of!(Il2CppPerfCounters, loader_classes) - 144usize]; + ["Offset of field: Il2CppPerfCounters::loader_total_classes"] + [::std::mem::offset_of!(Il2CppPerfCounters, loader_total_classes) - 148usize]; + ["Offset of field: Il2CppPerfCounters::loader_appdomains"] + [::std::mem::offset_of!(Il2CppPerfCounters, loader_appdomains) - 152usize]; + ["Offset of field: Il2CppPerfCounters::loader_total_appdomains"] + [::std::mem::offset_of!(Il2CppPerfCounters, loader_total_appdomains) - 156usize]; + ["Offset of field: Il2CppPerfCounters::loader_assemblies"] + [::std::mem::offset_of!(Il2CppPerfCounters, loader_assemblies) - 160usize]; + ["Offset of field: Il2CppPerfCounters::loader_total_assemblies"] + [::std::mem::offset_of!(Il2CppPerfCounters, loader_total_assemblies) - 164usize]; + ["Offset of field: Il2CppPerfCounters::loader_failures"] + [::std::mem::offset_of!(Il2CppPerfCounters, loader_failures) - 168usize]; + ["Offset of field: Il2CppPerfCounters::loader_bytes"] + [::std::mem::offset_of!(Il2CppPerfCounters, loader_bytes) - 172usize]; + ["Offset of field: Il2CppPerfCounters::loader_appdomains_uloaded"] + [::std::mem::offset_of!(Il2CppPerfCounters, loader_appdomains_uloaded) - 176usize]; + ["Offset of field: Il2CppPerfCounters::thread_contentions"] + [::std::mem::offset_of!(Il2CppPerfCounters, thread_contentions) - 180usize]; + ["Offset of field: Il2CppPerfCounters::thread_queue_len"] + [::std::mem::offset_of!(Il2CppPerfCounters, thread_queue_len) - 184usize]; + ["Offset of field: Il2CppPerfCounters::thread_queue_max"] + [::std::mem::offset_of!(Il2CppPerfCounters, thread_queue_max) - 188usize]; + ["Offset of field: Il2CppPerfCounters::thread_num_logical"] + [::std::mem::offset_of!(Il2CppPerfCounters, thread_num_logical) - 192usize]; + ["Offset of field: Il2CppPerfCounters::thread_num_physical"] + [::std::mem::offset_of!(Il2CppPerfCounters, thread_num_physical) - 196usize]; + ["Offset of field: Il2CppPerfCounters::thread_cur_recognized"] + [::std::mem::offset_of!(Il2CppPerfCounters, thread_cur_recognized) - 200usize]; + ["Offset of field: Il2CppPerfCounters::thread_num_recognized"] + [::std::mem::offset_of!(Il2CppPerfCounters, thread_num_recognized) - 204usize]; + ["Offset of field: Il2CppPerfCounters::interop_num_ccw"] + [::std::mem::offset_of!(Il2CppPerfCounters, interop_num_ccw) - 208usize]; + ["Offset of field: Il2CppPerfCounters::interop_num_stubs"] + [::std::mem::offset_of!(Il2CppPerfCounters, interop_num_stubs) - 212usize]; + ["Offset of field: Il2CppPerfCounters::interop_num_marshals"] + [::std::mem::offset_of!(Il2CppPerfCounters, interop_num_marshals) - 216usize]; + ["Offset of field: Il2CppPerfCounters::security_num_checks"] + [::std::mem::offset_of!(Il2CppPerfCounters, security_num_checks) - 220usize]; + ["Offset of field: Il2CppPerfCounters::security_num_link_checks"] + [::std::mem::offset_of!(Il2CppPerfCounters, security_num_link_checks) - 224usize]; + ["Offset of field: Il2CppPerfCounters::security_time"] + [::std::mem::offset_of!(Il2CppPerfCounters, security_time) - 228usize]; + ["Offset of field: Il2CppPerfCounters::security_depth"] + [::std::mem::offset_of!(Il2CppPerfCounters, security_depth) - 232usize]; + ["Offset of field: Il2CppPerfCounters::unused"] + [::std::mem::offset_of!(Il2CppPerfCounters, unused) - 236usize]; + ["Offset of field: Il2CppPerfCounters::threadpool_workitems"] + [::std::mem::offset_of!(Il2CppPerfCounters, threadpool_workitems) - 240usize]; + ["Offset of field: Il2CppPerfCounters::threadpool_ioworkitems"] + [::std::mem::offset_of!(Il2CppPerfCounters, threadpool_ioworkitems) - 248usize]; + ["Offset of field: Il2CppPerfCounters::threadpool_threads"] + [::std::mem::offset_of!(Il2CppPerfCounters, threadpool_threads) - 256usize]; + ["Offset of field: Il2CppPerfCounters::threadpool_iothreads"] + [::std::mem::offset_of!(Il2CppPerfCounters, threadpool_iothreads) - 260usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppObject__bindgen_ty_1"] + [::std::mem::size_of::() - 8usize]; + ["Alignment of Il2CppObject__bindgen_ty_1"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppObject__bindgen_ty_1::klass"] + [::std::mem::offset_of!(Il2CppObject__bindgen_ty_1, klass) - 0usize]; + ["Offset of field: Il2CppObject__bindgen_ty_1::vtable"] + [::std::mem::offset_of!(Il2CppObject__bindgen_ty_1, vtable) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppObject"][::std::mem::size_of::() - 16usize]; + ["Alignment of Il2CppObject"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppObject::monitor"] + [::std::mem::offset_of!(Il2CppObject, monitor) - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppArrayBounds"][::std::mem::size_of::() - 16usize]; + ["Alignment of Il2CppArrayBounds"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppArrayBounds::length"] + [::std::mem::offset_of!(Il2CppArrayBounds, length) - 0usize]; + ["Offset of field: Il2CppArrayBounds::lower_bound"] + [::std::mem::offset_of!(Il2CppArrayBounds, lower_bound) - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppArray"][::std::mem::size_of::() - 32usize]; + ["Alignment of Il2CppArray"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppArray::obj"][::std::mem::offset_of!(Il2CppArray, obj) - 0usize]; + ["Offset of field: Il2CppArray::bounds"][::std::mem::offset_of!(Il2CppArray, bounds) - 16usize]; + ["Offset of field: Il2CppArray::max_length"] + [::std::mem::offset_of!(Il2CppArray, max_length) - 24usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppArraySize"][::std::mem::size_of::() - 32usize]; + ["Alignment of Il2CppArraySize"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppArraySize::obj"] + [::std::mem::offset_of!(Il2CppArraySize, obj) - 0usize]; + ["Offset of field: Il2CppArraySize::bounds"] + [::std::mem::offset_of!(Il2CppArraySize, bounds) - 16usize]; + ["Offset of field: Il2CppArraySize::max_length"] + [::std::mem::offset_of!(Il2CppArraySize, max_length) - 24usize]; + ["Offset of field: Il2CppArraySize::vector"] + [::std::mem::offset_of!(Il2CppArraySize, vector) - 32usize]; +}; +pub const kIl2CppSizeOfArray: usize = 32; +pub const kIl2CppOffsetOfArrayBounds: usize = 16; +pub const kIl2CppOffsetOfArrayLength: usize = 24; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppString"][::std::mem::size_of::() - 24usize]; + ["Alignment of Il2CppString"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppString::object"] + [::std::mem::offset_of!(Il2CppString, object) - 0usize]; + ["Offset of field: Il2CppString::length"] + [::std::mem::offset_of!(Il2CppString, length) - 16usize]; + ["Offset of field: Il2CppString::chars"][::std::mem::offset_of!(Il2CppString, chars) - 20usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppReflectionType"][::std::mem::size_of::() - 24usize]; + ["Alignment of Il2CppReflectionType"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppReflectionType::object"] + [::std::mem::offset_of!(Il2CppReflectionType, object) - 0usize]; + ["Offset of field: Il2CppReflectionType::type_"] + [::std::mem::offset_of!(Il2CppReflectionType, type_) - 16usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppReflectionRuntimeType"] + [::std::mem::size_of::() - 48usize]; + ["Alignment of Il2CppReflectionRuntimeType"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppReflectionRuntimeType::type_"] + [::std::mem::offset_of!(Il2CppReflectionRuntimeType, type_) - 0usize]; + ["Offset of field: Il2CppReflectionRuntimeType::type_info"] + [::std::mem::offset_of!(Il2CppReflectionRuntimeType, type_info) - 24usize]; + ["Offset of field: Il2CppReflectionRuntimeType::genericCache"] + [::std::mem::offset_of!(Il2CppReflectionRuntimeType, genericCache) - 32usize]; + ["Offset of field: Il2CppReflectionRuntimeType::serializationCtor"] + [::std::mem::offset_of!(Il2CppReflectionRuntimeType, serializationCtor) - 40usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppReflectionMonoType"] + [::std::mem::size_of::() - 48usize]; + ["Alignment of Il2CppReflectionMonoType"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppReflectionMonoType::type_"] + [::std::mem::offset_of!(Il2CppReflectionMonoType, type_) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppReflectionEvent"][::std::mem::size_of::() - 24usize]; + ["Alignment of Il2CppReflectionEvent"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppReflectionEvent::object"] + [::std::mem::offset_of!(Il2CppReflectionEvent, object) - 0usize]; + ["Offset of field: Il2CppReflectionEvent::cached_add_event"] + [::std::mem::offset_of!(Il2CppReflectionEvent, cached_add_event) - 16usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppReflectionMonoEvent"] + [::std::mem::size_of::() - 40usize]; + ["Alignment of Il2CppReflectionMonoEvent"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppReflectionMonoEvent::event"] + [::std::mem::offset_of!(Il2CppReflectionMonoEvent, event) - 0usize]; + ["Offset of field: Il2CppReflectionMonoEvent::reflectedType"] + [::std::mem::offset_of!(Il2CppReflectionMonoEvent, reflectedType) - 24usize]; + ["Offset of field: Il2CppReflectionMonoEvent::eventInfo"] + [::std::mem::offset_of!(Il2CppReflectionMonoEvent, eventInfo) - 32usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppReflectionMonoEventInfo"] + [::std::mem::size_of::() - 64usize]; + ["Alignment of Il2CppReflectionMonoEventInfo"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppReflectionMonoEventInfo::declaringType"] + [::std::mem::offset_of!(Il2CppReflectionMonoEventInfo, declaringType) - 0usize]; + ["Offset of field: Il2CppReflectionMonoEventInfo::reflectedType"] + [::std::mem::offset_of!(Il2CppReflectionMonoEventInfo, reflectedType) - 8usize]; + ["Offset of field: Il2CppReflectionMonoEventInfo::name"] + [::std::mem::offset_of!(Il2CppReflectionMonoEventInfo, name) - 16usize]; + ["Offset of field: Il2CppReflectionMonoEventInfo::addMethod"] + [::std::mem::offset_of!(Il2CppReflectionMonoEventInfo, addMethod) - 24usize]; + ["Offset of field: Il2CppReflectionMonoEventInfo::removeMethod"] + [::std::mem::offset_of!(Il2CppReflectionMonoEventInfo, removeMethod) - 32usize]; + ["Offset of field: Il2CppReflectionMonoEventInfo::raiseMethod"] + [::std::mem::offset_of!(Il2CppReflectionMonoEventInfo, raiseMethod) - 40usize]; + ["Offset of field: Il2CppReflectionMonoEventInfo::eventAttributes"] + [::std::mem::offset_of!(Il2CppReflectionMonoEventInfo, eventAttributes) - 48usize]; + ["Offset of field: Il2CppReflectionMonoEventInfo::otherMethods"] + [::std::mem::offset_of!(Il2CppReflectionMonoEventInfo, otherMethods) - 56usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppReflectionField"][::std::mem::size_of::() - 56usize]; + ["Alignment of Il2CppReflectionField"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppReflectionField::object"] + [::std::mem::offset_of!(Il2CppReflectionField, object) - 0usize]; + ["Offset of field: Il2CppReflectionField::klass"] + [::std::mem::offset_of!(Il2CppReflectionField, klass) - 16usize]; + ["Offset of field: Il2CppReflectionField::field"] + [::std::mem::offset_of!(Il2CppReflectionField, field) - 24usize]; + ["Offset of field: Il2CppReflectionField::name"] + [::std::mem::offset_of!(Il2CppReflectionField, name) - 32usize]; + ["Offset of field: Il2CppReflectionField::type_"] + [::std::mem::offset_of!(Il2CppReflectionField, type_) - 40usize]; + ["Offset of field: Il2CppReflectionField::attrs"] + [::std::mem::offset_of!(Il2CppReflectionField, attrs) - 48usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppReflectionProperty"] + [::std::mem::size_of::() - 32usize]; + ["Alignment of Il2CppReflectionProperty"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppReflectionProperty::object"] + [::std::mem::offset_of!(Il2CppReflectionProperty, object) - 0usize]; + ["Offset of field: Il2CppReflectionProperty::klass"] + [::std::mem::offset_of!(Il2CppReflectionProperty, klass) - 16usize]; + ["Offset of field: Il2CppReflectionProperty::property"] + [::std::mem::offset_of!(Il2CppReflectionProperty, property) - 24usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppReflectionMethod"][::std::mem::size_of::() - 40usize]; + ["Alignment of Il2CppReflectionMethod"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppReflectionMethod::object"] + [::std::mem::offset_of!(Il2CppReflectionMethod, object) - 0usize]; + ["Offset of field: Il2CppReflectionMethod::method"] + [::std::mem::offset_of!(Il2CppReflectionMethod, method) - 16usize]; + ["Offset of field: Il2CppReflectionMethod::name"] + [::std::mem::offset_of!(Il2CppReflectionMethod, name) - 24usize]; + ["Offset of field: Il2CppReflectionMethod::reftype"] + [::std::mem::offset_of!(Il2CppReflectionMethod, reftype) - 32usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppReflectionGenericMethod"] + [::std::mem::size_of::() - 40usize]; + ["Alignment of Il2CppReflectionGenericMethod"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppReflectionGenericMethod::base"] + [::std::mem::offset_of!(Il2CppReflectionGenericMethod, base) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppMethodInfo"][::std::mem::size_of::() - 32usize]; + ["Alignment of Il2CppMethodInfo"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppMethodInfo::parent"] + [::std::mem::offset_of!(Il2CppMethodInfo, parent) - 0usize]; + ["Offset of field: Il2CppMethodInfo::ret"] + [::std::mem::offset_of!(Il2CppMethodInfo, ret) - 8usize]; + ["Offset of field: Il2CppMethodInfo::attrs"] + [::std::mem::offset_of!(Il2CppMethodInfo, attrs) - 16usize]; + ["Offset of field: Il2CppMethodInfo::implattrs"] + [::std::mem::offset_of!(Il2CppMethodInfo, implattrs) - 20usize]; + ["Offset of field: Il2CppMethodInfo::callconv"] + [::std::mem::offset_of!(Il2CppMethodInfo, callconv) - 24usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppPropertyInfo"][::std::mem::size_of::() - 48usize]; + ["Alignment of Il2CppPropertyInfo"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppPropertyInfo::parent"] + [::std::mem::offset_of!(Il2CppPropertyInfo, parent) - 0usize]; + ["Offset of field: Il2CppPropertyInfo::declaringType"] + [::std::mem::offset_of!(Il2CppPropertyInfo, declaringType) - 8usize]; + ["Offset of field: Il2CppPropertyInfo::name"] + [::std::mem::offset_of!(Il2CppPropertyInfo, name) - 16usize]; + ["Offset of field: Il2CppPropertyInfo::get"] + [::std::mem::offset_of!(Il2CppPropertyInfo, get) - 24usize]; + ["Offset of field: Il2CppPropertyInfo::set"] + [::std::mem::offset_of!(Il2CppPropertyInfo, set) - 32usize]; + ["Offset of field: Il2CppPropertyInfo::attrs"] + [::std::mem::offset_of!(Il2CppPropertyInfo, attrs) - 40usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppReflectionParameter"] + [::std::mem::size_of::() - 72usize]; + ["Alignment of Il2CppReflectionParameter"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppReflectionParameter::object"] + [::std::mem::offset_of!(Il2CppReflectionParameter, object) - 0usize]; + ["Offset of field: Il2CppReflectionParameter::AttrsImpl"] + [::std::mem::offset_of!(Il2CppReflectionParameter, AttrsImpl) - 16usize]; + ["Offset of field: Il2CppReflectionParameter::ClassImpl"] + [::std::mem::offset_of!(Il2CppReflectionParameter, ClassImpl) - 24usize]; + ["Offset of field: Il2CppReflectionParameter::DefaultValueImpl"] + [::std::mem::offset_of!(Il2CppReflectionParameter, DefaultValueImpl) - 32usize]; + ["Offset of field: Il2CppReflectionParameter::MemberImpl"] + [::std::mem::offset_of!(Il2CppReflectionParameter, MemberImpl) - 40usize]; + ["Offset of field: Il2CppReflectionParameter::NameImpl"] + [::std::mem::offset_of!(Il2CppReflectionParameter, NameImpl) - 48usize]; + ["Offset of field: Il2CppReflectionParameter::PositionImpl"] + [::std::mem::offset_of!(Il2CppReflectionParameter, PositionImpl) - 56usize]; + ["Offset of field: Il2CppReflectionParameter::MarshalAs"] + [::std::mem::offset_of!(Il2CppReflectionParameter, MarshalAs) - 64usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppReflectionModule"][::std::mem::size_of::() - 64usize]; + ["Alignment of Il2CppReflectionModule"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppReflectionModule::obj"] + [::std::mem::offset_of!(Il2CppReflectionModule, obj) - 0usize]; + ["Offset of field: Il2CppReflectionModule::image"] + [::std::mem::offset_of!(Il2CppReflectionModule, image) - 16usize]; + ["Offset of field: Il2CppReflectionModule::assembly"] + [::std::mem::offset_of!(Il2CppReflectionModule, assembly) - 24usize]; + ["Offset of field: Il2CppReflectionModule::fqname"] + [::std::mem::offset_of!(Il2CppReflectionModule, fqname) - 32usize]; + ["Offset of field: Il2CppReflectionModule::name"] + [::std::mem::offset_of!(Il2CppReflectionModule, name) - 40usize]; + ["Offset of field: Il2CppReflectionModule::scopename"] + [::std::mem::offset_of!(Il2CppReflectionModule, scopename) - 48usize]; + ["Offset of field: Il2CppReflectionModule::is_resource"] + [::std::mem::offset_of!(Il2CppReflectionModule, is_resource) - 56usize]; + ["Offset of field: Il2CppReflectionModule::token"] + [::std::mem::offset_of!(Il2CppReflectionModule, token) - 60usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppReflectionAssemblyName"] + [::std::mem::size_of::() - 112usize]; + ["Alignment of Il2CppReflectionAssemblyName"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppReflectionAssemblyName::obj"] + [::std::mem::offset_of!(Il2CppReflectionAssemblyName, obj) - 0usize]; + ["Offset of field: Il2CppReflectionAssemblyName::name"] + [::std::mem::offset_of!(Il2CppReflectionAssemblyName, name) - 16usize]; + ["Offset of field: Il2CppReflectionAssemblyName::codebase"] + [::std::mem::offset_of!(Il2CppReflectionAssemblyName, codebase) - 24usize]; + ["Offset of field: Il2CppReflectionAssemblyName::major"] + [::std::mem::offset_of!(Il2CppReflectionAssemblyName, major) - 32usize]; + ["Offset of field: Il2CppReflectionAssemblyName::minor"] + [::std::mem::offset_of!(Il2CppReflectionAssemblyName, minor) - 36usize]; + ["Offset of field: Il2CppReflectionAssemblyName::build"] + [::std::mem::offset_of!(Il2CppReflectionAssemblyName, build) - 40usize]; + ["Offset of field: Il2CppReflectionAssemblyName::revision"] + [::std::mem::offset_of!(Il2CppReflectionAssemblyName, revision) - 44usize]; + ["Offset of field: Il2CppReflectionAssemblyName::cultureInfo"] + [::std::mem::offset_of!(Il2CppReflectionAssemblyName, cultureInfo) - 48usize]; + ["Offset of field: Il2CppReflectionAssemblyName::flags"] + [::std::mem::offset_of!(Il2CppReflectionAssemblyName, flags) - 56usize]; + ["Offset of field: Il2CppReflectionAssemblyName::hashalg"] + [::std::mem::offset_of!(Il2CppReflectionAssemblyName, hashalg) - 60usize]; + ["Offset of field: Il2CppReflectionAssemblyName::keypair"] + [::std::mem::offset_of!(Il2CppReflectionAssemblyName, keypair) - 64usize]; + ["Offset of field: Il2CppReflectionAssemblyName::publicKey"] + [::std::mem::offset_of!(Il2CppReflectionAssemblyName, publicKey) - 72usize]; + ["Offset of field: Il2CppReflectionAssemblyName::keyToken"] + [::std::mem::offset_of!(Il2CppReflectionAssemblyName, keyToken) - 80usize]; + ["Offset of field: Il2CppReflectionAssemblyName::versioncompat"] + [::std::mem::offset_of!(Il2CppReflectionAssemblyName, versioncompat) - 88usize]; + ["Offset of field: Il2CppReflectionAssemblyName::version"] + [::std::mem::offset_of!(Il2CppReflectionAssemblyName, version) - 96usize]; + ["Offset of field: Il2CppReflectionAssemblyName::processor_architecture"] + [::std::mem::offset_of!(Il2CppReflectionAssemblyName, processor_architecture) - 104usize]; + ["Offset of field: Il2CppReflectionAssemblyName::contentType"] + [::std::mem::offset_of!(Il2CppReflectionAssemblyName, contentType) - 108usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppReflectionAssembly"] + [::std::mem::size_of::() - 96usize]; + ["Alignment of Il2CppReflectionAssembly"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppReflectionAssembly::object"] + [::std::mem::offset_of!(Il2CppReflectionAssembly, object) - 0usize]; + ["Offset of field: Il2CppReflectionAssembly::assembly"] + [::std::mem::offset_of!(Il2CppReflectionAssembly, assembly) - 16usize]; + ["Offset of field: Il2CppReflectionAssembly::evidence"] + [::std::mem::offset_of!(Il2CppReflectionAssembly, evidence) - 24usize]; + ["Offset of field: Il2CppReflectionAssembly::resolve_event_holder"] + [::std::mem::offset_of!(Il2CppReflectionAssembly, resolve_event_holder) - 32usize]; + ["Offset of field: Il2CppReflectionAssembly::minimum"] + [::std::mem::offset_of!(Il2CppReflectionAssembly, minimum) - 40usize]; + ["Offset of field: Il2CppReflectionAssembly::optional"] + [::std::mem::offset_of!(Il2CppReflectionAssembly, optional) - 48usize]; + ["Offset of field: Il2CppReflectionAssembly::refuse"] + [::std::mem::offset_of!(Il2CppReflectionAssembly, refuse) - 56usize]; + ["Offset of field: Il2CppReflectionAssembly::granted"] + [::std::mem::offset_of!(Il2CppReflectionAssembly, granted) - 64usize]; + ["Offset of field: Il2CppReflectionAssembly::denied"] + [::std::mem::offset_of!(Il2CppReflectionAssembly, denied) - 72usize]; + ["Offset of field: Il2CppReflectionAssembly::from_byte_array"] + [::std::mem::offset_of!(Il2CppReflectionAssembly, from_byte_array) - 80usize]; + ["Offset of field: Il2CppReflectionAssembly::name"] + [::std::mem::offset_of!(Il2CppReflectionAssembly, name) - 88usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppReflectionMarshal"][::std::mem::size_of::() - 72usize]; + ["Alignment of Il2CppReflectionMarshal"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppReflectionMarshal::object"] + [::std::mem::offset_of!(Il2CppReflectionMarshal, object) - 0usize]; + ["Offset of field: Il2CppReflectionMarshal::count"] + [::std::mem::offset_of!(Il2CppReflectionMarshal, count) - 16usize]; + ["Offset of field: Il2CppReflectionMarshal::type_"] + [::std::mem::offset_of!(Il2CppReflectionMarshal, type_) - 20usize]; + ["Offset of field: Il2CppReflectionMarshal::eltype"] + [::std::mem::offset_of!(Il2CppReflectionMarshal, eltype) - 24usize]; + ["Offset of field: Il2CppReflectionMarshal::guid"] + [::std::mem::offset_of!(Il2CppReflectionMarshal, guid) - 32usize]; + ["Offset of field: Il2CppReflectionMarshal::mcookie"] + [::std::mem::offset_of!(Il2CppReflectionMarshal, mcookie) - 40usize]; + ["Offset of field: Il2CppReflectionMarshal::marshaltype"] + [::std::mem::offset_of!(Il2CppReflectionMarshal, marshaltype) - 48usize]; + ["Offset of field: Il2CppReflectionMarshal::marshaltyperef"] + [::std::mem::offset_of!(Il2CppReflectionMarshal, marshaltyperef) - 56usize]; + ["Offset of field: Il2CppReflectionMarshal::param_num"] + [::std::mem::offset_of!(Il2CppReflectionMarshal, param_num) - 64usize]; + ["Offset of field: Il2CppReflectionMarshal::has_size"] + [::std::mem::offset_of!(Il2CppReflectionMarshal, has_size) - 68usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppReflectionPointer"][::std::mem::size_of::() - 32usize]; + ["Alignment of Il2CppReflectionPointer"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppReflectionPointer::object"] + [::std::mem::offset_of!(Il2CppReflectionPointer, object) - 0usize]; + ["Offset of field: Il2CppReflectionPointer::data"] + [::std::mem::offset_of!(Il2CppReflectionPointer, data) - 16usize]; + ["Offset of field: Il2CppReflectionPointer::type_"] + [::std::mem::offset_of!(Il2CppReflectionPointer, type_) - 24usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppThreadName"][::std::mem::size_of::() - 16usize]; + ["Alignment of Il2CppThreadName"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppThreadName::chars"] + [::std::mem::offset_of!(Il2CppThreadName, chars) - 0usize]; + ["Offset of field: Il2CppThreadName::unused"] + [::std::mem::offset_of!(Il2CppThreadName, unused) - 8usize]; + ["Offset of field: Il2CppThreadName::length"] + [::std::mem::offset_of!(Il2CppThreadName, length) - 12usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppRefCount"][::std::mem::size_of::() - 16usize]; + ["Alignment of Il2CppRefCount"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppRefCount::ref_"] + [::std::mem::offset_of!(Il2CppRefCount, ref_) - 0usize]; + ["Offset of field: Il2CppRefCount::destructor"] + [::std::mem::offset_of!(Il2CppRefCount, destructor) - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppLongLivedThreadData"] + [::std::mem::size_of::() - 24usize]; + ["Alignment of Il2CppLongLivedThreadData"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppLongLivedThreadData::ref_"] + [::std::mem::offset_of!(Il2CppLongLivedThreadData, ref_) - 0usize]; + ["Offset of field: Il2CppLongLivedThreadData::synch_cs"] + [::std::mem::offset_of!(Il2CppLongLivedThreadData, synch_cs) - 16usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppInternalThread"][::std::mem::size_of::() - 296usize]; + ["Alignment of Il2CppInternalThread"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppInternalThread::obj"] + [::std::mem::offset_of!(Il2CppInternalThread, obj) - 0usize]; + ["Offset of field: Il2CppInternalThread::lock_thread_id"] + [::std::mem::offset_of!(Il2CppInternalThread, lock_thread_id) - 16usize]; + ["Offset of field: Il2CppInternalThread::handle"] + [::std::mem::offset_of!(Il2CppInternalThread, handle) - 24usize]; + ["Offset of field: Il2CppInternalThread::native_handle"] + [::std::mem::offset_of!(Il2CppInternalThread, native_handle) - 32usize]; + ["Offset of field: Il2CppInternalThread::name"] + [::std::mem::offset_of!(Il2CppInternalThread, name) - 40usize]; + ["Offset of field: Il2CppInternalThread::state"] + [::std::mem::offset_of!(Il2CppInternalThread, state) - 56usize]; + ["Offset of field: Il2CppInternalThread::abort_exc"] + [::std::mem::offset_of!(Il2CppInternalThread, abort_exc) - 64usize]; + ["Offset of field: Il2CppInternalThread::abort_state_handle"] + [::std::mem::offset_of!(Il2CppInternalThread, abort_state_handle) - 72usize]; + ["Offset of field: Il2CppInternalThread::tid"] + [::std::mem::offset_of!(Il2CppInternalThread, tid) - 80usize]; + ["Offset of field: Il2CppInternalThread::debugger_thread"] + [::std::mem::offset_of!(Il2CppInternalThread, debugger_thread) - 88usize]; + ["Offset of field: Il2CppInternalThread::static_data"] + [::std::mem::offset_of!(Il2CppInternalThread, static_data) - 96usize]; + ["Offset of field: Il2CppInternalThread::runtime_thread_info"] + [::std::mem::offset_of!(Il2CppInternalThread, runtime_thread_info) - 104usize]; + ["Offset of field: Il2CppInternalThread::current_appcontext"] + [::std::mem::offset_of!(Il2CppInternalThread, current_appcontext) - 112usize]; + ["Offset of field: Il2CppInternalThread::root_domain_thread"] + [::std::mem::offset_of!(Il2CppInternalThread, root_domain_thread) - 120usize]; + ["Offset of field: Il2CppInternalThread::_serialized_principal"] + [::std::mem::offset_of!(Il2CppInternalThread, _serialized_principal) - 128usize]; + ["Offset of field: Il2CppInternalThread::_serialized_principal_version"] + [::std::mem::offset_of!(Il2CppInternalThread, _serialized_principal_version) - 136usize]; + ["Offset of field: Il2CppInternalThread::appdomain_refs"] + [::std::mem::offset_of!(Il2CppInternalThread, appdomain_refs) - 144usize]; + ["Offset of field: Il2CppInternalThread::interruption_requested"] + [::std::mem::offset_of!(Il2CppInternalThread, interruption_requested) - 152usize]; + ["Offset of field: Il2CppInternalThread::longlived"] + [::std::mem::offset_of!(Il2CppInternalThread, longlived) - 160usize]; + ["Offset of field: Il2CppInternalThread::threadpool_thread"] + [::std::mem::offset_of!(Il2CppInternalThread, threadpool_thread) - 168usize]; + ["Offset of field: Il2CppInternalThread::thread_interrupt_requested"] + [::std::mem::offset_of!(Il2CppInternalThread, thread_interrupt_requested) - 169usize]; + ["Offset of field: Il2CppInternalThread::stack_size"] + [::std::mem::offset_of!(Il2CppInternalThread, stack_size) - 172usize]; + ["Offset of field: Il2CppInternalThread::apartment_state"] + [::std::mem::offset_of!(Il2CppInternalThread, apartment_state) - 176usize]; + ["Offset of field: Il2CppInternalThread::critical_region_level"] + [::std::mem::offset_of!(Il2CppInternalThread, critical_region_level) - 180usize]; + ["Offset of field: Il2CppInternalThread::managed_id"] + [::std::mem::offset_of!(Il2CppInternalThread, managed_id) - 184usize]; + ["Offset of field: Il2CppInternalThread::small_id"] + [::std::mem::offset_of!(Il2CppInternalThread, small_id) - 188usize]; + ["Offset of field: Il2CppInternalThread::manage_callback"] + [::std::mem::offset_of!(Il2CppInternalThread, manage_callback) - 192usize]; + ["Offset of field: Il2CppInternalThread::flags"] + [::std::mem::offset_of!(Il2CppInternalThread, flags) - 200usize]; + ["Offset of field: Il2CppInternalThread::thread_pinning_ref"] + [::std::mem::offset_of!(Il2CppInternalThread, thread_pinning_ref) - 208usize]; + ["Offset of field: Il2CppInternalThread::abort_protected_block_count"] + [::std::mem::offset_of!(Il2CppInternalThread, abort_protected_block_count) - 216usize]; + ["Offset of field: Il2CppInternalThread::priority"] + [::std::mem::offset_of!(Il2CppInternalThread, priority) - 224usize]; + ["Offset of field: Il2CppInternalThread::owned_mutexes"] + [::std::mem::offset_of!(Il2CppInternalThread, owned_mutexes) - 232usize]; + ["Offset of field: Il2CppInternalThread::suspended"] + [::std::mem::offset_of!(Il2CppInternalThread, suspended) - 240usize]; + ["Offset of field: Il2CppInternalThread::self_suspended"] + [::std::mem::offset_of!(Il2CppInternalThread, self_suspended) - 248usize]; + ["Offset of field: Il2CppInternalThread::thread_state"] + [::std::mem::offset_of!(Il2CppInternalThread, thread_state) - 256usize]; + ["Offset of field: Il2CppInternalThread::unused"] + [::std::mem::offset_of!(Il2CppInternalThread, unused) - 264usize]; + ["Offset of field: Il2CppInternalThread::last"] + [::std::mem::offset_of!(Il2CppInternalThread, last) - 288usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppIOSelectorJob"][::std::mem::size_of::() - 40usize]; + ["Alignment of Il2CppIOSelectorJob"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppIOSelectorJob::object"] + [::std::mem::offset_of!(Il2CppIOSelectorJob, object) - 0usize]; + ["Offset of field: Il2CppIOSelectorJob::operation"] + [::std::mem::offset_of!(Il2CppIOSelectorJob, operation) - 16usize]; + ["Offset of field: Il2CppIOSelectorJob::callback"] + [::std::mem::offset_of!(Il2CppIOSelectorJob, callback) - 24usize]; + ["Offset of field: Il2CppIOSelectorJob::state"] + [::std::mem::offset_of!(Il2CppIOSelectorJob, state) - 32usize]; +}; +pub const Il2CppCallType_Il2Cpp_CallType_Sync: Il2CppCallType = 0; +pub const Il2CppCallType_Il2Cpp_CallType_BeginInvoke: Il2CppCallType = 1; +pub const Il2CppCallType_Il2Cpp_CallType_EndInvoke: Il2CppCallType = 2; +pub const Il2CppCallType_Il2Cpp_CallType_OneWay: Il2CppCallType = 3; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppMethodMessage"][::std::mem::size_of::() - 88usize]; + ["Alignment of Il2CppMethodMessage"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppMethodMessage::obj"] + [::std::mem::offset_of!(Il2CppMethodMessage, obj) - 0usize]; + ["Offset of field: Il2CppMethodMessage::method"] + [::std::mem::offset_of!(Il2CppMethodMessage, method) - 16usize]; + ["Offset of field: Il2CppMethodMessage::args"] + [::std::mem::offset_of!(Il2CppMethodMessage, args) - 24usize]; + ["Offset of field: Il2CppMethodMessage::names"] + [::std::mem::offset_of!(Il2CppMethodMessage, names) - 32usize]; + ["Offset of field: Il2CppMethodMessage::arg_types"] + [::std::mem::offset_of!(Il2CppMethodMessage, arg_types) - 40usize]; + ["Offset of field: Il2CppMethodMessage::ctx"] + [::std::mem::offset_of!(Il2CppMethodMessage, ctx) - 48usize]; + ["Offset of field: Il2CppMethodMessage::rval"] + [::std::mem::offset_of!(Il2CppMethodMessage, rval) - 56usize]; + ["Offset of field: Il2CppMethodMessage::exc"] + [::std::mem::offset_of!(Il2CppMethodMessage, exc) - 64usize]; + ["Offset of field: Il2CppMethodMessage::async_result"] + [::std::mem::offset_of!(Il2CppMethodMessage, async_result) - 72usize]; + ["Offset of field: Il2CppMethodMessage::call_type"] + [::std::mem::offset_of!(Il2CppMethodMessage, call_type) - 80usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppAppDomainSetup"][::std::mem::size_of::() - 168usize]; + ["Alignment of Il2CppAppDomainSetup"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppAppDomainSetup::object"] + [::std::mem::offset_of!(Il2CppAppDomainSetup, object) - 0usize]; + ["Offset of field: Il2CppAppDomainSetup::application_base"] + [::std::mem::offset_of!(Il2CppAppDomainSetup, application_base) - 16usize]; + ["Offset of field: Il2CppAppDomainSetup::application_name"] + [::std::mem::offset_of!(Il2CppAppDomainSetup, application_name) - 24usize]; + ["Offset of field: Il2CppAppDomainSetup::cache_path"] + [::std::mem::offset_of!(Il2CppAppDomainSetup, cache_path) - 32usize]; + ["Offset of field: Il2CppAppDomainSetup::configuration_file"] + [::std::mem::offset_of!(Il2CppAppDomainSetup, configuration_file) - 40usize]; + ["Offset of field: Il2CppAppDomainSetup::dynamic_base"] + [::std::mem::offset_of!(Il2CppAppDomainSetup, dynamic_base) - 48usize]; + ["Offset of field: Il2CppAppDomainSetup::license_file"] + [::std::mem::offset_of!(Il2CppAppDomainSetup, license_file) - 56usize]; + ["Offset of field: Il2CppAppDomainSetup::private_bin_path"] + [::std::mem::offset_of!(Il2CppAppDomainSetup, private_bin_path) - 64usize]; + ["Offset of field: Il2CppAppDomainSetup::private_bin_path_probe"] + [::std::mem::offset_of!(Il2CppAppDomainSetup, private_bin_path_probe) - 72usize]; + ["Offset of field: Il2CppAppDomainSetup::shadow_copy_directories"] + [::std::mem::offset_of!(Il2CppAppDomainSetup, shadow_copy_directories) - 80usize]; + ["Offset of field: Il2CppAppDomainSetup::shadow_copy_files"] + [::std::mem::offset_of!(Il2CppAppDomainSetup, shadow_copy_files) - 88usize]; + ["Offset of field: Il2CppAppDomainSetup::publisher_policy"] + [::std::mem::offset_of!(Il2CppAppDomainSetup, publisher_policy) - 96usize]; + ["Offset of field: Il2CppAppDomainSetup::path_changed"] + [::std::mem::offset_of!(Il2CppAppDomainSetup, path_changed) - 97usize]; + ["Offset of field: Il2CppAppDomainSetup::loader_optimization"] + [::std::mem::offset_of!(Il2CppAppDomainSetup, loader_optimization) - 100usize]; + ["Offset of field: Il2CppAppDomainSetup::disallow_binding_redirects"] + [::std::mem::offset_of!(Il2CppAppDomainSetup, disallow_binding_redirects) - 104usize]; + ["Offset of field: Il2CppAppDomainSetup::disallow_code_downloads"] + [::std::mem::offset_of!(Il2CppAppDomainSetup, disallow_code_downloads) - 105usize]; + ["Offset of field: Il2CppAppDomainSetup::activation_arguments"] + [::std::mem::offset_of!(Il2CppAppDomainSetup, activation_arguments) - 112usize]; + ["Offset of field: Il2CppAppDomainSetup::domain_initializer"] + [::std::mem::offset_of!(Il2CppAppDomainSetup, domain_initializer) - 120usize]; + ["Offset of field: Il2CppAppDomainSetup::application_trust"] + [::std::mem::offset_of!(Il2CppAppDomainSetup, application_trust) - 128usize]; + ["Offset of field: Il2CppAppDomainSetup::domain_initializer_args"] + [::std::mem::offset_of!(Il2CppAppDomainSetup, domain_initializer_args) - 136usize]; + ["Offset of field: Il2CppAppDomainSetup::disallow_appbase_probe"] + [::std::mem::offset_of!(Il2CppAppDomainSetup, disallow_appbase_probe) - 144usize]; + ["Offset of field: Il2CppAppDomainSetup::configuration_bytes"] + [::std::mem::offset_of!(Il2CppAppDomainSetup, configuration_bytes) - 152usize]; + ["Offset of field: Il2CppAppDomainSetup::serialized_non_primitives"] + [::std::mem::offset_of!(Il2CppAppDomainSetup, serialized_non_primitives) - 160usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppThread"][::std::mem::size_of::() - 80usize]; + ["Alignment of Il2CppThread"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppThread::obj"][::std::mem::offset_of!(Il2CppThread, obj) - 0usize]; + ["Offset of field: Il2CppThread::internal_thread"] + [::std::mem::offset_of!(Il2CppThread, internal_thread) - 16usize]; + ["Offset of field: Il2CppThread::start_obj"] + [::std::mem::offset_of!(Il2CppThread, start_obj) - 24usize]; + ["Offset of field: Il2CppThread::pending_exception"] + [::std::mem::offset_of!(Il2CppThread, pending_exception) - 32usize]; + ["Offset of field: Il2CppThread::principal"] + [::std::mem::offset_of!(Il2CppThread, principal) - 40usize]; + ["Offset of field: Il2CppThread::principal_version"] + [::std::mem::offset_of!(Il2CppThread, principal_version) - 48usize]; + ["Offset of field: Il2CppThread::delegate"] + [::std::mem::offset_of!(Il2CppThread, delegate) - 56usize]; + ["Offset of field: Il2CppThread::executionContext"] + [::std::mem::offset_of!(Il2CppThread, executionContext) - 64usize]; + ["Offset of field: Il2CppThread::executionContextBelongsToOuterScope"] + [::std::mem::offset_of!(Il2CppThread, executionContextBelongsToOuterScope) - 72usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppException"][::std::mem::size_of::() - 144usize]; + ["Alignment of Il2CppException"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppException::object"] + [::std::mem::offset_of!(Il2CppException, object) - 0usize]; + ["Offset of field: Il2CppException::className"] + [::std::mem::offset_of!(Il2CppException, className) - 16usize]; + ["Offset of field: Il2CppException::message"] + [::std::mem::offset_of!(Il2CppException, message) - 24usize]; + ["Offset of field: Il2CppException::_data"] + [::std::mem::offset_of!(Il2CppException, _data) - 32usize]; + ["Offset of field: Il2CppException::inner_ex"] + [::std::mem::offset_of!(Il2CppException, inner_ex) - 40usize]; + ["Offset of field: Il2CppException::_helpURL"] + [::std::mem::offset_of!(Il2CppException, _helpURL) - 48usize]; + ["Offset of field: Il2CppException::trace_ips"] + [::std::mem::offset_of!(Il2CppException, trace_ips) - 56usize]; + ["Offset of field: Il2CppException::stack_trace"] + [::std::mem::offset_of!(Il2CppException, stack_trace) - 64usize]; + ["Offset of field: Il2CppException::remote_stack_trace"] + [::std::mem::offset_of!(Il2CppException, remote_stack_trace) - 72usize]; + ["Offset of field: Il2CppException::remote_stack_index"] + [::std::mem::offset_of!(Il2CppException, remote_stack_index) - 80usize]; + ["Offset of field: Il2CppException::_dynamicMethods"] + [::std::mem::offset_of!(Il2CppException, _dynamicMethods) - 88usize]; + ["Offset of field: Il2CppException::hresult"] + [::std::mem::offset_of!(Il2CppException, hresult) - 96usize]; + ["Offset of field: Il2CppException::source"] + [::std::mem::offset_of!(Il2CppException, source) - 104usize]; + ["Offset of field: Il2CppException::safeSerializationManager"] + [::std::mem::offset_of!(Il2CppException, safeSerializationManager) - 112usize]; + ["Offset of field: Il2CppException::captured_traces"] + [::std::mem::offset_of!(Il2CppException, captured_traces) - 120usize]; + ["Offset of field: Il2CppException::native_trace_ips"] + [::std::mem::offset_of!(Il2CppException, native_trace_ips) - 128usize]; + ["Offset of field: Il2CppException::caught_in_unmanaged"] + [::std::mem::offset_of!(Il2CppException, caught_in_unmanaged) - 136usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppSystemException"][::std::mem::size_of::() - 144usize]; + ["Alignment of Il2CppSystemException"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppSystemException::base"] + [::std::mem::offset_of!(Il2CppSystemException, base) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppArgumentException"] + [::std::mem::size_of::() - 152usize]; + ["Alignment of Il2CppArgumentException"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppArgumentException::base"] + [::std::mem::offset_of!(Il2CppArgumentException, base) - 0usize]; + ["Offset of field: Il2CppArgumentException::argName"] + [::std::mem::offset_of!(Il2CppArgumentException, argName) - 144usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppTypedRef"][::std::mem::size_of::() - 24usize]; + ["Alignment of Il2CppTypedRef"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppTypedRef::type_"] + [::std::mem::offset_of!(Il2CppTypedRef, type_) - 0usize]; + ["Offset of field: Il2CppTypedRef::value"] + [::std::mem::offset_of!(Il2CppTypedRef, value) - 8usize]; + ["Offset of field: Il2CppTypedRef::klass"] + [::std::mem::offset_of!(Il2CppTypedRef, klass) - 16usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppDelegate"][::std::mem::size_of::() - 120usize]; + ["Alignment of Il2CppDelegate"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppDelegate::object"] + [::std::mem::offset_of!(Il2CppDelegate, object) - 0usize]; + ["Offset of field: Il2CppDelegate::method_ptr"] + [::std::mem::offset_of!(Il2CppDelegate, method_ptr) - 16usize]; + ["Offset of field: Il2CppDelegate::invoke_impl"] + [::std::mem::offset_of!(Il2CppDelegate, invoke_impl) - 24usize]; + ["Offset of field: Il2CppDelegate::target"] + [::std::mem::offset_of!(Il2CppDelegate, target) - 32usize]; + ["Offset of field: Il2CppDelegate::method"] + [::std::mem::offset_of!(Il2CppDelegate, method) - 40usize]; + ["Offset of field: Il2CppDelegate::delegate_trampoline"] + [::std::mem::offset_of!(Il2CppDelegate, delegate_trampoline) - 48usize]; + ["Offset of field: Il2CppDelegate::extraArg"] + [::std::mem::offset_of!(Il2CppDelegate, extraArg) - 56usize]; + ["Offset of field: Il2CppDelegate::invoke_impl_this"] + [::std::mem::offset_of!(Il2CppDelegate, invoke_impl_this) - 64usize]; + ["Offset of field: Il2CppDelegate::interp_method"] + [::std::mem::offset_of!(Il2CppDelegate, interp_method) - 72usize]; + ["Offset of field: Il2CppDelegate::interp_invoke_impl"] + [::std::mem::offset_of!(Il2CppDelegate, interp_invoke_impl) - 80usize]; + ["Offset of field: Il2CppDelegate::method_info"] + [::std::mem::offset_of!(Il2CppDelegate, method_info) - 88usize]; + ["Offset of field: Il2CppDelegate::original_method_info"] + [::std::mem::offset_of!(Il2CppDelegate, original_method_info) - 96usize]; + ["Offset of field: Il2CppDelegate::data"] + [::std::mem::offset_of!(Il2CppDelegate, data) - 104usize]; + ["Offset of field: Il2CppDelegate::method_is_virtual"] + [::std::mem::offset_of!(Il2CppDelegate, method_is_virtual) - 112usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppMulticastDelegate"] + [::std::mem::size_of::() - 128usize]; + ["Alignment of Il2CppMulticastDelegate"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppMulticastDelegate::delegate"] + [::std::mem::offset_of!(Il2CppMulticastDelegate, delegate) - 0usize]; + ["Offset of field: Il2CppMulticastDelegate::delegates"] + [::std::mem::offset_of!(Il2CppMulticastDelegate, delegates) - 120usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppMarshalByRefObject"] + [::std::mem::size_of::() - 24usize]; + ["Alignment of Il2CppMarshalByRefObject"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppMarshalByRefObject::obj"] + [::std::mem::offset_of!(Il2CppMarshalByRefObject, obj) - 0usize]; + ["Offset of field: Il2CppMarshalByRefObject::identity"] + [::std::mem::offset_of!(Il2CppMarshalByRefObject, identity) - 16usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppAppDomain"][::std::mem::size_of::() - 32usize]; + ["Alignment of Il2CppAppDomain"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppAppDomain::mbr"] + [::std::mem::offset_of!(Il2CppAppDomain, mbr) - 0usize]; + ["Offset of field: Il2CppAppDomain::data"] + [::std::mem::offset_of!(Il2CppAppDomain, data) - 24usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppStackFrame"][::std::mem::size_of::() - 72usize]; + ["Alignment of Il2CppStackFrame"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppStackFrame::obj"] + [::std::mem::offset_of!(Il2CppStackFrame, obj) - 0usize]; + ["Offset of field: Il2CppStackFrame::il_offset"] + [::std::mem::offset_of!(Il2CppStackFrame, il_offset) - 16usize]; + ["Offset of field: Il2CppStackFrame::native_offset"] + [::std::mem::offset_of!(Il2CppStackFrame, native_offset) - 20usize]; + ["Offset of field: Il2CppStackFrame::methodAddress"] + [::std::mem::offset_of!(Il2CppStackFrame, methodAddress) - 24usize]; + ["Offset of field: Il2CppStackFrame::methodIndex"] + [::std::mem::offset_of!(Il2CppStackFrame, methodIndex) - 32usize]; + ["Offset of field: Il2CppStackFrame::method"] + [::std::mem::offset_of!(Il2CppStackFrame, method) - 40usize]; + ["Offset of field: Il2CppStackFrame::filename"] + [::std::mem::offset_of!(Il2CppStackFrame, filename) - 48usize]; + ["Offset of field: Il2CppStackFrame::line"] + [::std::mem::offset_of!(Il2CppStackFrame, line) - 56usize]; + ["Offset of field: Il2CppStackFrame::column"] + [::std::mem::offset_of!(Il2CppStackFrame, column) - 60usize]; + ["Offset of field: Il2CppStackFrame::internal_method_name"] + [::std::mem::offset_of!(Il2CppStackFrame, internal_method_name) - 64usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppDateTimeFormatInfo"] + [::std::mem::size_of::() - 376usize]; + ["Alignment of Il2CppDateTimeFormatInfo"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::obj"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, obj) - 0usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::CultureData"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, CultureData) - 16usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::Name"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, Name) - 24usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::LangName"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, LangName) - 32usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::CompareInfo"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, CompareInfo) - 40usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::CultureInfo"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, CultureInfo) - 48usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::AMDesignator"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, AMDesignator) - 56usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::PMDesignator"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, PMDesignator) - 64usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::DateSeparator"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, DateSeparator) - 72usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::GeneralShortTimePattern"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, GeneralShortTimePattern) - 80usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::GeneralLongTimePattern"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, GeneralLongTimePattern) - 88usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::TimeSeparator"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, TimeSeparator) - 96usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::MonthDayPattern"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, MonthDayPattern) - 104usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::DateTimeOffsetPattern"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, DateTimeOffsetPattern) - 112usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::Calendar"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, Calendar) - 120usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::FirstDayOfWeek"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, FirstDayOfWeek) - 128usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::CalendarWeekRule"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, CalendarWeekRule) - 132usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::FullDateTimePattern"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, FullDateTimePattern) - 136usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::AbbreviatedDayNames"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, AbbreviatedDayNames) - 144usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::ShortDayNames"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, ShortDayNames) - 152usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::DayNames"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, DayNames) - 160usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::AbbreviatedMonthNames"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, AbbreviatedMonthNames) - 168usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::MonthNames"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, MonthNames) - 176usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::GenitiveMonthNames"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, GenitiveMonthNames) - 184usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::GenitiveAbbreviatedMonthNames"][::std::mem::offset_of!( + Il2CppDateTimeFormatInfo, + GenitiveAbbreviatedMonthNames + ) - 192usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::LeapYearMonthNames"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, LeapYearMonthNames) - 200usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::LongDatePattern"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, LongDatePattern) - 208usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::ShortDatePattern"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, ShortDatePattern) - 216usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::YearMonthPattern"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, YearMonthPattern) - 224usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::LongTimePattern"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, LongTimePattern) - 232usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::ShortTimePattern"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, ShortTimePattern) - 240usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::YearMonthPatterns"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, YearMonthPatterns) - 248usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::ShortDatePatterns"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, ShortDatePatterns) - 256usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::LongDatePatterns"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, LongDatePatterns) - 264usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::ShortTimePatterns"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, ShortTimePatterns) - 272usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::LongTimePatterns"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, LongTimePatterns) - 280usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::EraNames"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, EraNames) - 288usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::AbbrevEraNames"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, AbbrevEraNames) - 296usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::AbbrevEnglishEraNames"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, AbbrevEnglishEraNames) - 304usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::OptionalCalendars"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, OptionalCalendars) - 312usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::readOnly"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, readOnly) - 320usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::FormatFlags"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, FormatFlags) - 324usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::CultureID"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, CultureID) - 328usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::UseUserOverride"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, UseUserOverride) - 332usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::UseCalendarInfo"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, UseCalendarInfo) - 333usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::DataItem"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, DataItem) - 336usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::IsDefaultCalendar"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, IsDefaultCalendar) - 340usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::DateWords"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, DateWords) - 344usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::FullTimeSpanPositivePattern"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, FullTimeSpanPositivePattern) - 352usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::FullTimeSpanNegativePattern"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, FullTimeSpanNegativePattern) - 360usize]; + ["Offset of field: Il2CppDateTimeFormatInfo::dtfiTokenHash"] + [::std::mem::offset_of!(Il2CppDateTimeFormatInfo, dtfiTokenHash) - 368usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppNumberFormatInfo"][::std::mem::size_of::() - 216usize]; + ["Alignment of Il2CppNumberFormatInfo"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppNumberFormatInfo::obj"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, obj) - 0usize]; + ["Offset of field: Il2CppNumberFormatInfo::numberGroupSizes"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, numberGroupSizes) - 16usize]; + ["Offset of field: Il2CppNumberFormatInfo::currencyGroupSizes"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, currencyGroupSizes) - 24usize]; + ["Offset of field: Il2CppNumberFormatInfo::percentGroupSizes"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, percentGroupSizes) - 32usize]; + ["Offset of field: Il2CppNumberFormatInfo::positiveSign"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, positiveSign) - 40usize]; + ["Offset of field: Il2CppNumberFormatInfo::negativeSign"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, negativeSign) - 48usize]; + ["Offset of field: Il2CppNumberFormatInfo::numberDecimalSeparator"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, numberDecimalSeparator) - 56usize]; + ["Offset of field: Il2CppNumberFormatInfo::numberGroupSeparator"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, numberGroupSeparator) - 64usize]; + ["Offset of field: Il2CppNumberFormatInfo::currencyGroupSeparator"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, currencyGroupSeparator) - 72usize]; + ["Offset of field: Il2CppNumberFormatInfo::currencyDecimalSeparator"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, currencyDecimalSeparator) - 80usize]; + ["Offset of field: Il2CppNumberFormatInfo::currencySymbol"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, currencySymbol) - 88usize]; + ["Offset of field: Il2CppNumberFormatInfo::ansiCurrencySymbol"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, ansiCurrencySymbol) - 96usize]; + ["Offset of field: Il2CppNumberFormatInfo::naNSymbol"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, naNSymbol) - 104usize]; + ["Offset of field: Il2CppNumberFormatInfo::positiveInfinitySymbol"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, positiveInfinitySymbol) - 112usize]; + ["Offset of field: Il2CppNumberFormatInfo::negativeInfinitySymbol"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, negativeInfinitySymbol) - 120usize]; + ["Offset of field: Il2CppNumberFormatInfo::percentDecimalSeparator"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, percentDecimalSeparator) - 128usize]; + ["Offset of field: Il2CppNumberFormatInfo::percentGroupSeparator"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, percentGroupSeparator) - 136usize]; + ["Offset of field: Il2CppNumberFormatInfo::percentSymbol"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, percentSymbol) - 144usize]; + ["Offset of field: Il2CppNumberFormatInfo::perMilleSymbol"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, perMilleSymbol) - 152usize]; + ["Offset of field: Il2CppNumberFormatInfo::nativeDigits"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, nativeDigits) - 160usize]; + ["Offset of field: Il2CppNumberFormatInfo::dataItem"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, dataItem) - 168usize]; + ["Offset of field: Il2CppNumberFormatInfo::numberDecimalDigits"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, numberDecimalDigits) - 172usize]; + ["Offset of field: Il2CppNumberFormatInfo::currencyDecimalDigits"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, currencyDecimalDigits) - 176usize]; + ["Offset of field: Il2CppNumberFormatInfo::currencyPositivePattern"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, currencyPositivePattern) - 180usize]; + ["Offset of field: Il2CppNumberFormatInfo::currencyNegativePattern"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, currencyNegativePattern) - 184usize]; + ["Offset of field: Il2CppNumberFormatInfo::numberNegativePattern"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, numberNegativePattern) - 188usize]; + ["Offset of field: Il2CppNumberFormatInfo::percentPositivePattern"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, percentPositivePattern) - 192usize]; + ["Offset of field: Il2CppNumberFormatInfo::percentNegativePattern"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, percentNegativePattern) - 196usize]; + ["Offset of field: Il2CppNumberFormatInfo::percentDecimalDigits"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, percentDecimalDigits) - 200usize]; + ["Offset of field: Il2CppNumberFormatInfo::digitSubstitution"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, digitSubstitution) - 204usize]; + ["Offset of field: Il2CppNumberFormatInfo::readOnly"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, readOnly) - 208usize]; + ["Offset of field: Il2CppNumberFormatInfo::useUserOverride"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, useUserOverride) - 209usize]; + ["Offset of field: Il2CppNumberFormatInfo::isInvariant"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, isInvariant) - 210usize]; + ["Offset of field: Il2CppNumberFormatInfo::validForParseAsNumber"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, validForParseAsNumber) - 211usize]; + ["Offset of field: Il2CppNumberFormatInfo::validForParseAsCurrency"] + [::std::mem::offset_of!(Il2CppNumberFormatInfo, validForParseAsCurrency) - 212usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of NumberFormatEntryManaged"] + [::std::mem::size_of::() - 92usize]; + ["Alignment of NumberFormatEntryManaged"] + [::std::mem::align_of::() - 4usize]; + ["Offset of field: NumberFormatEntryManaged::currency_decimal_digits"] + [::std::mem::offset_of!(NumberFormatEntryManaged, currency_decimal_digits) - 0usize]; + ["Offset of field: NumberFormatEntryManaged::currency_decimal_separator"] + [::std::mem::offset_of!(NumberFormatEntryManaged, currency_decimal_separator) - 4usize]; + ["Offset of field: NumberFormatEntryManaged::currency_group_separator"] + [::std::mem::offset_of!(NumberFormatEntryManaged, currency_group_separator) - 8usize]; + ["Offset of field: NumberFormatEntryManaged::currency_group_sizes0"] + [::std::mem::offset_of!(NumberFormatEntryManaged, currency_group_sizes0) - 12usize]; + ["Offset of field: NumberFormatEntryManaged::currency_group_sizes1"] + [::std::mem::offset_of!(NumberFormatEntryManaged, currency_group_sizes1) - 16usize]; + ["Offset of field: NumberFormatEntryManaged::currency_negative_pattern"] + [::std::mem::offset_of!(NumberFormatEntryManaged, currency_negative_pattern) - 20usize]; + ["Offset of field: NumberFormatEntryManaged::currency_positive_pattern"] + [::std::mem::offset_of!(NumberFormatEntryManaged, currency_positive_pattern) - 24usize]; + ["Offset of field: NumberFormatEntryManaged::currency_symbol"] + [::std::mem::offset_of!(NumberFormatEntryManaged, currency_symbol) - 28usize]; + ["Offset of field: NumberFormatEntryManaged::nan_symbol"] + [::std::mem::offset_of!(NumberFormatEntryManaged, nan_symbol) - 32usize]; + ["Offset of field: NumberFormatEntryManaged::negative_infinity_symbol"] + [::std::mem::offset_of!(NumberFormatEntryManaged, negative_infinity_symbol) - 36usize]; + ["Offset of field: NumberFormatEntryManaged::negative_sign"] + [::std::mem::offset_of!(NumberFormatEntryManaged, negative_sign) - 40usize]; + ["Offset of field: NumberFormatEntryManaged::number_decimal_digits"] + [::std::mem::offset_of!(NumberFormatEntryManaged, number_decimal_digits) - 44usize]; + ["Offset of field: NumberFormatEntryManaged::number_decimal_separator"] + [::std::mem::offset_of!(NumberFormatEntryManaged, number_decimal_separator) - 48usize]; + ["Offset of field: NumberFormatEntryManaged::number_group_separator"] + [::std::mem::offset_of!(NumberFormatEntryManaged, number_group_separator) - 52usize]; + ["Offset of field: NumberFormatEntryManaged::number_group_sizes0"] + [::std::mem::offset_of!(NumberFormatEntryManaged, number_group_sizes0) - 56usize]; + ["Offset of field: NumberFormatEntryManaged::number_group_sizes1"] + [::std::mem::offset_of!(NumberFormatEntryManaged, number_group_sizes1) - 60usize]; + ["Offset of field: NumberFormatEntryManaged::number_negative_pattern"] + [::std::mem::offset_of!(NumberFormatEntryManaged, number_negative_pattern) - 64usize]; + ["Offset of field: NumberFormatEntryManaged::per_mille_symbol"] + [::std::mem::offset_of!(NumberFormatEntryManaged, per_mille_symbol) - 68usize]; + ["Offset of field: NumberFormatEntryManaged::percent_negative_pattern"] + [::std::mem::offset_of!(NumberFormatEntryManaged, percent_negative_pattern) - 72usize]; + ["Offset of field: NumberFormatEntryManaged::percent_positive_pattern"] + [::std::mem::offset_of!(NumberFormatEntryManaged, percent_positive_pattern) - 76usize]; + ["Offset of field: NumberFormatEntryManaged::percent_symbol"] + [::std::mem::offset_of!(NumberFormatEntryManaged, percent_symbol) - 80usize]; + ["Offset of field: NumberFormatEntryManaged::positive_infinity_symbol"] + [::std::mem::offset_of!(NumberFormatEntryManaged, positive_infinity_symbol) - 84usize]; + ["Offset of field: NumberFormatEntryManaged::positive_sign"] + [::std::mem::offset_of!(NumberFormatEntryManaged, positive_sign) - 88usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppCultureData"][::std::mem::size_of::() - 64usize]; + ["Alignment of Il2CppCultureData"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppCultureData::obj"] + [::std::mem::offset_of!(Il2CppCultureData, obj) - 0usize]; + ["Offset of field: Il2CppCultureData::AMDesignator"] + [::std::mem::offset_of!(Il2CppCultureData, AMDesignator) - 16usize]; + ["Offset of field: Il2CppCultureData::PMDesignator"] + [::std::mem::offset_of!(Il2CppCultureData, PMDesignator) - 24usize]; + ["Offset of field: Il2CppCultureData::TimeSeparator"] + [::std::mem::offset_of!(Il2CppCultureData, TimeSeparator) - 32usize]; + ["Offset of field: Il2CppCultureData::LongTimePatterns"] + [::std::mem::offset_of!(Il2CppCultureData, LongTimePatterns) - 40usize]; + ["Offset of field: Il2CppCultureData::ShortTimePatterns"] + [::std::mem::offset_of!(Il2CppCultureData, ShortTimePatterns) - 48usize]; + ["Offset of field: Il2CppCultureData::FirstDayOfWeek"] + [::std::mem::offset_of!(Il2CppCultureData, FirstDayOfWeek) - 56usize]; + ["Offset of field: Il2CppCultureData::CalendarWeekRule"] + [::std::mem::offset_of!(Il2CppCultureData, CalendarWeekRule) - 60usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppCalendarData"][::std::mem::size_of::() - 136usize]; + ["Alignment of Il2CppCalendarData"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppCalendarData::obj"] + [::std::mem::offset_of!(Il2CppCalendarData, obj) - 0usize]; + ["Offset of field: Il2CppCalendarData::NativeName"] + [::std::mem::offset_of!(Il2CppCalendarData, NativeName) - 16usize]; + ["Offset of field: Il2CppCalendarData::ShortDatePatterns"] + [::std::mem::offset_of!(Il2CppCalendarData, ShortDatePatterns) - 24usize]; + ["Offset of field: Il2CppCalendarData::YearMonthPatterns"] + [::std::mem::offset_of!(Il2CppCalendarData, YearMonthPatterns) - 32usize]; + ["Offset of field: Il2CppCalendarData::LongDatePatterns"] + [::std::mem::offset_of!(Il2CppCalendarData, LongDatePatterns) - 40usize]; + ["Offset of field: Il2CppCalendarData::MonthDayPattern"] + [::std::mem::offset_of!(Il2CppCalendarData, MonthDayPattern) - 48usize]; + ["Offset of field: Il2CppCalendarData::EraNames"] + [::std::mem::offset_of!(Il2CppCalendarData, EraNames) - 56usize]; + ["Offset of field: Il2CppCalendarData::AbbreviatedEraNames"] + [::std::mem::offset_of!(Il2CppCalendarData, AbbreviatedEraNames) - 64usize]; + ["Offset of field: Il2CppCalendarData::AbbreviatedEnglishEraNames"] + [::std::mem::offset_of!(Il2CppCalendarData, AbbreviatedEnglishEraNames) - 72usize]; + ["Offset of field: Il2CppCalendarData::DayNames"] + [::std::mem::offset_of!(Il2CppCalendarData, DayNames) - 80usize]; + ["Offset of field: Il2CppCalendarData::AbbreviatedDayNames"] + [::std::mem::offset_of!(Il2CppCalendarData, AbbreviatedDayNames) - 88usize]; + ["Offset of field: Il2CppCalendarData::SuperShortDayNames"] + [::std::mem::offset_of!(Il2CppCalendarData, SuperShortDayNames) - 96usize]; + ["Offset of field: Il2CppCalendarData::MonthNames"] + [::std::mem::offset_of!(Il2CppCalendarData, MonthNames) - 104usize]; + ["Offset of field: Il2CppCalendarData::AbbreviatedMonthNames"] + [::std::mem::offset_of!(Il2CppCalendarData, AbbreviatedMonthNames) - 112usize]; + ["Offset of field: Il2CppCalendarData::GenitiveMonthNames"] + [::std::mem::offset_of!(Il2CppCalendarData, GenitiveMonthNames) - 120usize]; + ["Offset of field: Il2CppCalendarData::GenitiveAbbreviatedMonthNames"] + [::std::mem::offset_of!(Il2CppCalendarData, GenitiveAbbreviatedMonthNames) - 128usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppCultureInfo"][::std::mem::size_of::() - 208usize]; + ["Alignment of Il2CppCultureInfo"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppCultureInfo::obj"] + [::std::mem::offset_of!(Il2CppCultureInfo, obj) - 0usize]; + ["Offset of field: Il2CppCultureInfo::is_read_only"] + [::std::mem::offset_of!(Il2CppCultureInfo, is_read_only) - 16usize]; + ["Offset of field: Il2CppCultureInfo::lcid"] + [::std::mem::offset_of!(Il2CppCultureInfo, lcid) - 20usize]; + ["Offset of field: Il2CppCultureInfo::parent_lcid"] + [::std::mem::offset_of!(Il2CppCultureInfo, parent_lcid) - 24usize]; + ["Offset of field: Il2CppCultureInfo::datetime_index"] + [::std::mem::offset_of!(Il2CppCultureInfo, datetime_index) - 28usize]; + ["Offset of field: Il2CppCultureInfo::number_index"] + [::std::mem::offset_of!(Il2CppCultureInfo, number_index) - 32usize]; + ["Offset of field: Il2CppCultureInfo::default_calendar_type"] + [::std::mem::offset_of!(Il2CppCultureInfo, default_calendar_type) - 36usize]; + ["Offset of field: Il2CppCultureInfo::use_user_override"] + [::std::mem::offset_of!(Il2CppCultureInfo, use_user_override) - 40usize]; + ["Offset of field: Il2CppCultureInfo::number_format"] + [::std::mem::offset_of!(Il2CppCultureInfo, number_format) - 48usize]; + ["Offset of field: Il2CppCultureInfo::datetime_format"] + [::std::mem::offset_of!(Il2CppCultureInfo, datetime_format) - 56usize]; + ["Offset of field: Il2CppCultureInfo::textinfo"] + [::std::mem::offset_of!(Il2CppCultureInfo, textinfo) - 64usize]; + ["Offset of field: Il2CppCultureInfo::name"] + [::std::mem::offset_of!(Il2CppCultureInfo, name) - 72usize]; + ["Offset of field: Il2CppCultureInfo::englishname"] + [::std::mem::offset_of!(Il2CppCultureInfo, englishname) - 80usize]; + ["Offset of field: Il2CppCultureInfo::nativename"] + [::std::mem::offset_of!(Il2CppCultureInfo, nativename) - 88usize]; + ["Offset of field: Il2CppCultureInfo::iso3lang"] + [::std::mem::offset_of!(Il2CppCultureInfo, iso3lang) - 96usize]; + ["Offset of field: Il2CppCultureInfo::iso2lang"] + [::std::mem::offset_of!(Il2CppCultureInfo, iso2lang) - 104usize]; + ["Offset of field: Il2CppCultureInfo::win3lang"] + [::std::mem::offset_of!(Il2CppCultureInfo, win3lang) - 112usize]; + ["Offset of field: Il2CppCultureInfo::territory"] + [::std::mem::offset_of!(Il2CppCultureInfo, territory) - 120usize]; + ["Offset of field: Il2CppCultureInfo::native_calendar_names"] + [::std::mem::offset_of!(Il2CppCultureInfo, native_calendar_names) - 128usize]; + ["Offset of field: Il2CppCultureInfo::compareinfo"] + [::std::mem::offset_of!(Il2CppCultureInfo, compareinfo) - 136usize]; + ["Offset of field: Il2CppCultureInfo::text_info_data"] + [::std::mem::offset_of!(Il2CppCultureInfo, text_info_data) - 144usize]; + ["Offset of field: Il2CppCultureInfo::dataItem"] + [::std::mem::offset_of!(Il2CppCultureInfo, dataItem) - 152usize]; + ["Offset of field: Il2CppCultureInfo::calendar"] + [::std::mem::offset_of!(Il2CppCultureInfo, calendar) - 160usize]; + ["Offset of field: Il2CppCultureInfo::parent_culture"] + [::std::mem::offset_of!(Il2CppCultureInfo, parent_culture) - 168usize]; + ["Offset of field: Il2CppCultureInfo::constructed"] + [::std::mem::offset_of!(Il2CppCultureInfo, constructed) - 176usize]; + ["Offset of field: Il2CppCultureInfo::cached_serialized_form"] + [::std::mem::offset_of!(Il2CppCultureInfo, cached_serialized_form) - 184usize]; + ["Offset of field: Il2CppCultureInfo::cultureData"] + [::std::mem::offset_of!(Il2CppCultureInfo, cultureData) - 192usize]; + ["Offset of field: Il2CppCultureInfo::isInherited"] + [::std::mem::offset_of!(Il2CppCultureInfo, isInherited) - 200usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppRegionInfo"][::std::mem::size_of::() - 96usize]; + ["Alignment of Il2CppRegionInfo"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppRegionInfo::obj"] + [::std::mem::offset_of!(Il2CppRegionInfo, obj) - 0usize]; + ["Offset of field: Il2CppRegionInfo::geo_id"] + [::std::mem::offset_of!(Il2CppRegionInfo, geo_id) - 16usize]; + ["Offset of field: Il2CppRegionInfo::iso2name"] + [::std::mem::offset_of!(Il2CppRegionInfo, iso2name) - 24usize]; + ["Offset of field: Il2CppRegionInfo::iso3name"] + [::std::mem::offset_of!(Il2CppRegionInfo, iso3name) - 32usize]; + ["Offset of field: Il2CppRegionInfo::win3name"] + [::std::mem::offset_of!(Il2CppRegionInfo, win3name) - 40usize]; + ["Offset of field: Il2CppRegionInfo::english_name"] + [::std::mem::offset_of!(Il2CppRegionInfo, english_name) - 48usize]; + ["Offset of field: Il2CppRegionInfo::native_name"] + [::std::mem::offset_of!(Il2CppRegionInfo, native_name) - 56usize]; + ["Offset of field: Il2CppRegionInfo::currency_symbol"] + [::std::mem::offset_of!(Il2CppRegionInfo, currency_symbol) - 64usize]; + ["Offset of field: Il2CppRegionInfo::iso_currency_symbol"] + [::std::mem::offset_of!(Il2CppRegionInfo, iso_currency_symbol) - 72usize]; + ["Offset of field: Il2CppRegionInfo::currency_english_name"] + [::std::mem::offset_of!(Il2CppRegionInfo, currency_english_name) - 80usize]; + ["Offset of field: Il2CppRegionInfo::currency_native_name"] + [::std::mem::offset_of!(Il2CppRegionInfo, currency_native_name) - 88usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppSafeHandle"][::std::mem::size_of::() - 32usize]; + ["Alignment of Il2CppSafeHandle"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppSafeHandle::base"] + [::std::mem::offset_of!(Il2CppSafeHandle, base) - 0usize]; + ["Offset of field: Il2CppSafeHandle::handle"] + [::std::mem::offset_of!(Il2CppSafeHandle, handle) - 16usize]; + ["Offset of field: Il2CppSafeHandle::state"] + [::std::mem::offset_of!(Il2CppSafeHandle, state) - 24usize]; + ["Offset of field: Il2CppSafeHandle::owns_handle"] + [::std::mem::offset_of!(Il2CppSafeHandle, owns_handle) - 28usize]; + ["Offset of field: Il2CppSafeHandle::fullyInitialized"] + [::std::mem::offset_of!(Il2CppSafeHandle, fullyInitialized) - 29usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppStringBuilder"][::std::mem::size_of::() - 48usize]; + ["Alignment of Il2CppStringBuilder"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppStringBuilder::object"] + [::std::mem::offset_of!(Il2CppStringBuilder, object) - 0usize]; + ["Offset of field: Il2CppStringBuilder::chunkChars"] + [::std::mem::offset_of!(Il2CppStringBuilder, chunkChars) - 16usize]; + ["Offset of field: Il2CppStringBuilder::chunkPrevious"] + [::std::mem::offset_of!(Il2CppStringBuilder, chunkPrevious) - 24usize]; + ["Offset of field: Il2CppStringBuilder::chunkLength"] + [::std::mem::offset_of!(Il2CppStringBuilder, chunkLength) - 32usize]; + ["Offset of field: Il2CppStringBuilder::chunkOffset"] + [::std::mem::offset_of!(Il2CppStringBuilder, chunkOffset) - 36usize]; + ["Offset of field: Il2CppStringBuilder::maxCapacity"] + [::std::mem::offset_of!(Il2CppStringBuilder, maxCapacity) - 40usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppSocketAddress"][::std::mem::size_of::() - 40usize]; + ["Alignment of Il2CppSocketAddress"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppSocketAddress::base"] + [::std::mem::offset_of!(Il2CppSocketAddress, base) - 0usize]; + ["Offset of field: Il2CppSocketAddress::m_Size"] + [::std::mem::offset_of!(Il2CppSocketAddress, m_Size) - 16usize]; + ["Offset of field: Il2CppSocketAddress::data"] + [::std::mem::offset_of!(Il2CppSocketAddress, data) - 24usize]; + ["Offset of field: Il2CppSocketAddress::m_changed"] + [::std::mem::offset_of!(Il2CppSocketAddress, m_changed) - 32usize]; + ["Offset of field: Il2CppSocketAddress::m_hash"] + [::std::mem::offset_of!(Il2CppSocketAddress, m_hash) - 36usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppSortKey"][::std::mem::size_of::() - 40usize]; + ["Alignment of Il2CppSortKey"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppSortKey::base"][::std::mem::offset_of!(Il2CppSortKey, base) - 0usize]; + ["Offset of field: Il2CppSortKey::str_"][::std::mem::offset_of!(Il2CppSortKey, str_) - 16usize]; + ["Offset of field: Il2CppSortKey::key"][::std::mem::offset_of!(Il2CppSortKey, key) - 24usize]; + ["Offset of field: Il2CppSortKey::options"] + [::std::mem::offset_of!(Il2CppSortKey, options) - 32usize]; + ["Offset of field: Il2CppSortKey::lcid"][::std::mem::offset_of!(Il2CppSortKey, lcid) - 36usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppErrorWrapper"][::std::mem::size_of::() - 24usize]; + ["Alignment of Il2CppErrorWrapper"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppErrorWrapper::base"] + [::std::mem::offset_of!(Il2CppErrorWrapper, base) - 0usize]; + ["Offset of field: Il2CppErrorWrapper::errorCode"] + [::std::mem::offset_of!(Il2CppErrorWrapper, errorCode) - 16usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppAsyncResult"][::std::mem::size_of::() - 88usize]; + ["Alignment of Il2CppAsyncResult"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppAsyncResult::base"] + [::std::mem::offset_of!(Il2CppAsyncResult, base) - 0usize]; + ["Offset of field: Il2CppAsyncResult::async_state"] + [::std::mem::offset_of!(Il2CppAsyncResult, async_state) - 16usize]; + ["Offset of field: Il2CppAsyncResult::handle"] + [::std::mem::offset_of!(Il2CppAsyncResult, handle) - 24usize]; + ["Offset of field: Il2CppAsyncResult::async_delegate"] + [::std::mem::offset_of!(Il2CppAsyncResult, async_delegate) - 32usize]; + ["Offset of field: Il2CppAsyncResult::data"] + [::std::mem::offset_of!(Il2CppAsyncResult, data) - 40usize]; + ["Offset of field: Il2CppAsyncResult::object_data"] + [::std::mem::offset_of!(Il2CppAsyncResult, object_data) - 48usize]; + ["Offset of field: Il2CppAsyncResult::sync_completed"] + [::std::mem::offset_of!(Il2CppAsyncResult, sync_completed) - 56usize]; + ["Offset of field: Il2CppAsyncResult::completed"] + [::std::mem::offset_of!(Il2CppAsyncResult, completed) - 57usize]; + ["Offset of field: Il2CppAsyncResult::endinvoke_called"] + [::std::mem::offset_of!(Il2CppAsyncResult, endinvoke_called) - 58usize]; + ["Offset of field: Il2CppAsyncResult::async_callback"] + [::std::mem::offset_of!(Il2CppAsyncResult, async_callback) - 64usize]; + ["Offset of field: Il2CppAsyncResult::execution_context"] + [::std::mem::offset_of!(Il2CppAsyncResult, execution_context) - 72usize]; + ["Offset of field: Il2CppAsyncResult::original_context"] + [::std::mem::offset_of!(Il2CppAsyncResult, original_context) - 80usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppAsyncCall"][::std::mem::size_of::() - 64usize]; + ["Alignment of Il2CppAsyncCall"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppAsyncCall::base"] + [::std::mem::offset_of!(Il2CppAsyncCall, base) - 0usize]; + ["Offset of field: Il2CppAsyncCall::msg"] + [::std::mem::offset_of!(Il2CppAsyncCall, msg) - 16usize]; + ["Offset of field: Il2CppAsyncCall::cb_method"] + [::std::mem::offset_of!(Il2CppAsyncCall, cb_method) - 24usize]; + ["Offset of field: Il2CppAsyncCall::cb_target"] + [::std::mem::offset_of!(Il2CppAsyncCall, cb_target) - 32usize]; + ["Offset of field: Il2CppAsyncCall::state"] + [::std::mem::offset_of!(Il2CppAsyncCall, state) - 40usize]; + ["Offset of field: Il2CppAsyncCall::res"] + [::std::mem::offset_of!(Il2CppAsyncCall, res) - 48usize]; + ["Offset of field: Il2CppAsyncCall::out_args"] + [::std::mem::offset_of!(Il2CppAsyncCall, out_args) - 56usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppExceptionWrapper"][::std::mem::size_of::() - 8usize]; + ["Alignment of Il2CppExceptionWrapper"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppExceptionWrapper::ex"] + [::std::mem::offset_of!(Il2CppExceptionWrapper, ex) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppIOAsyncResult"][::std::mem::size_of::() - 48usize]; + ["Alignment of Il2CppIOAsyncResult"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppIOAsyncResult::base"] + [::std::mem::offset_of!(Il2CppIOAsyncResult, base) - 0usize]; + ["Offset of field: Il2CppIOAsyncResult::callback"] + [::std::mem::offset_of!(Il2CppIOAsyncResult, callback) - 16usize]; + ["Offset of field: Il2CppIOAsyncResult::state"] + [::std::mem::offset_of!(Il2CppIOAsyncResult, state) - 24usize]; + ["Offset of field: Il2CppIOAsyncResult::wait_handle"] + [::std::mem::offset_of!(Il2CppIOAsyncResult, wait_handle) - 32usize]; + ["Offset of field: Il2CppIOAsyncResult::completed_synchronously"] + [::std::mem::offset_of!(Il2CppIOAsyncResult, completed_synchronously) - 40usize]; + ["Offset of field: Il2CppIOAsyncResult::completed"] + [::std::mem::offset_of!(Il2CppIOAsyncResult, completed) - 41usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppSocketAsyncResult"] + [::std::mem::size_of::() - 168usize]; + ["Alignment of Il2CppSocketAsyncResult"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppSocketAsyncResult::base"] + [::std::mem::offset_of!(Il2CppSocketAsyncResult, base) - 0usize]; + ["Offset of field: Il2CppSocketAsyncResult::socket"] + [::std::mem::offset_of!(Il2CppSocketAsyncResult, socket) - 48usize]; + ["Offset of field: Il2CppSocketAsyncResult::operation"] + [::std::mem::offset_of!(Il2CppSocketAsyncResult, operation) - 56usize]; + ["Offset of field: Il2CppSocketAsyncResult::delayedException"] + [::std::mem::offset_of!(Il2CppSocketAsyncResult, delayedException) - 64usize]; + ["Offset of field: Il2CppSocketAsyncResult::endPoint"] + [::std::mem::offset_of!(Il2CppSocketAsyncResult, endPoint) - 72usize]; + ["Offset of field: Il2CppSocketAsyncResult::buffer"] + [::std::mem::offset_of!(Il2CppSocketAsyncResult, buffer) - 80usize]; + ["Offset of field: Il2CppSocketAsyncResult::offset"] + [::std::mem::offset_of!(Il2CppSocketAsyncResult, offset) - 88usize]; + ["Offset of field: Il2CppSocketAsyncResult::size"] + [::std::mem::offset_of!(Il2CppSocketAsyncResult, size) - 92usize]; + ["Offset of field: Il2CppSocketAsyncResult::socket_flags"] + [::std::mem::offset_of!(Il2CppSocketAsyncResult, socket_flags) - 96usize]; + ["Offset of field: Il2CppSocketAsyncResult::acceptSocket"] + [::std::mem::offset_of!(Il2CppSocketAsyncResult, acceptSocket) - 104usize]; + ["Offset of field: Il2CppSocketAsyncResult::addresses"] + [::std::mem::offset_of!(Il2CppSocketAsyncResult, addresses) - 112usize]; + ["Offset of field: Il2CppSocketAsyncResult::port"] + [::std::mem::offset_of!(Il2CppSocketAsyncResult, port) - 120usize]; + ["Offset of field: Il2CppSocketAsyncResult::buffers"] + [::std::mem::offset_of!(Il2CppSocketAsyncResult, buffers) - 128usize]; + ["Offset of field: Il2CppSocketAsyncResult::reuseSocket"] + [::std::mem::offset_of!(Il2CppSocketAsyncResult, reuseSocket) - 136usize]; + ["Offset of field: Il2CppSocketAsyncResult::currentAddress"] + [::std::mem::offset_of!(Il2CppSocketAsyncResult, currentAddress) - 140usize]; + ["Offset of field: Il2CppSocketAsyncResult::acceptedSocket"] + [::std::mem::offset_of!(Il2CppSocketAsyncResult, acceptedSocket) - 144usize]; + ["Offset of field: Il2CppSocketAsyncResult::total"] + [::std::mem::offset_of!(Il2CppSocketAsyncResult, total) - 152usize]; + ["Offset of field: Il2CppSocketAsyncResult::error"] + [::std::mem::offset_of!(Il2CppSocketAsyncResult, error) - 156usize]; + ["Offset of field: Il2CppSocketAsyncResult::endCalled"] + [::std::mem::offset_of!(Il2CppSocketAsyncResult, endCalled) - 160usize]; +}; +pub const Il2CppResourceLocation_IL2CPP_RESOURCE_LOCATION_EMBEDDED: Il2CppResourceLocation = 1; +pub const Il2CppResourceLocation_IL2CPP_RESOURCE_LOCATION_ANOTHER_ASSEMBLY: Il2CppResourceLocation = + 2; +pub const Il2CppResourceLocation_IL2CPP_RESOURCE_LOCATION_IN_MANIFEST: Il2CppResourceLocation = 4; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppManifestResourceInfo"] + [::std::mem::size_of::() - 40usize]; + ["Alignment of Il2CppManifestResourceInfo"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppManifestResourceInfo::object"] + [::std::mem::offset_of!(Il2CppManifestResourceInfo, object) - 0usize]; + ["Offset of field: Il2CppManifestResourceInfo::assembly"] + [::std::mem::offset_of!(Il2CppManifestResourceInfo, assembly) - 16usize]; + ["Offset of field: Il2CppManifestResourceInfo::filename"] + [::std::mem::offset_of!(Il2CppManifestResourceInfo, filename) - 24usize]; + ["Offset of field: Il2CppManifestResourceInfo::location"] + [::std::mem::offset_of!(Il2CppManifestResourceInfo, location) - 32usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppAppContext"][::std::mem::size_of::() - 32usize]; + ["Alignment of Il2CppAppContext"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppAppContext::obj"] + [::std::mem::offset_of!(Il2CppAppContext, obj) - 0usize]; + ["Offset of field: Il2CppAppContext::domain_id"] + [::std::mem::offset_of!(Il2CppAppContext, domain_id) - 16usize]; + ["Offset of field: Il2CppAppContext::context_id"] + [::std::mem::offset_of!(Il2CppAppContext, context_id) - 20usize]; + ["Offset of field: Il2CppAppContext::static_data"] + [::std::mem::offset_of!(Il2CppAppContext, static_data) - 24usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppDecimal__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::size_of::() - 2usize]; + ["Alignment of Il2CppDecimal__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::align_of::() - 1usize]; + ["Offset of field: Il2CppDecimal__bindgen_ty_1__bindgen_ty_1::scale"] + [::std::mem::offset_of!(Il2CppDecimal__bindgen_ty_1__bindgen_ty_1, scale) - 0usize]; + ["Offset of field: Il2CppDecimal__bindgen_ty_1__bindgen_ty_1::sign"] + [::std::mem::offset_of!(Il2CppDecimal__bindgen_ty_1__bindgen_ty_1, sign) - 1usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppDecimal__bindgen_ty_1"] + [::std::mem::size_of::() - 2usize]; + ["Alignment of Il2CppDecimal__bindgen_ty_1"] + [::std::mem::align_of::() - 2usize]; + ["Offset of field: Il2CppDecimal__bindgen_ty_1::u"] + [::std::mem::offset_of!(Il2CppDecimal__bindgen_ty_1, u) - 0usize]; + ["Offset of field: Il2CppDecimal__bindgen_ty_1::signscale"] + [::std::mem::offset_of!(Il2CppDecimal__bindgen_ty_1, signscale) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppDecimal__bindgen_ty_2__bindgen_ty_1"] + [::std::mem::size_of::() - 8usize]; + ["Alignment of Il2CppDecimal__bindgen_ty_2__bindgen_ty_1"] + [::std::mem::align_of::() - 4usize]; + ["Offset of field: Il2CppDecimal__bindgen_ty_2__bindgen_ty_1::Lo32"] + [::std::mem::offset_of!(Il2CppDecimal__bindgen_ty_2__bindgen_ty_1, Lo32) - 0usize]; + ["Offset of field: Il2CppDecimal__bindgen_ty_2__bindgen_ty_1::Mid32"] + [::std::mem::offset_of!(Il2CppDecimal__bindgen_ty_2__bindgen_ty_1, Mid32) - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppDecimal__bindgen_ty_2"] + [::std::mem::size_of::() - 8usize]; + ["Alignment of Il2CppDecimal__bindgen_ty_2"] + [::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppDecimal__bindgen_ty_2::v"] + [::std::mem::offset_of!(Il2CppDecimal__bindgen_ty_2, v) - 0usize]; + ["Offset of field: Il2CppDecimal__bindgen_ty_2::Lo64"] + [::std::mem::offset_of!(Il2CppDecimal__bindgen_ty_2, Lo64) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppDecimal"][::std::mem::size_of::() - 16usize]; + ["Alignment of Il2CppDecimal"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppDecimal::reserved"] + [::std::mem::offset_of!(Il2CppDecimal, reserved) - 0usize]; + ["Offset of field: Il2CppDecimal::u"][::std::mem::offset_of!(Il2CppDecimal, u) - 2usize]; + ["Offset of field: Il2CppDecimal::Hi32"][::std::mem::offset_of!(Il2CppDecimal, Hi32) - 4usize]; + ["Offset of field: Il2CppDecimal::v"][::std::mem::offset_of!(Il2CppDecimal, v) - 8usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppDouble"][::std::mem::size_of::() - 8usize]; + ["Alignment of Il2CppDouble"][::std::mem::align_of::() - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppDouble_double"][::std::mem::size_of::() - 8usize]; + ["Alignment of Il2CppDouble_double"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppDouble_double::s"] + [::std::mem::offset_of!(Il2CppDouble_double, s) - 0usize]; + ["Offset of field: Il2CppDouble_double::d"] + [::std::mem::offset_of!(Il2CppDouble_double, d) - 0usize]; +}; +pub const Il2CppDecimalCompareResult_IL2CPP_DECIMAL_CMP_LT: Il2CppDecimalCompareResult = -1; +pub const Il2CppDecimalCompareResult_IL2CPP_DECIMAL_CMP_EQ: Il2CppDecimalCompareResult = 0; +pub const Il2CppDecimalCompareResult_IL2CPP_DECIMAL_CMP_GT: Il2CppDecimalCompareResult = 1; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppSingle"][::std::mem::size_of::() - 4usize]; + ["Alignment of Il2CppSingle"][::std::mem::align_of::() - 4usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppSingle_float"][::std::mem::size_of::() - 4usize]; + ["Alignment of Il2CppSingle_float"][::std::mem::align_of::() - 4usize]; + ["Offset of field: Il2CppSingle_float::s"] + [::std::mem::offset_of!(Il2CppSingle_float, s) - 0usize]; + ["Offset of field: Il2CppSingle_float::f"] + [::std::mem::offset_of!(Il2CppSingle_float, f) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of Il2CppByReference"][::std::mem::size_of::() - 8usize]; + ["Alignment of Il2CppByReference"][::std::mem::align_of::() - 8usize]; + ["Offset of field: Il2CppByReference::value"] + [::std::mem::offset_of!(Il2CppByReference, value) - 0usize]; +}; +#[repr(C)] +#[derive(Copy, Clone)] +pub union Il2CppRGCTXDefinitionData { + pub rgctxDataDummy: i32, + pub __methodIndex: MethodIndex, + pub __typeIndex: TypeIndex, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union Il2CppType__bindgen_ty_1 { + pub dummy: *mut ::std::os::raw::c_void, + pub __klassIndex: TypeDefinitionIndex, + pub typeHandle: Il2CppMetadataTypeHandle, + pub type_: *const Il2CppType, + pub array: *mut Il2CppArrayType, + pub __genericParameterIndex: GenericParameterIndex, + pub genericParameterHandle: Il2CppMetadataGenericParameterHandle, + pub generic_class: *mut Il2CppGenericClass, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union Il2CppHStringHeader__bindgen_ty_1 { + pub Reserved1: *mut ::std::os::raw::c_void, + pub Reserved2: [::std::os::raw::c_char; 24usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union Il2CppWin32Decimal__bindgen_ty_1 { + pub s: Il2CppWin32Decimal__bindgen_ty_1__bindgen_ty_1, + pub signscale: u16, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union Il2CppWin32Decimal__bindgen_ty_2 { + pub s2: Il2CppWin32Decimal__bindgen_ty_2__bindgen_ty_1, + pub lo64: u64, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union Il2CppVariant__bindgen_ty_1 { + pub n2: Il2CppVariant__bindgen_ty_1___tagVARIANT, + pub decVal: Il2CppWin32Decimal, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1 { + pub llVal: i64, + pub lVal: i32, + pub bVal: u8, + pub iVal: i16, + pub fltVal: f32, + pub dblVal: f64, + pub boolVal: IL2CPP_VARIANT_BOOL, + pub scode: i32, + pub cyVal: i64, + pub date: f64, + pub bstrVal: *mut Il2CppChar, + pub punkVal: *mut Il2CppIUnknown, + pub pdispVal: *mut ::std::os::raw::c_void, + pub parray: *mut Il2CppSafeArray, + pub pbVal: *mut u8, + pub piVal: *mut i16, + pub plVal: *mut i32, + pub pllVal: *mut i64, + pub pfltVal: *mut f32, + pub pdblVal: *mut f64, + pub pboolVal: *mut IL2CPP_VARIANT_BOOL, + pub pscode: *mut i32, + pub pcyVal: *mut i64, + pub pdate: *mut f64, + pub pbstrVal: *mut Il2CppChar, + pub ppunkVal: *mut *mut Il2CppIUnknown, + pub ppdispVal: *mut *mut ::std::os::raw::c_void, + pub pparray: *mut *mut Il2CppSafeArray, + pub pvarVal: *mut Il2CppVariant, + pub byref: *mut ::std::os::raw::c_void, + pub cVal: ::std::os::raw::c_char, + pub uiVal: u16, + pub ulVal: u32, + pub ullVal: u64, + pub intVal: ::std::os::raw::c_int, + pub uintVal: ::std::os::raw::c_uint, + pub pdecVal: *mut Il2CppWin32Decimal, + pub pcVal: *mut ::std::os::raw::c_char, + pub puiVal: *mut u16, + pub pulVal: *mut u32, + pub pullVal: *mut u64, + pub pintVal: *mut ::std::os::raw::c_int, + pub puintVal: *mut ::std::os::raw::c_uint, + pub n4: Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1___tagBRECORD, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union Il2CppRGCTXData { + pub rgctxDataDummy: *mut ::std::os::raw::c_void, + pub method: *const MethodInfo, + pub type_: *const Il2CppType, + pub klass: *mut Il2CppClass, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union MethodInfo__bindgen_ty_1 { + pub rgctx_data: *const Il2CppRGCTXData, + pub methodMetadataHandle: Il2CppMetadataMethodDefinitionHandle, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union MethodInfo__bindgen_ty_2 { + pub genericMethod: *const Il2CppGenericMethod, + pub genericContainerHandle: Il2CppMetadataGenericContainerHandle, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union Il2CppObject__bindgen_ty_1 { + pub klass: *mut Il2CppClass, + pub vtable: *mut Il2CppVTable, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union Il2CppDecimal__bindgen_ty_1 { + pub u: Il2CppDecimal__bindgen_ty_1__bindgen_ty_1, + pub signscale: u16, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union Il2CppDecimal__bindgen_ty_2 { + pub v: Il2CppDecimal__bindgen_ty_2__bindgen_ty_1, + pub Lo64: u64, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union Il2CppDouble_double { + pub s: Il2CppDouble, + pub d: f64, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union Il2CppSingle_float { + pub s: Il2CppSingle, + pub f: f32, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { + *byte |= mask; + } else { + *byte &= !mask; + } + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } +} +impl __IncompleteArrayField { + #[inline] + pub const fn new() -> Self { + __IncompleteArrayField(::std::marker::PhantomData, []) + } + #[inline] + pub fn as_ptr(&self) -> *const T { + self as *const _ as *const T + } + #[inline] + pub fn as_mut_ptr(&mut self) -> *mut T { + self as *mut _ as *mut T + } + #[inline] + pub unsafe fn as_slice(&self, len: usize) -> &[T] { + unsafe { ::std::slice::from_raw_parts(self.as_ptr(), len) } + } + #[inline] + pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] { + unsafe { ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len) } + } +} +impl ::std::fmt::Debug for __IncompleteArrayField { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + fmt.write_str("__IncompleteArrayField") + } +} +impl Il2CppType { + #[inline] + pub fn attrs(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32) } + } + #[inline] + pub fn set_attrs(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 16u8, val as u64) + } + } + #[inline] + pub fn type_(&self) -> Il2CppTypeEnum { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u32) } + } + #[inline] + pub fn set_type(&mut self, val: Il2CppTypeEnum) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 8u8, val as u64) + } + } + #[inline] + pub fn num_mods(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 5u8) as u32) } + } + #[inline] + pub fn set_num_mods(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 5u8, val as u64) + } + } + #[inline] + pub fn byref(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) } + } + #[inline] + pub fn set_byref(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(29usize, 1u8, val as u64) + } + } + #[inline] + pub fn pinned(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u32) } + } + #[inline] + pub fn set_pinned(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(30usize, 1u8, val as u64) + } + } + #[inline] + pub fn valuetype(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) } + } + #[inline] + pub fn set_valuetype(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(31usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + attrs: ::std::os::raw::c_uint, + type_: Il2CppTypeEnum, + num_mods: ::std::os::raw::c_uint, + byref: ::std::os::raw::c_uint, + pinned: ::std::os::raw::c_uint, + valuetype: ::std::os::raw::c_uint, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 16u8, { + let attrs: u32 = unsafe { ::std::mem::transmute(attrs) }; + attrs as u64 + }); + __bindgen_bitfield_unit.set(16usize, 8u8, { + let type_: u32 = unsafe { ::std::mem::transmute(type_) }; + type_ as u64 + }); + __bindgen_bitfield_unit.set(24usize, 5u8, { + let num_mods: u32 = unsafe { ::std::mem::transmute(num_mods) }; + num_mods as u64 + }); + __bindgen_bitfield_unit.set(29usize, 1u8, { + let byref: u32 = unsafe { ::std::mem::transmute(byref) }; + byref as u64 + }); + __bindgen_bitfield_unit.set(30usize, 1u8, { + let pinned: u32 = unsafe { ::std::mem::transmute(pinned) }; + pinned as u64 + }); + __bindgen_bitfield_unit.set(31usize, 1u8, { + let valuetype: u32 = unsafe { ::std::mem::transmute(valuetype) }; + valuetype as u64 + }); + __bindgen_bitfield_unit + } +} +impl MethodInfo { + #[inline] + pub fn is_generic(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_is_generic(&mut self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn is_inflated(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) } + } + #[inline] + pub fn set_is_inflated(&mut self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn wrapper_type(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) } + } + #[inline] + pub fn set_wrapper_type(&mut self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn has_full_generic_sharing_signature(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) } + } + #[inline] + pub fn set_has_full_generic_sharing_signature(&mut self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + is_generic: u8, + is_inflated: u8, + wrapper_type: u8, + has_full_generic_sharing_signature: u8, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let is_generic: u8 = unsafe { ::std::mem::transmute(is_generic) }; + is_generic as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let is_inflated: u8 = unsafe { ::std::mem::transmute(is_inflated) }; + is_inflated as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let wrapper_type: u8 = unsafe { ::std::mem::transmute(wrapper_type) }; + wrapper_type as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let has_full_generic_sharing_signature: u8 = + unsafe { ::std::mem::transmute(has_full_generic_sharing_signature) }; + has_full_generic_sharing_signature as u64 + }); + __bindgen_bitfield_unit + } +} +impl Il2CppClass { + #[inline] + pub fn initialized_and_no_error(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_initialized_and_no_error(&mut self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn initialized(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) } + } + #[inline] + pub fn set_initialized(&mut self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn enumtype(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) } + } + #[inline] + pub fn set_enumtype(&mut self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn nullabletype(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) } + } + #[inline] + pub fn set_nullabletype(&mut self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn is_generic(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) } + } + #[inline] + pub fn set_is_generic(&mut self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub fn has_references(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) } + } + #[inline] + pub fn set_has_references(&mut self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub fn init_pending(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u8) } + } + #[inline] + pub fn set_init_pending(&mut self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub fn size_init_pending(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) } + } + #[inline] + pub fn set_size_init_pending(&mut self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub fn size_inited(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u8) } + } + #[inline] + pub fn set_size_inited(&mut self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub fn has_finalize(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u8) } + } + #[inline] + pub fn set_has_finalize(&mut self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 1u8, val as u64) + } + } + #[inline] + pub fn has_cctor(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u8) } + } + #[inline] + pub fn set_has_cctor(&mut self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(10usize, 1u8, val as u64) + } + } + #[inline] + pub fn is_blittable(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u8) } + } + #[inline] + pub fn set_is_blittable(&mut self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub fn is_import_or_windows_runtime(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u8) } + } + #[inline] + pub fn set_is_import_or_windows_runtime(&mut self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 1u8, val as u64) + } + } + #[inline] + pub fn is_vtable_initialized(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u8) } + } + #[inline] + pub fn set_is_vtable_initialized(&mut self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub fn is_byref_like(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u8) } + } + #[inline] + pub fn set_is_byref_like(&mut self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + initialized_and_no_error: u8, + initialized: u8, + enumtype: u8, + nullabletype: u8, + is_generic: u8, + has_references: u8, + init_pending: u8, + size_init_pending: u8, + size_inited: u8, + has_finalize: u8, + has_cctor: u8, + is_blittable: u8, + is_import_or_windows_runtime: u8, + is_vtable_initialized: u8, + is_byref_like: u8, + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let initialized_and_no_error: u8 = + unsafe { ::std::mem::transmute(initialized_and_no_error) }; + initialized_and_no_error as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let initialized: u8 = unsafe { ::std::mem::transmute(initialized) }; + initialized as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let enumtype: u8 = unsafe { ::std::mem::transmute(enumtype) }; + enumtype as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let nullabletype: u8 = unsafe { ::std::mem::transmute(nullabletype) }; + nullabletype as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let is_generic: u8 = unsafe { ::std::mem::transmute(is_generic) }; + is_generic as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let has_references: u8 = unsafe { ::std::mem::transmute(has_references) }; + has_references as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let init_pending: u8 = unsafe { ::std::mem::transmute(init_pending) }; + init_pending as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let size_init_pending: u8 = unsafe { ::std::mem::transmute(size_init_pending) }; + size_init_pending as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let size_inited: u8 = unsafe { ::std::mem::transmute(size_inited) }; + size_inited as u64 + }); + __bindgen_bitfield_unit.set(9usize, 1u8, { + let has_finalize: u8 = unsafe { ::std::mem::transmute(has_finalize) }; + has_finalize as u64 + }); + __bindgen_bitfield_unit.set(10usize, 1u8, { + let has_cctor: u8 = unsafe { ::std::mem::transmute(has_cctor) }; + has_cctor as u64 + }); + __bindgen_bitfield_unit.set(11usize, 1u8, { + let is_blittable: u8 = unsafe { ::std::mem::transmute(is_blittable) }; + is_blittable as u64 + }); + __bindgen_bitfield_unit.set(12usize, 1u8, { + let is_import_or_windows_runtime: u8 = + unsafe { ::std::mem::transmute(is_import_or_windows_runtime) }; + is_import_or_windows_runtime as u64 + }); + __bindgen_bitfield_unit.set(13usize, 1u8, { + let is_vtable_initialized: u8 = unsafe { ::std::mem::transmute(is_vtable_initialized) }; + is_vtable_initialized as u64 + }); + __bindgen_bitfield_unit.set(14usize, 1u8, { + let is_byref_like: u8 = unsafe { ::std::mem::transmute(is_byref_like) }; + is_byref_like as u64 + }); + __bindgen_bitfield_unit + } +} +impl Il2CppDouble { + #[inline] + pub fn mantLo(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 32u8) as u32) } + } + #[inline] + pub fn set_mantLo(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 32u8, val as u64) + } + } + #[inline] + pub fn mantHi(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 20u8) as u32) } + } + #[inline] + pub fn set_mantHi(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(32usize, 20u8, val as u64) + } + } + #[inline] + pub fn exp(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(52usize, 11u8) as u32) } + } + #[inline] + pub fn set_exp(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(52usize, 11u8, val as u64) + } + } + #[inline] + pub fn sign(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(63usize, 1u8) as u32) } + } + #[inline] + pub fn set_sign(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(63usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + mantLo: u32, + mantHi: u32, + exp: u32, + sign: u32, + ) -> __BindgenBitfieldUnit<[u8; 8usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 32u8, { + let mantLo: u32 = unsafe { ::std::mem::transmute(mantLo) }; + mantLo as u64 + }); + __bindgen_bitfield_unit.set(32usize, 20u8, { + let mantHi: u32 = unsafe { ::std::mem::transmute(mantHi) }; + mantHi as u64 + }); + __bindgen_bitfield_unit.set(52usize, 11u8, { + let exp: u32 = unsafe { ::std::mem::transmute(exp) }; + exp as u64 + }); + __bindgen_bitfield_unit.set(63usize, 1u8, { + let sign: u32 = unsafe { ::std::mem::transmute(sign) }; + sign as u64 + }); + __bindgen_bitfield_unit + } +} +impl Il2CppSingle { + #[inline] + pub fn mant(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 23u8) as u32) } + } + #[inline] + pub fn set_mant(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 23u8, val as u64) + } + } + #[inline] + pub fn exp(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 8u8) as u32) } + } + #[inline] + pub fn set_exp(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 8u8, val as u64) + } + } + #[inline] + pub fn sign(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) } + } + #[inline] + pub fn set_sign(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(31usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1(mant: u32, exp: u32, sign: u32) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 23u8, { + let mant: u32 = unsafe { ::std::mem::transmute(mant) }; + mant as u64 + }); + __bindgen_bitfield_unit.set(23usize, 8u8, { + let exp: u32 = unsafe { ::std::mem::transmute(exp) }; + exp as u64 + }); + __bindgen_bitfield_unit.set(31usize, 1u8, { + let sign: u32 = unsafe { ::std::mem::transmute(sign) }; + sign as u64 + }); + __bindgen_bitfield_unit + } +} +extern "C" { + pub fn __va_start(arg1: *mut *mut ::std::os::raw::c_char, ...); +} +extern "C" { + pub fn __security_init_cookie(); +} +extern "C" { + pub fn __security_check_cookie(_StackCookie: usize); +} +extern "C" { + pub fn __report_gsfailure(_StackCookie: usize) -> !; +} +extern "C" { + pub static mut __security_cookie: usize; +} +extern "C" { + pub fn _invalid_parameter_noinfo(); +} +extern "C" { + pub fn _invalid_parameter_noinfo_noreturn() -> !; +} +extern "C" { + pub fn _invoke_watson( + _Expression: *const wchar_t, + _FunctionName: *const wchar_t, + _FileName: *const wchar_t, + _LineNo: ::std::os::raw::c_uint, + _Reserved: usize, + ) -> !; +} +extern "C" { + pub fn _errno() -> *mut ::std::os::raw::c_int; +} +extern "C" { + pub fn _set_errno(_Value: ::std::os::raw::c_int) -> errno_t; +} +extern "C" { + pub fn _get_errno(_Value: *mut ::std::os::raw::c_int) -> errno_t; +} +extern "C" { + pub fn __threadid() -> ::std::os::raw::c_ulong; +} +extern "C" { + pub fn __threadhandle() -> usize; +} +extern "C" { + pub fn _calloc_base(_Count: usize, _Size: usize) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn calloc( + _Count: ::std::os::raw::c_ulonglong, + _Size: ::std::os::raw::c_ulonglong, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn _callnewh(_Size: usize) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _expand( + _Block: *mut ::std::os::raw::c_void, + _Size: usize, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn _free_base(_Block: *mut ::std::os::raw::c_void); +} +extern "C" { + pub fn free(_Block: *mut ::std::os::raw::c_void); +} +extern "C" { + pub fn _malloc_base(_Size: usize) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn malloc(_Size: ::std::os::raw::c_ulonglong) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn _msize_base(_Block: *mut ::std::os::raw::c_void) -> usize; +} +extern "C" { + pub fn _msize(_Block: *mut ::std::os::raw::c_void) -> usize; +} +extern "C" { + pub fn _realloc_base( + _Block: *mut ::std::os::raw::c_void, + _Size: usize, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn realloc( + _Block: *mut ::std::os::raw::c_void, + _Size: ::std::os::raw::c_ulonglong, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn _recalloc_base( + _Block: *mut ::std::os::raw::c_void, + _Count: usize, + _Size: usize, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn _recalloc( + _Block: *mut ::std::os::raw::c_void, + _Count: usize, + _Size: usize, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn _aligned_free(_Block: *mut ::std::os::raw::c_void); +} +extern "C" { + pub fn _aligned_malloc(_Size: usize, _Alignment: usize) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn _aligned_offset_malloc( + _Size: usize, + _Alignment: usize, + _Offset: usize, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn _aligned_msize( + _Block: *mut ::std::os::raw::c_void, + _Alignment: usize, + _Offset: usize, + ) -> usize; +} +extern "C" { + pub fn _aligned_offset_realloc( + _Block: *mut ::std::os::raw::c_void, + _Size: usize, + _Alignment: usize, + _Offset: usize, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn _aligned_offset_recalloc( + _Block: *mut ::std::os::raw::c_void, + _Count: usize, + _Size: usize, + _Alignment: usize, + _Offset: usize, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn _aligned_realloc( + _Block: *mut ::std::os::raw::c_void, + _Size: usize, + _Alignment: usize, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn _aligned_recalloc( + _Block: *mut ::std::os::raw::c_void, + _Count: usize, + _Size: usize, + _Alignment: usize, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn _alloca(_Size: ::std::os::raw::c_ulonglong) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn _get_heap_handle() -> isize; +} +extern "C" { + pub fn _heapmin() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _heapwalk(_EntryInfo: *mut _HEAPINFO) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _heapchk() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _resetstkoflw() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn il2cpp_init(domain_name: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn il2cpp_init_utf16(domain_name: *const Il2CppChar) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn il2cpp_shutdown(); +} +extern "C" { + pub fn il2cpp_set_config_dir(config_path: *const ::std::os::raw::c_char); +} +extern "C" { + pub fn il2cpp_set_data_dir(data_path: *const ::std::os::raw::c_char); +} +extern "C" { + pub fn il2cpp_set_temp_dir(temp_path: *const ::std::os::raw::c_char); +} +extern "C" { + pub fn il2cpp_set_commandline_arguments( + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + basedir: *const ::std::os::raw::c_char, + ); +} +extern "C" { + pub fn il2cpp_set_commandline_arguments_utf16( + argc: ::std::os::raw::c_int, + argv: *const *const Il2CppChar, + basedir: *const ::std::os::raw::c_char, + ); +} +extern "C" { + pub fn il2cpp_set_config_utf16(executablePath: *const Il2CppChar); +} +extern "C" { + pub fn il2cpp_set_config(executablePath: *const ::std::os::raw::c_char); +} +extern "C" { + pub fn il2cpp_set_memory_callbacks(callbacks: *mut Il2CppMemoryCallbacks); +} +extern "C" { + pub fn il2cpp_get_corlib() -> *const Il2CppImage; +} +extern "C" { + pub fn il2cpp_add_internal_call( + name: *const ::std::os::raw::c_char, + method: Il2CppMethodPointer, + ); +} +extern "C" { + pub fn il2cpp_resolve_icall(name: *const ::std::os::raw::c_char) -> Il2CppMethodPointer; +} +extern "C" { + pub fn il2cpp_alloc(size: usize) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn il2cpp_free(ptr: *mut ::std::os::raw::c_void); +} +extern "C" { + pub fn il2cpp_array_class_get(element_class: *mut Il2CppClass, rank: u32) -> *mut Il2CppClass; +} +extern "C" { + pub fn il2cpp_array_length(array: *mut Il2CppArray) -> u32; +} +extern "C" { + pub fn il2cpp_array_get_byte_length(array: *mut Il2CppArray) -> u32; +} +extern "C" { + pub fn il2cpp_array_new( + elementTypeInfo: *mut Il2CppClass, + length: il2cpp_array_size_t, + ) -> *mut Il2CppArray; +} +extern "C" { + pub fn il2cpp_array_new_specific( + arrayTypeInfo: *mut Il2CppClass, + length: il2cpp_array_size_t, + ) -> *mut Il2CppArray; +} +extern "C" { + pub fn il2cpp_array_new_full( + array_class: *mut Il2CppClass, + lengths: *mut il2cpp_array_size_t, + lower_bounds: *mut il2cpp_array_size_t, + ) -> *mut Il2CppArray; +} +extern "C" { + pub fn il2cpp_bounded_array_class_get( + element_class: *mut Il2CppClass, + rank: u32, + bounded: u8, + ) -> *mut Il2CppClass; +} +extern "C" { + pub fn il2cpp_array_element_size(array_class: *const Il2CppClass) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn il2cpp_assembly_get_image(assembly: *const Il2CppAssembly) -> *const Il2CppImage; +} +extern "C" { + pub fn il2cpp_class_for_each( + klassReportFunc: ::std::option::Option< + unsafe extern "C" fn(klass: *mut Il2CppClass, userData: *mut ::std::os::raw::c_void), + >, + userData: *mut ::std::os::raw::c_void, + ); +} +extern "C" { + pub fn il2cpp_class_enum_basetype(klass: *mut Il2CppClass) -> *const Il2CppType; +} +extern "C" { + pub fn il2cpp_class_is_inited(klass: *const Il2CppClass) -> u8; +} +extern "C" { + pub fn il2cpp_class_is_generic(klass: *const Il2CppClass) -> u8; +} +extern "C" { + pub fn il2cpp_class_is_inflated(klass: *const Il2CppClass) -> u8; +} +extern "C" { + pub fn il2cpp_class_is_assignable_from(klass: *mut Il2CppClass, oklass: *mut Il2CppClass) + -> u8; +} +extern "C" { + pub fn il2cpp_class_is_subclass_of( + klass: *mut Il2CppClass, + klassc: *mut Il2CppClass, + check_interfaces: u8, + ) -> u8; +} +extern "C" { + pub fn il2cpp_class_has_parent(klass: *mut Il2CppClass, klassc: *mut Il2CppClass) -> u8; +} +extern "C" { + pub fn il2cpp_class_from_il2cpp_type(type_: *const Il2CppType) -> *mut Il2CppClass; +} +extern "C" { + pub fn il2cpp_class_from_name( + image: *const Il2CppImage, + namespaze: *const ::std::os::raw::c_char, + name: *const ::std::os::raw::c_char, + ) -> *mut Il2CppClass; +} +extern "C" { + pub fn il2cpp_class_from_system_type(type_: *mut Il2CppReflectionType) -> *mut Il2CppClass; +} +extern "C" { + pub fn il2cpp_class_get_element_class(klass: *mut Il2CppClass) -> *mut Il2CppClass; +} +extern "C" { + pub fn il2cpp_class_get_events( + klass: *mut Il2CppClass, + iter: *mut *mut ::std::os::raw::c_void, + ) -> *const EventInfo; +} +extern "C" { + pub fn il2cpp_class_get_fields( + klass: *mut Il2CppClass, + iter: *mut *mut ::std::os::raw::c_void, + ) -> *mut FieldInfo; +} +extern "C" { + pub fn il2cpp_class_get_nested_types( + klass: *mut Il2CppClass, + iter: *mut *mut ::std::os::raw::c_void, + ) -> *mut Il2CppClass; +} +extern "C" { + pub fn il2cpp_class_get_interfaces( + klass: *mut Il2CppClass, + iter: *mut *mut ::std::os::raw::c_void, + ) -> *mut Il2CppClass; +} +extern "C" { + pub fn il2cpp_class_get_properties( + klass: *mut Il2CppClass, + iter: *mut *mut ::std::os::raw::c_void, + ) -> *const PropertyInfo; +} +extern "C" { + pub fn il2cpp_class_get_property_from_name( + klass: *mut Il2CppClass, + name: *const ::std::os::raw::c_char, + ) -> *const PropertyInfo; +} +extern "C" { + pub fn il2cpp_class_get_field_from_name( + klass: *mut Il2CppClass, + name: *const ::std::os::raw::c_char, + ) -> *mut FieldInfo; +} +extern "C" { + pub fn il2cpp_class_get_methods( + klass: *mut Il2CppClass, + iter: *mut *mut ::std::os::raw::c_void, + ) -> *const MethodInfo; +} +extern "C" { + pub fn il2cpp_class_get_method_from_name( + klass: *mut Il2CppClass, + name: *const ::std::os::raw::c_char, + argsCount: ::std::os::raw::c_int, + ) -> *const MethodInfo; +} +extern "C" { + pub fn il2cpp_class_get_name(klass: *mut Il2CppClass) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn il2cpp_type_get_name_chunked( + type_: *const Il2CppType, + chunkReportFunc: ::std::option::Option< + unsafe extern "C" fn( + data: *mut ::std::os::raw::c_void, + userData: *mut ::std::os::raw::c_void, + ), + >, + userData: *mut ::std::os::raw::c_void, + ); +} +extern "C" { + pub fn il2cpp_class_get_namespace(klass: *mut Il2CppClass) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn il2cpp_class_get_parent(klass: *mut Il2CppClass) -> *mut Il2CppClass; +} +extern "C" { + pub fn il2cpp_class_get_declaring_type(klass: *mut Il2CppClass) -> *mut Il2CppClass; +} +extern "C" { + pub fn il2cpp_class_instance_size(klass: *mut Il2CppClass) -> i32; +} +extern "C" { + pub fn il2cpp_class_num_fields(enumKlass: *const Il2CppClass) -> usize; +} +extern "C" { + pub fn il2cpp_class_is_valuetype(klass: *const Il2CppClass) -> u8; +} +extern "C" { + pub fn il2cpp_class_value_size(klass: *mut Il2CppClass, align: *mut u32) -> i32; +} +extern "C" { + pub fn il2cpp_class_is_blittable(klass: *const Il2CppClass) -> u8; +} +extern "C" { + pub fn il2cpp_class_get_flags(klass: *const Il2CppClass) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn il2cpp_class_is_abstract(klass: *const Il2CppClass) -> u8; +} +extern "C" { + pub fn il2cpp_class_is_interface(klass: *const Il2CppClass) -> u8; +} +extern "C" { + pub fn il2cpp_class_array_element_size(klass: *const Il2CppClass) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn il2cpp_class_from_type(type_: *const Il2CppType) -> *mut Il2CppClass; +} +extern "C" { + pub fn il2cpp_class_get_type(klass: *mut Il2CppClass) -> *const Il2CppType; +} +extern "C" { + pub fn il2cpp_class_get_type_token(klass: *mut Il2CppClass) -> u32; +} +extern "C" { + pub fn il2cpp_class_has_attribute(klass: *mut Il2CppClass, attr_class: *mut Il2CppClass) -> u8; +} +extern "C" { + pub fn il2cpp_class_has_references(klass: *mut Il2CppClass) -> u8; +} +extern "C" { + pub fn il2cpp_class_is_enum(klass: *const Il2CppClass) -> u8; +} +extern "C" { + pub fn il2cpp_class_get_image(klass: *mut Il2CppClass) -> *const Il2CppImage; +} +extern "C" { + pub fn il2cpp_class_get_assemblyname( + klass: *const Il2CppClass, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn il2cpp_class_get_rank(klass: *const Il2CppClass) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn il2cpp_class_get_data_size(klass: *const Il2CppClass) -> u32; +} +extern "C" { + pub fn il2cpp_class_get_static_field_data( + klass: *const Il2CppClass, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn il2cpp_class_get_bitmap_size(klass: *const Il2CppClass) -> usize; +} +extern "C" { + pub fn il2cpp_class_get_bitmap(klass: *mut Il2CppClass, bitmap: *mut usize); +} +extern "C" { + pub fn il2cpp_stats_dump_to_file(path: *const ::std::os::raw::c_char) -> u8; +} +extern "C" { + pub fn il2cpp_stats_get_value(stat: Il2CppStat) -> u64; +} +extern "C" { + pub fn il2cpp_domain_get() -> *mut Il2CppDomain; +} +extern "C" { + pub fn il2cpp_domain_assembly_open( + domain: *mut Il2CppDomain, + name: *const ::std::os::raw::c_char, + ) -> *const Il2CppAssembly; +} +extern "C" { + pub fn il2cpp_domain_get_assemblies( + domain: *const Il2CppDomain, + size: *mut usize, + ) -> *mut *const Il2CppAssembly; +} +extern "C" { + pub fn il2cpp_raise_exception(arg1: *mut Il2CppException) -> !; +} +extern "C" { + pub fn il2cpp_exception_from_name_msg( + image: *const Il2CppImage, + name_space: *const ::std::os::raw::c_char, + name: *const ::std::os::raw::c_char, + msg: *const ::std::os::raw::c_char, + ) -> *mut Il2CppException; +} +extern "C" { + pub fn il2cpp_get_exception_argument_null( + arg: *const ::std::os::raw::c_char, + ) -> *mut Il2CppException; +} +extern "C" { + pub fn il2cpp_format_exception( + ex: *const Il2CppException, + message: *mut ::std::os::raw::c_char, + message_size: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn il2cpp_format_stack_trace( + ex: *const Il2CppException, + output: *mut ::std::os::raw::c_char, + output_size: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn il2cpp_unhandled_exception(arg1: *mut Il2CppException); +} +extern "C" { + pub fn il2cpp_native_stack_trace( + ex: *const Il2CppException, + addresses: *mut *mut usize, + numFrames: *mut ::std::os::raw::c_int, + imageUUID: *mut *mut ::std::os::raw::c_char, + imageName: *mut *mut ::std::os::raw::c_char, + ); +} +extern "C" { + pub fn il2cpp_field_get_flags(field: *mut FieldInfo) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn il2cpp_field_get_name(field: *mut FieldInfo) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn il2cpp_field_get_parent(field: *mut FieldInfo) -> *mut Il2CppClass; +} +extern "C" { + pub fn il2cpp_field_get_offset(field: *mut FieldInfo) -> usize; +} +extern "C" { + pub fn il2cpp_field_get_type(field: *mut FieldInfo) -> *const Il2CppType; +} +extern "C" { + pub fn il2cpp_field_get_value( + obj: *mut Il2CppObject, + field: *mut FieldInfo, + value: *mut ::std::os::raw::c_void, + ); +} +extern "C" { + pub fn il2cpp_field_get_value_object( + field: *mut FieldInfo, + obj: *mut Il2CppObject, + ) -> *mut Il2CppObject; +} +extern "C" { + pub fn il2cpp_field_has_attribute(field: *mut FieldInfo, attr_class: *mut Il2CppClass) -> u8; +} +extern "C" { + pub fn il2cpp_field_set_value( + obj: *mut Il2CppObject, + field: *mut FieldInfo, + value: *mut ::std::os::raw::c_void, + ); +} +extern "C" { + pub fn il2cpp_field_static_get_value(field: *mut FieldInfo, value: *mut ::std::os::raw::c_void); +} +extern "C" { + pub fn il2cpp_field_static_set_value(field: *mut FieldInfo, value: *mut ::std::os::raw::c_void); +} +extern "C" { + pub fn il2cpp_field_set_value_object( + instance: *mut Il2CppObject, + field: *mut FieldInfo, + value: *mut Il2CppObject, + ); +} +extern "C" { + pub fn il2cpp_field_is_literal(field: *mut FieldInfo) -> u8; +} +extern "C" { + pub fn il2cpp_gc_collect(maxGenerations: ::std::os::raw::c_int); +} +extern "C" { + pub fn il2cpp_gc_collect_a_little() -> i32; +} +extern "C" { + pub fn il2cpp_gc_start_incremental_collection(); +} +extern "C" { + pub fn il2cpp_gc_disable(); +} +extern "C" { + pub fn il2cpp_gc_enable(); +} +extern "C" { + pub fn il2cpp_gc_is_disabled() -> u8; +} +extern "C" { + pub fn il2cpp_gc_set_mode(mode: Il2CppGCMode); +} +extern "C" { + pub fn il2cpp_gc_get_max_time_slice_ns() -> i64; +} +extern "C" { + pub fn il2cpp_gc_set_max_time_slice_ns(maxTimeSlice: i64); +} +extern "C" { + pub fn il2cpp_gc_is_incremental() -> u8; +} +extern "C" { + pub fn il2cpp_gc_get_used_size() -> i64; +} +extern "C" { + pub fn il2cpp_gc_get_heap_size() -> i64; +} +extern "C" { + pub fn il2cpp_gc_wbarrier_set_field( + obj: *mut Il2CppObject, + targetAddress: *mut *mut ::std::os::raw::c_void, + object: *mut ::std::os::raw::c_void, + ); +} +extern "C" { + pub fn il2cpp_gc_has_strict_wbarriers() -> u8; +} +extern "C" { + pub fn il2cpp_gc_set_external_allocation_tracker( + func: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: usize, + arg3: ::std::os::raw::c_int, + ), + >, + ); +} +extern "C" { + pub fn il2cpp_gc_set_external_wbarrier_tracker( + func: ::std::option::Option, + ); +} +extern "C" { + pub fn il2cpp_gc_foreach_heap( + func: ::std::option::Option< + unsafe extern "C" fn( + data: *mut ::std::os::raw::c_void, + userData: *mut ::std::os::raw::c_void, + ), + >, + userData: *mut ::std::os::raw::c_void, + ); +} +extern "C" { + pub fn il2cpp_stop_gc_world(); +} +extern "C" { + pub fn il2cpp_start_gc_world(); +} +extern "C" { + pub fn il2cpp_gc_alloc_fixed(size: usize) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn il2cpp_gc_free_fixed(address: *mut ::std::os::raw::c_void); +} +extern "C" { + pub fn il2cpp_gchandle_new(obj: *mut Il2CppObject, pinned: u8) -> u32; +} +extern "C" { + pub fn il2cpp_gchandle_new_weakref(obj: *mut Il2CppObject, track_resurrection: u8) -> u32; +} +extern "C" { + pub fn il2cpp_gchandle_get_target(gchandle: u32) -> *mut Il2CppObject; +} +extern "C" { + pub fn il2cpp_gchandle_free(gchandle: u32); +} +extern "C" { + pub fn il2cpp_gchandle_foreach_get_target( + func: ::std::option::Option< + unsafe extern "C" fn( + data: *mut ::std::os::raw::c_void, + userData: *mut ::std::os::raw::c_void, + ), + >, + userData: *mut ::std::os::raw::c_void, + ); +} +extern "C" { + pub fn il2cpp_object_header_size() -> u32; +} +extern "C" { + pub fn il2cpp_array_object_header_size() -> u32; +} +extern "C" { + pub fn il2cpp_offset_of_array_length_in_array_object_header() -> u32; +} +extern "C" { + pub fn il2cpp_offset_of_array_bounds_in_array_object_header() -> u32; +} +extern "C" { + pub fn il2cpp_allocation_granularity() -> u32; +} +extern "C" { + pub fn il2cpp_unity_liveness_allocate_struct( + filter: *mut Il2CppClass, + max_object_count: ::std::os::raw::c_int, + callback: il2cpp_register_object_callback, + userdata: *mut ::std::os::raw::c_void, + reallocate: il2cpp_liveness_reallocate_callback, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn il2cpp_unity_liveness_calculation_from_root( + root: *mut Il2CppObject, + state: *mut ::std::os::raw::c_void, + ); +} +extern "C" { + pub fn il2cpp_unity_liveness_calculation_from_statics(state: *mut ::std::os::raw::c_void); +} +extern "C" { + pub fn il2cpp_unity_liveness_finalize(state: *mut ::std::os::raw::c_void); +} +extern "C" { + pub fn il2cpp_unity_liveness_free_struct(state: *mut ::std::os::raw::c_void); +} +extern "C" { + pub fn il2cpp_method_get_return_type(method: *const MethodInfo) -> *const Il2CppType; +} +extern "C" { + pub fn il2cpp_method_get_declaring_type(method: *const MethodInfo) -> *mut Il2CppClass; +} +extern "C" { + pub fn il2cpp_method_get_name(method: *const MethodInfo) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn il2cpp_method_get_from_reflection( + method: *const Il2CppReflectionMethod, + ) -> *const MethodInfo; +} +extern "C" { + pub fn il2cpp_method_get_object( + method: *const MethodInfo, + refclass: *mut Il2CppClass, + ) -> *mut Il2CppReflectionMethod; +} +extern "C" { + pub fn il2cpp_method_is_generic(method: *const MethodInfo) -> u8; +} +extern "C" { + pub fn il2cpp_method_is_inflated(method: *const MethodInfo) -> u8; +} +extern "C" { + pub fn il2cpp_method_is_instance(method: *const MethodInfo) -> u8; +} +extern "C" { + pub fn il2cpp_method_get_param_count(method: *const MethodInfo) -> u32; +} +extern "C" { + pub fn il2cpp_method_get_param(method: *const MethodInfo, index: u32) -> *const Il2CppType; +} +extern "C" { + pub fn il2cpp_method_get_class(method: *const MethodInfo) -> *mut Il2CppClass; +} +extern "C" { + pub fn il2cpp_method_has_attribute( + method: *const MethodInfo, + attr_class: *mut Il2CppClass, + ) -> u8; +} +extern "C" { + pub fn il2cpp_method_get_flags(method: *const MethodInfo, iflags: *mut u32) -> u32; +} +extern "C" { + pub fn il2cpp_method_get_token(method: *const MethodInfo) -> u32; +} +extern "C" { + pub fn il2cpp_method_get_param_name( + method: *const MethodInfo, + index: u32, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn il2cpp_profiler_install(prof: *mut Il2CppProfiler, shutdown_callback: Il2CppProfileFunc); +} +extern "C" { + pub fn il2cpp_profiler_set_events(events: Il2CppProfileFlags); +} +extern "C" { + pub fn il2cpp_profiler_install_enter_leave( + enter: Il2CppProfileMethodFunc, + fleave: Il2CppProfileMethodFunc, + ); +} +extern "C" { + pub fn il2cpp_profiler_install_allocation(callback: Il2CppProfileAllocFunc); +} +extern "C" { + pub fn il2cpp_profiler_install_gc( + callback: Il2CppProfileGCFunc, + heap_resize_callback: Il2CppProfileGCResizeFunc, + ); +} +extern "C" { + pub fn il2cpp_profiler_install_fileio(callback: Il2CppProfileFileIOFunc); +} +extern "C" { + pub fn il2cpp_profiler_install_thread( + start: Il2CppProfileThreadFunc, + end: Il2CppProfileThreadFunc, + ); +} +extern "C" { + pub fn il2cpp_property_get_flags(prop: *mut PropertyInfo) -> u32; +} +extern "C" { + pub fn il2cpp_property_get_get_method(prop: *mut PropertyInfo) -> *const MethodInfo; +} +extern "C" { + pub fn il2cpp_property_get_set_method(prop: *mut PropertyInfo) -> *const MethodInfo; +} +extern "C" { + pub fn il2cpp_property_get_name(prop: *mut PropertyInfo) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn il2cpp_property_get_parent(prop: *mut PropertyInfo) -> *mut Il2CppClass; +} +extern "C" { + pub fn il2cpp_object_get_class(obj: *mut Il2CppObject) -> *mut Il2CppClass; +} +extern "C" { + pub fn il2cpp_object_get_size(obj: *mut Il2CppObject) -> u32; +} +extern "C" { + pub fn il2cpp_object_get_virtual_method( + obj: *mut Il2CppObject, + method: *const MethodInfo, + ) -> *const MethodInfo; +} +extern "C" { + pub fn il2cpp_object_new(klass: *const Il2CppClass) -> *mut Il2CppObject; +} +extern "C" { + pub fn il2cpp_object_unbox(obj: *mut Il2CppObject) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn il2cpp_value_box( + klass: *mut Il2CppClass, + data: *mut ::std::os::raw::c_void, + ) -> *mut Il2CppObject; +} +extern "C" { + pub fn il2cpp_monitor_enter(obj: *mut Il2CppObject); +} +extern "C" { + pub fn il2cpp_monitor_try_enter(obj: *mut Il2CppObject, timeout: u32) -> u8; +} +extern "C" { + pub fn il2cpp_monitor_exit(obj: *mut Il2CppObject); +} +extern "C" { + pub fn il2cpp_monitor_pulse(obj: *mut Il2CppObject); +} +extern "C" { + pub fn il2cpp_monitor_pulse_all(obj: *mut Il2CppObject); +} +extern "C" { + pub fn il2cpp_monitor_wait(obj: *mut Il2CppObject); +} +extern "C" { + pub fn il2cpp_monitor_try_wait(obj: *mut Il2CppObject, timeout: u32) -> u8; +} +extern "C" { + pub fn il2cpp_runtime_invoke( + method: *const MethodInfo, + obj: *mut ::std::os::raw::c_void, + params: *mut *mut ::std::os::raw::c_void, + exc: *mut *mut Il2CppException, + ) -> *mut Il2CppObject; +} +extern "C" { + pub fn il2cpp_runtime_invoke_convert_args( + method: *const MethodInfo, + obj: *mut ::std::os::raw::c_void, + params: *mut *mut Il2CppObject, + paramCount: ::std::os::raw::c_int, + exc: *mut *mut Il2CppException, + ) -> *mut Il2CppObject; +} +extern "C" { + pub fn il2cpp_runtime_class_init(klass: *mut Il2CppClass); +} +extern "C" { + pub fn il2cpp_runtime_object_init(obj: *mut Il2CppObject); +} +extern "C" { + pub fn il2cpp_runtime_object_init_exception( + obj: *mut Il2CppObject, + exc: *mut *mut Il2CppException, + ); +} +extern "C" { + pub fn il2cpp_runtime_unhandled_exception_policy_set( + value: Il2CppRuntimeUnhandledExceptionPolicy, + ); +} +extern "C" { + pub fn il2cpp_string_length(str_: *mut Il2CppString) -> i32; +} +extern "C" { + pub fn il2cpp_string_chars(str_: *mut Il2CppString) -> *mut Il2CppChar; +} +extern "C" { + pub fn il2cpp_string_new(str_: *const ::std::os::raw::c_char) -> *mut Il2CppString; +} +extern "C" { + pub fn il2cpp_string_new_len( + str_: *const ::std::os::raw::c_char, + length: u32, + ) -> *mut Il2CppString; +} +extern "C" { + pub fn il2cpp_string_new_utf16(text: *const Il2CppChar, len: i32) -> *mut Il2CppString; +} +extern "C" { + pub fn il2cpp_string_new_wrapper(str_: *const ::std::os::raw::c_char) -> *mut Il2CppString; +} +extern "C" { + pub fn il2cpp_string_intern(str_: *mut Il2CppString) -> *mut Il2CppString; +} +extern "C" { + pub fn il2cpp_string_is_interned(str_: *mut Il2CppString) -> *mut Il2CppString; +} +extern "C" { + pub fn il2cpp_thread_current() -> *mut Il2CppThread; +} +extern "C" { + pub fn il2cpp_thread_attach(domain: *mut Il2CppDomain) -> *mut Il2CppThread; +} +extern "C" { + pub fn il2cpp_thread_detach(thread: *mut Il2CppThread); +} +extern "C" { + pub fn il2cpp_thread_get_all_attached_threads(size: *mut usize) -> *mut *mut Il2CppThread; +} +extern "C" { + pub fn il2cpp_is_vm_thread(thread: *mut Il2CppThread) -> u8; +} +extern "C" { + pub fn il2cpp_current_thread_walk_frame_stack( + func: Il2CppFrameWalkFunc, + user_data: *mut ::std::os::raw::c_void, + ); +} +extern "C" { + pub fn il2cpp_thread_walk_frame_stack( + thread: *mut Il2CppThread, + func: Il2CppFrameWalkFunc, + user_data: *mut ::std::os::raw::c_void, + ); +} +extern "C" { + pub fn il2cpp_current_thread_get_top_frame(frame: *mut Il2CppStackFrameInfo) -> u8; +} +extern "C" { + pub fn il2cpp_thread_get_top_frame( + thread: *mut Il2CppThread, + frame: *mut Il2CppStackFrameInfo, + ) -> u8; +} +extern "C" { + pub fn il2cpp_current_thread_get_frame_at(offset: i32, frame: *mut Il2CppStackFrameInfo) -> u8; +} +extern "C" { + pub fn il2cpp_thread_get_frame_at( + thread: *mut Il2CppThread, + offset: i32, + frame: *mut Il2CppStackFrameInfo, + ) -> u8; +} +extern "C" { + pub fn il2cpp_current_thread_get_stack_depth() -> i32; +} +extern "C" { + pub fn il2cpp_thread_get_stack_depth(thread: *mut Il2CppThread) -> i32; +} +extern "C" { + pub fn il2cpp_override_stack_backtrace(stackBacktraceFunc: Il2CppBacktraceFunc); +} +extern "C" { + pub fn il2cpp_type_get_object(type_: *const Il2CppType) -> *mut Il2CppObject; +} +extern "C" { + pub fn il2cpp_type_get_type(type_: *const Il2CppType) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn il2cpp_type_get_class_or_element_class(type_: *const Il2CppType) -> *mut Il2CppClass; +} +extern "C" { + pub fn il2cpp_type_get_name(type_: *const Il2CppType) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn il2cpp_type_is_byref(type_: *const Il2CppType) -> u8; +} +extern "C" { + pub fn il2cpp_type_get_attrs(type_: *const Il2CppType) -> u32; +} +extern "C" { + pub fn il2cpp_type_equals(type_: *const Il2CppType, otherType: *const Il2CppType) -> u8; +} +extern "C" { + pub fn il2cpp_type_get_assembly_qualified_name( + type_: *const Il2CppType, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn il2cpp_type_get_reflection_name(type_: *const Il2CppType) + -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn il2cpp_type_is_static(type_: *const Il2CppType) -> u8; +} +extern "C" { + pub fn il2cpp_type_is_pointer_type(type_: *const Il2CppType) -> u8; +} +extern "C" { + pub fn il2cpp_image_get_assembly(image: *const Il2CppImage) -> *const Il2CppAssembly; +} +extern "C" { + pub fn il2cpp_image_get_name(image: *const Il2CppImage) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn il2cpp_image_get_filename(image: *const Il2CppImage) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn il2cpp_image_get_entry_point(image: *const Il2CppImage) -> *const MethodInfo; +} +extern "C" { + pub fn il2cpp_image_get_class_count(image: *const Il2CppImage) -> usize; +} +extern "C" { + pub fn il2cpp_image_get_class(image: *const Il2CppImage, index: usize) -> *const Il2CppClass; +} +extern "C" { + pub fn il2cpp_capture_memory_snapshot() -> *mut Il2CppManagedMemorySnapshot; +} +extern "C" { + pub fn il2cpp_free_captured_memory_snapshot(snapshot: *mut Il2CppManagedMemorySnapshot); +} +extern "C" { + pub fn il2cpp_set_find_plugin_callback(method: Il2CppSetFindPlugInCallback); +} +extern "C" { + pub fn il2cpp_register_log_callback(method: Il2CppLogCallback); +} +extern "C" { + pub fn il2cpp_debugger_set_agent_options(options: *const ::std::os::raw::c_char); +} +extern "C" { + pub fn il2cpp_is_debugger_attached() -> u8; +} +extern "C" { + pub fn il2cpp_register_debugger_agent_transport( + debuggerTransport: *mut Il2CppDebuggerTransport, + ); +} +extern "C" { + pub fn il2cpp_debug_get_method_info( + arg1: *const MethodInfo, + methodDebugInfo: *mut Il2CppMethodDebugInfo, + ) -> u8; +} +extern "C" { + pub fn il2cpp_unity_install_unitytls_interface( + unitytlsInterfaceStruct: *const ::std::os::raw::c_void, + ); +} +extern "C" { + pub fn il2cpp_custom_attrs_from_class(klass: *mut Il2CppClass) -> *mut Il2CppCustomAttrInfo; +} +extern "C" { + pub fn il2cpp_custom_attrs_from_method(method: *const MethodInfo) -> *mut Il2CppCustomAttrInfo; +} +extern "C" { + pub fn il2cpp_custom_attrs_from_field(field: *const FieldInfo) -> *mut Il2CppCustomAttrInfo; +} +extern "C" { + pub fn il2cpp_custom_attrs_get_attr( + ainfo: *mut Il2CppCustomAttrInfo, + attr_klass: *mut Il2CppClass, + ) -> *mut Il2CppObject; +} +extern "C" { + pub fn il2cpp_custom_attrs_has_attr( + ainfo: *mut Il2CppCustomAttrInfo, + attr_klass: *mut Il2CppClass, + ) -> u8; +} +extern "C" { + pub fn il2cpp_custom_attrs_construct(cinfo: *mut Il2CppCustomAttrInfo) -> *mut Il2CppArray; +} +extern "C" { + pub fn il2cpp_custom_attrs_free(ainfo: *mut Il2CppCustomAttrInfo); +} +extern "C" { + pub fn il2cpp_class_set_userdata( + klass: *mut Il2CppClass, + userdata: *mut ::std::os::raw::c_void, + ); +} +extern "C" { + pub fn il2cpp_class_get_userdata_offset() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn il2cpp_set_default_thread_affinity(affinity_mask: i64); +} +extern "C" { + pub fn il2cpp_unity_set_android_network_up_state_func(func: Il2CppAndroidUpStateFunc); +} +extern "C" { + pub fn __doserrno() -> *mut ::std::os::raw::c_ulong; +} +extern "C" { + pub fn _set_doserrno(_Value: ::std::os::raw::c_ulong) -> errno_t; +} +extern "C" { + pub fn _get_doserrno(_Value: *mut ::std::os::raw::c_ulong) -> errno_t; +} +extern "C" { + pub fn memchr( + _Buf: *const ::std::os::raw::c_void, + _Val: ::std::os::raw::c_int, + _MaxCount: ::std::os::raw::c_ulonglong, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn memcmp( + _Buf1: *const ::std::os::raw::c_void, + _Buf2: *const ::std::os::raw::c_void, + _Size: ::std::os::raw::c_ulonglong, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn memcpy( + _Dst: *mut ::std::os::raw::c_void, + _Src: *const ::std::os::raw::c_void, + _Size: ::std::os::raw::c_ulonglong, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn memmove( + _Dst: *mut ::std::os::raw::c_void, + _Src: *const ::std::os::raw::c_void, + _Size: ::std::os::raw::c_ulonglong, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn memset( + _Dst: *mut ::std::os::raw::c_void, + _Val: ::std::os::raw::c_int, + _Size: ::std::os::raw::c_ulonglong, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn strchr( + _Str: *const ::std::os::raw::c_char, + _Val: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn strrchr( + _Str: *const ::std::os::raw::c_char, + _Ch: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn strstr( + _Str: *const ::std::os::raw::c_char, + _SubStr: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn wcschr( + _Str: *const ::std::os::raw::c_ushort, + _Ch: ::std::os::raw::c_ushort, + ) -> *mut ::std::os::raw::c_ushort; +} +extern "C" { + pub fn wcsrchr(_Str: *const wchar_t, _Ch: wchar_t) -> *mut wchar_t; +} +extern "C" { + pub fn wcsstr(_Str: *const wchar_t, _SubStr: *const wchar_t) -> *mut wchar_t; +} +extern "C" { + pub fn _memicmp( + _Buf1: *const ::std::os::raw::c_void, + _Buf2: *const ::std::os::raw::c_void, + _Size: usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _memicmp_l( + _Buf1: *const ::std::os::raw::c_void, + _Buf2: *const ::std::os::raw::c_void, + _Size: usize, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn memccpy( + _Dst: *mut ::std::os::raw::c_void, + _Src: *const ::std::os::raw::c_void, + _Val: ::std::os::raw::c_int, + _Size: ::std::os::raw::c_ulonglong, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn memicmp( + _Buf1: *const ::std::os::raw::c_void, + _Buf2: *const ::std::os::raw::c_void, + _Size: usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn wcscat_s( + _Destination: *mut wchar_t, + _SizeInWords: rsize_t, + _Source: *const wchar_t, + ) -> errno_t; +} +extern "C" { + pub fn wcscpy_s( + _Destination: *mut wchar_t, + _SizeInWords: rsize_t, + _Source: *const wchar_t, + ) -> errno_t; +} +extern "C" { + pub fn wcsncat_s( + _Destination: *mut wchar_t, + _SizeInWords: rsize_t, + _Source: *const wchar_t, + _MaxCount: rsize_t, + ) -> errno_t; +} +extern "C" { + pub fn wcsncpy_s( + _Destination: *mut wchar_t, + _SizeInWords: rsize_t, + _Source: *const wchar_t, + _MaxCount: rsize_t, + ) -> errno_t; +} +extern "C" { + pub fn wcstok_s( + _String: *mut wchar_t, + _Delimiter: *const wchar_t, + _Context: *mut *mut wchar_t, + ) -> *mut wchar_t; +} +extern "C" { + pub fn _wcsdup(_String: *const wchar_t) -> *mut wchar_t; +} +extern "C" { + pub fn wcscat(_Destination: *mut wchar_t, _Source: *const wchar_t) -> *mut wchar_t; +} +extern "C" { + pub fn wcscmp( + _String1: *const ::std::os::raw::c_ushort, + _String2: *const ::std::os::raw::c_ushort, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn wcscpy(_Destination: *mut wchar_t, _Source: *const wchar_t) -> *mut wchar_t; +} +extern "C" { + pub fn wcscspn(_String: *const wchar_t, _Control: *const wchar_t) -> usize; +} +extern "C" { + pub fn wcslen(_String: *const ::std::os::raw::c_ushort) -> ::std::os::raw::c_ulonglong; +} +extern "C" { + pub fn wcsnlen(_Source: *const wchar_t, _MaxCount: usize) -> usize; +} +extern "C" { + pub fn wcsncat( + _Destination: *mut wchar_t, + _Source: *const wchar_t, + _Count: usize, + ) -> *mut wchar_t; +} +extern "C" { + pub fn wcsncmp( + _String1: *const ::std::os::raw::c_ushort, + _String2: *const ::std::os::raw::c_ushort, + _MaxCount: ::std::os::raw::c_ulonglong, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn wcsncpy( + _Destination: *mut wchar_t, + _Source: *const wchar_t, + _Count: usize, + ) -> *mut wchar_t; +} +extern "C" { + pub fn wcspbrk(_String: *const wchar_t, _Control: *const wchar_t) -> *mut wchar_t; +} +extern "C" { + pub fn wcsspn(_String: *const wchar_t, _Control: *const wchar_t) -> usize; +} +extern "C" { + pub fn wcstok( + _String: *mut wchar_t, + _Delimiter: *const wchar_t, + _Context: *mut *mut wchar_t, + ) -> *mut wchar_t; +} +extern "C" { + pub fn _wcserror(_ErrorNumber: ::std::os::raw::c_int) -> *mut wchar_t; +} +extern "C" { + pub fn _wcserror_s( + _Buffer: *mut wchar_t, + _SizeInWords: usize, + _ErrorNumber: ::std::os::raw::c_int, + ) -> errno_t; +} +extern "C" { + pub fn __wcserror(_String: *const wchar_t) -> *mut wchar_t; +} +extern "C" { + pub fn __wcserror_s( + _Buffer: *mut wchar_t, + _SizeInWords: usize, + _ErrorMessage: *const wchar_t, + ) -> errno_t; +} +extern "C" { + pub fn _wcsicmp(_String1: *const wchar_t, _String2: *const wchar_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _wcsicmp_l( + _String1: *const wchar_t, + _String2: *const wchar_t, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _wcsnicmp( + _String1: *const wchar_t, + _String2: *const wchar_t, + _MaxCount: usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _wcsnicmp_l( + _String1: *const wchar_t, + _String2: *const wchar_t, + _MaxCount: usize, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _wcsnset_s( + _Destination: *mut wchar_t, + _SizeInWords: usize, + _Value: wchar_t, + _MaxCount: usize, + ) -> errno_t; +} +extern "C" { + pub fn _wcsnset(_String: *mut wchar_t, _Value: wchar_t, _MaxCount: usize) -> *mut wchar_t; +} +extern "C" { + pub fn _wcsrev(_String: *mut wchar_t) -> *mut wchar_t; +} +extern "C" { + pub fn _wcsset_s(_Destination: *mut wchar_t, _SizeInWords: usize, _Value: wchar_t) -> errno_t; +} +extern "C" { + pub fn _wcsset(_String: *mut wchar_t, _Value: wchar_t) -> *mut wchar_t; +} +extern "C" { + pub fn _wcslwr_s(_String: *mut wchar_t, _SizeInWords: usize) -> errno_t; +} +extern "C" { + pub fn _wcslwr(_String: *mut wchar_t) -> *mut wchar_t; +} +extern "C" { + pub fn _wcslwr_s_l(_String: *mut wchar_t, _SizeInWords: usize, _Locale: _locale_t) -> errno_t; +} +extern "C" { + pub fn _wcslwr_l(_String: *mut wchar_t, _Locale: _locale_t) -> *mut wchar_t; +} +extern "C" { + pub fn _wcsupr_s(_String: *mut wchar_t, _Size: usize) -> errno_t; +} +extern "C" { + pub fn _wcsupr(_String: *mut wchar_t) -> *mut wchar_t; +} +extern "C" { + pub fn _wcsupr_s_l(_String: *mut wchar_t, _Size: usize, _Locale: _locale_t) -> errno_t; +} +extern "C" { + pub fn _wcsupr_l(_String: *mut wchar_t, _Locale: _locale_t) -> *mut wchar_t; +} +extern "C" { + pub fn wcsxfrm(_Destination: *mut wchar_t, _Source: *const wchar_t, _MaxCount: usize) -> usize; +} +extern "C" { + pub fn _wcsxfrm_l( + _Destination: *mut wchar_t, + _Source: *const wchar_t, + _MaxCount: usize, + _Locale: _locale_t, + ) -> usize; +} +extern "C" { + pub fn wcscoll(_String1: *const wchar_t, _String2: *const wchar_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _wcscoll_l( + _String1: *const wchar_t, + _String2: *const wchar_t, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _wcsicoll(_String1: *const wchar_t, _String2: *const wchar_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _wcsicoll_l( + _String1: *const wchar_t, + _String2: *const wchar_t, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _wcsncoll( + _String1: *const wchar_t, + _String2: *const wchar_t, + _MaxCount: usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _wcsncoll_l( + _String1: *const wchar_t, + _String2: *const wchar_t, + _MaxCount: usize, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _wcsnicoll( + _String1: *const wchar_t, + _String2: *const wchar_t, + _MaxCount: usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _wcsnicoll_l( + _String1: *const wchar_t, + _String2: *const wchar_t, + _MaxCount: usize, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn wcsdup(_String: *const wchar_t) -> *mut wchar_t; +} +extern "C" { + pub fn wcsicmp(_String1: *const wchar_t, _String2: *const wchar_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn wcsnicmp( + _String1: *const wchar_t, + _String2: *const wchar_t, + _MaxCount: usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn wcsnset(_String: *mut wchar_t, _Value: wchar_t, _MaxCount: usize) -> *mut wchar_t; +} +extern "C" { + pub fn wcsrev(_String: *mut wchar_t) -> *mut wchar_t; +} +extern "C" { + pub fn wcsset(_String: *mut wchar_t, _Value: wchar_t) -> *mut wchar_t; +} +extern "C" { + pub fn wcslwr(_String: *mut wchar_t) -> *mut wchar_t; +} +extern "C" { + pub fn wcsupr(_String: *mut wchar_t) -> *mut wchar_t; +} +extern "C" { + pub fn wcsicoll(_String1: *const wchar_t, _String2: *const wchar_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn strcpy_s( + _Destination: *mut ::std::os::raw::c_char, + _SizeInBytes: rsize_t, + _Source: *const ::std::os::raw::c_char, + ) -> errno_t; +} +extern "C" { + pub fn strcat_s( + _Destination: *mut ::std::os::raw::c_char, + _SizeInBytes: rsize_t, + _Source: *const ::std::os::raw::c_char, + ) -> errno_t; +} +extern "C" { + pub fn strerror_s( + _Buffer: *mut ::std::os::raw::c_char, + _SizeInBytes: usize, + _ErrorNumber: ::std::os::raw::c_int, + ) -> errno_t; +} +extern "C" { + pub fn strncat_s( + _Destination: *mut ::std::os::raw::c_char, + _SizeInBytes: rsize_t, + _Source: *const ::std::os::raw::c_char, + _MaxCount: rsize_t, + ) -> errno_t; +} +extern "C" { + pub fn strncpy_s( + _Destination: *mut ::std::os::raw::c_char, + _SizeInBytes: rsize_t, + _Source: *const ::std::os::raw::c_char, + _MaxCount: rsize_t, + ) -> errno_t; +} +extern "C" { + pub fn strtok_s( + _String: *mut ::std::os::raw::c_char, + _Delimiter: *const ::std::os::raw::c_char, + _Context: *mut *mut ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn _memccpy( + _Dst: *mut ::std::os::raw::c_void, + _Src: *const ::std::os::raw::c_void, + _Val: ::std::os::raw::c_int, + _MaxCount: usize, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn strcat( + _Destination: *mut ::std::os::raw::c_char, + _Source: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn strcmp( + _Str1: *const ::std::os::raw::c_char, + _Str2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _strcmpi( + _String1: *const ::std::os::raw::c_char, + _String2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn strcoll( + _String1: *const ::std::os::raw::c_char, + _String2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _strcoll_l( + _String1: *const ::std::os::raw::c_char, + _String2: *const ::std::os::raw::c_char, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn strcpy( + _Destination: *mut ::std::os::raw::c_char, + _Source: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn strcspn( + _Str: *const ::std::os::raw::c_char, + _Control: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_ulonglong; +} +extern "C" { + pub fn _strdup(_Source: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn _strerror(_ErrorMessage: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn _strerror_s( + _Buffer: *mut ::std::os::raw::c_char, + _SizeInBytes: usize, + _ErrorMessage: *const ::std::os::raw::c_char, + ) -> errno_t; +} +extern "C" { + pub fn strerror(_ErrorMessage: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn _stricmp( + _String1: *const ::std::os::raw::c_char, + _String2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _stricoll( + _String1: *const ::std::os::raw::c_char, + _String2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _stricoll_l( + _String1: *const ::std::os::raw::c_char, + _String2: *const ::std::os::raw::c_char, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _stricmp_l( + _String1: *const ::std::os::raw::c_char, + _String2: *const ::std::os::raw::c_char, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn strlen(_Str: *const ::std::os::raw::c_char) -> ::std::os::raw::c_ulonglong; +} +extern "C" { + pub fn _strlwr_s(_String: *mut ::std::os::raw::c_char, _Size: usize) -> errno_t; +} +extern "C" { + pub fn _strlwr(_String: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn _strlwr_s_l( + _String: *mut ::std::os::raw::c_char, + _Size: usize, + _Locale: _locale_t, + ) -> errno_t; +} +extern "C" { + pub fn _strlwr_l( + _String: *mut ::std::os::raw::c_char, + _Locale: _locale_t, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn strncat( + _Destination: *mut ::std::os::raw::c_char, + _Source: *const ::std::os::raw::c_char, + _Count: ::std::os::raw::c_ulonglong, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn strncmp( + _Str1: *const ::std::os::raw::c_char, + _Str2: *const ::std::os::raw::c_char, + _MaxCount: ::std::os::raw::c_ulonglong, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _strnicmp( + _String1: *const ::std::os::raw::c_char, + _String2: *const ::std::os::raw::c_char, + _MaxCount: usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _strnicmp_l( + _String1: *const ::std::os::raw::c_char, + _String2: *const ::std::os::raw::c_char, + _MaxCount: usize, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _strnicoll( + _String1: *const ::std::os::raw::c_char, + _String2: *const ::std::os::raw::c_char, + _MaxCount: usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _strnicoll_l( + _String1: *const ::std::os::raw::c_char, + _String2: *const ::std::os::raw::c_char, + _MaxCount: usize, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _strncoll( + _String1: *const ::std::os::raw::c_char, + _String2: *const ::std::os::raw::c_char, + _MaxCount: usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn _strncoll_l( + _String1: *const ::std::os::raw::c_char, + _String2: *const ::std::os::raw::c_char, + _MaxCount: usize, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn __strncnt(_String: *const ::std::os::raw::c_char, _Count: usize) -> usize; +} +extern "C" { + pub fn strncpy( + _Destination: *mut ::std::os::raw::c_char, + _Source: *const ::std::os::raw::c_char, + _Count: ::std::os::raw::c_ulonglong, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn strnlen(_String: *const ::std::os::raw::c_char, _MaxCount: usize) -> usize; +} +extern "C" { + pub fn _strnset_s( + _String: *mut ::std::os::raw::c_char, + _SizeInBytes: usize, + _Value: ::std::os::raw::c_int, + _MaxCount: usize, + ) -> errno_t; +} +extern "C" { + pub fn _strnset( + _Destination: *mut ::std::os::raw::c_char, + _Value: ::std::os::raw::c_int, + _Count: usize, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn strpbrk( + _Str: *const ::std::os::raw::c_char, + _Control: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn _strrev(_Str: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn _strset_s( + _Destination: *mut ::std::os::raw::c_char, + _DestinationSize: usize, + _Value: ::std::os::raw::c_int, + ) -> errno_t; +} +extern "C" { + pub fn _strset( + _Destination: *mut ::std::os::raw::c_char, + _Value: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn strspn( + _Str: *const ::std::os::raw::c_char, + _Control: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_ulonglong; +} +extern "C" { + pub fn strtok( + _String: *mut ::std::os::raw::c_char, + _Delimiter: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn _strupr_s(_String: *mut ::std::os::raw::c_char, _Size: usize) -> errno_t; +} +extern "C" { + pub fn _strupr(_String: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn _strupr_s_l( + _String: *mut ::std::os::raw::c_char, + _Size: usize, + _Locale: _locale_t, + ) -> errno_t; +} +extern "C" { + pub fn _strupr_l( + _String: *mut ::std::os::raw::c_char, + _Locale: _locale_t, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn strxfrm( + _Destination: *mut ::std::os::raw::c_char, + _Source: *const ::std::os::raw::c_char, + _MaxCount: ::std::os::raw::c_ulonglong, + ) -> ::std::os::raw::c_ulonglong; +} +extern "C" { + pub fn _strxfrm_l( + _Destination: *mut ::std::os::raw::c_char, + _Source: *const ::std::os::raw::c_char, + _MaxCount: usize, + _Locale: _locale_t, + ) -> usize; +} +extern "C" { + pub fn strdup(_String: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn strcmpi( + _String1: *const ::std::os::raw::c_char, + _String2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn stricmp( + _String1: *const ::std::os::raw::c_char, + _String2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn strlwr(_String: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn strnicmp( + _String1: *const ::std::os::raw::c_char, + _String2: *const ::std::os::raw::c_char, + _MaxCount: usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn strnset( + _String: *mut ::std::os::raw::c_char, + _Value: ::std::os::raw::c_int, + _MaxCount: usize, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn strrev(_String: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn strset( + _String: *mut ::std::os::raw::c_char, + _Value: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn strupr(_String: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub static kIl2CppUInt64Max: u64; +} +extern "C" { + pub static kIl2CppUIntPtrMax: usize; +} +extern "C" { + pub static kIl2CppNewLine: [Il2CppChar; 3usize]; +} +extern "C" { + pub static mut il2cpp_defaults: Il2CppDefaults; +} diff --git a/libil2cpp/src/ty.rs b/libil2cpp/src/ty.rs index 6edea002..a78d7415 100644 --- a/libil2cpp/src/ty.rs +++ b/libil2cpp/src/ty.rs @@ -56,9 +56,15 @@ unsafe impl WrapRaw for Il2CppType { } impl PartialEq for Il2CppType { + #[cfg(any(feature = "il2cpp_v24", feature = "unity2018"))] fn eq(&self, other: &Self) -> bool { unsafe { self.raw().data.klassIndex == other.raw().data.klassIndex } } + + #[cfg(feature = "il2cpp_v31")] + fn eq(&self, other: &Self) -> bool { + unsafe { self.raw().data.__klassIndex == other.raw().data.__klassIndex } + } } impl Eq for Il2CppType {} @@ -78,9 +84,15 @@ impl fmt::Display for Il2CppType { macro_rules! builtins { ($($const:ident => ($variant:ident, $id:ident, $name:literal),)*) => { + + // essentially Windows clang will use i32 + // https://github.com/rust-lang/rust-bindgen/issues/1966 + + #[doc = "Builtin C# types"] #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] - #[cfg_attr(feature = "unity2019", repr(u32))] + #[cfg_attr(feature = "il2cpp_v31", repr(i32))] + #[cfg_attr(feature = "il2cpp_v24", repr(u32))] #[cfg_attr(feature = "unity2018", repr(i32))] pub enum Builtin { $( @@ -93,7 +105,10 @@ macro_rules! builtins { #[doc = "Whether the type represents the given [`Builtin`]"] #[inline] pub fn is_builtin(&self, builtin: Builtin) -> bool { - #[cfg(feature = "unity2019")] + #[cfg(feature = "il2cpp_v31")] + { self.raw().type_() == builtin as i32 } + + #[cfg(feature = "il2cpp_v24")] { self.raw().type_() == builtin as u32 } #[cfg(feature = "unity2018")] diff --git a/libil2cpp/wrapper.h b/libil2cpp/wrapper.h new file mode 100644 index 00000000..3956ac5b --- /dev/null +++ b/libil2cpp/wrapper.h @@ -0,0 +1,7 @@ +#include "extern/includes/libil2cpp/il2cpp/libil2cpp/il2cpp-api.h" +#include "extern/includes/libil2cpp/il2cpp/libil2cpp/il2cpp-config-api.h" +#include "extern/includes/libil2cpp/il2cpp/libil2cpp/il2cpp-api-types.h" +#include "extern/includes/libil2cpp/il2cpp/libil2cpp/il2cpp-config.h" +#include "extern/includes/libil2cpp/il2cpp/libil2cpp/il2cpp-metadata.h" +#include "extern/includes/libil2cpp/il2cpp/libil2cpp/il2cpp-object-internals.h" +#include "extern/includes/libil2cpp/il2cpp/libil2cpp/il2cpp-tabledefs.h" diff --git a/proc_macros/Cargo.toml b/proc_macros/Cargo.toml index 15684e96..24796c68 100644 --- a/proc_macros/Cargo.toml +++ b/proc_macros/Cargo.toml @@ -13,10 +13,10 @@ edition = "2021" proc-macro = true [dependencies] -syn = { version = "1", features = ["full", "extra-traits"] } +syn = { version = "2", features = ["full", "extra-traits"] } quote = "1" proc-macro2 = "1" -heck = "0.3" +heck = "0.5" [features] default = [] diff --git a/proc_macros/src/hook.rs b/proc_macros/src/hook.rs index 3779613e..7dd3cd4b 100644 --- a/proc_macros/src/hook.rs +++ b/proc_macros/src/hook.rs @@ -1,4 +1,4 @@ -use heck::{CamelCase, SnakeCase}; +use heck::{ToLowerCamelCase, ToSnakeCase}; use proc_macro::TokenStream; use proc_macro2::{Group, TokenStream as TokenStream2, TokenTree as TokenTree2}; use quote::{format_ident, quote, quote_spanned, ToTokens}; @@ -147,7 +147,7 @@ impl Metadata { fn struct_name(&self) -> Ident { let hook_name = self.hook_name().to_string(); - let struct_name = hook_name.to_camel_case(); + let struct_name = hook_name.to_lower_camel_case(); format_ident!("{}Struct", struct_name) } @@ -466,7 +466,7 @@ fn unit_ty() -> Type { } fn attr_is(attr: &Attribute, ident: &str) -> bool { - matches!(attr.path.get_ident(), Some(ai) if ai == ident) + matches!(attr.path().get_ident(), Some(ai) if ai == ident) } fn staticify(tokens: impl ToTokens) -> TokenStream2 { diff --git a/proc_macros/src/lib.rs b/proc_macros/src/lib.rs index d60a8544..3c79fd88 100644 --- a/proc_macros/src/lib.rs +++ b/proc_macros/src/lib.rs @@ -277,12 +277,12 @@ impl Parse for RangeInput { let span = range.span(); let start = range - .from + .start .ok_or_else(|| Error::new(span, "tuple length range must have a lower bound"))?; let start = parse_range_bound(*start)?; let end = range - .to + .end .ok_or_else(|| Error::new(span, "tuple length range must have an upper bound"))?; let end = parse_range_bound(*end)?; diff --git a/rust-toolchain b/rust-toolchain.toml similarity index 100% rename from rust-toolchain rename to rust-toolchain.toml